• 体现了事物的多态性
  • 创建多态的方法：Fu f = new Zi()
  • 父类对象指向子类内存地址

多态访问成员方法的特点

1、编译看左，运行看右
2、编译的时候看=左边的类型中，是否定义了该方法，如果有就编译通过，如果没有就编译报错
3、运行的时候看=右边的类型中，对象所属的类中，如果对这个方法提供了新的实现，最终运行的就是子类对这个方法的实现，如果没有因为继承，所以使用父类的实现

注意：子类的特有成员方法是无法调用的

示例：

  1. package com.bxw.demo;
  3. import java.io.FileInputStream;
  5. public class Class多态 {
  6.     public static void main(String[] args) {
  7.         // 创建多态
  8.         Fu fu = new Zi();
  9.         // 创建了一个父类指向子类内存的多态
  10.         // 子类中特有的方法和成员变量是无法被调用的。但是子类中没有重写父类中的方法时，多态对调
  11.         // 会调用父类的成员方法。注意子类的特有成员方法是无法调用的
  12.         fu.getFuAge();
  13.         fu.getFuName();
  14. //        fu.getZiId(); // 无法调用
  16.     }
  17. }
  19. // 创建一个父类
  20. class Fu{
  21.     private String name;
  22.     private int age;
  24.     public Fu() {
  25.     }
  27.     public Fu(String name, int age) {
  28.         this.name = name;
  29.         this.age = age;
  30.     }
  32.     public String getName() {
  33.         return name;
  34.     }
  36.     public void setName(String name) {
  37.         this.name = name;
  38.     }
  40.     public int getAge() {
  41.         return age;
  42.     }
  44.     public void setAge(int age) {
  45.         this.age = age;
  46.     }
  47.     // 创建一个获取name父类方法
  48.     public void getFuName(){
  49.         System.out.println("父类中方法");
  50.     }
  51.     // 创建一个获取age的父类方法
  52.     public void getFuAge(){
  53.         System.out.println("父类中的方法");
  54.     }
  55. }
  56. // 创建一个子类
  57. class Zi extends Fu{
  58.     private int id;
  60.     public Zi() {
  61.     }
  63.     public Zi(String name, int age, int id) {
  64.         super(name, age);
  65.         this.id = id;
  66.     }
  68.     public Zi(int id) {
  69.         this.id = id;
  70.     }
  72.     public int getId() {
  73.         return id;
  74.     }
  76.     public void setId(int id) {
  77.         this.id = id;
  78.     }
  79.     // 重写父类中的方法
  81.     @Override
  82.     public void getFuAge() {
  83.         System.out.println("重写了父类的getFuAge方法");
  84.     }
  86.     @Override
  87.     public void getFuName() {
  88.         System.out.println("重写了父类的getFuName方法");
  89.     }
  91.     // 创建一个子类特有的方法
  92.     public void getZiId() {
  93.         System.out.println("创建了一个子类特有的方法");
  94.     }
  95. }

向上向下转型

  1. package com.bxw.demo;
  3. import java.io.FileInputStream;
  5. public class Class多态 {
  6.     public static void main(String[] args) {
  7.         // 多态的实现就是向上转型
  8.         Fu fu = new Zi("jack",12,21);
  9.         fu.getFuAge();
  10.         fu.getFuName();
  11.         // 向下转型
  12.         Zi zi = (Zi)fu;
  13.         // 向下转型之后可以调用子类的特有方法了
  14.         zi.getZiId();
  15.         System.out.println("name:" + zi.getName() + " age:" + zi.getAge() + " id:" + zi.getId());
  17.     }
  18. }
  19. // 创建一个父类
  20. class Fu{
  21.     private String name;
  22.     private int age;
  24.     public Fu() {
  25.     }
  27.     public Fu(String name, int age) {
  28.         this.name = name;
  29.         this.age = age;
  30.     }
  32.     public String getName() {
  33.         return name;
  34.     }
  36.     public void setName(String name) {
  37.         this.name = name;
  38.     }
  40.     public int getAge() {
  41.         return age;
  42.     }
  44.     public void setAge(int age) {
  45.         this.age = age;
  46.     }
  47.     // 创建一个获取name父类方法
  48.     public void getFuName(){
  49.         System.out.println("父类中方法");
  50.     }
  51.     // 创建一个获取age的父类方法
  52.     public void getFuAge(){
  53.         System.out.println("父类中的方法");
  54.     }
  55. }
  56. // 创建一个子类
  57. class Zi extends Fu{
  58.     private int id;
  60.     public Zi() {
  61.     }
  63.     public Zi(String name, int age, int id) {
  64.         super(name, age);
  65.         this.id = id;
  66.     }
  68.     public Zi(int id) {
  69.         this.id = id;
  70.     }
  72.     public int getId() {
  73.         return id;
  74.     }
  76.     public void setId(int id) {
  77.         this.id = id;
  78.     }
  79.     // 重写父类中的方法
  81.     @Override
  82.     public void getFuAge() {
  83.         System.out.println("重写了父类的getFuAge方法");
  84.     }
  86.     @Override
  87.     public void getFuName() {
  88.         System.out.println("重写了父类的getFuName方法");
  89.     }
  91.     // 创建一个子类特有的方法
  92.     public void getZiId() {
  93.         System.out.println("创建了一个子类特有的方法");
  94.     }
  95. }
  • 向上转型：多态的实现就是属于向上转型
  • 向下转型：必须是已经经过向上转型的才可以进行向下转型
  • 格式：Zi z = (Zi) f

示例：

instanceof

这个关键字用与判断多态instanceof指定的数据类型，返回值是一个布尔值

示例：

  1. package com.bxw.demo.demo07;
  3. import java.io.FileReader;
  5. public class instanceof判断 {
  6.     public static void main(String[] args) {
  7.         // 多态实现
  8.         Fu fu = new Zi();
  9.         Fu fu1 = new Fu();
  10.         Zi zi1 = new Zi();
  11.         // 使用instanceof关键字来判断fu是否之Zi类型
  12.         System.out.println(fu instanceof Zi);// true  向上转型
  13.         System.out.println(fu instanceof Fu);// true  对象关系
  14.         System.out.println(fu1 instanceof Fu);// true 对象关系
  15.         System.out.println(fu1 instanceof Zi);// false 反了
  16.         System.out.println(zi1 instanceof Fu); // true 继承关系
  17.         // instanceof的作用是能更准确的进行向下转型
  18.         if (fu instanceof Zi == true){
  19.             System.out.println("已向上转型");
  20.             Zi zi = (Zi)fu;
  21.             System.out.println("向下转型成功");
  22.         }
  23.         if (fu1 instanceof Zi == false){
  24.             System.out.println("未向上转型");
  25.         }
  26.     }
  27. }
  28. // 父类
  29. class Fu{
  30.     String name = "jack";
  31.     public void printName(){
  32.         System.out.println(this.name);
  33.     }
  34. }
  35. // 子类
  36. class Zi extends Fu{
  37.     int age = 18;
  38.     public void printName_Age(){
  39.         System.out.println(this.name + "--" + this.age);
  40.     }
  41. }