Java三大特性之多态性

对象的多态性：

对象多态性是从继承关系中的多个类而来

向上转型：

将子类实例转化为父类实例
格式：父类 父类对象=子类实例；->自动转换
向下转型：

将父类的是实例转换为子类实例
格式：子类 子类对象=(子类)父类实例； ->强制转换

1.创建一个父类A，并且声明为抽象类

abstract class A{
    private String name;

    public A(){}
    public A(String name){this.name=name;}

    public void setName(String name){this.name=name;}
    public String getName(){return name;}

    public abstract void eat();
}

2.创建两个子类B和C并且都继承A

class B extends A{
    public B(){}
    public B(String name){super(name);}

    public void eat(){
        System.out.println(this.getName()+"爱看妹子");
    }
}
class C extends A{
    public C(){}
 //将b实例化时，传过来的name，再用super关键字调用父类带参的构造方法，将name传回
    public C(String name){super(name);}

    public  void eat(){
        System.out.println(this.getName()+"爱睡觉");
    }
    public void wc(){
        System.out.println(this.getName()+"爱上厕所");
    }
}

 使用B和C类实例化后，调用这个eat方法

 public static void main(String[] args) {
        B b=new B("八嘎");
        b.eat();
        C c=new C("二蛋");
        c.eat();
}

 执行上市代码结果:

八嘎爱看妹子
二蛋爱睡觉

 将子类实例化转化为父类实例（这样就体现出了多态性）

public class duoTaiXingTest {
 public static void main(String[] args) {
        A ab=new B("渣渣辉");     //用父类创建父类的对象和子类创建的功能一样
        A ba=new C("胖子");
         eat(ab);                //将对象传回给eat方法
         eat(ba);
        }
//这个方法一定实在main方法外部，与main方法属于同级在同一类中
     public static void eat(A c){           //这里的形参只能使用父类来创建，相当于是c=ab,c=ba
        System.out.println("ABC爱吃大米");
        c.eat();                            //再用这个对象去调用类里的eat方法
     }
}

 代码执行结果:

ABC爱吃大米
渣渣辉爱看妹子
ABC爱吃大米
胖子爱睡觉

 源码：

public class duoTaiXingTest {
    public static void main(String[] args) {
       /* B b=new B("八嘎");
        b.eat();
        C c=new C("二蛋");
        c.eat();*/
        A ab=new B("渣渣辉");
        A ba=new C("胖子");
         eat(ab);
         eat(ba);
        }
    //这个方法一定实在main方法外部，与main方法属于同级在同一类中
     public static void eat(A c){       //这里的形参只能使用父类来创建，相当于是c=ab,c=ba
        System.out.println("ABC爱吃大米");
        c.eat();
       // C ba=(C)c;      //将main方法中调用这个eat方法传的由父类A创建的对象给c接收，再将A类的c对象强制转换为C类对象由b接收，再用b调用这个wc方法
       // ba.wc();
     }
    }
abstract class A{
    private String name;

    public A(){}
    public A(String name){this.name=name;}

    public void setName(String name){this.name=name;}
    public String getName(){return name;}

    public abstract void eat();
}
class B extends A{
    public B(){}
    //将b实例化时，传过来的name，再用super关键字调用父类带参的构造方法，将name传回
    public B(String name){super(name);}

    public void eat(){
        System.out.println(this.getName()+"爱看妹子");
    }
}
class C extends A{
    public C(){}
    public C(String name){super(name);}

    public  void eat(){
        System.out.println(this.getName()+"爱睡觉");
    }
    public void wc(){
        System.out.println(this.getName()+"爱上厕所");
    }
}

 

 

多态性小结：
1.方法的重载与重写就是方法的多态性的表现
2.多个子类就是父类中的多种形态
3.父类引用可以指向子类对象，自动转换
4.子类对象指向父类引用需要强制转换(注意:类型不对会报异常)
5.再实际开发中进来使用父类引用(更利于扩展)