Java基础语法（六）----面向对象（3）多态

1、多态的概述

      多态是指一个对象在不同时刻表现出来的不同状态，是指父类的对象接受子类的对象。

     举例：

       猫可以是猫的类型。猫 m = new 猫();

       同时猫也是动物的一种，也可以把猫称为动物 (Animal 是猫类的父类)。Animal an=new 猫();

2、多态前提和体现

 * 有继承关系 

 * 有方法重写 

 * 有父类引用指向子类对象

3、成员访问特点

   定义一个父类Person,子类Student

   //父类

public class Person {
    public String name="Lily";
    public String sex="女";
    public int age=30;

    public Person() {
        System.out.println("我是父类的空参构造方法");
    }

    public Person(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        System.out.println("我是父类的带参构造方法");
    }

    public void show(){
        System.out.println("我是父类的show方法");
    }

    public static void eat(){
        System.out.println("我是父类中的静态方法");
    }
}

 

  //子类

public class Student extends Person {
    public String name="abc";
    public String classNum="class1";
    public Student(){
        System.out.println("我是子类的空参构造");
    }
    public Student(String name,String sex,int age,String classNum) {
        this.name=name;
        this.sex=sex;
        this.age=age;
        this.classNum = classNum;
        System.out.println("我是子类的带参构造方法");
    }
    public void show(){
        System.out.println("这是子类中的show方法");
    }
    public static void eat(){
        System.out.println("这是子类中的静态方法");
    }
}

1) 成员变量

   编译看左边，运行看左边，第一个“看左边”是指看父类是否存在该成员变量，第二个“看左边”是指访问父类的成员变量。

  *1、Person p=new Student(); p调用成员变量,编译时看父类中是否存在该变量，若存在运行时访问父类的成员变量，若不存在，则会报错，测试类如下：

  

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

        //  Person student=new Student("Bob","男",18,"高三一班");

        Person student = new Student();
        System.out.println(student.name);
        System.out.println(student.sex);
        System.out.println(student.age);
        //会报错，因为父类没有定义classNum成员变量
        //System.out.println(student.classNum);


    }
}

   //运行结果

   *2、  Person p=new Student("Bob","男",18,"高三一班");   p调用成员变量（该成员变量在子类中存在同名变量，如子类中有和父类变量名相同的name，这个成员变量编译看左边，运行看左边,没有同名的变量访问的仍是子类的成员变量）,测试类如下：

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

        Person student=new Student("Bob","男",18,"高三一班");
        System.out.println(student.name);
        System.out.println(student.age);
        //会报错，因为父类没有定义classNum成员变量
        //System.out.println(student.classNum);
    }
}

//运行结果

  

2)成员方法

   编译看左边，运行看右边

  多态调用成员方法的前提是父类和子类存在同名方法，否则就会编译报错；当多态对象访问该方法时，会默认访问子类的方法。

   测试类：

  

public class Test1 {
    public static void main(String[] args) {
        Person student = new Student();
        student.show();
    }
}

   //运行结果

 

3) 静态方法

   编译看左边，运行看左边

    //测试类

public class Test1 {
    public static void main(String[] args) {
        Person student = new Student();
        student.eat();
    }
}

   

    //运行结果：

   

  4、多态的好处

   * 提高了程序的维护性(由继承保证)

   * 提高了程序的扩展性(由多态保证)

  5、多态的弊端

   * 不能访问子类特有功能。

 

  6、多态中的转型问题

    多态的弊端是不能访问子类特有的功能，那么我们如何才能访问子类的特有功能呢?所以提出了多态中的转型，来实现这种操作。

 1) 向下转型

    以上述的Person、Student类为例，向下转型是指将父类对象用其相对应的子类对象接收.

    Person p = new Student();

    Student stu = (Student) p;   //实现向下转型

2) 向上转型

   多态的存储数据的形式就是一个向上转型，用其父类对象来接收子类对象。