java学习笔记 --- 多态

一、多态

　（1）定义：同一个对象在不同时刻体现出来的不同状态。父类的引用或者接口的引用指向了自己的子类对象。　　　

　　　　  Dog d = new Dog();//Dog对象的类型是Dog类型。

      　　  Animal a = new Dog();//Dog对象的类型右边是Dog类型，左边Animal类型。

　（2）多态的前提：
  　　　　　　A:有继承或者实现关系。
  　　　　　　B:有方法重写。
  　　　　　　C:有父类或者父接口引用指向子类对象。
  
  　　　　多态的分类：
   　　　　　　a:具体类多态
   　　　　　　　　 class Fu {}
   　　　　　　　　 class Zi extends Fu {}
    
   　　　　　　　　 Fu f = new Zi();
  　　　　　　 b:抽象类多态
    　　　　　　　　abstract class Fu {}
    　　　　　　　　class Zi extends Fu {}
    
    　　　　　　　　Fu f = new Zi();
  　　　　　　 c:接口多态
   　　　　　　　　 interface Fu {}
    　　　　　　　　class Zi implements Fu {}
    
   　　　　　　　　 Fu f = new Zi();

  （3)多态的好处：
  　　　　A:提高代码的维护性(继承体现)
  　　　　B:提高代码的扩展性(多态体现)

　 (4)多态的弊端

　　　　通过父类引用操作子类对象时，只能使用父类中已有的方法，不能操作子类特有的方法。

　　　　现象：
   　　　　　　子可以当作父使用，父不能当作子使用。

  （5）多态中的成员访问特点
  　　　　A:成员变量
  　　　　　　 编译看左边，运行看左边
 　　　　 B:构造方法
   　　　　　　子类的构造都会默认访问父类构造
 　　　　 C:成员方法
   　　　　　　编译看左边，运行看右边
 　　　　 D:静态方法
   　　　　　　编译看左边，运行看左边

class Fu {
    public int num = 100;

    public void show() {
        System.out.println("show Fu");
    }
    
    public static void function() {
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    public void show() {
        System.out.println("show Zi");
    }
    
    public void method() {
        System.out.println("method zi");
    }
    
    public static void function() {
        System.out.println("function Zi");
    }
}

class DuoTaiDemo {
    public static void main(String[] args) {
        //要有父类引用指向子类对象。(向上转型）
        //父 f =  new 子();
        Fu f = new Zi();
        //调用成员变量时，编译时看父类，父类有才能通过编译，运行时也看父类的，因为我们看到的是“父亲”
            
         System.out.println(f.num);
        
         //System.out.println(f.num2);编译错误，找不到符号（父亲没有这个变量）
        
         //调用成员方法时，编译时看父亲，只有父亲有，我们才能用，运行时看子类（右边），因为我们本质还是“孩子”，不是“父亲”
        　f.show();
         //f.method();编译错误找不到符号(父亲没有这个方法）
　　　　　//调用静态方法时，编译看父类，运行也看父类，因为静态和类相关，算不上重写，所以，访问还是左边的
          f.function();
    }
}

（6）多态转型问题：
  　　　　向上转型：
  　　　　　　 Fu f = new Zi();
  　　　　向下转型：
  　　　　　　 Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。