0
0

Java零基础(第十三章)---》方法覆盖和多态

🏀方法覆盖

❤️回顾一下方法重载：
⭐️什么时候使用方法重载(overload)？
当在一个类当中，如果功能相似的话，建议将名字定义的一样，这样代码美观，并且方便编程。
⭐️什么条件满足之后能够构成方法重载（overload）？
条件一：在同一个类当中；
条件二：方法名相同；
条件三：参数列表不同（个数、顺序、类型）；

❤️什么时候使用方法覆盖（override）?
⭐️子类继承父类之后，当继承过来的方法无法满足当前子类的业务需求时，子类有权利对这个方法进行重新编写，有必要进行“方法的覆盖”。
⭐️方法覆盖又叫做：方法重写，英语单词叫做：Override、Overwrite，都可以。

  1. ⭐️重要结论：当子类对父类继承过来的方法进行“方法覆盖”之后，子类对象调用该方法的时候，一定执行覆盖之后的方法。

⭐️当我们代码怎么编写的时候，在代码级别上构成了方法覆盖(override)呢？
条件一：在两个类中，并且两个类必须要有继承关系。
条件二：重写之后的方法和之前的方法具有：
** 相同的返回值类型、
相同的方法名、
相同的形式参数列表。**
条件三：访问权限不能更低，可以更高。（public->protected->private）
条件四：重写之后的方法不能比之前的方法抛出更多的异常，可以更少。

❤️注意事项：（这几个注意事项，当学习了下面的多态语法之后自然就明白了！）
注意1：方法覆盖只是针对于方法，和属性无关。
注意2：私有方法无法覆盖。
注意3：构造方法不能被继承，所以构造方法也不能被覆盖。
注意4：方法覆盖只是针对于“实例方法”，“静态方法覆盖”没有意义。

❤️例1：方法覆盖的引出

⭐️当前程序存在的问题（设计上的问题）？
鸟儿在执行move()方法的时候，最好输出的结果是：“鸟儿在飞翔”
但是当前的程序在执行move()方法的时候输出的结果是："动物在移动！"
很显然Bird子类从Animal父类中继承过来的move()方法已经无法满足子类的业务需求。

  1. public class OverrideTest01{
  2.     public static void main(String[] args){
  3.         // 创建鸟对象
  4.         Bird b = new Bird();
  5.         b.move();    // 让鸟儿移动
  7.         // 创建Cat类型对象
  8.         Cat c = new Cat();
  9.         c.move();// 让猫儿走猫步
  10.     }
  11. }
  13. // 父类 
  14. class Animal{
  15.     // 移动
  16.     public void move(){
  17.         System.out.println("动物在移动！");
  18.     }
  19. }
  21. // 子类--------------有继承关系
  22. class Bird extends Animal{  
  23.   // 子类继承父类中，有一些“行为”可能不需要改进，有一些“行为”可能面临着必须改进。
  24.   // 因为父类中继承过来的方法已经无法满足子类的业务需求。
  25.   //例如： 鸟儿在移动的时候希望输出鸟儿在飞翔！！！！
  26. }
  28. class Cat extends Animal{
  29.     //例如： 猫在移动的时候，我希望输出：猫在走猫步！！！！！！
  30. }

❤️例2：使用方法覆盖

  1. public class OverrideTest02{
  2.     public static void main(String[] args){
  3.         Bird b = new Bird();
  4.         b.move(); //----方法覆盖
  5.         b.sing(1000); //Animal sing....
  7.         Cat c = new Cat();
  8.         c.move(); //----方法重载
  9.     }
  10. }
  12. class Animal{
  13.     public void move(){
  14.         System.out.println("动物在移动！");
  15.     }
  17.     public void sing(int i){
  18.         System.out.println("Animal sing....");
  19.     }
  20. }
  21. //1.条件一：具有继承关系
  22. class Bird extends Animal{ 
  24.     // 对move方法进行方法覆盖，方法重写，override
  25.     // 最好将父类中的方法原封不动的复制过来。（不建议手动编写）
  26.     // 方法覆盖，就是将继承过来的那个方法给覆盖掉了。继承过来的方法没了。
  27. //2.条件二:重写之后的方法和之前的方法具有：相同的返回值类型、相同的方法名、相同的形式参数列表。
  28.     public void move(){  
  29.         System.out.println("鸟儿在飞翔！！！");
  30.     }
  31. //3.条件三：访问权限不能更低，可以更高
  32.     //protected表示受保护的。没有public开放。
  33.     // 错误：正在尝试分配更低的访问权限; 以前为public，此时只能为public或者更高
  34.     /*
  35.     protected void move(){
  36.         System.out.println("鸟儿在飞翔！！！");
  37.     }
  38.     */
  39. //4. 条件四：重写之后的方法不能比之前的方法抛出更多的异常，可以更少。
  40.     //错误：被覆盖的方法未抛出Exception，父类没有抛出异常！
  41.     /*
  42.     public void move() throws Exception{
  43.         System.out.println("鸟儿在飞翔！！！");
  44.     }
  45.     */
  47.     // 分析：这个sing()和父类中的sing(int i)有没有构成方法覆盖呢？
  48.     // 没有，原因是，这两个方法根本就是两个完全不同的方法。
  49.     // 可以说这两个方法构成了方法重载吗？可以。
  50.     public void sing(){
  51.         System.out.println("Bird sing.....");
  52.     }
  53. }
  55. class Cat extends Animal{ 
  57.     // 方法重写
  58.     public void move(){
  59.         System.out.println("猫在走猫步！！！");
  60.     }
  61. }

