day11遇见狂神说学Java

instanceof 和类型转换

instanceof判断两者关系

使用instanceof判断是否有父子关系

public class Application {
    public static void main(String[] args) {
        Object object=new Student();//Object->People->Student;Object->String
        System.out.println(object instanceof Object);//True
        System.out.println(object instanceof Student);//True
        System.out.println(object instanceof People);//True
        System.out.println(object instanceof String);//false
        System.out.println(object instanceof Teacher);//false
        System.out.println("-------------------------------------------");
        People people= new Student();//Object->People->Teacher
        System.out.println(people instanceof Object);//True
        System.out.println(people instanceof Student);//True
        System.out.println(people instanceof People);//True
//        System.out.println(people instanceof String);//编译报错
        System.out.println(people instanceof Teacher);//False
        System.out.println("------------------------------------------");
        Student student=new Student();//Object->People->Student
        System.out.println(student instanceof Object);//True
        System.out.println(student instanceof Student);//True
        System.out.println(student instanceof People);//True
        //System.out.println(student instanceof String);//编译报错
        //System.out.println(student instanceof Teacher);//编译报错
        System.out.println("------------------------------------------");
        Teacher teacher=new Teacher();//Object->People->Teacher
        System.out.println(teacher instanceof Object);//True
        //System.out.println(teacher instanceof Student);//编译报错
        System.out.println(teacher instanceof People);//True
        //System.out.println(teacher instanceof String);//编译报错
        System.out.println(teacher instanceof Teacher);//True
    }
}

总结：判断是否可以编译，应该看instanceof两边是否有关联；判断结果，就观察该支线上，是否有父子关系，有即为True，没有即为False

强制类型转换

向下转型

public class Application {
    public static void main(String[] args) {
        People people=new Student();//此时people是People类型，不能调用Student里的方法
        Student obj1=(Student) people;//第一种向下转型的方法
        obj1.run();
        obj1.go();
        ((Student)people).go();//第二种方法
        
    }
}
public class People {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends People{
    public void go()
    {
        System.out.println("go");
    }
}

向上转型

public class Application {
    public static void main(String[] args) {
    Student student=new Student();
    People people=student;

    }
}
public class People {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends People{
    public void go()
    {
        System.out.println("go");
    }
}

静态变量和非静态变量

public class  Student  {
    private static int age;
    private double score;
    public static void run(){

    }
    public void go(){

    }

    public static void main(String[] args) {
        System.out.println(Student.age);//static方法可以直接通过类来调用
        Student s1=new Student();
        System.out.println(s1.score);//非静态只能通过对象调用
        Student.run();//静态方法可以通过类直接调用
        s1.go();//非静态方法只能通过对象调用
    }
}//匿名代码块在对象加载时，开始被创建，在构造器之前

匿名代码块和静态代码块

public final class Person {//通过final修饰符修饰的父类，子类无法继承
    {
        //匿名代码块在对象加载时，开始被创建，在构造器之前
        System.out.println("匿名代码块");
    }
    static {
        //静态代码块在类加载时开始被创建,只执行一次
        System.out.println("静态代码块");
    }

    public static void main(String[] args) {
        Person person1=new Person();
        System.out.println("==========");
        Person person2=new Person();
    }
}