• 博主简介：努力学习的预备程序媛一枚~
• 博主主页： @是瑶瑶子啦
• 所属专栏: Java岛冒险记【从小白到大佬之路】

前言

write in the front:

• 如何理解封装？
  试想：我们使用微波炉的时候，只用设置好时间，按下“开始”即可运作。作为一个产品的使用者，我们希望生产者能把最简单的接口暴露给我们，而至于微波炉按下开关后，内部是具体如何运作的，这些细节不用我们操心。“高内聚，低耦合”。节省使用者的学习成本和时间成本程序设计也是如此。同时，由于封装了内部细节，提供了对外的接口，作为使用者的我们无法直接随意对内部进行操作，保证了内部数据的安全.
  

• 封装是程序设计的第一原则,Java设计中有两种封装的体现：

  • 方法(函数）:为了减少重复代码和分解复杂操作，计算机引入了函数（子程序）的概念，Java中把这称为方法（Method).（【Java】保姆级讲解|从0到1学会方法及方法重载 （ 入门，包懂）).
  • 类

接下来我们具体感受一下Java中的封装（主要是讲封装在类上的体现）：

目录

• 前言
• Part1：引入：
• Part2：封装举例：
• Part3：如何封装：
• • 3.1：private实现封装：
  • 3.2：getter&setter方法：
  • 3.3：总结：封装步骤：
  • 3.4：实际封装应用案例：
  • 3.5：补充：IDEA快速根据private生成getter()&setter
• Part4：stetter（）和构造器相结合
• Part5：封装的意义/作用/好处
• Part6：
• • 6.1：反思、深入
  • 6.2：补充：函数体现封装
  • 6.3：总结：

Part1：引入：

• 我们用面向对象语言编程时会涉及到以下两个视角：

• 类的实现者：实现类内部细节—微波炉内部设计者

• 类的调用者：调用已有的类—微波炉的使用者

• 封装的本质是不向类的调用者透露过多类的实现内容，只提供特定的接口，让类的调用者去使用类

我们在学习Java的时候经常会用到jdk-API文档，通过文档来查询某个类怎么使用：

此时我们的视角是：类的调用者，我们的目的是使用这个类，而不关注这个类的具体实现。这正是封装的体现。Java开发者实现了一些类，把这些类的具体实现内容（类的源码）封装，只向外提供一些(接口），方便类的调用者去直接使用（再不用看源码的情况下，能快速使用这个类）。

Part2：封装举例：

class Person{
    public String myName;
    public int age;
    public String sex;
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1=new Person();
        person1.name=19;
    }
}

• 假设类的实现者需要通过修改类的实现内容来升级功能：将name修改为myName：

class Person{
    private String myName = "yaoyao"//修改
    public int age;
    public String sex;
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1=new Person();
        person1.myName=2000;//修改
    }
}

