Java的封装性，继承性和多态性

沧月点水

已于 2023-12-17 14:34:02 修改

阅读量115

点赞数 1

文章标签： java 开发语言

于 2023-12-17 14:25:51 首次发布

本文链接：https://blog.csdn.net/2301_79927426/article/details/135044367

版权

java的封装性，继承性和多态性

Java拥有三种特性，分别是封装性，继承性和多态性，对于我们来说，大部分人已经接触过封装性，听说过后两个特性，所以我们今天来简单介绍一下封装性，以及重点介绍一下后两个特性。😅

一、封装性简述

首先，我们要知道的是平时我们在Java中使用的各种方法，本身就是封装性的一种体现。将一种功能放在一个方法之中，要用的时候直接用方法就可以了，而没必要考虑方法中的各种变量或是结构。

以下是封装性的定义

1.1.0定义

在面向对象编程（OOP）中，封装性是一种重要的概念，它指的是将类的内部实现细节隐藏起来，只暴露必要的接口给外部使用。封装性有助于实现类的抽象和保护类的内部状态，同时提供了良好的模块化和代码组织方式。

1.1.1接口和抽象类

在定义之中，我们看到了接口和抽象类这两个词，现在我们先来解释一下
这两个概念

接口（interface）是抽象类的集合，我们可以把接口看成是一个规范，它定义了一组方法的名称和参数，但没有提供具体的实现。接口的作用是提供一种统一的行为规范，使得不同的类可以遵循相同的接口，以便于代码的组织和复用。
抽象类则是一种缺乏具体的信息去组成一个完整的类的类。

public interface MyInterface {
  // 抽象方法
  void myMethod();

  // 常量
  int MY_CONSTANT = 10;

  // 默认方法
  default void defaultMethod() {
    // 提供默认实现
  }
}

public class MyClass implements MyInterface {
  
  @Override
  public void myMethod() {
    // 具体实现
  }
}

通常来说，接口中包含的的是抽象方法，但是我们也能够加入默认方法和常量（常量要初始化，而默认方法可以有具体说明，运用关键字default）

1.1.2 封装的实现

封装的实现通常运用到一些访问修饰符。（如 public、private、protected）来限制成员变量和方法的访问权限。

public class MyClass {
  private int apple;

  
  public int getMyApple() {
    return myApple;
  }

  public void setMyApple(int value) {
    if (value >= 0) {
      myApple = value;
    }
  }
}

而以上的这些方法，相当在Java 中已经被封装起来了，者能够使整个代码模块化，灵活化和更安全。

二、继承性简述

继承性是指在两个类若有相同之处的时候，我们可以让一个类继承另一个类拥有的属性和方法，从而避免重复劳动。这个过程就像是基因的遗传，我们拥有这上一辈的特性，同是可已拥有多个长辈的特性，同时，我们还可能会发生一些基因突变，而拥有自己的特有的属性。

2.1.0 定义

在面向对象编程（OOP）中，继承性是指一个类（子类或派生类）可以继承另一个类（父类或基类）的属性和方法。这意味着子类可以复用父类的代码，而无需重新实现相同的功能。

2.1.1 继承的实现方式

在Java中，使用extends关键字来实现继承。

public class ChildClass extends ParentClass {
    int number;
    tring string;

    public countNumber(string number)
        return number.length

}

2.1.2子类与父类的关系

被继承的类叫做父类，又叫做基类或超类。
继承的类叫做子类，又叫做派生类。

2.1.3子类的覆写

子类可以覆盖（重写）父类的方法，提供特定的实现。使用 @Override 注解可以确保正确覆盖父类的方法。我们可以理解为运用父类里的抽象类来创建具体方法。

@Override
public void someMethod() {
  
}

2.1.4super关键字

子类可以使用super关键字调用父类的方法或访问父类的成员变量。

 public Father(String name, String work) {
    // 调用父类构造方法
    super(name);
    this.work = work;
  }

2.2.0 实例示例

class Phone {
  public void makeCall() {
    System.out.println("打电话");
  }

  // 发短信方法
  public void sendSMS() {
    System.out.println("发短信");
  }
}

// 华为手机
class Huawei extends Phone {
  // 华为手机特有的拍照方法
  public void capturePhoto() {
    System.out.println("用华为手机拍照哦");
  }
}

// 苹果手机
class iPhone extends Phone {
  // 重写父类的发短信方法
  @Override
  public void sendSMS() {
    System.out.println("用iPhone发 iMessage");
  }

  // 苹果手机特有的方法
  public void callSiri() {
    System.out.println("呼叫黑丝蕊");
  }
}

// 小米手机
class Xiaomi extends Phone {
  // 小米手机特有的方法
  public void recordVideo() {
    System.out.println("用小米录像");
  }
}


public class myPhone {
  public static void main(String[] args) {
    // 创建华为手机对象
    Huawei huawei = new Huawei();
    huawei.makeCall();   
    huawei.sendSMS();  
    huawei.capturePhoto(); 

    // 创建苹果手机对象
    iPhone iPhone = new iPhone();
    iPhone.makeCall();    // 调用父类方法
    iPhone.sendSMS();     // 调用子类重写的方法
    iPhone.callSiri();    // 调用子类方法

    // 创建小米手机对象
    Xiaomi xiaomi = new Xiaomi();
    xiaomi.makeCall();   
    xiaomi.sendSMS();  
    xiaomi.recordVideo(); 
  }
}

三、多态性概述

最后，我们来介绍一下多态性的相关知识

多态性不是说有多种状态，而是有多种形态。举一个例子，一个人可以有多种身份，可以是一个学生，一个宅男，当然还是一个人类，多态就像是多种身份，多种标签。所以说继承性是多态性实现的基础。
在这里插入图片描述

3.1.1 多态性的实现

父子关系
父类引用指向子类（父类对象对象名=new 子类名称（））
接口
接口也是能够体现多态性
（接口名称对象名=new 实现类名称（））

public class Fu{
    public void methodF(){
    // 父类方法
    }

}

public class Zi extends Fu{
    @Override
    public void method(){
    // 子类方法
    }

}


public class Multi{
    public static void main (String[] args){


    Fu mnn =new Zi()};
    mnn.method();
    mnn.methodF();
    #zi类也是属于父类，所以也能够访问在父类中的方法，这就能体现多态性
    
}

注意的是多态中的成员变量，要看应用的类，引用的类若没有该变量，即到上一级查找。若是成员方法，则看new的类中的方法

3.1.2 多态的好处

总体而言，多态性提高了代码的灵活性和可扩展性，使得程序能够更容易适应变化。

3.1.3 具体定义

编译时多态性（静态多态性）：指在编译阶段就能确定方法的调用。这主要通过方法的重载来实现。重载是指在同一个类中定义多个方法，它们具有相同的名字但不同的参数列表。而通过不同的输入参数，编译器就能够判断是哪个方法。
运行时多态性（动态多态性）：指在程序运行时根据对象的实际类型确定方法的调用。这主要通过方法的重写和接口来实现。这就是我上面所介绍的内容。
总体而言，多态性提高了代码的灵活性和可扩展性，使得程序能够更容易适应变化。

3.1.3 具体定义

编译时多态性（静态多态性）：指在编译阶段就能确定方法的调用。这主要通过方法的重载来实现。重载是指在同一个类中定义多个方法，它们具有相同的名字但不同的参数列表。而通过不同的输入参数，编译器就能够判断是哪个方法。
运行时多态性（动态多态性）：指在程序运行时根据对象的实际类型确定方法的调用。这主要通过方法的重写和接口来实现。这就是我上面所介绍的内容。😘