❤️例1

  1. //一定要注意：方法覆盖/重写的时候，建议将父类的方法复制粘贴，这样比较保险。
  2. public class OverrideTest03{
  3.     public static void main(String[] args){
  4.        // 创建中国人对象
  5.       // ChinaPeople p1 = new ChinaPeople("张三"); //err
  6.       // 错误原因：没有这样的构造方法,没有有参构造方法
  7.         
  8.         ChinaPeople p1 = new ChinaPeople();// 能调用默认的无参构造方法！
  9.         p1.setName("张三");
  10.         p1.speak();
  12.         // 创建美国人对象
  13.         // AmericPeople p2 = new AmericPeople("jack"); 
  14.        // 错误原因：没有这样的构造方法
  16.         AmericPeople p2 = new AmericPeople();
  17.         p2.setName("jack");
  18.         p2.speak();
  19.     }
  20. }
  22. //------------------------人
  23. class People{
  24.     private String name;    // 属性
  26. // 构造方法----不能继承
  27.     public People(){}
  28.     public People(String name){
  29.         this.name = name;
  30.     }
  31. //setter and getter方法----能继承
  32.     public void setName(String name){
  33.         this.name = name;    
  34.     }
  35.     public String getName(){
  36.         return name;
  37.     }
  38.  
  39. // 人都会说话
  40.     public void speak(){
  41.         System.out.println(name + "....");
  42.     }
  43. }
  45. //----------中国人
  46. class ChinaPeople extends People{ // 继承
  47.     //构造方法是不能被继承的，这里也没有写；默认是有一个无参的构造方法
  48.     // 中国人说话是汉语；所以子类需要对父类的speak()方法进行重写
  49.     public void speak(){
  50.         System.out.println(this.getName() + "正在说汉语");
  51.     }
  52. }
  54. //----------美国人
  55. class AmericPeople extends People{
  56.      //构造方法是不能被继承的，这里也没有写；默认是有一个无参的构造方法
  57.     // 美国人说话是英语；所以子类需要对父类的speak()方法进行重写
  58.     public void speak(){
  59.         System.out.println(getName() + " speak english!");
  60.     }
  61. }

❤️例2：覆盖toString方法

⭐️关于Object类中的toString()方法
1、toString()方法的作用是什么？
作用：将“java对象”转换成“字符串的形式”。

  1.     2、Object类中toString()方法的默认实现是什么？       
  1.    public String toString() {
  2.                 return getClass().getName() + "@" + Integer.toHexString(hashCode());
  3.             }
  1.       toString: 方法名的意思是转换成String

⭐️含义：调用一个java对象的toString()方法就可以将该java对象转换成字符串的表示形式。

  1. public class OverrideTest04{
  2.     public static void main(String[] args){
  3.         // 创建一个日期对象
  4.         MyDate t1 = new MyDate();
  5.         // 调用toString()方法（将对象转换成字符串形式。）
  6.         // 问：你对这个输出结果满意吗？不满意，希望输出：xxxx年xx月xx日
  7.         //-------重写MyDate的toString()方法之前的结果
  8.         //System.out.println(t1.toString()); //MyDate@28a418fc 
  10.         //-------重写MyDate的toString()方法之后的结果
  11.         System.out.println(t1.toString());
  13.         //-------直接输出一个引用的时候，println方法会自动调用引用的toString方法。
  14.         System.out.println(t1); //默认调用toString方法
  16.         MyDate t2 = new MyDate(2008, 8, 8);
  17.         System.out.println(t2); //2008年8月8日
  19.         //创建学生对象
  20.         Student s = new Student(1111, "zhangsan");
  21.         // 重写toString()方法之前
  22.         //System.out.println(s); //Student@87aac27
  23.         // 重写toString()方法之后
  24.         // 输出一个学生对象的时候，可能更愿意看到学生的信息，不愿意看到对象的内存地址。
  25.         System.out.println(s.toString());
  26.         System.out.println(s);//这两行结果是等价的
  27.     }
  28. }
  30. // 日期类
  31. class MyDate {
  32.     private int year;
  33.     private int month;
  34.     private int day;
  35. //构造方法
  36.     public MyDate(){
  37.         this(1970,1,1);
  38.     }
  39.     public MyDate(int year,int month,int day){
  40.         this.year = year;
  41.         this.month = month;
  42.         this.day = day;
  43.     }
  44. //set和get接口方法
  45.     public void setYear(int year){
  46.         this.year = year;
  47.     }
  48.     public int getYear(){
  49.         return year;
  50.     }
  51.     public void setMonth(int month){
  52.         this.month = month;
  53.     }
  54.     public int getMonth(){
  55.         return month;
  56.     }
  57.     public void setDay(int day){
  58.         this.day = day;
  59.     }
  60.     public int getDay(){
  61.         return day;
  62.     }
  64.     // 调用toString()方法进行字符串转换的时候，
  65.     // 希望转换的结果是：xxxx年xx月xx日，这种格式。
  66.     public String toString() { //toString方法覆盖
  67.         return year + "年" + month + "月" + day + "日";
  68.     }
  69. }
  71. class Student{ //默认继承Object类，里面有toString方法
  72.     int no;
  73.     String name;
  74.     public Student(int no, String name){
  75.         this.no = no;
  76.         this.name = name;
  77.     }
  78.     // 重写，方法覆盖
  79.     public String toString() {
  80.         return "学号：" + no + "，姓名：" + name;
  81.     }
  82. }

