封装和继承

本文深入解析Java封装和继承的核心概念,涵盖属性私有化、getter/setter方法、包组织结构、访问权限修饰符及static关键字的使用,助力开发者掌握面向对象编程的关键技巧。

封装和继承

一、掌握封装的使用

封装:类和对象章节

另一半的封装概念:将一些不安全的信息进行封装(保护),然后将可以直接被我们使用的部分开放出来(接口)。(提升安全性和可用性,有面向接口编程的思想)

使用步骤:未来这些类组件都应该采用封装来进行信息保护

  • 属性私有化(private)
  • 提供公共的getter【getXX()】和setter【setXX()】方法
  • 根据需求在setter和getter方法中添加逻辑判断

一般的 javaBean的规范

javaBean:其实指的就是我们那些对象类。

  • 属性私有化
  • 提供公共的getter和setter方法
  • 提供无参构造
  • 实现序列化接口(序列化其实就是我们的对象在流之间进行转换的一种概念)

封装的优势

二、掌握包组织结构

package:从第二章节就开始创建了

它的作用就是用于对源代码进行分包管理,方便我们开发和阅读,另外也在一定程度上解决了同一个文件夹下无法出现同名文件。

规范:要求包名全部小写 公司域名的倒叙+应用程序名+【部门名称】+【功能模块】

导包 在我们使用类的时候:(一个类使用另一个类)

​ 1.如果是在同一个包中使用某个类,那么直接可以进行使用

​ 2.如果是在不同的包中使用某个类,必须先进行导包

​ 3.如果使用的是java.lang包下的内容的话,不需要导包。例如:System、Math…(这是JVM自动导入)

包声明语法(必须出现在文件中的第一行有效代码):package 包地址;

导包的语法(必须出现在类声明上方,包声明下方): import 类的全限定名;例如:java.util.Scanner;

如果需要用到java.util包中的很多内容:那么可以直接import java util

三、访问权限修饰符

访问修饰符:在类的语法和方法的语法上

private

package 当你不写访问修饰符时 代表的就是包级别的访问

protected

public

在一个类文件中,被public修饰的类的名称必须和文件名相同

一般情况下不会再一个类文件中定义多个类。

四、掌握static关键字

static :如果被它修饰的方法,在调用非static修饰的方法时,必须创建对象才能使用

static 表示静态的,被他修饰的信息要和JVM运行时数据区-方法去打交道。

它可以修饰:

  • 属性:类属性/类变量/静态变量 可以同过类名直接调用
  • 方法:类方法/静态方法
  • 代码块:静态代码块

​ 静态代码块只执行一次,在类加载的时候执行

​ 构造代码块会随着对象创建而执行,优先于构造方法执行

注意事项:

  • static修饰的信息都是属于类的信息,它们会随着类的加载而进行初始化。
  • static修饰的信息是可以被类的所有对象共享的。

五、掌握继承的使用

