java学习笔记10（多态）

多态：

　　举例：描述一个事物的多种形态，如Student类继承了person类，一个Student对象既是Student，又是person

　　多态体现为：父类引用变量可以指向子类对象

 　　多态的前提：必须有父子类关系 或者类实现接口关系，否则无法完成多态

　　在使用多态后的父类 引用变量来调用方法时， 会调用子类重写后的方法

 

　　举例：

public class Fu{
　　public void show(){
　　　　System.out.println("父类的show方法");
　　}
}

public class Zi extends Fu{
    public static int num=777;
    public void show(){
        System.out.println("子类重写父类的show方法");
    }
}

public class Test{
      
      public static void main(String[] args){
            //利用多态性
    
           //公式： 父类类型   变量= new  子类的对象
           Fu   f=new  Zi();
           f.show();
      }
}
//输出：子类重写父类的show方法        

抽象类多态

public abstract class Fu {
    public abstract void method();
}

public class Zi extends Fu{
    public void method() {
        System.out.println("我是子类");
        
    }
    
}

public class Test {
    public static void main(String[] args) {
        Fu f=new Zi();
        //抽象类多态定义格式；
        //抽象类 变量名 = new 抽象类子类();
        f.method();
    }
}

接口多态

public interface Fu {
    public abstract void method();
}

public class Zi implements Fu{
    public void method() {
        System.out.println("我重写了接口中的method方法");
        
    }
    
}

public class Test {
    public static void main(String[] args){
        Fu f=new Zi();
        f.method();
    }
}

多态中成员方法的特点

public class Fu{
    int a = 1;
}

public class Zi  extends Fu{
        int a= 2;
}

public class Test{

    public static void main(String[] args){

         Fu  f= new  Zi();
           System.out.println(f.a);
    }
}
// 输出：1

成员变量：

　　编译的时候，参考父类中有没有这个变量，如果有，编译成功，如果没有，编译失败

　　运行的时候，运行的是父类的变量值

　　总结： 编译运行全看父类

成员方法：

　　父类中没有声明或者定义的方法无法调用，

　　子类如果重写，调用的是子类方法，子类没有重写，调用父类的方法

　　总结：编译看父类，运行看子类

多态转型：

　　　　向上转型：

　　　　　　java是一种强制数据类型语言，参与运算的数据，需要保证类型的统一

　　　　　　如 person p = new Student();

　　　　　　l两个数据类型是不同的，但是成功运行

　　　　　　优点：  可以调用子类和父类的共有内容

　　　　　　缺点：  无法调用子类特有的内容

　　　　如果想调用子类的特有内容

　　　　向下转型：（类似以前的强制转型）

　　　　Student   s = (Student)p；

　　　　由父类类型强制转回子类的类型

　　　　　　好处：可以调用子类特有的功能

public abstract class Animals {
    public abstract void eat();
}

public class Cat extends Animals{
    public void eat(){
        System.out.println("猫在吃");
    }
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }
}

public class Dog extends Animals{
    public void eat(){
        System.out.println("狗再吃");
    }
    public void lookhome(){
        System.out.println("狗看家");
    }
}

public abstract class Test {
    public static void main(String[] args) {
        Animals  a1=new Cat();
        Animals  a2=new Dog();
        a1.eat();
        a2.eat();
        //向下转型，调用子类特有的方法
        //使用if instanceof  为了确保安全性
        if(a1 instanceof Cat){
            Cat c=(Cat)a1;
            c.catchMouse();
        }
        if (a2 instanceof Dog) {
            Dog d= (Dog)a2;
            d.lookhome();
        }
    }
}