❤️小总结

⭐️关于Object类中toString()方法的覆盖？
（1） toString()方法存在的作用就是：将java对象转换成字符串形式。
（2）大多数的java类toString()方法都是需要覆盖的。因为Object类中提供的toString()
方法输出的是一个java对象的内存地址。

⭐️方法重载和方法覆盖有什么区别？
（1）方法重载发生在同一个类当中。
（2）方法覆盖是发生在具有继承关系的父子类之间。
（3）方法重载是一个类中，方法名相同，参数列表不同。
（4）方法覆盖是具有继承关系的父子类，并且重写之后的方法必须和之前的方法一致：
方法名一致、参数列表一致、返回值类型一致。

🏀多态（重要）

多态的基础语法
** ❤️**向上转型和向下转型的概念。

  1.    ⭐️**向上转型：子--->父 (upcasting)
  2.          例如：Animal a = new Cat(); 又被称为自动类型转换**

** ⭐️向下转型：父--->子 (downcasting)
例如：Cat c = (Cat)a; 又被称为强制类型转换，需要添加强制类型转换符。**
⭐️什么时候需要向下转型？
答： 需要调用或者执行子类对象中特有的方法。必须进行向下转型，才可以调用。
⭐️向下转型有风险吗？
答： 容易出现ClassCastException（类型转换异常）
⭐️怎么避免这个风险？
答：instanceof运算符，可以在程序运行阶段动态的判断某个引用指向的对象是否为某一种类型。向下转型之前一定要使用instanceof运算符进行判断。

  1.         语法结构：(引用 instanceof 类型)

不管是向上转型还是向下转型，首先他们之间必须有继承关系，这样编译器就不会报错。

❤️什么是多态？
⭐️多种形态，多种状态，编译和运行有两个不同的状态。编译期叫做静态绑定。运行期叫做动态绑定。
⭐️例如：Animal a = new Cat(); a.move();
（1）编译的时候编译器发现a的类型是Animal，所以编译器会去Animal类中找move()方法找到了，绑定，编译通过。

  1.      （2）运行的时候和底层堆内存当中的实际对象有关；真正执行的时候会自动调用“堆内存中真实对象”的相关方法。

多态的典型代码：父类型的引用指向子类型的对象。

❤️什么时候必须进行向下转型？
⭐️调用子类对象上特有的方法时

❤️父类Animal

  1. // 动物类：父类
  2. public class Animal{
  3.     // 移动的方法
  4.     public void move(){ 
  5.         System.out.println("动物在移动！！！");
  6.     }
  8. }

❤️子类Bird

  1. // 鸟儿类：子类
  2. public class Bird extends Animal{
  3.     //1. 继承move方法并重写父类的move方法
  4.     public void move(){
  5.         System.out.println("鸟儿在飞翔！！！");
  6.     }
  8.     //2. 子类型对象特有的sing方法。
  9.     public void sing(){
  10.         System.out.println("鸟儿在歌唱！！！");
  11.     }
  13. }

❤️子类Cat

  1. // 猫类，子类
  2. public class Cat extends Animal{
  3.     //1. 继承move方法并重写父类的move方法
  4.     public void move(){
  5.         System.out.println("cat走猫步！");
  6.     }
  8.     //2. 子类型对象特有的catchMouse方法。
  9.     public void catchMouse(){
  10.         System.out.println("猫正在抓老鼠！！！！");
  11.     }
  13. }

❤️测试Test01方法，程序的入口

**知识点回顾和补充 **

⭐️两个概念：
（1）第一个：向上转型，子 ---> 父（自动类型转换）
例如：父类型的引用允许指向子类型的对象：Animal a2 = new Cat();
a2就是父类型的引用；new Cat()是一个子类型的对象；允许a2这个父类型引用指向子类型的对象。
（2）第二个：向下转型，父 ---> 子（强制类型转换，需要加强制类型转换符）

⭐️注意：java中允许向上转型，也允许向下转型。
无论是向上转型，还是向下转型，两种类型之间必须有继承关系，没有继承关系编译器报错。我们平常说向上转型和向下转型，不要说自动类型转换，也不要说强制类型转换，因为自动类型转换和强制类型转换是使用在基本数据类型方面的，在引用类型转换这里只有向上和向下转型。
⭐️多态指的是： 多种形态；父类型引用指向子类型对象。包括编译阶段和运行阶段：
编译阶段：静态绑定父类的方法。
运行阶段：动态绑定子类型对象的方法。
⭐️什么时候必须使用“向下转型”？
当你需要访问的是子类对象中“特有”的方法。此时必须进行向下转型。

