具有继承关系的两个类中的非静态方法才可以重写，new出的子类对象调用的都是子类中重写后的方法，而静态方法重写后，在测试类中new出子类方法，调用哪一个类的方法则要看接收这个对象的变量名的类是父类还是子类，是谁的类就调用谁的方法。
重写的只能是子父类之间共有的public的方法：其一为public，其二为方法。
重载是相对于本类的方法名相同，参数列表不同；而重写对象是具有继承关系的两个子父类之间共有的public方法的重新编码。
方法的重写用在类与类的继承之间的，区别于方法的重载，方法重载是方法名相同，参数或者参数列表不同，而方法的重写是对具有继承关系的方法体内部的代码重新编写实现与父类不同的功能。

重写与属性毫无关联，是方法的重写。

具有继承关系的两个类（父类与子类）中有共同的static修饰的静态方法，static修饰的内容随类一起加载，对于父类与子类都有的静态方法，将子类中的静态方法重写，输出方法仅与new出对象左边接收值的类型有关，是父类对象则调用的是父类中的方法，如果接收的是子类的对象则调用的是子类中的方法



对于具有继承关系的两个类中具有的共同的非静态方法，重写之后，无论是什么类型的变量名接收new出的子类对象输出的方法都是子类中重写的方法，而静态方法则是看左边接收变量的类型来决定调用父类还是子类的方法。

重写需要注意什么，以及为什么要重写两个继承关系的类的方法：

封面人物
我忘了从哪下载下来的了，应该是微博里特别出名的一个画师。
继承
简介：继承是面向对象的三个基本特征之一，继承是实现复用性的一个重要手段，可以在不重复编写已实现的功能的前提下,对功能进行复用和拓展。许多OO(Object Oriented,面向对象)语言都支持两种继承方式：
接口继承-只继承方法签名，属性，但是子类必须提供实现的能力；
实现继承-继承实际方法，直接使用基类的属性和方法而无需额外编码；
JS中函数没有签名，所以无法实现接口继承，只支持实现继承，且实现继承主要依靠原型链来实现的。
原型链
基本思想:利用原型让一个引用类型继承另一个引用类型的属性或方法。
构造函数、原型与实例的关系:
每个构造函数都有一个原型对象（prototype）
原型对象都包含一个指向构造函数的指针（constructor）
实例包含一个指向原型对象的内部指针（__proto__）
基本概念： 
__proto__属性，它是对象所独有的，可以看到__proto__属性都是由一个对象指向一个对象，即指向它们的原型对象（也可以理解为父对象），那么这个属性的作用是什么呢？它的作用就是当访问一个对象的属性时，如果该对象内部不存在这个属性，那么就会去它的__proto__属性所指向的那个对象（可以理解为父对象）里找，如果父对象也不存在这个属性，则继续往父对象的__proto__属性所指向的那个对象（可以理解为爷爷对象）里找，如果还没找到，则继续往上找….直到原型链顶端null（可以理解为原始人。。。），此时若还没找到，则返回undefined（可以理解为，再往上就已经不是“人”的范畴了，找不到了，到此为止），由以上这种通过__proto__属性来连接对象直到null的一条链即为我们所谓的原型链。 
不懂的先看这篇文章 《帮你彻底搞懂JS中的prototype、__proto__与constructor》，每天上班读一遍，周一到周五，基本就明白了，不会再迷糊了。
实现原型链
可以在《JavaScript高级程序设计》P162-6.3继承和《JavaScript设计模式》P19-2.3传宗接代-继承 中可以看到类似的代码。在设计模式一书中称其为类式继承，我沿用这个称呼也这么叫了，并对原书中的代码进行了小修改。
实现本质：重写原型对象，代之以一个新类型的实例。
代码：
/**
            类式继承
            类式继承需要将父类的实例赋值给子类的的原型对象prototype

            类的原型对象作用是就是为了类的原型添加共有属性和方法，但是类本身不能不直接访问这些属性和方法，必须通过原型prototype来访问。

            实例化父类时，new关键字将父类的构造函数，属性和方法复制给了实例化对象，并且将实例化对象的__proto__指向了父类的原型对象。

            这样实例对象就拥有了父类原型对象上的属性和方法。

            并且，实例对象可以直接访问父类原型对象上的属性和方法。
        */

        //声明父类
        function SuperClass() {
            this.superValue = "我是父类";
        }

        //增加父类公共方法--类的原型对象作用是就是为了类的原型添加共有属性和方法
        SuperClass.prototype.getSuperValue = function () {
            //为父类原型对象上添加一个获取值的方法
            console.log(this.superValue)
        }
        //声明子类
        function SubClass() {
            this.subValue = "我是子类";
        }

        //继承父类--父类的实例赋值给子类的的原型对象prototype
        //new关键字将父类的构造函数，属性和方法复制给了实例化对象，并且将实例化对象的__proto__指向了父类的原型对象
        SubClass.prototype = new SuperClass();//在此处时重写原型对象

        //增加子类公共方法
        SubClass.prototype.getSubValue = function () {
            //为子类原型对象上添加一个获取值的方法
            console.log(this.subValue);
        }

        //实例化
        var instance = new SubClass();

        //使用
        instance.getSubValue(); //我是子类
        instance.getSuperValue(); //我是父类--实例对象可以直接访问父类原型对象上的属性和方法
