Vane's Blog

vuePress-theme-reco Vane    2018 - 2020
Vane's Blog Vane's Blog

Choose mode

  • dark
  • auto
  • light
首页
分类
  • 设计模式
  • 重新认识系列
  • 源码解析
标签
时间轴
关于
  • GitHub
  • 简书
author-avatar

Vane

8

文章

6

标签

首页
分类
  • 设计模式
  • 重新认识系列
  • 源码解析
标签
时间轴
关于
  • GitHub
  • 简书
  • 重新认识《面向对象 - 三大特性(封装、继承、多态)》

    • 封装
      • 继承
        • 多态

        重新认识《面向对象 - 三大特性(封装、继承、多态)》

        vuePress-theme-reco Vane    2018 - 2020

        重新认识《面向对象 - 三大特性(封装、继承、多态)》


        Vane 2020-04-21 面试 面向对象

        三大基本特性是理解六大基本原则的前提。

        # 封装

        利用抽象数据类型将数据和基于数据的操作封装在一起,使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部,尽可能地隐藏内部的细节,只保留一些对外的接口使其与外部发生联系。用户无需关心对象内部的细节,但可以通过对象对外提供的接口来访问该对象。

        优点:

        • 减少耦合:可以独立地开发、测试、优化、使用、理解和修改
        • 减轻维护的负担:可以更容易被理解,并且在调试的时候可以不影响其他模块
        • 有效地调节性能:可以通过剖析来确定哪些模块影响了系统的性能
        • 提高软件的可重用性

        降低了构建大型系统的风险:即使整个系统不可用,但是这些独立的模块却有可能是可用的 以下 Person 类封装 name、gender、age 等属性,外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性,而无法获取 age 属性,但是 age 属性可以供 work() 方法使用。

        注意到 gender 属性使用 int 数据类型进行存储,封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时,也可以在不影响客户端代码的情况下进行。

        public class Person {
        
            private String name;
            private int gender;
            private int age;
        
            public String getName() {
                return name;
            }
        
            public String getGender() {
                return gender == 0 ? "man" : "woman";
            }
        
            public void work() {
                if (18 <= age && age <= 50) {
                    System.out.println(name + " is working very hard!");
                } else {
                    System.out.println(name + " can't work any more!");
                }
            }
        }
        
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22

        # 继承

        继承实现了 IS-A 关系,例如 Cat 和 Animal 就是一种 IS-A 关系,因此 Cat 可以继承自 Animal,从而获得 Animal 非 private 的属性和方法。

        继承应该遵循里氏替换原则,子类对象必须能够替换掉所有父类对象。

        Cat 可以当做 Animal 来使用,也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 向上转型 。

        Animal animal = new Cat();
        
        1

        # 多态

        多态分为编译时多态和运行时多态:

        • 编译时多态主要指方法的重载
        • 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定

        运行时多态有三个条件:

        • 继承
        • 覆盖(重写)
        • 向上转型

        下面的代码中,动物类(Animal)有两个子类:猫(Cat) 和 狗(Dog),它们都覆盖了父类的 cry() 方法,并且在 main() 方法中使用父类 Animal 来引用 Cat 和 Dog 对象。在 Animal 引用调用 cry() 方法时,会执行实际引用对象所在类的 cry() 方法,而不是 Animal 类的方法。

        public class Animal {
        
            public void cry() {
                System.out.println("Animal is crying...");
            }
        }
        
        1
        2
        3
        4
        5
        6
        public class Cat extends Animal {
        
            public void cry() {
                System.out.println("Miao~Miao~Miao~");
            }
        }
        
        1
        2
        3
        4
        5
        6
        public class Dog extends Animal {
        
            public void cry() {
                System.out.println("Wang! Wang!Wang!");
            }
        }
        
        1
        2
        3
        4
        5
        6
        public class Music {
        
            public static void main(String[] args) {
                //父类的引用指向子类对象
                Animal cat = new Cat(); 
                Animal dog = new Dog();
                cat.cry();
                dog.cry();
            }
        }
        
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        Miao~Miao~Miao~
        Wang! Wang!Wang!
        
        1
        2

        本文转载自CS-Notes 的《面向对象思想》一文

        参考文章:

        • 面向对象的三大基本特征,五大基本原则
        • 面向对象编程三大特性------封装、继承、多态