19java的封装继承多态（下）

19java的封装继承多态（下）
方法重写

注意：方法的重写是针对继承来说的，没有继承关系不叫方法的重写。
下面先给一个重写的错误写法：
```
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
- 重写只有方法的重写，没有属性的重写
为什么要重写方法？
1. 父类的方法，子类不一定需要，或者不一定满足。
重写方法的快捷键：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()方法；子类可以执行父类的方法，但是父类不能执行子类的方法。
多态的注意事项：
1. 多态是方法的多态，没有属性的多态
2. 父类和子类的强制类型转换必须合法，eg：不能把Student转成String。类型转换异常：ClassCastException！
3. 存在条件：有继承关系，方法需要重写，父类引用指向子类对象 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);//编译错误
}
}
```
分析：
1. 第一部分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
2. 第二部分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类（父类），就是低优先级（子类）转高优先级（父类），可以直接转换。
- 关于什么时候需要强制转换，什么时候可以在直接转换的记忆方法，我觉得可以这样记忆：使用老鼠进洞来记忆。高优先级是大老鼠，低优先级是小老鼠，大老鼠要进小老鼠的洞进不去，那就强制塞进去；而小老鼠进大老鼠的洞可以直接进去。
类的类型转换的意义：方便方法的调用，减少重复的代码。
自学java，请多多指教！
相关阅读:
Streams那些事之概述与原理
 ORA12514: ORACLE 监听错误
 使用软件工具插件备忘
 jquery 弹出遮罩插件 prettyPhoto 参数说明
 SQL 9位随机码
 向上下左右不间断无缝滚动的效果(兼容火狐和IE)[转]
SQL 将一串字符串转换为列插入临时表
 jQuery插件开发全解析[转]
DIV+CSS命名规范
 ASP.NET中Session跨站点共享实现方式
原文地址：https://www.cnblogs.com/fanfada/p/13774003.html

19java的封装继承多态（下）

方法重写

多态

instanceof关键字

强制类型转换（类）