java面向对象----多态

多态

多态是指一种行为具有多种表现形式；

多态就是同一个接口，使用不同的实例而执行不同操作；

比如一台打印机它的行为是打印，但是打印可以有多种表现形式，可以打印黑白的，也可以打印彩色的。

多态的优点

• 1. 消除类型之间的耦合关系
• 2. 可替换性
• 3. 可扩充性
• 4. 接口性
• 5. 灵活性
• 6. 简化性

多态实现方式

1.重写和重载

重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。 这种多态通过函数的重写以及向上转型来实现。

重载式多态，也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道，方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。（但是这里是有歧义的，有的人觉得不应该把重载也算作多态。我的理解是：同一个行为具有多个不同表现形式或形态的能力就是多态，所以我认为重载也是一种多态。）

2.接口

接口的存在是为了形成一种规约。接口中不能有普通成员变量，也不能具有非纯虚函数。

C++ 中接口其实就是全虚基类。

Java 中接口是用 interface 修饰的类。

PS: 接口就是虚到极点的抽象类。

3.抽象类和抽象方法

抽象类的存在是因为父类中既包括子类共性函数的具体定义，也包括需要子类各自实现的函数接口。抽象类中可以有数据成员和非抽象方法。

C++ 中抽象类只需要包括纯虚函数，既是一个抽象类。如果仅仅包括虚函数，不能定义为抽象类，因为类中其实没有抽象的概念。

Java 抽象类是用 abstract 修饰声明的类。

PS: 抽象类其实是一个半虚半实的东西，可以全部为虚，这时候变成接口。

class Animal{
    public int age;      //此处在Animal中定义类型为int，名为age的变量。
    public void move(){
        System.out.println("动物总是不安分");
    }
}
     
class Dog extends Animal{
    public double age;    //此处在Dog中定义新类型double,名为age的变量。当然int尝试也可以。 
    public void move(){
        age =10;
        System.out.println("狗跑的很快");
    }
}
class Cat extends Animal{
    public void move(){
        super.age = 3;   //此处继承age，并赋值为3.且该类中未重新定义变量。
        System.out.println("猫跳的很高");
    }
}     
public class DuiXiang03{
    public static void main(String args[]){
        Animal a = new Animal(); // Animal 对象
        Animal b = new Dog(); // Dog 对象
        Animal c =new Cat(); //Cat 对象
        Dog  d= new Dog();
        Cat  e= new Cat();

        a.move();//执行 Animal 类的方法
        b.move();//执行 Dog 类的方法
        c.move();//执行 Cat 类的方法
        d.move();//执行Dog 类的方法
        e.move();//执行 Cat 类的方法
        Object aValue = a.age;
        Object bValue = b.age;      // b.age有两个age值，一个是自定义的age值，一个是继承的age值
        Object cValue = c.age;     
        Object dValue = d.age;      // d.age有两个age值，一个是自定义的age值，一个是继承的age值
        Object eValue =e.age;
        System.out.println("The type of "+a.age+" is "+(aValue instanceof Double ? "double" : (aValue instanceof Integer ? "int" : "")));     // Animal 类中的 age 未被赋值
        System.out.println("The type of "+b.age+" is "+(bValue instanceof Double ? "double" : (bValue instanceof Integer ? "int" : "")));     // b.age有两个age值，输出取引用名为Animal的int类型值
        System.out.println("The type of "+c.age+" is "+(cValue instanceof Double ? "double" : (cValue instanceof Integer ? "int" : "")));     // c.age只有一个age值，是super所继承的Animal中的age值，再被赋值为3
        System.out.println("The type of "+d.age+" is "+(dValue instanceof Double ? "double" : (dValue instanceof Integer ? "int" : "")));     // d.age有两个age值，输出取引用名为Dog的double类型值
        System.out.println("The type of "+e.age+" is "+(eValue instanceof Double ? "double" : (eValue instanceof Integer ? "int" : "")));     // c.age只有一个age值，是super所继承的Animal中的age值，再被赋值为3
    }
}

 

动物总是不安分
狗跑的很快
猫跳的很高
狗跑的很快
猫跳的很高
The type of 0 is int
The type of 0 is int
The type of 3 is int
The type of 10.0 is double
The type of 3 is int

Java虚函数，抽象函数

虚函数

虚函数的存在是为了多态。

C++ 中普通成员函数加上 virtual 关键字就成为虚函数。

Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是 Java 的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

PS: 其实 C++ 和 Java 在虚函数的观点大同小异，异曲同工罢了。

抽象函数

抽象函数也称纯虚函数。存在是为了定义接口

c++纯虚函数
virtual void print();
java纯虚函数：
abstract void print();

C++ 虚函数    ==  Java 普通函数

C++ 纯虚函数  ==  Java 抽象函数

C++ 抽象类    ==  Java 抽象类

C++ 虚基类    ==  Java 接口