java的多态详解

多态

1.什么是多态？

• 动态编译：类型：可扩展性
• 即同一种方法可以根据发送对象的不同而采用多种不同的行为方式。
• 一个对象(下图的student对象)的实际类型是确定的，但可以指向对象（student对象）的引用的类型（student类、person类、Object类）有很多。前提是这些引用类型是指向对象的父类。

例如

student s1 = new student();
person s2 = new student();
Object s3 = new student();
s1.study();
s2.study();
s3.study();
s1.sleep();
s2.sleep();
s3.sleep();

• 多态的存在条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类方法

2.怎么运用多态

1. 首先咱们要建立三个程序，一个是主程序，一个student类（子类），另一个是person类（父类）。
2. 咱们要知道一个对象的实际类型是确定的。

​ new student()；就是new了一个student类型的，

2. 但是，可以指向这个对象（student类）的的引用类型（student类、person类、Object类）就不是确定的了。例如

student s1 = new student();
person s2 = new student();
Object s3 = new student();

​ 也就是父类的引用（person类、object类）指向子类（student）。我们可以通过父类去new子类。

a.有继承关系的时候

这种情况就是继承关系，父类里面有的方法，子类也会有，因为继承关系

• person类（父类）

public class person {
  public void sleep(){
      System.out.println("sleep");
  }
}

• student类（子类）

public class student extends person{

}

• 主程序

public class application {
    public static void main(String[] args) {
        student s1 = new student();    //自己指向自己
        person s2 = new student();     //父类的引用指向子类
        Object s3 = new student();     //父类的引用指向子类
        s1.sleep();                    //子类继承了父类的方法，因此子类也含有这个方法。
        s2.sleep();                    //父类有这个方法 
    }
}
=================================================
    最终输出的结果是
    sleep
    sleep

b.父类的引用指向子类独有的方法（高类型像低类型需要强制转换）

还有另外一种情况就是子类中编写了一个方法，父类里面没有，你想通过引用父类来指向子类，那么他就需要将类型强制转换。代码如下

• person类（父类）

public class person {
  public void sleep(){
      System.out.println("sleep");
  }
}                //此时父类里面只有sleep方法

• student类（子类）

public class student extends person {
    public void study() {                     //我单独在子类里面编写了一个study方法，这个方法是父类没有的。
        System.out.println("study");
    }
}                //此时子类里面有sleep方法和study方法，sleep方法是继承父类的，study方法是自己编写的，父类没有该方法。

• 主程序

public class application {
    public static void main(String[] args) {
        student s1 = new student();
        person s2 = new student();
        Object s3 = new student();
        s1.study();                         //我通过引用student类来指向student对象
        ((student)s2).study();              //我通过引用person类来指向student对象，因person没有该方法，需强制转换 
    }
}
=========================================================
    最终的输出结果
    study
    study

c.子类重写父类的方法

这种情况就是，咱们之前讲过的重写，父类和子类同时写了相同的方法体，但父类和子类的方法内容不一样，此时无论使用父类指向对象，还是之类（自己）指向对象，他们输出的内容都是子类中重写的内容。代码如下

• person(父类)

public class person {
  public void sleep(){
      System.out.println("sleep");
  }
}

• student（子类）

public class student extends person {

    @Override                           //重写：子类重写了父类的方法
    public void sleep() {
        System.out.println("不睡觉");
    }
}

• 主程序

public class application {
    public static void main(String[] args) {
        student s1 = new student();
        person s2 = new student();
        Object s3 = new student();
       s1.sleep();     //当进行重写的时候，无论引用类型是父类还是子类，他最终输出结果都是重写后的内容。
       s2.sleep();
    }
}
=============================================
    最终输出结果
    不睡觉
    不睡觉

3.小结

1. 在主程序中

   • 子类：能调用的方法都是自己的或者是继承父类的
   • 父类：可以指向子类，但是不能调用子类独有的方法，若想要调用，需要强制转换。但要记住高类型转到低类型需要强制转换。

2. 多态的注意事项

• 多态是方法的多态，属性没有多态
• 父类和子类，有联系的，父子之间的转换 否则会类型转换异常
• 存在条件：继承关系，父类引用指向子类对象。
• 不能重写的
  • static：方法，属于类，它不属于实例
  • final:常量
  • private方法