Java个人学习笔记--多态

1. java中的多态
a. 引用的多态
--父类的引用可以指向本类对象，如：Animal obj1 = new Animal();
--父类的引用可以指向子类对象，如：Animal obj2 = new Dog();
注意，子类引用不能指向父类对象，如：Dog obj3 = new Animal();是错误的。
b. 方法的多态
--父类引用指向父类对象时，可调用父类中的方法；
--父类引用指向子类对象时，可调用的是子类中重写的方法，或者继承的父类方法。
--注意：父类引用不能调用子类独有的方法。父类引用指向子类对象，也是不能调用子类独有的方法的。

例子：
父类Animal：

public class Animal {
    public void eat(){
        System.out.println("动物能吃东西");
    }

}

子类Dog：

package com.duotai;

public class Dog extends Animal {
    // 子类中重写eat（）方法
    public void eat(){
        System.out.println("够能吃骨头和肉");
    }
    public void watchDoor(){
        System.out.println("狗具有看门的能力");
    }

}

子类Cat：

package com.duotai;

public class Cat extends Animal {

}

测试类Test：

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal obj1 = new Animal();
        Animal obj2 = new Dog();//父类的引用可以指向子类对象。
        Animal obj3 = new Cat();
        //注意，不能用子类引用指向父类对象,如：Dog obj3 = new Animal();是错误的
        obj1.eat();//父类引用指向父类对象时，调用父类中的eat()
        obj2.eat();//父类引用指向子类对象时，调用的是子类中的eat()
        obj3.eat();//子类中没有重写eat()方法，调用的是继承父类的eat()
        //注意：父类引用不能调用子类独有的方法，如：obj2.watchDoor();是错误的
        Dog obj4 = new Dog();
        obj4.watchDoor();//子类自己的引用才能调用自己独有的方法

    }

}

输出结果如下：

动物能吃东西
够能吃骨头和肉
动物能吃东西
狗具有看门的能力

2. 引用类型转化
a.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换。不存在风险。
如：

        Dog dog1 = new Dog();
        Animal animal = dog1;//将dog1转换成Animal类，是小类型到大类型的转换。

b.向下类型转换（强制类型转换），是大类型和小类型。是有风险的，可能会有内存溢出的现象。
如：

Dog dog2 = (Dog)animal;//将animal转换成Dog类。

c. instanceof运算符，来解决引用对象的类型，避免类型转化的安全性问题。
如:

        if(animal instanceof Cat){
            Cat cat =(Cat)animal;
            System.out.println("可以强制类型转换，将animal转换成Cat类");
        }else{
            System.out.println("不能强制类型转换，不能将animal转换成Cat类");
        }

3.抽象类
a. 使用abstract关键字修饰的类即为抽象类。
b. 应用场景：多用在父类，用来约束子类必须有哪些方法，而并不关注子类如何去实现。
c. 抽象类中的抽象方法也用abstract 修饰，抽象方法没有方法体，以分号结束。
d. eclipse中，创建子类时，会自动重写抽象方法，我们只需要加入方法的实现步骤即可。
例子：
抽象类（父类）如下：

public abstract class Telephone {
    public abstract void Call();//抽象方法没有方法体，以分号结束。
    public abstract void Message();

}

子类1：

public class cellPhone extends Telephone {

    @Override
    public void Call() {
        // TODO Auto-generated method stub
        System.out.println("用键盘输入实现打电话");

    }

    @Override
    public void Message() {
        // TODO Auto-generated method stub
        System.out.println("用键盘输入实现发短信");

    }

}

子类2：

public class smartPhone extends Telephone {

    @Override
    public void Call() {
        // TODO Auto-generated method stub
        System.out.println("语音实现打电话");

    }

    @Override
    public void Message() {
        // TODO Auto-generated method stub
        System.out.print("语音实现发短信");

    }

}

测试类（main函数）：

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Telephone obj1 = new cellPhone();
        Telephone obj2 = new smartPhone();
        obj1.Call();
        obj1.Message();
        obj2.Call();
        obj2.Message();

    }

}

4. 接口
a.接口的概念
--接口可以理解为一种特殊的类，有全局常量和公共的抽象方法所组成。
--类是一种具体实现体，接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
--定义接口不再使用class关键字，而是使用interface关键字。
b.接口定义的基本语法：
[修饰符] interface 接口名 [extends 父接口1，父接口2...]
{
零个到多个常量定义...
零个到多个抽象方法的定义
}
--接口就是用来被继承、被实现的，修饰符一般建议用public。
注意：不能使用private 和protect 修饰接口
interface前一定有一个abstract关键字，如果没写，系统会自动加上abstract。
--接口可以继承多个父接口。（与普通类不同，类是单继承的）
--接口中的属性是常量，及时定义时不添加public static final 修饰符，系统也会自动加上。
--接口中的方法只能是抽象方法，总是使用，及时定义时不添加public abstract修饰符，系统也会自动加上。

c. 使用接口
一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，不够灵活，通过实现多个接口可以做补充。
d. 继承父类实现接口的语法为：
[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
}
-- 如果要继承父类，继承父类必须在实现接口之前