确定原型与实例的关系：使用instanceof操作符。instanceof运算符用于测试构造函数的prototype属性是否出现在对象的原型链中的任何位置。
代码：
//通过instanceof检测某个对象是否是某个类的实例
        //instanceof通过判断对象的prototype链来判断某个对象是否是某个类的实例
        console.log(instance instanceof SuperClass); //true
        console.log(instance instanceof SubClass); //true

        //instanceof是检测某个对象是否是某个类的实例，它并不表示两者的继承关系
        console.log(SubClass instanceof SuperClass); //false


        //实际继承SuperClass 是 SubClass.prototype ，所以
        console.log(SubClass.prototype instanceof SuperClass) //true

        //所有对象的都是Object 的实例
        console.log(instance instanceof Object) //true
谨慎的定义方法：子类有时需要覆盖父类中的某个方法，或者添加父类中不存在的某个方法。但不管怎样，给原型添加方法的代码一定要放在继承父类（重写原型对象）语句之后。同时，使用原型链实现继承时，不能使用对象字面量给子类创建原型方法。因为会重写原型链。
代码：
//声明父类
        function SuperClass() {
            this.superValue = "我是父类";
        }

        SuperClass.prototype.getSuperValue = function () {
  
            console.log(this.superValue)
        }
        //声明子类
        function SubClass() {
            this.subValue = "我是子类";
        }

        //继承父类
        SubClass.prototype = new SuperClass();

        //使用字面量添加方法，会导致上一行无效
        SubClass.prototype={
           getSubValue : function () {
             console.log(this.subValue);
           },
           otherMethod:function(){
             //.....
           }
        }
        //实例化
        var instance = new SubClass();

        console.log(instance.getSuperValue());//error
类式继承两大缺点：
引用类型值的误修改--原型属性中的引用类型属性会被所有实例共享-子类实例更改从父类原型继承来的引用类型共有属性会影响其他子类。
无法传递参数--由于子类的继承是靠其prototype对父类的实例化实现的，所以无法传递参数。
代码：
function Father() {
            this.base='base';
            this.books = ['1', 'js', 'php'];
        }

        function Son() {};

        Son.prototype = new Father();

        var instance1 = new Son();

        var instance2 = new Son();

        console.log(instance1.books)
        console.log(instance2.books)

        instance1.books.push("设计")
        console.log(instance2.books);
        //可以尝试修改实例属性base 查看另一个实例是否受影响
总结：如果对JS中的继承概念比较模糊，思维比较混乱，心态比较惧怕，那么推荐你沉下心来仔细看看《JavaScript高级程序设计》第6章 面向对象的程序设计。有道是“书读百遍，其义自见”，其实用不了，这章看十来遍就够够的了，就明白了，那种明白的感觉像什么呢？用烟民的感觉给你形容一下：候机3个小时，坐了6个小时，出关1个小时，到机场大厅外，点着了烟，抽的第三口那种感觉。
 再次推荐这篇文章：
李重楼：帮你彻底搞懂JS中的prototype、__proto__与constructor（图解）​zhuanlan.zhihu.com
参考资料：
《JavaScript高级程序设计（第3版）》（第6章面向对象的程序设计）
《JavaScript权威指南》（真厚啊~）

