32、Java基础之多态

多态

• 多态注意事项:
  1.多态是方法的多态，属性没有多态
  2．父类和子类，有联系类型转换异常! classCastException !
  3．存在条件:继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son( )；

• 以下没有多态
  1、 static方法，属于类，它不属于实例
  2、final常量;
  3、 private方法;

• 同一方法根据发送对象的不同采用多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件
有继承关系
子类重写父类方法
父类引用指向子类对象

• 注意:多态是方法的多态，属性没有多态性。
• 多态实例

父类

public class DuoTaiFather {
    public void test(){
        System.out.println("父类");
    }
}

子类

public class DuoTaiSon extends DuoTaiFather{
    public void test(){
        System.out.println("子类");
    }
    public void say(){
        System.out.println("子类说话了");
    }
}

main方法

public class C7DuoTai {
    public static void main(String[] args) {
        /**
         * 一个对象的实际类型是确定的
         *
         *  可以指向的引用类型就不确定了:父类的引用指向子类
         *  子类能调用的方法都是自己的或者继承父类的!
         */
        DuoTaiFather dTFather = new DuoTaiFather();
        dTFather.test();// 输出父类  ，父类调用自己的方法
        System.out.println("===================");

        /**
         *  子类的引用类型不能指向父类 ，因此，即使强转，也无法执行
         */
//        ((DuoTaiSon)dTFather).say();

        DuoTaiSon dTSon  = new DuoTaiSon();
        dTSon.test();   // 输出 子类  ， 子类 调用自己的方法
        System.out.println("===================");

        /**
         * 父类的引用  可以  指向子类
         * 但  父类不能调用子类独有的方法
         * 象能执行哪些方法，主要看对象左边的类型，和右边关系不大
         * 当子类重写了父类的方法后，父类的引用 指向 子类 ，父类调用此方法会执行子类重写后的的方法
         */
        DuoTaiFather dTFather1 = new DuoTaiSon();
        dTFather1.test();   // 输出 子类， 子类重写了父类的方法
        ((DuoTaiSon) dTFather1).say();  // 输出了 子类说话了  ，父类  转为 子类后，可以使用子类自己的方法
    }
}

instanceof
判断一个对象是什么类型
1．父类引用指向子类的对象
2．把子类转换为父类，向上转型;
3．把父类转换为子类，向下转型;强制转换
4. 方便方法的调用，减少重复的代码!简介

Docter

public class Docter {
    /**
     * 一个类即使什么都不写，它也会存在一个方法
     * 显示的定义构造器
     */
    String name;
    int age;

    /**
     *  1。使川new关键字，本质是在调用构造器
     *  2.用来初始化值
     */
    public Docter(){

    }

    /**
     * 有参构造:一旦定义了有参构造，无参构造 就必须显示定义！！！
     * @param name
     */
    public Docter(String name){
        this.name = name;
    }

    public Docter(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

JiChengFather

public class JiChengFather {
//    private JiChengFather jiChengFather= new JiChengFather();

    public String abc = "我是父类中的String";

//    public JiChengFather() {
//        System.out.println("JiChengFather 无参构造器执行了");
//    }

    public JiChengFather(String aaa){
        System.out.println("JiChengFather 有参构造器执行了");
    }

    public void pullName(){
        System.out.println("JiChengFather");
    }

    public static void sayStatic(){
        System.out.println("好家伙,这是静态方法");
    }

    public  void say(){
        System.out.println("好家伙，这是非静态,public");
    }

    /**
     * private 无法被继承
     */
    private  void sayPrivate(){
        System.out.println("好家伙，这是非静态,private");
    }

    void sayDefault(){
        System.out.println("好家伙，这是非静态,default(default省略不写)");
    }

    protected void sayProtected(){
        System.out.println("好家伙，这是非静态，protected ");
    }
}

JiChengSon

public class JiChengSon extends JiChengFather{
    private String abc = "我是子类中的String";

    public JiChengSon() {
        /**
         *    1、隐葳代码:调用了父类的无参构选
         *    2、调用父类的构造器，必须要在子类构造器的第一行,之前不可添加别的代码
         *      Call to 'super()' must be first statement in constructor body
         *    3、如果父类只展示出了有参构造，则要在super() 的括号中添加相应的参数
         */
        super("dfsf");//  父类只展示出了有参构造，则要在super() 的括号中添加相应的参数
        System.out.println("JiChengSon 无参构造器 执行了");
    }



    public void pullName(){
        System.out.println("JiChengSon");
    }

    public void superAndThis(String abc){
        System.out.println(abc); //方法传入的String
        System.out.println(this.abc); //当前类中私有的String
        System.out.println(super.abc);  //父类的String
    }

    public void pullHisName(String name){
        pullName();     // 调用当前类的方法
        this.pullName();  // 调用当前类的方法
        super.pullName(); // 调用父类的方法
    }

    public void say(){
        System.out.println("深知身在情常在，怅望江头江水声！");
    }
}

main方法

public class C8Instanceof {
    public static void main(String[] args) {
        Object object =new JiChengSon();
        System.out.println(object instanceof JiChengFather);//t
        System.out.println(object instanceof JiChengSon);//t
        System.out.println(object instanceof Object);//t
        System.out.println(object instanceof Docter);//f

        System.out.println("===============");
        JiChengFather jiChengFather = new JiChengSon();
        System.out.println(jiChengFather instanceof JiChengFather);//t
        System.out.println(jiChengFather instanceof JiChengSon);//t
        System.out.println(jiChengFather instanceof Object);//t
//        System.out.println(jiChengFather instanceof Docter);//编译报错
//        System.out.println(jiChengFather instanceof String);//编译报错

        /**
         * 父类转子类,需要强转
         *      方法一： ((JiChengSon)jiChengFather).say();
         *      方法二： JiChengSon zhuanhuan = (JiChengSon) jiChengFather;//强制转换
         *              zhuanhuan.say();
         */
        JiChengSon zhuanhuan = (JiChengSon) jiChengFather;//强制转换
        zhuanhuan.say();

        ((JiChengSon)jiChengFather).say();      //同上，只不过两句合并为了一句

        /**
         *  子类转换为父类，可以自然转换，但注意，可能丢失自己的本来的一些方法!
         */
        JiChengSon jiChengSon = new JiChengSon();
        JiChengFather zhuanhuan2= jiChengSon;
        zhuanhuan2.say();
    }
}