⭐️运行是出现异常： java.lang.ClassCastException：类型转换异常！
java.lang.NullPointerException：空指针异常！

⭐️怎么避免ClassCastException异常的发生？？？
新的内容，运算符： instanceof （运行阶段动态判断）
第一：instanceof可以在运行阶段动态判断引用指向的对象的类型。
第二：instanceof的语法： (引用 instanceof 类型)
第三：instanceof运算符的运算结果只能是：true/false
第四：c是一个引用，c变量保存了内存地址指向了堆中的对象。
假设(c instanceof Cat)为true表示:
c引用指向的堆内存中的java对象是一个Cat。
假设(c instanceof Cat)为false表示:
c引用指向的堆内存中的java对象不是一个Cat。
好习惯：
任何时候，任何地点，对类型进行向下转型时，一定要使用
instanceof 运算符进行判断。（java规范中要求的。）
这样可以很好的避免：ClassCastException（类型转换异常）

  1. public class Test01{
  2.     public static void main(String[] args){
  3.     //1.调用父类的move    
  4.         Animal a1 = new Animal();
  5.         a1.move(); //动物在移动！！！
  7.     //2.调用Cat子类方法覆盖的move    
  8.         Cat c1 = new Cat();
  9.         c1.move(); //cat走猫步！
  11.     //3.调用Bird子类方法覆盖的move
  12.         Bird b1 = new Bird();
  13.         b1.move(); //鸟儿在飞翔！！！
  15.     //4. 新知识点：多态：父类型的引用指向子类型的对象
  16.         Animal a2 = new Cat();
  17.         Animal a3 = new Bird(); //必须存在继承关系才可以这样写
  19.  /*
  20.     1、Animal和Cat之间有继承关系！
  21.     2、Animal是父类，Cat是子类。
  22.     3、Cat is a Animal，这句话能说通！
  23.     4、java中支持这样的一个语法：父类型的引用允许指向子类型的对象。
  24.       例如：Animal a2 = new Cat();
  25.            a2就是父类型的引用。
  26.            new Cat()是一个子类型的对象。
  27.            允许a2这个父类型引用指向子类型的对象。
  28.     5、假设存在一个Dog类，并不是继承父类Animal
  29.       例如：Animal a4 = new Dog(); // 没有继承关系的两个类型之间不存在转型
  30.       错误: 不兼容的类型: Dog无法转换为Animal
  31. */
  33.     //5. 调用a2的move()方法
  34.         /*
  35.             多态：多种形态，多种状态。
  36.             分析：a2.move();
  37.             java程序分为编译阶段和运行阶段。
  38.                （1）编译阶段：静态绑定
  39.                     对于编译器来说，编译器只知道a2的类型是Animal，
  40.                     所以编译器在检查语法的时候，会去Animal.class
  41.                     字节码文件中找move()方法，找到了，绑定上move()
  42.                     方法，编译通过，静态绑定成功。（编译阶段属于静态绑定。）
  43.                 （2）分析运行阶段：动态绑定
  44.                     运行阶段的时候，实际上在堆内存中创建的java对象是
  45.                     Cat对象，所以move的时候，真正参与move的对象是一只猫，
  46.                     所以运行阶段会动态执行Cat对象的move()方法。这个过程
  47.                     属于运行阶段绑定。（运行阶段绑定属于动态绑定。）
  49.             多态表示多种形态：编译的时候一种形态；运行的时候另一种形态。
  50.         */
  51.         a2.move(); //cat走猫步！
  52.         
  53.         // 调用a3的move()方法
  54.         a3.move(); //鸟儿在飞翔！！！
  56.         // ======================================================================
  57.         6、Animal a5 = new Cat(); // 底层对象是一只猫。
  58.         //a5.catchMouse(); //这个方法实际上是子类特有的方法，不是继承过来的；静态绑定失败！
  59.         // 分析这个程序能否编译和运行呢？
  60.         // 分析程序一定要分析编译阶段的静态绑定和运行阶段的动态绑定。
  61.         // 只有编译通过的代码才能运行。没有编译，根本轮不到运行。
  62.         // 错误: 找不到符号
  63.         // why??? 因为编译器只知道a5的类型是Animal，去Animal.class文件中找catchMouse()方法；结果没有找到，所以静态绑定失败，编译报错。无法运行。（语法不合法。）
  64.         
  65.         //7、 假设代码写到了这里，我非要调用catchMouse()方法怎么办？
  66.         // 这个时候就必须使用“向下转型”了。（强制类型转换）
  67.         // 以下这行代码为啥没报错？？？？
  68.         // 因为a5是Animal类型，转成Cat，Animal和Cat之间存在继承关系。所以没报错。
  69.         Cat x = (Cat)a5;
  70.         x.catchMouse(); //猫正在抓老鼠！！！！
  72.         //8、 向下转型有风险吗？
  73.         Animal a6 = new Bird(); //表面上a6是一个Animal，运行的时候实际上是一只鸟儿。
  74.         //Cat y = (Cat)a6; //却要强转成猫儿
  75.         //y.catchMouse();
  76.         /*
  77.             分析以下程序，编译报错还是运行报错？？？
  78.                 （1）编译器检测到a6这个引用是Animal类型，
  79.                 而Animal和Cat之间存在继承关系，所以可以向下转型。
  80.                 编译没毛病。
  82.                 （2）运行阶段，堆内存实际创建的对象是：Bird对象。
  83.                 在实际运行过程中，拿着Bird对象转换成Cat对象
  84.                 就不行了。因为Bird和Cat之间没有继承关系。
  85.             
  86.             运行是出现异常，这个异常和空指针异常一样非常重要，也非常经典：
  87.                 java.lang.ClassCastException：类型转换异常。
  88.             
  89.             java.lang.NullPointerException：空指针异常。这个也非常重要。
  90.         */
  91.         
  93.         //9、 怎么避免ClassCastException异常的发生？？？
  94.         /*    
  95.             新的内容，运算符：
  96.                 instanceof （运行阶段动态判断）
  97.             第一：instanceof可以在运行阶段动态判断引用指向的对象的类型。
  98.             第二：instanceof的语法：
  99.                 (引用 instanceof 类型)
  100.             第三：instanceof运算符的运算结果只能是：true/false
  101.             第四：c是一个引用，c变量保存了内存地址指向了堆中的对象。
  102.                 假设(c instanceof Cat)为true表示:
  103.                     c引用指向的堆内存中的java对象是一个Cat。
  104.                 假设(c instanceof Cat)为false表示:
  105.                     c引用指向的堆内存中的java对象不是一个Cat。
  106.             
  107.             程序员要养成一个好习惯：
  108.                 任何时候，任何地点，对类型进行向下转型时，一定要使用
  109.                 instanceof 运算符进行判断。（java规范中要求的。）
  110.                 这样可以很好的避免：ClassCastException
  111.         */
  112.         System.out.println(a6 instanceof Cat); //false
  114.         if(a6 instanceof Cat){ // 如果a6是一只Cat
  115.             Cat y = (Cat)a6;  // 再进行强制类型转换
  116.             y.catchMouse();
  117.         }
  118.     }
  119. }