最近在看代码的时候遇到一个天坑，由于习惯性思维，可能大部分人都会掉近这个坑，所以拿出来记录一下
子类使用super调用的父类方法里，再调用父类的方法
先来看一段代码（该段代码只是作为测试用，正常编码时类名一定要规范编写）
package supertetst;

/**
 * @Author: x1aolone
 * @Date: 2019/11/8 22:11
 */

class father {
    public void invoke () {
        say();
    }

    public void say () {
        System.out.println("father say");
    }
}

class child extends father{
    @Override
    public void invoke () { 
    	super.invoke(); 
    }

    @Override
    public void say () { 
    	System.out.println("child say"); 
    }
}


public class test {
    public static void main(String[] args) {
        child c = new child();
        c.invoke();
    }
}


猜猜上面的代码运行结果是什么？

"child say"
你没有看错，答案不是想象之中的"father say"，实际上调用的是子类中的say方法。
在刚看到代码时，你可能想当然地以为代码的执行顺序是：子类invoke()  =>  父类invoke()  =>  父类invoke()
但是，通过debug断点发现，上面这段代码的执行顺序是：子类invoke()  =>  父类invoke()  =>  子类invoke()
OK，虽然上面的例子有点“毁三观”，但是你可能以为你已经明白super的使用方法了，那么再看看下面这个粒子
子类使用super调用的父类方法里，再调用父类的变量
package supertetst;

/**
 * @Author: x1aolone
 * @Date: 2019/11/8 22:11
 */

class father {
    public String a = "father";

    public void invoke () {
        System.out.println(a);
    }
}

class child extends father{

    public String a = "child";

    @Override
    public void invoke () { super.invoke(); }
}


public class test {
    public static void main(String[] args) {
        child c = new child();
        c.invoke();
    }
}


在这一段例子中，变量a是公共变量，可以由子类继承，于是父类的变量a会被子类的变量a隐藏，类似@Override
按照我们上一个例子得出的教训，子类通过super调用的父类invoke方法，在父类Invoke方法里再调用say方法，实际上调用的是子类的invoke方法，那么此时父类的invoke方法使用的变量a应该也是子类覆盖过的变量a，也就是输出"child"
很遗憾！结果是输出“father”，也就是父类自己的变量a
那么经过以上两个例子，我们可以发现：
子类通过super调用父类的invoke方法，在父类的invoke方法中，如果调用方法，则优先选择子类重写的方法，如果使用变量，则选择父类自己的变量（这里可没有优先二字）
对于不关心原理的人来说，你只需要看到这个坑，记住上面那句话，不要再想当然采坑就好了，对于喜欢问“为什么”的同学，我们下面就来聊聊它到底是为什么
成员变量的隐藏和方法重写
如果父类中存在一个可继承的变量，并且子类中存在同类型、同名的变量，那么父类的变量会被隐藏，称为成员变量的隐藏

如果父类中存在一个可继承的方法，并且子类中存在同名、同参数类型、同参数个数、同返回值的方法，那么父类的方法会被隐藏，成为方法重写
无论是变量还是方法，其实都只是被隐藏了而已，在《JAVA程序设计精编教程》中是这么说的：“如果子类想使用被隐藏的方法或成员变量，必须使用关键字super”
super关键字
在JAVA中，super关键字用来操作被隐藏的成员变量和方法，对于变量，使用方式如super.x，对于方法啊，使用方式如super.x()
到这里，JAVA的基础知识就复习得差不多了，需要注意的是，例子1和例子中在父类和子类中同时出现的变量、方法，其实只是在子类中被隐藏了而已，在访问时是需要通过super关键字才能访问的。
回到我们的例子，先看例子1，为了方便你们阅读，再贴一遍代码
package supertetst;

/**
 * @Author: x1aolone
 * @Date: 2019/11/8 22:11
 */

class father {
    public void invoke () {
        say();
    }

    public void say () {
        System.out.println("father say");
    }
}

class child extends father{
    @Override
    public void invoke () { 
    	super.invoke(); 
    }

    @Override
    public void say () { 
    	System.out.println("child say"); 
    }
}


public class test {
    public static void main(String[] args) {
        child c = new child();
        c.invoke();
    }
}


