多态~~~

父类

package com.oop.Demo08;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-07-02 15:29
 **/
public class Person {
    public void run(){
        System.out.println("run");
    }

}

子类

package com.oop.Demo08;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-07-02 15:29
 **/
public class Student extends Person {
    @Override
    public void run() {
        System.out.println("son");
    }

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

应用类
package com.oop;
import com.oop.Demo03.Pet;
import com.oop.Demo08.Person;
import com.oop.Demo08.Student;
import com.oop.Demo07.A;
import com.oop.Demo07.B;

/**

• @program: JavaSE
• @description:
• @author: lijiaoyang
• @create: 2021-06-24 15:53
  **/
  public class Application {
  public static void main(String[] args) {

//一个对象的实际类型是确定的
new Student();
new Person();

    //可以指向的引用类型就不确定了；父类的引用指向了子类，也就是父类可以直接引用子类

    //Student是子类，调用的方法是自己的或者继承父类的！
    Student s1=new Student();

    //Person 父类型，可以指向子类，但是不能调用子类独有的方法
    Person s2=new Student();
    Object s3=new Student();//Object类是所有类的父类

    //对象执行哪些方法，主要看对象左边的类型，和右边关系不大！！！
    s2.run();//子类重写了父类的方法，执行了子类的方法
    s1.run();


    ((Student) s2).eat();//强制转换



}

}

/*
多态注意事项：
1.多态是方法的多态，属性没有多态！
2.父类和子类，有联系。这里有问题的话，报的异常是：类型转换异样，ClassCastException!
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！即：father s1=new son();
*/

/*
方法的修饰词，以下不能重写：
1.static 方法，属于类，它不属于实例
2.final 常量
3.private方法

*/

---

instanceof

---

父类

package com.oop.Demo09;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-07-02 17:42
 **/
public class Person {
    public void run(){
        System.out.println("run");
    }
}

子类

package com.oop.Demo09;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-07-02 17:43
 **/
public class Teacher extends Person {
}

package com.oop.Demo09;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-07-02 17:42
 **/
public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}

应用类

package com.oop;
import com.oop.Demo03.Pet;
import com.oop.Demo07.A;
import com.oop.Demo07.B;
import com.oop.Demo09.Person;
import com.oop.Demo09.Student;
import com.oop.Demo09.Teacher;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-24 15:53
 **/
public class Application {
    public static void main(String[] args) {

/*
        //Object>String
        //Object>Person>Student
        //Object>Person>Teacher
        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

        //instanceof只适用于存在父子关系的类之间

        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);//编译报错


*/
    //类型之间的转化：基本类型转化  高转低》强转   低转高》直接转
        //父类可以指向子类，但是不能调用子类独有的方法
        Person obj=new Student();

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

    //子类转换为父类，可能丢失一些自己的本来方法！
    Student student=new Student();
    student.go();
    Person person=student;//低转高》直接转
        person.go();

   /*
   1.父类的引用指向子类的对象；
   2.把子类转换为父类，向上转型
   3.把父类转换为子类，向下转型，需要强转，可能会丢失子类的方法
   4.作用：方便方法的调用，减少重复代码！保持代码简洁

   抽象：封装，继承，多态 抽象类 接口
    */

    }

}