❤️测试Test02方法：instanceof的常规使用

  1. public class Test02{
  2.     public static void main(String[] args){
  3.         Animal x = new Bird();
  4.         Animal y = new Cat();
  6.         if(x instanceof Bird){
  7.             Bird b = (Bird)x;
  8.             b.sing();
  9.         } else if(x instanceof Cat){
  10.             Cat c = (Cat)x;
  11.             c.catchMouse();
  12.         }
  14.         if(y instanceof Bird){
  15.             Bird b = (Bird)y;
  16.             b.sing();
  17.         } else if(y instanceof Cat){
  18.             Cat c = (Cat)y;
  19.             c.catchMouse();
  20.         }
  21.     }
  22. }

❤️测试Test03方法：为什么使用instanceof

  1. public class Test03{
  2.     public static void main(String[] args){
  3.         // main方法是程序员A负责编写。
  4.         AnimalTest at = new AnimalTest();
  5.         at.test(new Cat());
  6.         at.test(new Bird());
  7.     }
  8. }
  10. public class AnimalTest{    
  11.     // test方法是程序员B负责编写。
  12.     // 这个test()方法的参数是一个Animal
  13.     public void test(Animal a){ // 实例方法----只知道animal，但是不知道具体的调用方法
  14.         // 你写的这个方法别人会去调用。
  15.         // 别人调用的时候可能给你test()方法传过来一个Bird
  16.         // 当然也可能传过来一个Cat
  17.         // 对于我来说，我不知道你调用的时候给我传过来一个啥。
  18.         if(a instanceof Cat){
  19.             Cat c = (Cat)a;
  20.             c.catchMouse();
  21.         }else if(a instanceof Bird){
  22.             Bird b = (Bird)a;
  23.             b.sing();
  24.         }
  25.     }
  27. }

❤️起初程序---先不使用多态（先理解逻辑）

⭐️Dog类---宠物

  1. //---宠物狗类
  2. public class Dog{
  3.     public void eat(){
  4.         System.out.println("狗狗喜欢啃骨头，吃的很香！");
  5.     }    
  6. }

⭐️Master类---主人

  1. // 主人类
  2. public class Master{
  3.     //---只喜欢狗狗
  4.     public void feed(Dog d){
  5.         d.eat();
  6.     }
  7. }

⭐️测试Test

  1. //---测试程序
  2. public class Test{
  3.     public static void main(String[] args){
  4.         //创建主人对象
  5.         Master master = new Master();
  6.         //创建狗狗对象
  7.         Dog dog = new Dog();
  8.         //主人喂---建立联系
  9.         master.feed(dog);
  10.     }
  11. }

❤️中间程序---假如又喜欢其它宠物，增加程序

