• 封装、继承和多态

    目录

    • 前言
    • 一、什么是封装？
    • 二、什么是继承？
    • 三、什么是多态？

    前言

    其实封装、继承和多态不仅仅是java的特性，而是所有面向对象程序的三大特性。

    一、什么是封装？

    封装就是对类内部的实现细节进行隐藏，然后对类外提供公开的接口。

    在Java 中主要通过访问权限来实现封装， 访问权限用来控制方法或者属性能否直接在类外使用 。 Java 中提供了四种访问限定符：

    封装一般就是我们把类属性加上private进行修饰，把属性进行私有化。 

    1. public class Student {
    2.  
    3. private String name;
    4.  
    5. private int age;
    6.  
    7. private int classid;
    8. }

    在这个学生类中，我们把name和age以及classid属性被设置为私有的，那么它只能被这个类访问，而不能被其他类访问，因此信息是隐藏的。为了让外部进行访问，我们还可以为每个属性提供公开的方法：Getter and Setter

    1.  public String getName() {
    2.         return name;
    3.     }
    4.  
    5.     public void setName(String name) {
    6.         this.name = name;
    7.     }
    8.  
    9.     public int getAge() {
    10.         return age;
    11.     }
    12.  
    13.     public void setAge(int age) {
    14.         this.age = age;
    15.     }
    16.  
    17.     public int getClassid() {
    18.         return classid;
    19.     }
    20.  
    21.     public void setClassid(int classid) {
    22.         this.classid = classid;
    23.     }

    因此，如果外部类想要访问类中私有成员变量的都必须使用这些getter和setter方法。

    封装的优点：良好的包装可以减少耦合；类的内部结构可以自由修改；可以更精确地控制成员变量；隐藏信息和实现细节。

    二、什么是继承？

    在Java中，可以通过extends关键字申明一个类是从另一个类继承而来的：

    1. class 父类 {
    2.  
    3. }
    4.  
    5. class 子类 extends 父类 {
    6.  
    7. }

    继承其实是父类对子类的共性的抽取， 实现代码的复用。

     

     

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

    如果访问的成员变量子类中有，优先访问自己的成员变量。
    如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
    如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
    成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找 。

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

    通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到 则访问，否则编译报错。
    通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同 ( 重载 ) ，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

    如果子类中存在与父类中相同的成员时，那么在子类中访问父类相同名称的成员就需要使用super关键字。super关键字的主要作用：在子类方法中访问父类的成员。了解super可以参考这篇文章。

    super和this有什么区别？-java_crazy__xieyi的博客-CSDN博客

    三、什么是多态？

    一个引用调用同一个方法，因为这个引用 引用的对象不一样，导致调用这个方法，所表现出来的行为不一样。这种思想就叫做多态。

    在 java 中要实现多态，必须要满足如下几个条件，缺一不可：
    1. 必须在继承体系下
    2. 子类必须要对父类中方法进行重写
    3. 通过父类的引用调用重写的方法
    多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。 
    1. public class Animal {
    2.     String name; 
    3.     int age;
    4.  
    5.     public Animal(String name, int age){
    6.         this.name = name;
    7.         this.age = age;
    8.     }
    9.     public void eat(){ //重写了eat方法
    10.         System.out.println(name + "吃饭");
    11.     }
    12. }
    13. public class Cat extends Animal{
    14.     public Cat(String name, int age){
    15.         super(name, age);
    16.     }
    17.     @Override   //重写了eat方法
    18.     public void eat(){
    19.         System.out.println(name+"吃鱼~~~");
    20.     }
    21. }
    22.  
    23. public class Dog extends Animal {
    24.     public Dog(String name, int age){
    25.         super(name, age);
    26.     }
    27.     @Override
    28.     public void eat(){
    29.         System.out.println(name+"吃骨头~~~");
    30.     }
    31. }
    32.  
    33. ///分割线//
    34.  
    35.  
    36.  
    37. public class TestAnimal {
    38.     // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
    39.     // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
    40.     // 注意：此处的形参类型必须时父类类型才可以
    41.     public static void eat(Animal a){
    42.         a.eat();
    43.     }
    44.     public static void main(String[] args) {
    45.         Cat cat = new Cat("元宝",2);  
    46.         Dog dog = new Dog("小七", 1);
    47.         eat(cat); //元宝吃鱼
    48.         eat(dog); //小七吃骨头
    49.     }
    50. }
    在上述代码中 , 分割线上方的代码是 类的实现者 编写的 , 分割线下方的代码是 类的调用者 编写的 .
    当类的调用者在编写 eat 这个方法的时候 , 参数类型为 Animal ( 父类 ), 此时在该方法内部并 不知道 , 也不关注 当前的 a 引用指向的是哪个类型 ( 哪个子类 ) 的实例 . 此时 a 这个引用调用 eat 方法可能会有多种不同的表现 ( 和 a 引用的实例相关), 这种行为就称为 多态。

  • 相关阅读:
    Spring相关知识点
    【JavaScript高级程序设计】重点-第四章笔记：原始值与引用值、执行上下文与作用域、垃圾回收
    Efficient Similarity Joins for Near Duplicate Detection论文总结
    Linux学习笔记之设备驱动篇(3)_内核模块_实验篇
    SolidWorks快捷键
    Gitee Pages个人简历部署（上）
    Springboot+swagger2
    K8s稳居容器榜首，Docker冲顶技术热词，微服务应用热度不减，2021云原生开发者现状
    开源代码分享(3)—微电网鲁棒定价策略(附matlab代码)
    预发部署时机器总是重启两次的“简单”排查
  • 原文地址：https://blog.csdn.net/crazy_xieyi/article/details/126196968