• 【Java】面向对象:继承、组合和多态


    文章目录

    • 一. 面向对象三大特性之继承
    • 二. 面向对象三大特性之多态

    一. 面向对象三大特性之继承

    1. 继承的概念

    继承(inheritance)机制:是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加新功能,这样产生新的类,称派生类(子类)。

    继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用。

    例如:狗和猫都是动物,那么我们就可以将共性的内容进行抽取,然后采用继承的思想来达到共用

     

    上述图示中,Dog和Cat都继承了Animal类,其中:Animal类称为父类/基类/超类,Dog和Cat可以称为Animal的子类/派生类,继承之后,子类可以复用父类中成员,子类在实现时只需关心自己新增加的成员即可。

    2. 继承的语法

    在Java中如果要表示类之间的继承关系,需要借助 extends 关键字,具体如下:

    1. 修饰符 class 子类 extends 父类 {
    2. // ...
    3. }

    此时将 1 中的设计思想使用代码实现:

    1. // Animal.java
    2. public class Animal{
    3. String name;
    4. int age;
    5. public void eat(){
    6. System.out.println(name + "正在吃饭");
    7. }
    8. public void sleep(){
    9. System.out.println(name + "正在睡觉");
    10. }
    11. }
    12. // Dog.java
    13. public class Dog extends Animal{
    14. void bark(){
    15. System.out.println(name + "汪汪汪~~~");
    16. }
    17. }
    18. // Cat.Java
    19. public class Cat extends Animal{
    20. void mew(){
    21. System.out.println(name + "喵喵喵~~~");
    22. }
    23. }
    24. // TestExtend.java
    25. public class TestExtend {
    26. public static void main(String[] args) {
    27. Dog dog = new Dog();
    28. // dog类中并没有定义任何成员变量,
    29. //name和age属性是从父类Animal中继承下来的
    30. System.out.println(dog.name);
    31. System.out.println(dog.age);
    32. //dog访问的eat()和sleep()方法也是从Animal中继承下来的
    33. dog.eat();
    34. dog.sleep();
    35. dog.bark();
    36. }
    37. }

    注意:

    1. 子类会将父类中的成员变量或者成员方法继承到子类中了
    2. 子类继承父类之后,必须要新添加自己特有的成员,体现出与基类的不同,否则就没有必要继承了

    3. 父类成员的访问

    3.1 子类中访问父类的成员变量

    1. 子类和父类不存在同名成员变量
    1. public class Base {
    2. int a;
    3. int b;
    4. }
    5. public class Derived extends Base{
    6. int c;
    7. public void method(){
    8. a = 10; // 访问从父类中继承下来的a
    9. b = 20; // 访问从父类中继承下来的b
    10. c = 30; // 访问子类自己的c
    11. }
    12. }
    1. 子类和父类成员变量同名
    1. public class Base {
    2. int a;
    3. int b;
    4. int c;
    5. }
    6. public class Derived extends Base{
    7. int a; // 与父类中成员a同名,且类型相同
    8. char b; // 与父类中成员b同名,但类型不同
    9. public void method(){
    10. a = 100; // 访问子类自己新增的a
    11. b = 101; // 访问子类自己新增的b
    12. c = 102; // 子类没有c,访问从父类继承下来的c
    13. // d = 103; // 编译失败,因为父类和子类都没有定义成员变量d
    14. }
    15. }

    在子类方法中 或者 通过子类对象访问成员时:

    • 如果访问的成员变量子类中有,优先访问自己的成员变量。
    • 如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有定义,则编译报错。
    • 如果访问的成员变量与父类中 成员变量同名 ,则优先访问自己的。

    成员变量访问遵循就近原则,自己有优先自己的,如果没有则向父类中找

    3.2 子类中访问父类的成员方法

    1. 父类和子类的成员方法 名字不同
    1. public class Base {
    2. public void methodA(){
    3. System.out.println("Base中的methodA()");
    4. }
    5. }
    6. public class Derived extends Base{
    7. public void methodB(){
    8. System.out.println("Derived中的methodB()方法");
    9. }
    10. public void methodC(){
    11. methodB(); // 访问子类自己的methodB()
    12. methodA(); // 访问父类继承的methodA()
    13. // methodD(); // 编译失败,在整个继承体系中没有发现方法methodD()
    14. }
    15. }
    1. 父类和子类的成员方法 名字相同
    1. public class Base {
    2. int a;
    3. int b;
    4. public void methodA(){
    5. System.out.println("Base中的methodA()");
    6. }
    7. public void methodB(){
    8. System.out.println("Base中的methodB()");
    9. }
    10. }
    11. public class Derived extends Base{
    12. public void methodA(int a) {
    13. System.out.println("Derived中的method(int)方法");
    14. }
    15. public void methodB(){
    16. System.out.println("Derived中的methodB()方法");
    17. }
    18. public void methodC(){
    19. methodA(); // 没有传参,访问父类中的methodA()
    20. methodA(20); // 传递int参数,访问子类中的methodA(int)
    21. methodB(); // 直接访问,则永远访问到的都是子类中的methodB(),基类的无法访问到
    22. }
    23. }

    【总结】:

    • 通过子类对象访问父类与子类中不同名方法时, 优先 在子类中找,找到则访问;否则在父类中找,找到则访问,如果父类中也没有则编译报错。
    • 通过派生类对象访问父类与子类同名方法时,如果父类和子类 同名方法的参数列表不同(重载) ,根据调用方法适传递的参数选择合适的方法访问;如果没有则报错。
    • 通过派生类对象访问父类与子类同名方法时,如果父类和子类 同名方法的参数列表、返回值都相同 ,则遵循就近原则,直接访问子类中的方法,不会访问父类中的方法。

    4. protected 的使用场景

     

    结合下面代码理解父类中不同访问权限的成员在子类中的可见性:

    注意:父类中private成员变量虽然在子类中不能直接访问,但是也继承到子类中了

    1. // extend01包中
    2. public class B {
    3. private int a;
    4. protected int b;
    5. public int c;
    6. int d;
    7. }
    8. // extend01包中
    9. // 同一个包中的子类
    10. public class D extends B{
    11. public void method(){
    12. // super.a = 10; // 编译报错,父类private成员在相同包子类中不可见
    13. super.b = 20; // 父类中protected成员在相同包子类中可以直接访问
    14. super.c = 30; // 父类中public成员在相同包子类中可以直接访问
    15. super.d = 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
    16. }
    17. }
    18. // extend02包中
    19. // 不同包中的子类
    20. public class C extends B {
    21. public void method(){
    22. //super.a = 10; // 编译报错,父类中private成员在不同包子类中不可见
    23. super.b = 20; // 父类中protected修饰的成员在不同包子类中可以直接访问
    24. super.c = 30; // 父类中public修饰的成员在不同包子类中可以直接访问
    25. //super.d = 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
    26. }
    27. }
    28. // extend02包中
    29. // 不同包中的类
    30. public class TestC {
    31. public static void main(String[] args) {
    32. C c = new C();
    33. c.method();
    34. // System.out.println(c.a); // 编译报错,父类中private成员在不同包其他类中不可见
    35. // System.out.println(c.b); // 父类中protected成员在不同包其他类中不能直接访问
    36. System.out.println(c.c); // 父类中public成员在不同包其他类中可以直接访问
    37. // System.out.println(c.d); // 父类中默认访问权限修饰的成员在不同包其他类中不能直接访问
    38. }
    39. }

    5. 继承方式

    但在Java中只支持以下几种继承方式:

    注意:Java中不支持多继承,且一般我们不希望出现超过三层的继承关系。

    6. final 关键字

    final关键可以用来修饰变量、成员方法以及类。

    1. 修饰变量或字段,表示常量(即不能修改)
    final int a = 10;
    a = 20; // 编译出错,这里a是常量,不可以被修改
    1. 修饰类:表示此类不能被继承
    1. final public class Animal {
    2. ...
    3. }
    4. public class Bird extends Animal {
    5. ...
    6. }
    7. // 编译出错
    8. Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

    观察 String 字符串类的源码, 默认就是用 final 修饰的, 不能被继承.

    1. 修饰方法:final修饰的方法叫做密封方法,不能被重写。

    7. 继承与组合

    和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是 将一个类的实例作为另外一个类的字段 。

    继承表示对象之间是is-a的关系,比如:狗是动物,猫是动物

    组合表示对象之间是has-a的关系,比如:汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合,因为汽车是有这些部件组成的。

    1. // 轮胎类
    2. class Tire{
    3. // ...
    4. } /
    5. / 发动机类
    6. class Engine{
    7. // ...
    8. } /
    9. / 车载系统类
    10. class VehicleSystem{
    11. // ...
    12. }
    13. class Car{
    14. private Tire tire; // 可以复用轮胎中的属性和方法
    15. private Engine engine; // 可以复用发动机中的属性和方法
    16. private VehicleSystem vs; // 可以复用车载系统中的属性和方法
    17. // ...
    18. } /
    19. / 奔驰是汽车
    20. class Benz extend Car{
    21. // 将汽车中包含的:轮胎、发送机、车载系统全部继承下来
    22. }

    组合和继承都可以实现代码复用,应该使用继承还是组合,需要根据应用场景来选择,一般建议:能用组合尽量用组合。

    二. 面向对象三大特性之多态

    1. 多态的概念

    俗来说,就是多种形态,**具体点就是去完成某个行为,当不同的对象去完成时会产生出不同 的状态;**同一件事情,发生在不同对象身上,就会产生不同的结果。

    2. 重写

    重写(override):也称为覆盖。重写是子类对父类 非静态、非private修饰,非final修饰,非构造方法等 的实现过程进行重新编写, 返回值和形参都不能改变 。**即外壳不变,核心重写!**重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

    【 方法重写的规则 】

    @Override
    

    【重写和重载的区别】

    方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现

    区别点重写(override)重载(override)
    参数列表绝对不可以修改必须修改
    返回类型不可以修改【除非可以构成父子类关系】可以修改
    访问限定符不能比父类中被重写的方法的访问权限更低可以修改

    【 重写的设计原则 】

    对于已经投入使用的类,尽量不要进行修改。最好的方式是:重新定义一个新的类,来重复利用其中共性的内容,并且添加或者改动新的内容。

    **静态绑定:**也称为前期绑定(早绑定),即在编译时,根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

    **动态绑定:**也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法。 这也是多态的特征。

    3. 向上转型和向下转型

    3.1 向上转型

    向上转型:实际就是创建一个子类对象,将其当成父类对象来使用

    语法格式:父类类型 对象名 = new 子类类型( )

    //animal是父类类型,但可以引用一个子类对象,因为是从小范围向大范围的转换。
    Animal animal = new Cat("元宝",2);

    【使用场景】

    1. 直接赋值
    2. 方法传参
    3. 方法返回
    1. public class TestAnimal {
    2. // 2. 方法传参:形参为父类型引用,可以接收任意子类的对象
    3. public static void eatFood(Animal a){
    4. a.eat();
    5. }
    6. // 3. 作返回值:返回任意子类对象
    7. public static Animal buyAnimal(String var){
    8. if("狗" == var){
    9. return new Dog("狗狗",1);
    10. }else if("猫" == var){
    11. return new Cat("猫猫", 1);
    12. }else{
    13. return null;
    14. }
    15. }
    16. public static void main(String[] args) {
    17. Animal cat = new Cat("元宝",2);
    18. // 1. 直接赋值:子类对象赋值给父类对象
    19. Dog dog = new Dog("小七", 1);
    20. eatFood(cat);
    21. eatFood(dog);
    22. Animal animal = buyAnimal("狗");
    23. animal.eat();
    24. animal = buyAnimal("猫");
    25. animal.eat();
    26. }
    27. }
    28. public class Animal{
    29. String name;
    30. int age;
    31. public void eat(){
    32. System.out.println(name + "正在吃饭");
    33. }
    34. public void sleep(){
    35. System.out.println(name + "正在睡觉");
    36. }
    37. }
    38. // Dog.java
    39. public class Dog extends Animal{
    40. void bark(){
    41. System.out.println(name + "汪汪汪~~~");
    42. }
    43. }
    44. // Cat.Java
    45. public class Cat extends Animal{
    46. void mew(){
    47. System.out.println(name + "喵喵喵~~~");
    48. }
    49. }

    向上转型的优点:让代码实现更简单灵活。

    向上转型的缺陷:不能调用到子类特有的方法。

    3.2 向下转型

    将一个子类对象经过向上转型之后当成父类方法使用,再无法调用子类的方法,但有时候可能需要调用子类特有的方法,此时:将父类引用再还原为子类对象即可,即向下转型

    1. public class TestAnimal {
    2. public static void main(String[] args) {
    3. Cat cat = new Cat("元宝",2);
    4. Dog dog = new Dog("小七", 1);
    5. // 向上转型
    6. Animal animal = cat;
    7. animal.eat();
    8. animal = dog;
    9. animal.eat();
    10. // 编译失败,编译时编译器将animal当成Animal对象处理
    11. // 而Animal类中没有bark方法,因此编译失败
    12. // animal.bark();
    13. // 向上转型
    14. // 程序可以通过编程,但运行时抛出异常---因为:animal实际指向的是狗
    15. // 现在要强制还原为猫,无法正常还原,运行时抛出:ClstException
    16. cat = (Cat)animal;
    17. cat.mew();
    18. // animal本来指向的就是狗,因此将animal还原为狗也是安全的
    19. dog = (Dog)animal;
    20. dog.bark();
    21. }
    22. }

    向下转型用的比较少,而且不安全,万一转换失败,运行时就会抛异常。Java中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为true,则可以安全转换。

    instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例,返回 boolean 的数据类型。

    1. public class TestAnimal {
    2. public static void main(String[] args) {
    3. Cat cat = new Cat("元宝",2);
    4. Dog dog = new Dog("小七", 1);
    5. // 向上转型
    6. Animal animal = cat;
    7. animal.eat();
    8. animal = dog;
    9. animal.eat();
    10. if(animal instanceof Cat){
    11. cat = (Cat)animal;
    12. cat.mew();
    13. }
    14. if(animal instanceof Dog){
    15. dog = (Dog)animal;
    16. dog.bark();
    17. }
    18. }
    19. }

    4. 多态实现条件

    在java中要实现多态,必须要满足如下几个条件,缺一不可:

    1. 必须在继承体系下
    2. 子类必须要对父类中方法进行重写
    3. 通过父类的引用调用重写的方法

    多态体现:在代码运行时,当传递不同类对象时,会调用对应类中的方法。

    实现多态的实例:

    1. public class Animal {
    2. String name;
    3. int age;
    4. public Animal(String name, int age){
    5. this.name = name;
    6. this.age = age;
    7. }
    8. public void eat(){
    9. System.out.println(name + "吃饭");
    10. }
    11. }
    12. public class Cat extends Animal{
    13. public Cat(String name, int age){
    14. super(name, age);
    15. }
    16. @Override
    17. public void eat(){
    18. System.out.println(name+"吃鱼~~~");
    19. }
    20. }
    21. public class Dog extends Animal {
    22. public Dog(String name, int age){
    23. super(name, age);
    24. }
    25. @Override
    26. public void eat(){
    27. System.out.println(name+"吃骨头~~~");
    28. }
    29. }
    30. ///分割线//
    31. public class TestAnimal {
    // 编译器在编译代码时,并不知道要调用Dog 还是 Cat 中eat的方法
    // 等程序运行起来后,形参a引用的具体对象确定后,才知道调用那个方法
    // 注意:此处的形参类型必须时父类类型才可以
     
    1. public static void eat(Animal a){
    2. a.eat();
    3. }
    4. public static void main(String[] args) {
    5. Cat cat = new Cat("元宝",2);
    6. Dog dog = new Dog("小七", 1);
    7. eat(cat);
    8. eat(dog);
    9. }
    10. }

    执行结果:

    在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者(调用类中的方法) 编写的。

    当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并 不知道 , 也不关注 当前的 a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态 .

     

    5. 多态的优缺点

    5.1 使用多态好处

    1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else

    圈复杂度是一种描述一段代码复杂程度的方式,计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”;如果一个方法的圈复杂度太高, 就需要考虑重构,不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10 。

    例如要打印多个形状, 如果不基于多态, 实现代码如下:

    1. public class Test{
    2. public static void drawShapes() {
    3. Rect rect = new Rect();
    4. Cycle cycle = new Cycle();
    5. Flower flower = new Flower();
    6. String[] shapes = {
    7. "cycle", "rect", "cycle", "rect", "flower"};
    8. for (String shape : shapes) {
    9. if (shape.equals("cycle")) {
    10. cycle.draw();
    11. } else if (shape.equals("rect")) {
    12. rect.draw();
    13. } else if (shape.equals("flower")) {
    14. flower.draw();
    15. }
    16. }
    17. }
    18. public static void main(String[] args) {
    19. drawShapes();
    20. }
    21. }
    22. class Shape {
    23. //属性....
    24. public void draw() {
    25. System.out.println("画图形!");
    26. }
    27. }
    28. class Rect extends Shape{
    29. @Override
    30. public void draw() {
    31. System.out.println("♦");
    32. }
    33. }
    34. class Cycle extends Shape{
    35. @Override
    36. public void draw() {
    37. System.out.println("●");
    38. }
    39. }
    40. class Flower extends Shape{
    41. @Override
    42. public void draw() {
    43. System.out.println("❀");
    44. }
    45. }

    如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单

    1. public static void drawShapes() {
    2. // 我们创建了一个 Shape 对象的数组.
    3. Shape[] shapes = {
    4. new Cycle(),
    5. new Rect(),
    6. new Cycle(),
    7. new Rect(),
    8. new Flower()
    9. };
    10. for (Shape shape : shapes) {
    11. shape.draw();
    12. }
    13. }
    1. 可扩展能力更强

    如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

    对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低;而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高。

    1. class Triangle extends Shape {
    2. @Override
    3. public void draw() {
    4. System.out.println("△");
    5. }
    6. }

    5.2 多态的缺陷

    1. 代码的运行效率降低
    2. 属性没有多态性,当父类和子类都有同名属性的时候,通过父类引用,只能引用父类自己的成员属性 。
    3. 构造方法没有多态性 。
  • 相关阅读:
    js图像对比可用的一些资源
    【教3妹学算法-每日1题】非递增顺序的最小子序列
    2023年PMP考试会用新版教材吗?回复来了!
    CentOS安装Docker
    运维-技能大杂烩
    C 语言进阶
    @hook扩展分析
    AIGC程序员效能提升之道
    【高级篇 / ZTNA】(7.0) ❀ 04. FortiClient 下载与安装 ❀ FortiGate 防火墙
    【力扣每日一题】2023.9.12 课程表Ⅳ
  • 原文地址:https://blog.csdn.net/guanshengg/article/details/126280024