⭐️又喜欢猫咪，增加Cat类---宠物

  1. //增加---宠物猫类
  2. public class Cat{
  3.     public static void main(String[] args){
  4.         System.out.println("猫咪喜欢吃鱼，吃的很香！");
  5.     }
  6. }

⭐️还要修改Master类---主人

  1. // 主人类
  2. public class Master{
  3.     //---只喜欢狗狗
  4.     public void feed(Dog d){
  5.         d.eat();
  6.     }
  7.     //---又喜欢猫咪了
  8.     //实际上写死了，每次有新需求都要改Master里面的代码，扩展性不好
  9.     public void feed(Cat c){
  10.         c.eat();
  11.     }
  12. }

⭐️测试Test

  1. //---测试程序，测试多态在开发中的作用
  2. public class Test{
  3.     public static void main(String[] args){
  4.         //创建主人对象
  5.         Master master = new Master();
  6.         //创建狗狗对象
  7.         Dog dog = new Dog();
  8.         //主人喂---建立联系
  9.         master.feed(dog);
  11.         //创建猫咪对象
  12.         Cat cat = new Cat();
  13.         master.feed(cat);
  14.     }
  15. }

❤️最终程序---使用多态，增加可扩展性；以后增加新宠物既不需要修改Master类代码！

⭐️思考：软件在扩展新需求过程当中，修改Master这个类有什么问题？
一定要记住：软件在扩展过程当中，修改的越少越好。修改的越多，你的系统当前的稳定性就越差，未知的风险就越多。

⭐️其实这里涉及到一个软件的开发原则：
软件开发原则有七大原则：其中有一条最基本的原则：OCP（开闭原则）

⭐️什么是开闭原则？
对扩展开放（你可以额外添加，没问题），对修改关闭（最好很少的修改现有程序）。软件的扩展过程当中，修改的越少越好。

⭐️什么是软件扩展性？
假设电脑中的内存条部件坏了，我们可以买一个新的插上，直接使用。这个电脑的设计就考虑了“扩展性”。内存条的扩展性很好。
⭐️面向父类型编程，面向更加抽象进行编程，不建议面向具体编程。因为面向具体编程会让软件的扩展力很差。

⭐️不在写具体的宠物类，写一个抽象类Pet作为父类；其它具体宠物作为子类

  1. public class Pet{
  2.     public void eat(){ //具体方法不用写，后面具体子类会覆盖整个方法
  3.         
  4.     }
  5. }

⭐️Dog子类和Cat子类

  1. //---宠物狗类
  2. public class Dog extends Pet{ //子类继承父类
  3.     public void eat(){    //方法的覆盖
  4.         System.out.println("狗狗喜欢啃骨头，吃的很香！");
  5.     }    
  6. }
  1. //---宠物猫类
  2. public class Cat extends Pet{//子类继承父类
  3.     public void eat(){//方法的覆盖
  4.         System.out.println("猫咪喜欢吃鱼，吃的很香！");
  5.     }
  6. }

⭐️Master类---主人

  1. // 主人类
  2. public class Master{
  3.     public void feed(Pet pet){
  4.  //传过来一个抽象类（父类）;假设是猫类：Pet pet = new Cat()
  5.         // 编译的时候，编译器发现pet是Pet类，会去Pet类中找eat()方法，结果找到了，编译通过
  6.         // 运行的时候，底层实际的对象是什么，就自动调用到该实际对象对应的eat()方法上。
  7.         // 这就是多态的使用。
  8.         pet.eat();
  9.     }
  10. }

⭐️测试Test---测试代码不变

  1. //---测试程序，测试多态在开发中的作用
  2. public class Test{
  3.     public static void main(String[] args){
  4.         //创建主人对象
  5.         Master master = new Master();
  6.         //创建狗狗对象
  7.         Dog dog = new Dog();
  8.         //主人喂---建立联系
  9.         master.feed(dog);
  11.         //创建猫咪对象
  12.         Cat cat = new Cat();
  13.         master.feed(cat);
  14.     }
  15. }

❤️总结多态在开发中的作用

⭐️多态在开发中的作用是：降低程序的耦合度，提高程序的扩展力。

  1.    public class Master{
  2.             public void feed(Dog d){}
  3.             public void feed(Cat c){}
  4.         }
  5. //以上的代码中表示：Master和Dog以及Cat的关系很紧密（耦合度高）。导致扩展力很差。
  1.    public class Master{
  2.             public void feed(Pet pet){
  3.                 pet.eat();
  4.             }
  5.         }
  6. //以上的代表中表示：Master和Dog以及Cat的关系就脱离了，Master关注的是Pet类。
  7.   这样Master和Dog以及Cat的耦合度就降低了，提高了软件的扩展性。

** ⭐️面向对象的三大特征：封装、继承、多态**

** （1）有了封装，有了这种整体的概念之后。
（2）对象和对象之间产生了继承。
（3）有了继承之后，才有了方法的覆盖和多态。
⭐️这里提到了一个软件开发原则：
七大原则最基本的原则：OCP（对扩展开放，对修改关闭）
目的是：降低程序耦合度，提高程序扩展力。
⭐️面向抽象编程，不建议面向具体编程!**

