面向对象之多态

1）多态：向上转型（父类引用指向子类对象）

package OOP.com.polymorphic;
/*多态向上转型：父类引用指向子类对象。
*          1.普通父类型 引用变量=new 子类对象();//这个父类型不是抽象类
* */
class Animal{

}
class Dog extends Animal{

}
public class demo01 {
    public static void main(String[] args) {
        Animal a=new Dog();//父类引用（Animal）指向子类的Dog对象
        //子类型(Dog)向上提升为父类型（Animal）  不可以反过来
    }
}

package OOP.com.polymorphic;
/**
 * 多态向上转型第二种格式：
 * 抽象父类型  引用变量名=new 子类对象();
 * */
abstract class Person{

}
class Worker extends Person{

}
public class demo02 {
    public static void main(String[] args) {
        Worker w=new Worker();
        Person p=new Worker();
    }
}

package OOP.com.polymorphic;
/*
*多态向上转型的第三种格式：
* 父接口类型  引用变量名=new 接口的实现类对象
* */

interface Smoking{

}
class Student implements Smoking{

}
public class Demo03 {
    Smoking s=new Student();//学生实现了抽烟功能
}

2）多态：向下强转

package OOP.com.polymorphic.com.polymorphic;
/*向下转型：将父类型强制转换成子类型
* */
class Person{
    public void eat(){
        System.out.println("人吃饭");
    }
}
class  Student extends Person{
    public void study(){
        System.out.println("学生学习");
    }
}
public class demo {
    public static void main(String[] args) {
        Person p=new Student();
        //父类(Person)引用指向子类对象(new Student)
        p.eat();
        //我们把学生看作一个人，因为所有人都吃饭，因此可以调eat方法
        //p.study();
        // 不可以，因此刻把学生看作一个人，不是所有人都学习
        //把p由原来的Person类型转换成Student
        Student s=(Student)p;//p由person类型转换成Student
                          //向下转型 父类型转换成子类型
                        //原来我们把学生称作一个人，现在相当于回归本色，把学生叫成学生
        s.study();//学生吃饭
        s.eat();//学生学习
    }
}

3）多态访问变量的特点：看引用变量左边

package OOP.com.polymorphic.visit;

/*多态成员变量的访问特点：
*     编译时期：看左边
*     运行期：看左边
* */
class Fu{
    int number=4;
}
class Zi extends Fu{
    int number=10;
}
public class Demo04 {
    public static void main(String[] args) {
        Fu f= new Zi();//父类引用指向子类对象
        System.out.println(f.number);//向上转型
    }
}

4）多态访问成员方法的特点：这里主要表现为派生类覆盖超类的方法，
                       若子类未重写，则直接继承，即不存在覆盖。

package OOP.com.polymorphic.visit;
/*多态中成员方法的访问特点：

*       编译时期：  Fu1 f=new zi1();
*       f.method();
*      // f.function();
*      编译时期会看多态形式等号左边的类型中是否定义调用的成员方法
*      如果有编译通过，如果没有编译失败
*      运行时期：
*      运行期会看多态形式右边的类型是否定义了调用成员方法，如果有
*      则直接执行并调用重写的方法，没有则调用超类的方法，因为派生类
*      继承了超类的方法。
* */
class Fu1{
    public void method(){
        System.out.println("fu1方法");
    }
}
class zi1 extends Fu1{
    //重写父类的方法
    public void method(){
        System.out.println("zi1方法");
    }
    //定义一个子类特有的方法
    public void function(){
        System.out.println("子类特有的方法");
    }
}
public class Demo05 {
    public static void main(String[] args) {
        Fu1 f=new zi1();
        f.method();//运行结果为子类所特有的方法
        //f.function();
    }
}

5）instanceof:判断引用变量是否是右边类或者接口的一个实例

package OOP.com.polymorphic.visit;
/*
* instanceof 运算符
* 格式：
*    引用变量名instanceof类名/接口名
*    运算结果为boolean类型。
*    引用变量是否属于右边的一个实例对象。
* */
interface  JD{

}
class Animal{

}
class Dog extends Animal implements JD{

}
class Sheep extends Animal{

}
public class InstanceofDemo {
    public static void main(String[] args) {
        //1.普通类的形式
        Dog d=new Dog();
        boolean b1=d instanceof Dog;
        System.out.println(b1);//判断d引用的对象(new Dog())能否是Dog类型

        //2.多态形式
        Animal a=new Dog();
        boolean b2=a instanceof Dog;//判断a引用指向对象(new Dog())是Dog类型
        System.out.println(b2);

        //3.接口多态形式
        JD jd=new Dog();
        boolean b3=jd instanceof Dog;
        System.out.println(b3);

        //4.instanceof为false
        Animal s=new Sheep();
        boolean b4=s instanceof Dog;
        System.out.println(b4);
    }
}