当前位置：首页 > 行业知识 > 【类与对象JAVA（详）】（二）封装、构造方法、代码块

行业知识

【类与对象JAVA（详）】（二）封装、构造方法、代码块

2026-10-26 13:36:00 来源：互联网转载

个人主页 : @赶路人- -

个人格言 :

要努力成为梧桐，让喜鹊在这里栖息。

要努力成为大海，让百川在这里聚积。

7.display,vt.显示，显示器 [dɪˈsple] 8.set,v.设置，n.集合 [sɛt]

1.封装

什么是封装?

封装（Encapsulation）是面向对象编程中的一种基本概念，指的是将对象的内部状态和行为封装起来，对外只暴露必要的接口或方法，以保证数据的安全性和完整性，同时隐藏实现细节，方便后续的维护和扩展。

在Java中，封装通常通过使用访问修饰符（Access Modifiers）来实现。Java中有三种访问修饰符：public、protected和private。它们用于控制类、属性和方法的可见性和访问权限。

public: 公共的，可以被任何类访问；

protected：受保护的，可以被同一包内的类和该类的子类访问；

private：私有的，只能被该类的内部方法访问。

通过合理地使用访问修饰符，我们可以将类的实现细节隐藏起来，避免外部代码直接访问和修改对象的内部状态，从而提高了代码的安全性和稳定性。

此外，Java还提供了封装的另一种实现方式，即getter和setter方法。getter方法用于获取属性的值，setter方法用于设置属性的值。通过这种方式，我们可以控制属性的读写操作，同时可以在读写属性时添加一些额外的逻辑或验证。

1.1private实现封装

直接使用public

class Person {public String name = "张三";public int age = 18;}class Test {public static void main(String[] args) {Person person = new Person();System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");}}

执行结果

我叫张三, 今年18岁

这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类. 学习成本较高
一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高
范例：使用 private 封装属性, 并提供 public 方法供类的调用者使用.
```
lass Person {private String name = "李四";private int age = 20;public void show() {System.out.println("我叫" + name + ", 今年" + age + "岁");}}class Test {public static void main(String[] args) {Person person = new Person();person.show();}}
```
执行结果
我叫李四, 今年20岁
- 此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.
- 同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到name, age 这样的字段).
  那么问题来了~~ 类的实现者万一修改了 public 方法 show 的名字, 岂不是类的调用者仍然需要大量修改代码嘛?
  这件事情确实如此, 但是一般很少会发生. 一般类的设计都要求类提供的 public 方法能比较稳定, 不应该频繁发生大的改变. 尤其是对于一些基础库中的类, 更是如此. 每次接口的变动都要仔细考虑兼容性问题.
  
  !
  - private 不光能修饰字段, 也能修饰方法
  - 通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public,就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.
    1.2getter和setter方法
    
    当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了。(详细可查看上面的访问修饰符修饰范围)
```
class Person {private String name = "张三";private int age = 18;public void show() {System.out.println("我叫" + name + ", 今年" + age + "岁");}}class Test {public static void main(String[] args) {Person person = new Person();person.age = 20;person.show();}}// 编译出错//Test.java:13: 错误: age可以在Person中访问private//person.age = 20;//  ^//1 个错误
```
    此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法
    代码示例：
```
class Person{private String name;//实例成员变量private int age;public void setName(String name){//name = name;//不能这样写 因为局部变量优先this.name = name;//this引用，表示调用该方法的对象}public String getName(){return name;}public void show(){System.out.println("name:" + name + "age:" + age);}}public static void main(String[] args){person person = new Person();person.setName("haoyang");String name = person.getName();System.out.println(name);person.show();}
```
    运行结果：
    haoyang
    name：haoyang age：0
    
    !
    - getName即为getter方法，表示获取这个成员的值。
    - setName即为setter方法，表示设置这个成员的值。
    - 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this，相当与自赋值。this表示当前实例的引用。
    - 不是所用的字段都一定提供setter/getter方法，而是要根据实际情况决定提供那种方法。
    - 在IDEA中可以使用alt + insert(或者 alt + F12)快速生成 setter / getter 方法。在VSCode中可以使用鼠标右键菜单-> 源代码操作中自动生成setter / getter方法。
      2.构造方法
      
      构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.
      new 执行过程
      - 为对象分配内存空间
      - 调用对象的构造方法
        2.1基本语法
        