编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从而发出不同的声音。
可以弹奏的乐器包括二胡、钢琴和琵琶。
实现思路及关键代码：
1)定义乐器类Instrument，包括方法makeSound()
2)定义乐器类的子类：二胡Erhu、钢琴Piano和小提琴Violin
3)定义乐手类Musician，可以弹奏各种乐器play(Instrument i)
4)定义测试类，给乐手不同的乐器让他弹奏

  1. /*
  2. 编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从而发出不同的声音。
  3. 可以弹奏的乐器包括二胡、钢琴和琵琶。
  4.     实现思路及关键代码：
  5.         1)定义乐器类Instrument，包括方法makeSound()
  6.         2)定义乐器类的子类：二胡Erhu、钢琴Piano和小提琴Violin
  7.         3)定义乐手类Musician，可以弹奏各种乐器play(Instrument i)
  8.         4)定义测试类，给乐手不同的乐器让他弹奏
  9. */
  11. public class Test{
  12.     public static void main(String[] args){
  13. //4.测试
  14.      //-------------第一种方法
  15.        //创建乐器对象
  16.        Erhu erhu = new Erhu();
  17.        Piano piano = new Piano();
  18.        Violin violin = new Violin();
  19.        //创建乐手对象
  20.        Musician musician = new Musician();
  21.        //play
  22.        musician.play(erhu);
  23.        musician.play(piano);
  24.        musician.play(violin);
  26.      //-------------第二种方法---父类的引用指向子类的对象
  27.        //创建乐器对象
  28.        Instrument erhu1 = new Erhu();
  29.        Instrument piano1 = new Piano();
  30.        Instrument violin1 = new Violin();
  31.        //创建乐手对象
  32.        Musician musician1 = new Musician();
  33.        //play
  34.        musician1.play(erhu1);
  35.        musician1.play(piano1);
  36.        musician1.play(violin1);
  37.        musician.play(violin);
  39.      //-------------第三种方法
  40.        //创建乐手对象
  41.        Musician musician2 = new Musician();
  42.        //play
  43.        musician2.play(new Erhu());
  44.        musician2.play(new Piano());
  45.        musician2.play(new Violin());
  47.     }
  48. }
  50. //3. 乐手类
  51. //---按照题目要求的方法
  53. class Musician{
  54.     public void play(Instrument i){
  55.         i.makeSound();
  56.     }
  57. }
  59. /*
  60. //----使用以前的方法
  61. class Musician{
  62.     Instrument i;
  63.     //构造方法
  64.     public Musician(){ //无参构造
  65.     } 
  66.     public Musician(Instrument i){ //有参构造犯
  67.         this.i = i;
  68.     }
  69.     //play方法
  70.     public void play(){
  71.         i.makeSound();
  72.     }
  73. }
  74. */
  76. //1. 乐器类---父类
  77. class Instrument{
  78.     // 乐器发声 ---方法
  79.     public void makeSound(){
  80.         
  81.     }
  82. }
  84. //2.  三个子类
  85. class Erhu extends Instrument{
  86.     public void makeSound(){ //方法重写
  87.         System.out.println("二胡的声音！！！");
  88.     }
  89. }
  90. class Piano extends Instrument{
  91.     public void makeSound(){ //方法重写
  92.         System.out.println("钢琴的声音！！！");
  93.     }
  94. }
  95. class Violin extends Instrument{
  96.     public void makeSound(){ //方法重写
  97.         System.out.println("小提琴的声音！！！");
  98.     }
  99. }

❤️静态方法不谈覆盖

  1. **⭐️**私有方法无法覆盖。
  2.  **⭐️**方法覆盖只是针对于“实例方法”，“静态方法覆盖”没有意义。（这是因为方法覆盖通常和多态联合起来）
  3.  **⭐️**总结两句话： **私有不能覆盖；静态不谈覆盖**。

⭐️方法覆盖需要和多态机制联合起来使用才有意义。 

  1. Animal a = new Cat();
  2. a.move();

要的是什么效果？
（1）编译的时候move()方法是Animal的。
（2）运行的时候自动调用到子类重写move()方法上。
⭐️假设没有多态机制，只有方法覆盖机制，你觉得有意义吗？
（1）没有多态机制的话，方法覆盖可有可无。

  1.   （2）没有多态机制，方法覆盖也可以没有，如果父类的方法无法满足
  2.    （3）子类业务需求的时候，子类完全可以定义一个全新的方法。
  3.    （4）方法覆盖和多态不能分开。

⭐️静态方法存在方法覆盖吗？
（1）多态自然就和对象有关系了。
（2）而静态方法的执行不需要对象。
（3）所以，一般情况下，我们会说静态方法“不存在”方法覆盖；不探讨静态方法的覆盖。

  1. public class OverrideTest05{
  2.     public static void main(String[] args){
  3.         
  4.         Animal a = new Cat(); //多态
  5.         a.doSome(); //就等价于Animal.doSome()
  6.         //最终结果还是调用父类的doSome；因为静态方法和对象无关。
  7.         // 虽然使用“引用.”来调用。但是实际运行的时候还是替换成：Animal.doSome()
  8.         
  9.     }
  10. }
  12. class Animal{
  13.     // 父类的静态方法
  14.     public static void doSome(){
  15.         System.out.println("Animal的doSome方法执行！");
  16.     }
  17. }
  19. class Cat extends Animal{
  20.     // 尝试在子类当中对父类的静态方法进行重写
  21.     public static void doSome(){
  22.         System.out.println("Cat的doSome方法执行！");
  23.     }
  24. }

