自学JAVA-多态(oop编程)

多态顾名思义指的是多种状态，方法和对象具有多种形态。是面对对象编程的三大特征之一，多态建立在封装和继承的基础上进行的。当我们有很多类，方法很多时，我们多态可以有效地减少代码量。多态的具体体现分为两种方法的多态和对象的多态。

方法的多态

方法的多态体现在方法的重载和方法的重写

class A{
    public int aa(int num1,int num2){
        return num1+num2;
        
    }
    public int aa(int num1,int num2,int num3){
        return num1*num2*num3;
    }
}
public class overRide {
    public static void main(String[] args) {
        A a=new A();
        a.aa(11,22);
        a.aa(11,44,55);
    }
}

这里是一个方法重载，两个方法不同参数，调用了不同的方法，这是一种不同的形态，体现了方法的多态。方法的重写也体现了对象的多态和重载类似。

对象的多态

对象的多态有几句知识点：

1.一个对象的编译类型和运行类型可以不一致。

这句话从一个例子解读

Animal animal=new dog();

Animal是dog的父类，animal是对象的引用，而=号右边的才是真正的对象，我们用父类anima对象引用l指向子类，Animal是编译类型，运行类型是new 出来的dog，所以左边和右边可以不一致。也可以一致。

2.编译类型在定义对象时就确定了，不能改变。

3.运行类型是可以变化的

Animal animal=new cat();

此时运行类型是cat(更改)，编译类型任然是Animal

4.编译类型在=的左边，运行类型在右边

为了更好的体现编译类型和运行类型的效果，我写一个例子

有一个Animal类，一个Dog类，一个Cat类。

Animal中有一个方法

class Animal{
    public void animal(){
        System.out.println("父类中的animal被调用");
    }
}

让dog，cat类继承Animal类各自写一个方法

public class overRide {
    public static void main(String[] args) {
        Animal animal=new Dog();
        animal.animal();//这里指向的是dog类的对象，运行到该行时，animal运行类型是dog
    }
}
class Animal{
    public void animal(){
        System.out.println("父类中的animal被调用");
    }
}
class Cat extends Animal{
    public void animal(){
        System.out.println("小猫是动物");
    }
}
class Dog extends Animal {
    public void animal(){
        System.out.println("小狗是动物");
    }
}

运行结果为dog的方法

多态的向上转型是指父类指向了子类的对象

语法规则：父类类型 父类引用名=new 子类类型（）；

例：Animal animal=new dog();

这么写可以用父类的一个引用指向所有的子类对象，用父类统一管理。

向上转型的特点是：编译类型看左边，运行类型看右边。

可以调用父类中所有的成员（属性和方法）（需遵守访问权限）

不能调用子类的特有方法

这句话的解释指最终运行结果是由运行类型决定的

public class animal {//父类animal有一个方法eat
    public void eat() {
        System.out.println("动物吃食");
    }
}

public class cat extends animal{//子类cat重写了方法eat
    public void eat(){
        System.out.println("小猫吃猫粮");

    }
}

public class Animal {
    public static void main(String[] args) {
        animal animal=new cat();
        animal.eat();//请问这里的animal调用的是父类的eat方法还是我们子类的eat方法
        //这里animal是父类引用指向子类的对象，实际的运行类型是cat,
        // 那么这里调用方法是子类重写的方法，这就是最终运行结果看子类的具体实现
    }
}

向下转型

在上面 向上转型中我们只能访问父类的重写方法，不能访问到子类的特有方法。为了访问到子类的特有方法，我们可以使用向下转型。

语法：子类类型 子类名 =（子类类型）父类引用

例：

Cat cat =(Cat)animal;

向下转型有以下注意事项：

1.只能强转父类的引用，不能强转父类的对象

2.要求父类的引用指向的是当前目标类型的对象

我父类的指向是子类的运行类型，不能是其他的对象。

3.可以访问到子类的所有成员。

那么在我们需要访问属性的时候，看的是不是运行类型呢？

需要注意的是，属性不能被重写，访问属性看的是编译类型而非运行类型。

Animal animal=new cat();
animal.name;//这里调用的属性是animal的属性

instanceof比较操作符，用于判断运行类型是不是xx的类型或xx类型的子类型。可以和向下转型结合，调用子类特有的方法。