方法重写
注意：方法的重写是针对继承来说的，没有继承关系不叫方法的重写。
下面先给一个重写的错误写法：
package oop.OopDemo; import oop.OopDemo.Demo02_extends.Person; import oop.OopDemo.Demo02_extends.Student; public class Application { public static void main(String[] args) { Student student = new Student(); student.print(); Person person = new Student();//父类的引用（对象）指向子类 person.print(); } }package oop.OopDemo.Demo02_extends; public class Student extends Person { public Student() { System.out.println("Student is running!"); } public static void print() { System.out.println("I'm Student class!"); } }package oop.OopDemo.Demo02_extends; public class Person { public Person() {//无参构造器 System.out.println("Person is running!"); } public static void print() { System.out.println("I'm Person class!"); } }运行结果:
观察以上的运行结果，首先是运行了Student类的无参构造器，因为首先new了一个Student类的对象，这是正常的，然后调用子类的方法print()，然后又使用父类Person实例化一个子类Student的对象person，运行的也是Student类的无参构造器，这个也能理解，new的谁就调用谁的无参构造器。使用person这个对象调用print()方法，发现调用的是父类的print()方法，记住这个现象，等下作对比。
现在我们把子类和父类的print()方法的修饰符static都去掉，发现两个print()方法前面都出现了这个图标，而且点击还能相互跳转，此时才是真正的方法的重写，如下图：
运行结果：
分析以上结果发现：对于继承关系下的方法的重写，静态方法和非静态方法的区别很大！（不要随便用Static修饰符），非静态方法才是方法的重写。重写之后，不管是使用Student还是使用Person对Student进行初始化，使用初始化对象调用重写的方法，调用的都是子类的方法。子类重写父类的方法，就执行子类的方法，子类如果没有重写父类的方法，就调用父类的方法。
注意：经测试，重写的方法名（修饰符）必须相同，并不能扩大（留作以后再考究）
总结：重写必须有继承关系，子类重写父类的方法！（父类的引用（对象)指向子类）
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但是不能缩小。范围大小排序：public > protected > default > private
- 抛出的异常：范围可以缩小但是不能扩大。Exception > ClassNotFoundException
- 重写只有方法的重写，没有属性的重写
为什么要重写方法？
- 父类的方法，子类不一定需要，或者不一定满足。
重写方法的快捷键：Alt+Insert 选择Override Methods...（只能把光标放在子类中才能正确生成重写方法）
多态
动态编译，引用类型（对象）的可扩展性，继承关系下，方法可能重写也可能不重写，如果父类和子类拥有相同的方法（被子类重写），不管是直接使用子类进行实例化，还是使用父类的引用类型指向子类进行实例化，其对象调用被重写的方法都是执行子类的方法，如果是父类特有或子类特有，那么分别执行自己的方法，程序在运行之前（程序）不知道执行的过程，但是作为开发者肯定要知道运行过程。
关于这里的多态，我觉得理解继承和方法的重写，多态就差不多理解了 ，下面还是用程序说明一下吧：
package oop.OopDemo; import oop.OopDemo.Polymorphic.Person; import oop.OopDemo.Polymorphic.Student; import oop.OopDemo.Polymorphic.Teacher; public class Application { public static void main(String[] args) { Person person = new Person(); animalShout(person); Person person1 = new Student(); animalShout(person1); Student student = new Student(); animalShout(student); Teacher teacher = new Teacher(); animalShout(teacher); } public static void animalShout(Person person) { person.speech(); } }package oop.OopDemo.Polymorphic; public class Person { public String name; public Person() {//无参构造器 } public void speech() { System.out.println("Person is speeching!"); } }package oop.OopDemo.Polymorphic; public class Student extends Person { public Student() { } //多态 public void speech() { System.out.println("Student is speeching!"); } }package oop.OopDemo.Polymorphic; public class Teacher extends Person{ //多态 public void speech() { System.out.println("Teacher is speeching!"); } }输出结果：
Person person = new Student();这句话是父类的引用类型指向子类，这个对象person还是属于Person类，对象能执行的方法主要看左边的类型，跟右边的类型关系不大（不是没有关系）。
我们看到子类重写了父类的方法，然后使用对象student和person调用被重写的方法run()，执行的是子类的run()方法；子类可以执行父类的方法，但是父类不能执行子类的方法。
多态的注意事项：
- 多态是方法的多态，没有属性的多态
- 父类和子类的强制类型转换必须合法，eg：不能把Student转成String。类型转换异常：ClassCastException！
- 存在条件：有继承关系，方法需要重写，父类引用指向子类对象 Father person = new Son();
不能被重写的方法：
- static方法，属于类，不属于实例，不能被重写；
- 被final 修饰的方法不能被重写，在常量池里面，不能被更改；
- 被private修饰的方法是私有的，不能被重写。
instanceof关键字
判断两个类之间有没有父子关系
直接用代码解释：
package oop.OopDemo; import oop.OopDemo.Polymorphic.Person; import oop.OopDemo.Polymorphic.Student; import oop.OopDemo.Polymorphic.Teacher; public class Application { public static void main(String[] args) { // Object > Person > Student // Object > Person > Teacher // Object > String Object object = new Student(); System.out.println(object instanceof Student);//true只要有长辈关系都算true System.out.println(object instanceof Person);//true System.out.println(object instanceof Object);//true System.out.println(object instanceof Teacher);//false Teacher类和Student类属于兄弟关系，false System.out.println(object instanceof String);//false 关系更远，false System.out.println("=================="); Person person = new Student(); System.out.println(person instanceof Student);//true只要有长辈关系都算true System.out.println(person instanceof Person);//true System.out.println(person instanceof Object);//true System.out.println(person instanceof Teacher);//false // System.out.println(person instanceof String);//编译错误 System.out.println("=================="); Person person1 = new Person(); System.out.println(person1 instanceof Student);//false System.out.println(person1 instanceof Teacher);//false System.out.println(person1 instanceof Person);//true System.out.println(person1 instanceof Object);//true System.out.println("=================="); Student student = new Student(); System.out.println(student instanceof Student);//true只要有长辈关系都算true System.out.println(student instanceof Person);//true System.out.println(student instanceof Object);//true // System.out.println(student instanceof Teacher);//编译错误 // System.out.println(student instanceof String);//编译错误 } }分析：
第一部分Object object = new Student();，使用父类Object的引用指向子类Student，也就是说object是指向Student类的，关键字instanceof是判断有没有长辈关系（包括父子和祖孙），如：
- object instanceof Student： object 是指向Student类的，自己跟自己肯定是true
- object instanceof Person： object 是指向Student类的，Student类是Person类的子类，true
- object instanceof Object： object 是指向Student类的，Student类是Object类的子类，true
- object instanceof Teacher： object 是指向Student类的，Student类与Teacher类没有长辈（父子）关系，是兄弟关系，false
- object instanceof String： object 是指向Student类的，与String类没有关系，false
第二部分Person person1 = new Person();，实例化一个Person对象，
- person1 instanceof Student：person1 指向Person类，Person类是Student类的父类，false
- person1 instanceof Student：person1 指向Person类，Person类是Teacher类的父类，false
- person1 instanceof Person: person1 指向Person类，自己跟自己肯定是true
- person1 instanceof Object：person1 指向Person类，Person类是Object类的父类，true
至此，应该理清思路了
- 在进行实例化的时候，不管是直接实例化一个类的对象，还是使用父类的引用类型指向子类进行实例化，都要抓住一个关键点：对象是指向哪个类，就用哪个类参与instanceof的判断
- 使用关键字instanceof进行判断时，格式上必须要求对象在作，类在右，否则会报错
- 对于上面出现的一些编译错误，我还不清楚是什么原因。
强制类型转换（类）
类的强制类型转换跟基本数据类型的强制类型转换的原则是相同的，都是高转低，需强制；低转高，可直接。
下面直接看程序实例：
package oop.OopDemo; import oop.OopDemo.Polymorphic.Person; import oop.OopDemo.Polymorphic.Student; public class Application { public static void main(String[] args) { //父类与子类之间的类型转换 父转子 Person student = new Student();//student的类型是Person类型，student是指向Student类的 ((Student) student).run();//父转子：高转低，需强制类型转换（老鼠进洞） Student student1=(Student)student; student1.run(); //子转父 Student student2 = new Student(); Person person=student2;//子转父：低转高，可直接转换，不用强制类型 person.sleep(); // person.run();//丢失了父类本来的方法，不能使用父类run() ((Person)student2).sleep(); } }package oop.OopDemo.Polymorphic; public class Person { public void sleep() { System.out.println("Person is sleeping!"); } }package oop.OopDemo.Polymorphic; public class Student extends Person { public void run() { System.out.println("Student is running!"); } }运行结果：
总结：
- 需要注意的是：语句Person student = new Student(); 对象student的类型是Person类型，student是指向Student类的。对象student的类型是父类Person，现在想调用子类的run()方法，注意这是高优先级（父类）转低优先级（子类），需要强制类型转换，代码中给了两种方式均是可行的；
- 语句Student student2 = new Student();实例化了一个类型为Student 的对象student2 ，但是此时我想用Student类（子类） 的对象student2调用父类Person的sleep()方法，就需要把对象student2的类型从Student类（子类）转换成Person类（父类），就是低优先级（子类）转高优先级（父类），可以直接转换。
- 关于什么时候需要强制转换，什么时候可以在直接转换的记忆方法，我觉得可以这样记忆：使用老鼠进洞来记忆。高优先级是大老鼠，低优先级是小老鼠，大老鼠要进小老鼠的洞进不去，那就强制塞进去；而小老鼠进大老鼠的洞可以直接进去。
类的类型转换的意义：方便方法的调用，减少重复的代码。