封装

1.封装

◆该露的露，该藏的藏
◆我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不 允许外部干涉;低耦合:仅暴露少量的方法给外部使用 。
◆封装(数据的隐藏)
◆通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

封装的主要作用是将对象的属性（数据）与操作这些属性的方法（行为）捆绑在一起，限制外部对对象的直接访问，以保证数据的完整性和安全性。

记住这句话就够了:属性私有，get/set

学生类 Student

package com.oop.demo01;

public class Student {
//名字
//年龄
//分数
//性别
//地区

//学习（） 这里做的是一个方法，但是方法一般不封装
public int age=25;//定义一个public的变量 做一个封装private的反例说明封装的好处
private String name; //注意变量名不能重复
private int score;
private char gender;
private String address;

//alt + insert 快捷加入get / set方法
//先手写一个 对name进行访问 和赋值
  //获取实例化对象的name,是非静态方法
public String getName(){
  //默认是空null 实例变量/成员变量
  return this.name;
}
//这是一个含参无返回值的方法  将括号内的名字给赋值给实例化后的对象
public void setName(String name){
  this.name=name;
}
//alt +insert 快捷生成 get set方法


public int getScore() {
  return score;
}

public void setScore(int score) {
  this.score = score;
}

public char getGender() {
  return gender;
}

public void setGender(char gender) {
  //这里来演示下封装的好处 就是对赋值进行判断  避免出现"奇怪"的赋值情况
  switch(gender){
      case '男':this.gender = gender;break;
      case '女':this.gender = gender;break;
      default:
          System.out.println("你输入的性别有误！");break;
  }
}

public String getAddress() {
  return address;
}

public void setAddress(String address) {
  this.address = address;
}
}

启动类Application

package com.oop.demo01;//封装！
//包内启动项
//Demo01 封装！（主要是针对属性进行封装） 追求 “高内聚，低耦合”
//属性私有（private）， get/set
//alt+insert 快捷加入get/set方法
public class Application {
public static void main(String[] args) {
  Student student = new Student();
  student.age=200;//这里我直接实例话之后修改student 的age值（因为它是public的
  //这里显然有问题，直接操作这个变量可能出现问题，年龄不可能到200 所以我们对类的属性进行封装、用接口（get/set方法）对它进行赋值和访问
  //演示封装（属性私有  get/set）
  //System.out.println(student.name); 由于属性私有private 不能直接访问属性，用写好的接口去赋值和访问
  System.out.println(student.getName());//还没有赋值  默认为空 null
  student.setName("巢安龙");
  System.out.println(student.getName());
  //演示封装后的优势 ： 避免奇怪的赋值
  student.setGender('男');//注意：”男“和‘男’ 是不同的 ”男是字符串“  ‘男’是字符！
  System.out.println(student.getGender());
  student.setGender('女');//避免奇怪的赋值

}
}

输出结果：

null
巢安龙
男

成员变量：

• age 是公有的（public），表示不需要封装，任何类都可以直接访问和修改它。
• 其他成员变量（name, score, gender, address）是私有的（private），它们只能在 Student 类的内部访问，外部访问需要通过方法来进行。

封装方法：

• getter 和 setter 方法：通过 get 和 set 方法封装了对私有变量的访问和修改。这是一种标准的封装方式，外部只能通过 get 方法获取数据，通过 set 方法修改数据。
• 性别的特殊封装：在 setGender() 方法中，加入了性别赋值的合法性检查，确保只接受 男 或 女 作为合法的性别值。如果用户输入了非法的性别值，程序会提示错误信息。

实例化对象：通过 new Student() 创建了 Student 类的实例对象 student。

直接修改公有属性 age：示范了直接修改公有属性 age，虽然可以修改，但不推荐这样做，因为没有对值的控制或检查，可能出现非法值。

通过封装方法访问私有属性：

• student.setName("巢安龙") 用来设置 name，getName() 用来访问 name。
• 使用 student.setGender('男') 和 student.getGender() 设置并获取 gender，并通过封装确保了性别输入的合法性。通过 student.setGender('X') 示范了输入非法性别时的错误提示。

总结与注意点：

1. 封装的好处：

封装主要是保护对象的内部数据，避免外部随意修改对象的状态，保证数据的合法性。封装可以带来以下几个好处：

• 提高数据安全性：通过 private 将成员变量隐藏，外部不能直接修改，必须通过 getter 和 setter 方法来访问。
• 增强可维护性：如果需要修改数据的访问逻辑（如添加检查、格式化等），可以直接在 getter 和 setter 方法中进行修改，而不影响外部代码的使用。
• 控制修改：例如在 setGender() 方法中，可以控制性别的赋值，避免非法值被赋给 gender。

2. 访问修饰符的使用：

• public：可以被所有类访问，几乎不做限制。比如 age 就是 public，直接暴露给外部使用。
• private：只能在当前类中访问，外部无法直接访问。比如 name, score, gender 和 address 都是 private，需要通过方法来访问和修改。
• 封装的关键：通过 private 限制外部直接访问成员变量，保证数据的完整性和安全性，同时通过 public 的 getter 和 setter 方法来间接访问。

3. 封装方法的设计：

• getter 方法：用于获取私有变量的值，通常命名为 get + 变量名（如 getName()）。
• setter 方法：用于设置私有变量的值，通常命名为 set + 变量名（如 setName()）。在设置值时可以进行有效性检查（例如性别的合法性检查）。

4. 封装与面向对象的其他特性：

封装是面向对象编程的三大特性之一（其他两个是继承和多态）。它通过将数据和操作数据的方法绑定在一起，确保数据的完整性，并限制对数据的访问，增强代码的可维护性和灵活性。

总结：

封装是面向对象编程的基本原则之一，通过将数据（属性）和对数据的操作（方法）捆绑在一起，保护了数据的隐私。通过 private 和 public 的组合，配合 getter 和 setter 方法，封装能有效避免对数据的不合理修改，并增强程序的健壮性和可维护性。