【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;
    }
}

123456789101112

假设类的实现者需要通过修改类的实现内容来升级功能：将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;//修改
    }
}

123456789101112

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

Part3：如何封装：

3.1：private实现封装：

java中利用两个关键字搭配来实现封装:成员变量、成员方法被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();
    }
}
1234567891011121314

这样形式是一个封装：将myName\age\sex封装起来了，无法通过对象直接访问，只可以通过一个公开的方法-show()来显示（只读不写）
:属性被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());
    }
}
12345678910111213141516

:设置公开setter方法，当前属性值
:设置公开getter方法，当前属性值.

你可能会想，如果类的实现者修改了对外公开的属性/方法，这样不是同样会增加类的调用者的学习&使用成本嘛？
答：

3.3：总结：封装步骤：

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

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

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");
	}
}
12345678910111213141516171819202122

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

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

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

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");
	}
1234567891011121314151617181920212223

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

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

Part6：

6.1：反思、深入

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

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

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