第八天

面向对象编程有三大特性：封装、继承、多态。有的资料上对面向对象的编程说成4个基本特征：抽象，封装、继承、多态。

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

继承是为了重用父类代码。两个类若存在通常"D is a B"（D被包含在B内）的关系就可以使用继承。同时继承也为实现多态做了铺垫。那么什么是多态呢？多态的实现机制又是什么？

1、什么是多态

说多态前我们首先要知道Java的引用类型变量有两种更细类型：一个是编译时类型，一个是运行时类型。

编译时类型由声明这个变量的时候决定的，比如 String a="你好";

运行时类型则是由实际赋值给这个变量的对象来决定的。Integer b=1; String a = b;

如果编译时类型和运行时类型不一致的时候，就可能出现所谓的多态！子类类型的对象赋值给父类类型的引用变量！

 

比如一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。酒神一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：

      酒 a = 剑南春 // 这个时候就发生了java里边说的：多态

      酒 b = 五粮液

      酒 c = 酒鬼酒

说一句话：剑南春是白酒， 白酒做成父类，剑南春是白酒的子类，java语言！

上面的例子中酒是一个类， 剑南春也是一个类， 酒类包含了剑南春这个子类，我们把子类的对象赋值给父类类型的引用变量叫做子类的向上转型。

用代码来表示：

public class Wine { 
    public void fun1() {
        System.out.println("这是Wine类的fun1方法，无参数的这个fun1方法");
        fun2();
    }
    public void fun2() {
        System.out.println("这是Wine类的fun2方法");
    }
}

public class JNC extends Wine{
//    public void fun1() {
//        System.out.println("这是Wine类的fun1方法，无参数的这个fun1方法");
//        fun2();
//    }
//    public void fun2() {
//        System.out.println("这是Wine类的fun2方法");
//    }
    //方法的重载，方法名一样，参数列表不一样，互相称对方使自己的方法的重载
    public void fun1(String a) {  //这个方法fun1（String a）是对父类中的fun1方法进行了重载
        System.out.println("JNC");
        fun2();
    }
/**
*子类重写父类方法
*指向子类的父类引用调用fun2时，必定是调用该方法
*/
    //在父类中有fun2方法，在子类中，写一个完全一样的方法，方法名和参数列表都一样
    public void fun2() { //这个时候，我们叫子类中对父类中的方法进行 重写，覆盖现象
        System.out.println("这是JNC类里的fun2方法");     
    }
}

public class TestMain {
  public static void main(String[] args) {
     Wine a = new Wine(); //左边是编译时类型：Wine，右边是：new Wine()类型：Wine
     //编译时类型和运行时类型是一致的，这种情况下，没有多态这个概念
     Wine b = new JNC();//java语言的语法是允许的，首先这种情况下，编译时类型和运行时类型就不一致
     //这个时候就是多态，将这种赋值，我们叫子类JNC 对象的向上转型
     b.fun1(); //对于这个调用，我们必须搞清楚问题，
     //1、 b.fun1（）调用的是哪个方法
     //2、 b这个引用变量，能不能调用有参数的这个fun1（String a）的方法
     //3、 b引用变量调用的fun1方法里边，又调用了fun2这个方法，必须搞清楚，调用的是哪个fun2方法
     //输出结果如下
     //这是Wine类的fun1方法，无参数的这个fun1方法
     //这是JNC类里的fun2方法
  }
}

从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。

分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是同一个方法，

父类中没有含参数的fun1方法，向上转型后会丢失子类里的特有方法，所以用JNC这个类的对象的Wine类型引用是不能引用有参数的fun1(String a)方法。

而子类JNC重写了fun2() ，那么指向JNC的Wine引用会优先调用JNC中fun2()方法。

 

所以对于多态我们可以总结如下：

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。

若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法，他们优先级高于父类中的方法。

 

 

2、多态的实现机制

基于继承(包括我们后面要讲的接口，对接口的实现我们也可以理解为一种特殊的继承)的多态实现机制主要表现在父类和继承该父类的

一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。多态：多种形态，就是多态性!（用代码是说明一下！）

 

public class Animals {
    public void eat() {   //动物这个类，都有吃这个动作行为
        
    }
}

public class Dog extends Animals {
    
    //对父类里的方法，重写，重写的方法，会覆盖父类里的同名，参数列表的方法
    public void eat() {
        System.out.println("狗狗吃东西是用舔的！");
    }
}

public class Bird extends Animals{
    
    //在鸟这个子类里也可以重写父类里的eat方法
    public void eat() {
        System.out.println("鸟吃东西是用啄");
    }
}

public class Test {
      public static void main(String[] args) {
        //Java语法中，允许把子类的对象，赋值给父类类型的引用变量
          Animals a;//定义了一个Animals类型的变量
          a=new Dog();//Dog是Animals类的子类
          a.eat(); //输出狗狗吃东西是用舔的！
          Animals b=new Bird();
          b.eat();//输出鸟吃东西是用啄
    }
}

有关多态的经典例子：

public class A {
    public String show(A a) {
        return "A AND A";
    }
    
    public String show(D d) {
        return "A AND D";
    }
}

public class B extends A{
   public String show(B b) {
    return "B AND B";
   }
   public String show(A a) {
    return "B AND A";
   }
}

public class C extends B{

}

public class D extends B{

}

public class Test {
      public static void main(String[] args) {
          A a1 = new A();
          A a2 = new B();
          B b = new B();
          C c = new C();
          D d = new D();
          //能不能搞清楚这个9个show方法的调用，分别是属于那个类的show方法
          System.out.println("1--" + a1.show(b)); //输出1--A AND A
          System.out.println("2--" + a1.show(c)); //输出2--A AND A
          System.out.println("3--" + a1.show(d)); //输出3--A AND D
          System.out.println("4--" + a2.show(b)); //输出4--B AND A
          System.out.println("5--" + a2.show(c)); //输出5--B AND A
          System.out.println("6--" + a2.show(d)); //输出6--A AND D
          System.out.println("7--" + b.show(b));  //输出7--B AND B
          System.out.println("8--" + b.show(c));  //输出8--B AND B
          System.out.println("9--" + b.show(d));  //输出9--A AND D
    }
}

在这里看结果1、2、3还好理解，从4开始就开始糊涂了，对于4来说为什么输出不是“B and B”呢？

 

其实在继承链中对象方法的调用存在优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

 

首先我们分析5，a2.show(c)，a2是A类型的引用变量，所以this就代表了A，a2.show(c),它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。

 

当超类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，

在看一个例子说明：a2.show(b)；

     

这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说由B来决定调用谁的方法,

所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？

这里我们忽略了后面那句话“但是这儿被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！

所以这句话在这里不适用？那么难道是这句话错误了？非也！

其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。

所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。