package oop.Demo07;
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);  能不能编通过，X与Y是否纯在父子关系
        System.out.println(object instanceof Student);     //ture
        System.out.println(object instanceof Person);       //ture
        System.out.println(object instanceof Object);       //ture
        System.out.println(object instanceof Teacher);      //false    此处的object是Student类型的，与Teacher不是父子关系
        System.out.println(object instanceof String);       //false
        Person person = new Student();
        System.out.println(person instanceof Student);     //ture
        System.out.println(person instanceof Person);       //ture
        System.out.println(person instanceof Object);       //ture
        System.out.println(person instanceof Teacher);      //false
    //    System.out.println(person instanceof String);       //编译报错,没有关系就报错
        Student student = new Student();
        System.out.println(student instanceof Student);     //ture
        System.out.println(student instanceof Person);       //ture
        System.out.println(student instanceof Object);       //ture
      //  System.out.println(student instanceof Teacher);      //编译报错
        //    System.out.println(student instanceof String);       //编译报错
    }
}

package oop.Demo07;
public class Person {
    public void run(){
        System.out.println("run");
    }
}

package oop.Demo07;
public class Student extends Person{
    public void go() {
        System.out.println("go");
    }
}

package oop.Demo07;
public class Teacher extends Person{
}

// 父类
public class Parent {}
// 子类
public class Son extends Parent {}
// 女儿类
public class Daughter extends Parent {}

Son son = new Son();
Parent parent = (Parent) son;

Parent son = new Son();
Parent parent = (Parent) son;

Parent parent = new Parent();
Son son = (Son) parent;

Parent parent = new Son();
Son son = (Son) parent;

Parent parent = new Son();
Daughter daughter = (Daughter) parent;

package oop.Demo07;
public class Application {
    public static void main(String[] args) {
        //  Person父类  run（）方法   ，   Student子类 go（）方法
        // 父类的方法，子类可以用，但是子类特有的方法，父类不可以调用
        Person person = new Person();
        person.run();
        //  person.go();   子类特有的方法，父类不可以调用
        Student student1 = new Student();
        student1.go();
        student1.run();
        //向上转型，子转父
        //也可以理解为将一个子类的对象转化为父类的对象（隐形转型，自动的）,小类转大类
        Person one = new Person();
        one.run();
        Person two = new Student();
        //  父类引用子类实例，可以调用子类重写父类的的方法以及父类派生的方法，无法调用子类独有的方法
        //  注意：父类中的静态方法无法被子类重写，所以向上转型之后，只能调用到父类原有的静态方法。（如果父类中存在静态方法）
        two.run();
        // two.go();     报错，父类引用子类实例，无法调用子类独有的方法
        //子类转化为父类，可能会丢失自己本来的一些方法。  子类转父类，子类拓展的方法会丢失。
        // 向下转型，必须强转
        //类型之间的的转化 ：父转子,向下转换要强制转换，也就是父类转为子类要强转
         Person obj = new Student();
        // obj.go()   会报错， obj是父类Person对象实例，需要将obj转换为Student类型,才可以使用Student类型的方法
         Student student = (Student) obj;
         student.go();
        //二合一：  ((Student) obj).go();
     /*
     1. 父类引用指向子类的对象
     2. 把子类转换为父类，向上转型，直接转；
     3. 把父类转换为子类，向下转型，强制转换；
     4. 方便方法的调用，减少重复的代码，简洁
      */
    }
}