在例子1中，主函数调用child.invoke()，代码继续往下执行，super.invoke()，这个时候就要注意了，子类通过super关键字访问子类中被隐藏invoke方法，说到底还是在子类中，此时执行被隐藏的invoke()方法，内容为say()，自然就会调用子类中重写的say()，因为子类中被隐藏的say()是需要使用super才能调用的
再来看例子2，为什么变量就不会用子类的变量了呢？
package supertetst;

/**
* @Author: x1aolone
* @Date: 2019/11/8 22:11
*/

class father {
   public String a = "father";

   public void invoke () {
       System.out.println(a);
   }
}

class child extends father{

   public String a = "child";

   @Override
   public void invoke () { super.invoke(); }
}


public class test {
   public static void main(String[] args) {
       child c = new child();
       c.invoke();
   }
}


在《JAVA程序设计精编教程》中讲述成员变量的隐藏时，有这么一句话：“需要注意的是，子类对象仍然可以调用从父类继承的方法操作隐藏的成员变量”
子类隐藏掉的invoke()方法，是从父类继承的，从上面这句话可以看出，从父类继承的方法所操作的变量仍然是从父类的继承变量。
于是乎，子类调用super.invoke()来使用那个从父类中继承的、被隐藏的invoke()方法，这个方法中操作的变量仍然是从父类中继承的、被隐藏的变量，所以输出的答案是"father"
当然了，这个机制看起来跟我上面例子1提到的原理有点冲突，既然是调用隐藏的方法，访问变量就应该访问子类的变量不是？
所以个人觉得例子2出现的问题可能是个机制问题，由于面向对象编程时常常需要封装，变量设为private后子类无法继承，于是使用继承getter、setter的方法来访问父类私有变量，由于这种情况遇见得多，我们会下意识地认为父类方法调用某个方法时调用的是自己的方法，但实际上无论例子1的子类invoke()是否存在，输出都是"child"，通过子类对象调用的父类方法invoke()在实际执行时调用的是子类已经重写的say()方法，即使把子类对象上转型成父类对象以后，再调用invoke()，结果仍然是调用子类的say()，父类的say()根本不会被调用
上面这个问题可能跟jvm有关，先埋个坑，等以后了解到jvm的相关知识，再回来填

概念：一种类与类之间的关系，使用已存在的类作为基础建立新的类
被继承的叫做父类，具有类共性的私有属性和方法
继承父类的类叫子类，可以沿用父类功能，也可以增加定义自己的新功能或者新属性，但不能选择性的继承父类，一旦继承就是全部继承父类的所有开放性特征
特点：利于代码的复用，缩短开发周期，提高编码效率
子类继承父类的规则：一个类只能继承一个父类；子类只能继承父类的非私有成员；子类继承来的方法可以直接使用或者进行方法重写；子类不能访问其他子类的成员方法；父类不可以访问子类特有的成员
方法重写：有继承关系的子类中才能进行方法重写；重写方法要求方法名相同，参数列表相同（参数的顺序、个数、类型，但不限制参数名相同），方法返回值类型相同；访问修饰符可以不同（子类重写方法的访问权限范围一定要大于或等于父类被重写方法的访问权限）
方法重载：在同一个类中；方法名相同，参数列表不同（参数顺序、个数、类型），参数名相同与否无关；方法返回值、访问修饰符任意；
Object类是所有类的父类，java中的每个类都可以使用Object中定义的方法equals()和toString();
修饰符final：修饰类表示该类不允许被继承；修饰方法表示该方法不允许被子类重写（但是可以被子类继承）；修饰变量表示该变量不允许再被修改；
super关键字：可以用super访问父类中被允许被子类派生的任意成员（方法、成员属性）；语法：super.xx;可以通过super()调用父类允许被访问的构造方法，必须放在子类构造方法的第一行；注：父类的构造方法不允许被子类继承和重写，但是可以通过super调用
子类的构造过程中（new 子类对象时）会调用其父类的构造方法，如果子类的构造方法中没有写明调用父类的构造方法，则系统会默认自动调用父类的无参构造方法，若此情况下父类中没有无参构造方法，则会编译错误（推荐创建父类时手动加上无参构造方法）
继承的初始化顺序：子类对象实例化时执行顺序：父类静态代码块；子类静态代码块；父类的构造代码块；父类的无参构造；子类的构造代码块；子类的无参构造方法；注：在进行静态信息加载的时候，是以类中的成员位置为加载顺序的依据，访问修饰符不影响成员加载顺序，跟书写位置有关；