        语法规则
        
        方法名称必须与类名称相同
        构造方法没有返回值类型声明
        每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
        !
        如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数。
        若类中定义了构造方法，则默认的无参构造将不再生成。(救急不救穷)
        构造方法支持重载. 规则和普通方法的重载一致。
        class Person {private String name;//实例成员变量private int age;private String sex;//默认构造函数构造对象public Person() {this.name = "caocao";this.age = 10;this.sex = "男";}//带有3个参数的构造函数public Person(String name,int age,String sex) {this.name = name;this.age = age;this.sex = sex;}public void show(){System.out.println("name: "+name+" age: "+age+" sex: "+sex);}}public class Main{public static void main(String[] args) {Person p1 = new Person();//调用不带参数的构造函数如果程序没有提供会调用不带参数的构造函数p1.show();Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数p2.show();}}
        
        执行结果
        name: caocao age: 10 sex: 男
        name: zhangfei age: 80 sex:男
        
        2.2this关键字
        
        this：表示当前对象引用(注意不是当前对象，因为使用this时对象还没生成). 可以借助 this 来访问对象的字段和方法。
        
        class Person {private String name;//实例成员变量private int age;private String sex;//默认构造函数构造对象public Person() {//this调用构造函数this("abc", 18, "max");//调用构造函数，必须放在第一行进行显示}//这两个构造函数之间的关系为重载。public Person(String name,int age,String sex) {this.name = name;this.age = age;this.sex = sex;}public void show() {System.out.println("name: "+name+" age: "+age+" sex: "+sex);}}public class Main{public static void main(String[] args) {Person person = new Person();//调用不带参数的构造函数person.show();}}
        
        输出结果：
        name: abc age: 18 sex: max
        
        可以发现在构造函数的内部，就可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，就已经使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用.
        
        3.代码块
        
        字段的初始化方式有：
        
        就地初始化
        使用构造方法初始化
        使用代码块初始化
        前两种方式前面篇幅已经见过了, 接下来介绍第三种方式, 使用代码块初始化
        
        3.1什么是代码块
        
        使用 {} 定义的一段代码.
        根据代码块定义的位置以及关键字，又可分为以下四种：
        
        普通代码块
        构造块
        静态块
        同步代码块
        3.2普通代码块
        
        普通代码块：定义在方法中的代码块
        
        public class Main{public static void main(String[] args){{//直接使用{}定义，普通代码块int x = 1;System.out.println("x1 = " + x);}int x = 2;System.out.println("x2 = " + x);}}
        
        运行结果：
        x1 = 1
        x2 = 2
        (这种用法较少见)
        
        3.3构造代码块
        
        构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量.
        
        class Person{ private String name;//实例成员变量 private int age; private String sex; public Person() { System.out.println("I am Person init()!"); } //实例代码块 { this.name = "abc"; this.age = 12; this.sex = "man"; System.out.println("I am instance init()!"); } public void show(){ System.out.println("name: "+name+" age: "+age+" sex: "+sex); }}public class Main { public static void main(String[] args) { Person p1 = new Person(); p1.show(); }}
        
        运行结果:
        I am instance init()!
        I am Person init()!
        name: abc age: 12 sex: man
        
        !
        （初学者）注意看运行结果的顺序和代码编写的顺序，
        相信聪明的你一下子就发现了，实例代码块是优于构造函数执行的。
        是的，代码块是优于构造函数执行的。
        
        3.4静态代码块
        
        使用static定义的代码块。一般用于初始化静态成员属性。
        
        class Person{ private String name;//实例成员变量 private int age; private String sex; private static int count = 0;//静态成员变量由类共享数据方法区 public Person(){ System.out.println("I am Person init()!"); } //实例代码块 { this.name = "abc"; this.age = 12; this.sex = "man"; System.out.println("I am instance init()!"); } //静态代码块 static { count = 10;//只能访问静态数据成员 System.out.println("I am static init()!"); } public void show(){ System.out.println("name: "+name+" age: "+age+" sex: "+sex); }}public class Main { public static void main(String[] args) { Person p1 = new Person(); Person p2 = new Person();//静态代码块是否还会被执行？ }}
        
        运行结果：
        I am static init()!
        I am instance init()!
        I am Person init()!
        Iam instance init()!
        I am Person init()!
        
        !
        
        静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
        静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行