20220305—上下转型、instanceof、Static

一、对象类型的转换

注意强制类型转换

（1）没有继承关系的两个类不能强制类型转换

（2）父类向下转型的前提：父类对象要先引用这个子类

  public class Demo01_Bird {

    public void eat(){
        System.out.println("Eat!");
    }
}

   public class Demo01_Pigeon extends Demo01_Bird{

    //子类：鸽子的方法
    public void say(){
        System.out.println("Hello!");
    }
}
        //向上转型，意义：某只鸽子是一只鸟
        //向上转型：将子类类型的对象转换为父类类型的对象
        Demo01_Bird Bird = new Demo01_Pigeon();

        //向下转型，意义：某只鸟是一只鸽子
        //Demo01_Pigeon Pigeon = Demo01_Bird;  错误示范，原因是：父类对象不能直接赋值给予子类对象
        Demo01_Pigeon Pigeon = (Demo01_Pigeon) Bird;  //正确示范，需要进行强制类型转换

        Bird.eat();                    //父类自己的方法
        ((Demo01_Pigeon) Bird).say();  //父类调用子类方法时，需要强制类型转换
        Pigeon.say();                  //子类自己的方法
        Pigeon.eat();                  //子类可以直接调用父类的方法
    }
}

二、Instanceof

作用：判断一个类是否实现了某个接口，判断一个实例对象是否属于一个类

//继承情况：object>Square>Quadrangle
        //        object>Square>Trapezoid
        //        object>Circular
        //测试向上转型情况
        Demo_Instanceof_Square Square = new Demo_Instanceof_Quadrangle();
        System.out.println(Square instanceof Demo_Instanceof_Square);   //True
        System.out.println(Square instanceof Demo_Instanceof_Quadrangle);  //True
        System.out.println(Square instanceof Object);  //True
        System.out.println(Square instanceof Demo_Instanceof_Trapezoid); //False
        //System.out.println(Square instanceof Demo_Instanceof_Circular);  二者没有继承关系，因此不能比较

        System.out.println("***********************");
        //测试Object类情况(向上转型)
        Object object = new Demo_Instanceof_Quadrangle();
        System.out.println(object instanceof Demo_Instanceof_Square);      //True
        System.out.println(object instanceof Demo_Instanceof_Quadrangle);  //True
        System.out.println(object instanceof Object);                       //True
        System.out.println(object instanceof Demo_Instanceof_Circular);     //False
        System.out.println(object instanceof Demo_Instanceof_Trapezoid);    //False
        
        System.out.println("***********************");
        //测试Object类情况
        Object object1 = new Object();
        System.out.println(object1 instanceof Demo_Instanceof_Square);      //False
        System.out.println(object1 instanceof Demo_Instanceof_Quadrangle);  //False
        System.out.println(object1 instanceof Object);                       //True
        System.out.println(object1 instanceof Demo_Instanceof_Circular);     //False
        System.out.println(object1 instanceof Demo_Instanceof_Trapezoid);    //False
    }
}

三、Static

1.Static属性与方法

public class Demo_Static_Student {

    private static int age;  //静态变量
    private float score;     //非静态变量

    public void run(){
        System.out.println("Run!");
        go();  //非静态方法可以直接访问静态方法
    }

    public static void go(){
        System.out.println("Go!");
    }

    public static void main(String[] args) {
        //run();  主方法用static声明，不能直接调用非静态方法
        new Demo_Static_Student().run(); //必须构造对象，再调用非静态方法
        Demo_Static_Student.go();  //类名.方法/成员 形式，目的是突出是静态的
        go();   //可以直接访问静态方法
    }
}

2.静态代码块

（1）代码块的输出顺序：静态代码块>匿名代码块>构造方法

（2）Static代码块只执行一次

public class Demo_Static_Person {
    {
        //代码块（匿名代码块），第二执行，赋初始值
        System.out.println("匿名代码块");
    }

    static {
        //静态代码块,最早执行，和类一块加载
        System.out.println("静态代码块");
    }

    public Demo_Static_Person() {
        //构造方法代码块，第三执行
        System.out.println("构造方法代码块");
    }

    public static void main(String[] args) {
        Demo_Static_Person Person = new Demo_Static_Person();
        Demo_Static_Person Person1 = new Demo_Static_Person();
    }
}

3.静态导入包

import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Demo_Static_Bag {
    public static void main(String[] args) {

        //常规方法
        //System.out.println(Math.random());
        //System.out.println(Math.PI);

        //静态导入包方法，可以省略Math
        System.out.println(random());
        System.out.println(PI);

    }
}

4.Static练习

在Cust类中创建一个静态整数类型属性Count，在构造方法中让Count自增。

public class Demo_Static_Cust {

    static int count =0;
    String name;

    public Demo_Static_Cust(String name) {
        this.name=name;
        count++;
    }

    public static void main(String[] args) {
        Demo_Static_Cust c1 = new Demo_Static_Cust("Tom");
        System.out.println("我是第"+Demo_Static_Cust.count+"位顾客，我叫"+c1.name);
        Demo_Static_Cust c2 = new Demo_Static_Cust("Jack");
        System.out.println("我是第"+Demo_Static_Cust.count+"位顾客，我叫"+c2.name);
        Demo_Static_Cust c3 = new Demo_Static_Cust("Mary");
        System.out.println("我是第"+Demo_Static_Cust.count+"位顾客，我叫"+c3.name);

    }
}

本练习中，由于count是静态变量，是共享的，因此构造一个对象就能让count实现一次自增。