instanceof、类型转换和static

instanceof

package com.oop;

import com.oop.demo07.Person;
import com.oop.demo07.Student;
import com.oop.demo07.Teacher;

public class Application {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student
        Object object = new Student();
        //System.out.println(X instanceof Y);//能不能编译通过
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//False
        System.out.println(object instanceof String);//False
        System.out.println("=================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//False
        //System.out.println(person instanceof String);//编译报错
        System.out.println("=================================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(person instanceof String);//编译报错

    }
}

类型转换

package com.oop;

import com.oop.demo07.Person;
import com.oop.demo07.Student;
import com.oop.demo07.Teacher;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化： 父    子
        //高                 低
        Person obj = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student student = (Student) obj;
        student.go();
        //或者直接写((Student)obj).go();

        //子类转换为父类，可能丢失自己的本来的一些方法！

    }
}
/*
1.父类引用指向子类的对象
2.子类转换为父类，向上转型；不用强制转换
3.把父类转换为子类，向下转型：强制转换
4.方便方法的调用，减少重复的代码！简洁
 */

static

package com.oop.demo08;

//static
public class Student {
    private  static  int age;//静态变量
    private  double score;//非静态变量

    public void run(){//非静态方法：可以调用静态方法的东西和自己的

    }
    public static void go(){//静态方法：不能调用非静态方法，只能调用自己的

    }
//    public static void main(String[] args) {
//        new Student().run();
//    }
    public static void main(String[] args) {
        Student.go();
    }

 /*   public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
  */
}

package com.oop.demo08;

public class Person {
    //2: 赋初始值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //1：只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }

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

package com.oop.demo08;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}