Java多态特性以及抽象类

目录

多态：

多态是什么：

多态怎么用：

多态的instanceof关键字和多态转型：

多态是什么：

多态理解：

• 字面意思：多种形态，一个事物可以有多个形态，比如dog，一个具体的dog（哈巴狗），它是dog也是动物。哈巴狗同时出现两种形态    ，同一个行为具有不同表现形式或形态的能力

• 具体Java语言层面：可以分为方法层面的多态和面向对象层面的多态，面向对象层面的多态：小明同学既是学生类的实例化，同时也是属于学生类的父类----人类，把学生类的对象赋给父类类型即：

  Person xiaoming=new Student();//子类的对象，使用父类的类型
  

  方法层面上的多态：就是方法重写，子类继承父类的方法，重写父类的方法，多个子类有同名的不同执行效果的方法。

• 封装，继承，多态是Java三大特性

多态怎么用：

使用多态的前提：必须存在继承关系。方法重写

方法的多态：

方法的多态主要体现在子类继承父类，子类对父类的方法重写，多个子类重写父类的方法，不同子类的同名方法具有不同执行效果，形成方法的多态

比如：

public class Zongbu {
    String name;
    String area;
    String jiang;
    //自我介绍方法
    //子类继承父类的介绍方法
   
    public void judge(Zongbu z){
        //通过子类重写父类的方法
        z.giveLesson();
    }
    public void giveLesson() {
    }

}
 class Jiaojava extends Zongbu{

    //把父类的方法重写
    public void giveLesson(){
        System.out.println("这是第一个子类的成员方法");
    }
    //构造方法
    public Jiaojava(String name,String area,String jiang){
        this.area=area;
        this.name=name;
        this.jiang=jiang;
    }

}

 class Jiaonet extends Zongbu {

    //把父类的方法重写
    public void giveLesson(){
        System.out.println("第二个子类的成员方法");
    }
    //构造方法
    public Jiaonet(String name,String area,String jiang){
        this.area=area;
        this.name=name;
        this.jiang=jiang;
    }
}

方法的多态的好处是：可以实例化子类的对象调用相同的方法。，但有一个问题就是不同的子类具有相同的方法，但是调用者不确定哪个对象调用。对于这个问题就需要用到对象层面的多态解决了。

对象多态：

语法：

Person xiaoming=new Student();
父类类型 变量名=new 子类类型（）；

此时的成员方法在编译时候要看左边 ，运行时要看右边；

 Tset6 zi = new zi();
        System.out.println(zi.num);
        zi.shwo();//表面类型时父类的，实际类型是子类的，调用的时候是子类的方法

 成员变量编译还是运行都是看左边：

public class Test5 {
    public static void main(String[] args) {
        Tset6 zi = new zi();
        System.out.println(zi.num);//类型时父类的，调用的父类属性
        zi.shwo();

    }
}
class Tset6{
    int age;
    int num=1000;
    public void shwo(){
        System.out.println("父类的方法");
    }
}
class zi extends Tset6{
    int id;
    int num=100;
    public void shwo(){
        System.out.println("这是子类的方法");
    }
}

  

多态的instanceof关键字和多态转型：

转型分为向上转型和向下转型。向上转型就是子类向父类转型（自动转换）的过程，父类引用指向子类对象。

可以画一幅图解释一下为什么可以自动转换：

在这幅图中student，teacher都是person的子类，person父类包含这两个子类，小范围的可以自动转换到大范围的，就像我们数据类型转换的一样。int类型可以自动转换为long类型的数据类型。

向下转换就是父类转换为子类，这是一个强制转换的过程。因为父类要转换为子类时，不知道要转换为哪一个子类，所以这个时候就需要强制转为对应的子类类型。

代码举例：

public class Test5 {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();
        a.eat();               

        // 向下转型  
        Dog d = (Dog)a;//a是父类的类型
    }
}

转型异常：

我们这段代码

public class Test5 {
    public static void main(String[] args) {

        // 向上转型的过程
        Animal animal = new Cat();

 
        // 向下转型
        Dog dog = (Dog) animal;

结果： 

 可以从输出来看，编译通过了但是还是报错。这是因为我创建了一个cat类的对象但是把它强转为dog类的，所以会报错。

但是我们如何避免这种情况呢？

使用instanceof关键字：避免类型转换异常，判断该类型是否属于该类型或者子类类型，如果是，我们就可以强转

语法：

变量名 instanceof 数据类型

 返回的是布尔类型的数据，当为真时返回ture

代码：

向下转型
        if (animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.show();
        } else if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.show();