• 结果/问题出现：
  • 由于类的实现者修改了类的实现，导致类的调用者不得也修改自己的代码-----高耦合、类的调用者使用类的成本增高–>程序复杂度过高，不便于维护(必须先学习源码，才可以使用）
  • 同时，直接公开属性，可能会由于类的调用者给属性赋值不合理的数据，导致属性错误/不合理–数据不安全
• 解决—封装
  • 那么如何才能解决类的实现者在后期维护、修改的过程中，最大限度的不影响类的使用者呢（降低程序的复杂度）？以及保护属性数据的安全呢？----封装。

Part3：如何封装：

3.1：private实现封装：

• java中利用private，public两个关键字搭配来实现封装
  • private:成员变量、成员方法被private修饰时，类的调用者无法访问&使用，只有在类内部可以访问&使用。（即，这些被封装起来的属性/行为，对于类的调用者来说是不可见的–无法直接访问&调用）。
  • private:成员变量、成员方法被public修饰时，类的调用者可以直接访问&使用。

🌇eg:

class Person{
    private String myName = "yaoyao"//修改
    private int age=19;
    private String sex="femal";
    public void show(){
    	System.out.println(myName+age+sex);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1=new Person();
        person1.show();
    }
}

• 这样形式是一个封装：将myName\age\sex封装起来了，无法通过对象直接访问，只可以通过一个公开的方法-show()来显示（只读不写）
• 问题:属性被private修饰之后，调用者无法直接访问到属性，这样确实提高了可维护性、降低了耦合性,但是如何获取/修改被private修饰的属性呢？

3.2：getter&setter方法：

class Person{
    private String myName;
    public void setMyName(String name){//对外提供访问属性方法
    	this.myName = name;
    }
    public String getMyName(){//对外提供获取属性方法
    	return this.myName;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.setMyName("yaoyao");
        System.out.println(person1.getMyName());
    }
}

• setter():设置公开setter方法，设置当前属性值
• getter():设置公开getter方法，获取当前属性值.

📬Tips:

你可能会想，如果类的实现者修改了对外公开的属性/方法，这样不是同样会增加类的调用者的学习&使用成本嘛？
答： 一般类的设计都要求：类提供的 public 方法/属性能比较稳定–不频繁发生大的修改. 尤其是对于一些基础库中的类. 每次接口的变动都要仔细考虑兼容性问题

3.3：总结：封装步骤：

1. private修饰相应属性–属性私有化
2. 制作相对应公开的setter/getter方法

public void setXXX(参数列表）{
	//验证传参是否合理
			...
	//合理即可赋值：
	属性 = 形参；
}

public void getXXX(){
	//权限判断
	return XXX;
}

3.4：实际封装应用案例：

public class Student(){
	private String name;//名字
	public static setName(String name){
		//对数据进行验证合理性
		if(name.length() >= 2 && name.length() <=10){
			this.name = name;
		}
		else{
			System.out.println("设置名字长度超过范围，未设置成功");
		}
	}
	public static getName(){
		return this.name;
	}
}
class Demo{
	public static void main (String[] args){
		Student student = new Student();
		//若传入这样不合理数据，则无法成功修改属性
		student.setName("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh");
	}
}

3.5：补充：IDEA快速根据private生成getter()&setter

• 鼠标右键选择generate(重构）/alt+insert
  
• 选择：
  
  
• 即可生成：
  

Part4：stetter（）和构造器相结合

• 【写法】:将setter写在构造器内部
• 【作用】:保护属性数据安全

public class Student(){
	private String name;//名字
	public static setName(String name){
		//对数据进行验证合理性
		if(name.length() >= 2 && name.length() <=10){
			this.name = name;
		}
		else{
			System.out.println("设置名字长度超过范围，未设置成功");
		}
	}
	public static getName(){
		return this.name;
	}
	//构造器(本质：初始化数据）
	public Student(String name){
		setName(name);//直接在构造器内调用set方法
	}
}
class Demo{
	public static void main (String[] args){
		Student student = new Student("HHHHHHHHHHHHHHHhhhhhhhhhhhhhhhh");
	}

Part5：封装的意义/作用/好处

• 安全性：用private隐藏内部细节(外部不能随意访问），对传入数据进行验证，保证安全合理。避免因为外部的无意修改，破坏内部数据—提高代码安全性
• 复用性：这里是指使用类把属性、成员方法封装起来的封装。即，一旦类的实现者实现了一个类，下一次遇到同样的问题，不必再次写一遍，而是直接调用类实现者写好的代码即可—提高代码复用性。
• 高内聚：隐藏类内部的实现细节，不允许外部干涉，便于后期维护------降低程序复杂度。
• 低耦合：暴露少量接口供外部使用，且尽量方便。提高类使用者的学习成本、使用成本。便于协助、扩展。

Part6：

6.1：反思、深入

的确，我们谈到封装，可能最先想到的是类，并且封装在类上体现的学问、细节，确实很多。封装是一种思想，Java的函数和类本身是这种思想的明显体现。我的意思是，如果类中的属性都是public，我们仍然认为类是一种封装。但是如果只是单单的这样浅层次的封装，肯定会带来很多问题（如上文已经讲到的：安全性、使用成本…)

于是，我们需要更深层次的封装—上面Part所讲的，其实本质就是在类的基础上，再次封装（或许可以叫作套娃？）。

• 可以这样理解：类是一个书包，封装了各种各样的文具、书（数据、对数据的操作）。—类的外层封装
• 在书包中放个铅笔盒，专门用来放🖊，这个铅笔盒，我们叫作—封装在类中体现。本文大篇幅讲解的，其实是此封装！
• public和private干嘛？
  • public修饰类：表示这个书包别人可以拿到（别人可以打开这个书包拉链）
  • public&private修饰方法/属性：封装类内部细节！private修饰属性，就相当于把数据封在铅笔盒中了，就算你拿到了书包并且打开，并不代表你可以打开铅笔盒获取铅笔！但是public修饰getter()，说明打开铅笔盒的操作是可以使用的。
    

6.2：补充：函数体现封装

虽然类体现封装的确占大头，但是，函数（就是Java中的方法），也体现了封装，既然此文是讲封装，怎么能少的了我们的函数老爷呢？

• 程序的构成
  程序由数据和指令构成。大程序可以分为小程序，小程序可以再次细分—>子程序（分而治之）。

  所有我们看到有些地方把函数也称为子程序。程序是数据，指令的集合。所以：函数也是封装的体现

6.3：总结：

通过上面，可以看到，其实程序本身就是封装，类、函数是封装中的封装…

总之，请记住：
 封装是程序设计的第一原则, 类&方法是封装的不唯二体现。通过封装，我们才能站在更高层次思考问题。

---