<think> 我们正在讨论封装继承的区别。根据引用[^1][^2][^3][^4][^5],封装继承是面向对象编程的两大基本特征,它们有不同的目的实现方式。 封装(Encapsulation)的核心是隐藏对象的内部状态实现细节,仅通过公开的接口(方法)与外界交互。这样可以提高代码的安全性可维护性。例如,在Java中,我们可以使用private关键字来修饰属性,然后提供public的gettersetter方法来访问修改这些属性(如引用[^4]所示)。 继承(Inheritance)则是子类继承父类的特征行为,使得子类具有父类的属性方法,同时还可以添加自己特有的属性方法。继承体现了类与类之间的层次关系,支持代码的重用扩展(如引用[^2]所述)。 具体区别如下: 1. **目的不同**: - 封装是为了隐藏内部实现细节,保护数据完整性,降低模块间的耦合度[^1][^3]。 - 继承是为了实现代码的复用扩展,建立类之间的层次关系(父类与子类)[^2]。 2. **实现方式不同**: - 封装通过访问修饰符(如private, protected, public)来实现,通常结合gettersetter方法[^4]。 - 继承通过关键字(如Java的`extends`)来实现,子类自动拥有父类的非私有成员(属性方法)[^2]。 3. **关系不同**: - 封装主要关注一个类内部的实现,将数据与操作数据的方法绑定在一起[^3]。 - 继承关注类与类之间的关系,是多个类之间的纵向联系(从一般到特殊)[^2]。 4. **代码示例对比**: - 封装示例(引用[^4]): ```java class Student { private String name; // 私有属性,封装 public void setName(String name) { // 公开方法设置name this.name = name; } public String getName() { // 公开方法获取name return this.name; } } ``` - 继承示例(引用[^2]): ```java class Animal { // 父类 void eat() { System.out.println("Animal is eating"); } } class Dog extends Animal { // 子类继承父类 void bark() { System.out.println("Dog is barking"); } } ``` 5. **设计原则**: - 封装符合“信息隐藏”原则,强调对象内部状态的保护[^3][^5]。 - 继承符合“is-a”关系(例如:Dog is an Animal),强调代码重用层次化设计[^2]。 总结: 封装继承是面向对象编程中相辅相成的两个概念,但它们解决的问题不同。封装着重于内部细节的隐藏,而继承着重于类之间的关系代码复用。 §§相关问题§§ 1. 封装如何提高代码的安全性? 2. 继承可能带来什么问题? 3. 多态与封装继承有什么关系? </think> ### 封装继承的区别 封装继承是面向对象编程的两大核心特征,它们从不同维度解决代码组织问题,主要区别如下: #### 1. **核心目的不同** - **封装**:隐藏对象内部实现细节,仅暴露可控的接口 ```java class BankAccount { private double balance; // 私有属性(封装) public void deposit(double amount) { // 公开接口 if (amount > 0) this.balance += amount; } public double getBalance() { // 受控访问 return this.balance; } } ``` 通过私有化`balance`属性,外部只能通过`deposit()``getBalance()`方法操作数据,确保数据安全性[^3][^4]。 - **继承**:建立类之间的层级关系,实现代码复用 ```java class Animal { // 父类 void breathe() { System.out.println("呼吸中..."); } } class Fish extends Animal { // 子类继承 void swim() { System.out.println("游泳中..."); } } ``` `Fish`自动获得`breathe()`方法,无需重复实现[^2]。 #### 2. **实现机制对比** | 特性 | 封装 | 继承 | |--------------|--------------------------------|-------------------------------| | **访问控制** | 使用`private/protected`修饰属性 | 使用`extends`关键字建立关系 | | **代码焦点** | 单个类的内部实现 | 多个类之间的层级关系 | | **典型操作** | 定义getter/setter方法 | 重写父类方法(`@Override`) | | **核心原则** | 信息隐藏 | 代码复用与扩展 | #### 3. **解决的问题不同** - **封装的核心价值** - 防止非法数据修改(如余额不能为负数) - 降低模块耦合度(修改内部实现不影响外部调用) - 符合"高内聚,低耦合"设计原则[^1][^4] - **继承的核心价值** - 避免重复代码(子类复用父类逻辑) - 支持多态特性(父类引用指向子类对象) - 构建类层次体系(如`Animal→Mammal→Dog`)[^2][^5] #### 4. **实际应用场景** - **使用封装的场景** ```java class User { private String password; // 敏感数据必须封装 public void setPassword(String pwd) { if (isValidPassword(pwd)) this.password = encrypt(pwd); } } ``` - **使用继承的场景** ```java abstract class Shape { // 父类定义公共接口 abstract double area(); } class Circle extends Shape { // 子类实现差异化 double area() { return Math.PI * radius * radius; } } ``` ### 关键区别总结 | 维度 | 封装 | 继承 | |------------|-------------------------------|-------------------------------| | **目标** | 保护数据完整性 | 建立类层级关系 | | **范围** | 作用于单个类内部 | 作用于多个类之间 | | **关键词** | `private`/`protected`/getter | `extends`/`implements` | | **风险** | 过度封装导致冗余代码 | 深度继承破坏封装性[^1][^3] | > 封装是"内向"的自我保护机制,继承是"外向"的层级扩展机制。实践中常结合使用: > ```java > class SecureLogger extends Logger { // 继承 > private String encryptionKey; // 封装 > public void log(String msg) { > super.log(encrypt(msg)); // 复用+增强 > } > } > ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值