❤️私有方法不能覆盖

因为方法私有化，我们只能在本类中进行访问；所以我们new对象调用的还是本类中的方法，而不是重写后的方法！

  1. // 私有方法不能覆盖。
  2. public class OverrideTest06{
  4.     // 私有方法；私有的只有当前的类中才能访问
  5.     private void doSome(){ 
  6.         System.out.println("OverrideTest06's private method doSome execute!");
  7.     }
  9.     // 入口
  10.     public static void main(String[] args){
  11.         // 多态
  12.         OverrideTest06 ot = new T();
  13.         ot.doSome(); 
  14.         //OverrideTest06's private method doSome execute!
  15.         //对于私有的无法覆盖，打印的还是原来父类的doSome；如果把private改成public就可以覆盖
  16.     }
  17. }
  19. /*
  20. //--------在外部类中无法访问私有的。
  21. class MyMain{
  22.     public static void main(String[] args){
  23.         OverrideTest06 ot = new T();
  24.         //错误: doSome() 在 OverrideTest06 中是 private 访问控制
  25.         //ot.doSome();
  26.     }
  27. }
  28. */
  30. // 子类：私有方法也能继承过来，但是不能直接访问，可以使用setter和getter方法
  31.         //也可以进行重写，但是访问权限只能那更高
  32. class T extends OverrideTest06{ //继承
  33.     // 尝试重写父类中的doSome()方法
  34.     // 访问权限不能更低，可以更高。
  35.     public void doSome(){
  36.         System.out.println("T's public doSome method execute!");
  37.     }
  38. }

❤️方法覆盖的返回值类型

** ⭐️在方法覆盖中，关于方法的返回值类型。
什么条件满足之后，会构成方法的覆盖呢？
1、发生具有继承关系的两个类之间。
2、父类中的方法和子类重写之后的方法：
具有相同的方法名、相同的形式参数列表、相同的返回值类型！
** ⭐️学习了多态机制之后：
“相同的返回值类型”可以修改一下吗？
对于返回值类型是基本数据类型来说，必须一致。
对于返回值类型是引用数据类型来说，重写之后返回值类型可以变的更小。

  1.            ** 例如：本来返回值是父类型(Animal)，我们重写后返回值可以是子类型(Cat)**
  1. public class OverrideTest07{
  2.     public static void main(String[] args){
  3.         // 一般重写的时候都是复制粘贴。不要动。不要改。    
  4.     }
  5. }
  6. //----------父类
  7. class Animal{
  8. //----------------------------------1.对于基本数据类型
  9. //对于基本数据类型：父类和子类返回类型必须保持一致！
  10.     //1.1
  11.     public double sum(int a, int b){
  12.         return a + b;
  13.     }
  14.     //1.2
  15.     public long sum(int a, int b){
  16.         return a + b;
  17.     }
  18. }
  20. //----------子类
  21. class Cat extends Animal{
  22.     //1.1---父类double，子类返回double没问题
  23.     public double sum(int a, int b){// 重写
  24.         return a + b;
  25.     }
  26.     //1.1---父类double，子类返回int；从大到小---错误
  27.     // 错误: Cat中的sum(int,int)无法覆盖Animal中的sum(int,int)
  28.     public int sum(int a, int b){// 重写
  29.         return a + b;
  30.     }
  32.     //1.2---父类int，子类返回long；从小到大---错误
  33.     public long sum(int a, int b){
  34.         return a + b;
  35.     }
  36. }
  38. //----------------------------------2.引用数据类型
  39. //对于引用数据类型，返回类型范围变小了可以；变大了不可以！
  40. // 父类
  41. class MyClass1{
  42.     public Animal getAnimal(){ //父类是Animal（父类）类型
  43.         return null;
  44.     }
  45. }
  47. // 子类
  48. class MyClass2 extends MyClass1{
  50.     //2.1 重写父类的方法，返回还是Animal，肯定可以
  51.     public Animal getAnimal(){
  52.         return null;
  53.     }
  55.     //2.2 重写的时候返回值类型由Animal变成了Cat，变小了。（可以，java中允许）
  56.     public Cat getAnimal(){ //子类是Cat（子类）类型，变小了；可以！
  57.         return null;
  58.     }
  60.     //2.3 重写的时候返回值类型由Animal变成了Object。变大了。（不行，java中不允许）
  61.     public Object getAnimal(){ 子类是Object（老祖宗）类型，变大了；不可以！
  62.         return null;
  63.     }
  65. }
标签： java 开发语言
本文转载自: https://blog.csdn.net/m0_61933976/article/details/125070919
版权归原作者 @每天都要敲代码 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Java零基础(第十三章)---》方法覆盖和多态”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？