Java学习笔记：面向对象技术(6)——多态

参考视频：bilibili遇见狂神说

3、多态

• 动态编译：类型
• 即同一方法可以根据放送对象的不同而采用多种不同的行为方式。
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

package 面向对象OOP.多态;
//父类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

package 面向对象OOP.多态;
//子类为空，继承父类
public class Student extends Person{

}

package 面向对象OOP.多态;

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

        //一个对象的实际类型是确定的，但可以指向的引用类型就不确定了。
        //new Student();
        //new Person();

        //父类的引用指向子类。
        Student s1 = new Student();
        Person s2 = new Student();  //正常执行父类的方法
        Object s3 = new Student();

        s2.run();
    }
}

执行结果：run

package 面向对象OOP.多态;
//重写子类方法
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
}

package 面向对象OOP.多态;

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();
		
        //对象能执行哪些方法，主要看对象左边的类型和右边的关系。
        s2.run();//子类重写了父类的方法，执行子类的方法，如果不重写，执行父类方法。
        s1.run();//正常执行子类方法。
    }
}

执行结果：
	son
	son

• 多态存在的条件

• 有继承关系。

• 子类重写父类方法。

• 父类引用指向子类对象。

• 注意：

  • 多态是方法的多态，属性没有多态性。
  • 父类和子类，有联系。类型转换异常！
  • 存在条件：继承关系，方法需要重写，父类引用指向子类对象。
  • 多态不存在的情况：
    • static 方法属于类，不属于实例。
    • final属于常量。
    • private方法。

• instanceof关键字的作用：

  • System.out.println(x instanceof y);
  • 上面代码能不能编译通过在于x和y之间有没有继承的关系。
  • 如果x是y的一个实例，则为true，如果不为一个实例，则为false。

package 面向对象OOP.多态;
//Student类继承Person类
//所有类都继承Object类
import 面向对象OOP.继承.Teacher;

public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);

    }
}

执行结果：
    true
    true
    true
    false
    false

• 向下转型和向上转型

package 面向对象OOP.多态;

import 面向对象OOP.继承.Teacher;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化： 父    子
        //高                 低
        Person student = new Person();
        //student.go();属于引用类型Person的Student实例无法调用student类里面的go方法
        //因为Person类是父类，处于高，它不存在子类Student中特有的go方法
        //所以需要用到强制类型转换。
        //将Person类型转换为Student类型，我们就可以使用Student类型的方法了。
        ((Student)student).go();

        //那么低转高应该怎么转呢？
        Student student1 = new Student();
        student1.go();
        Person person = student1;
        //子类转父类可以会丢失自己本身特有的一些方法。

    }
}

static关键字

package 面向对象OOP.static关键字详解;

//static
public class Student {

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

    //对于方法来说
    public void run(){

    }
    public static void 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);
        //System.out.println(Student.score);    //报错

        new Student().run();//对于非静态方法，只能引用调用。
        go();//非静态方法可以直接调用本类中的静态方法直接调用
        Student.go();//对于调用其他类的静态方法，需要加上类名调用。


    }
}

//对于final修饰的类
public final class Person{
    //这样的类不能被继承，相当于断子绝孙类
}

package 面向对象OOP.static关键字详解;

public class Person {
    {
        //这个大括号叫做代码块，因为没有名字，所以叫匿名代码块。
    }

    static {
        //static开头的叫做静态代码块。
    }
}