我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
我们使用的电脑，内部有CPU、硬盘、键盘、鼠标等等，每一个部件通过某种连接方式一起工作，但是各个部件之间又是独立的
现实生活中，每一个个体与个体之间是有边界的，每一个团体与团体之间是有边界的，而同一个个体、团体内部的信息是互通的，只是对外有所隐瞒。
面向对象编程语言是对客观世界的模拟，客观世界里每一个事物的内部信息都是隐藏在对象内部的，外界无法直接操作和修改，只能通过指定的方式进行访问和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
随着我们系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面向对象的开发原则要遵循“高内聚、低耦合”，而“高内聚，低耦合”的体现之一：
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
通俗的讲，封装就是把该隐藏的隐藏起来，该暴露的暴露出来。那么暴露的程度如何控制呢？就是依赖访问控制修饰符，也称为权限修饰符来控制。
访问控制修饰符来控制相应的可见边界，边界有如下：
（1）类
（2）包
（3）子类
（4）模块：Java9之后引入
权限修饰符：public,protected,缺省,private
| 修饰符 | 本类 | 本包 | 其他包子类 | 其他包非子类 |
|---|---|---|---|---|
| private | √ | × | × | × |
| 缺省 | √ | √ | × | × |
| protected | √ | √ | √ | × |
| public | √ | √ | √ | √ |
外部类：public和缺省
成员变量、成员方法、构造器、成员内部类：public,protected,缺省,private
提示：protected修饰非静态成员，跨包时，只能在子类的非静态成员中访问，在静态成员中无论是否创建对象都不能访问。
package com.atguigu.test01.access1;
?
public class Father {
public int a;
protected int b;
int c;
private int d;
public static int e;
protected static int f;
static int g;
private static int h;
}
?
class Mother{
public Mother(){
}
}
package com.atguigu.test01.access1;
?
//本包非子类中
public class Other {
public static void method(){
Father obj = new Father();
System.out.println(obj.a);
System.out.println(obj.b);
System.out.println(obj.c);
// System.out.println(obj.d);//跨类不可见
System.out.println(Father.e);
System.out.println(Father.f);
System.out.println(Father.g);
// System.out.println(h);//跨类不可见
}
public void fun(){
Father obj = new Father();
System.out.println(obj.a);
System.out.println(obj.b);
System.out.println(obj.c);
// System.out.println(obj.d);//跨类不可见
System.out.println(Father.e);
System.out.println(Father.f);
System.out.println(Father.g);
// System.out.println(h);//跨类不可见
}
}
?
package com.atguigu.test01.access1;
?
//本包子类中
public class Sub extends Father{
public static void method(){
//静态直接访问非静态都不行
/* System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);*/
Father obj = new Father();
System.out.println(obj.a);
System.out.println(obj.b);
System.out.println(obj.c);
// System.out.println(obj.d);//跨类不可见
System.out.println(e);
System.out.println(f);
System.out.println(g);
// System.out.println(h);//跨类不可见
}
public void fun(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
// System.out.println(d);//跨类不可见
System.out.println(e);
System.out.println(f);
System.out.println(g);
// System.out.println(h);//跨类不可见
}
}
package com.atguigu.test01.access1;
?
public class Father {
public int a;
protected int b;
int c;
private int d;
public static int e;
protected static int f;
static int g;
private static int h;
}
?
package com.atguigu.test01.other;
?
import com.atguigu.test01.access1.Father;
?
public class Another {
public static void method(){
Father obj = new Father();
System.out.println(obj.a);
// System.out.println(obj.b);//跨包非子类不可见
// System.out.println(obj.c);//跨包不可见
// System.out.println(obj.d);//跨类不可见
System.out.println(Father.e);
// System.out.println(Father.f);//跨包非子类不可见
// System.out.println(Father.g);//跨包不可见
// System.out.println(h);//跨类不可见
}
public void fun(){
Father obj = new Father();
System.out.println(obj.a);
// System.out.println(obj.b);//跨包非子类不可见
// System.out.println(obj.c);//跨包不可见
// System.out.println(obj.d);//跨类不可见
System.out.println(Father.e);
// System.out.println(Father.f);//跨包非子类不可见
// System.out.println(Father.g);//跨包不可见
// System.out.println(h);//跨类不可见
}
}
?
package com.atguigu.test01.other;
?
import com.atguigu.test01.access1.Father;
?
public class Son extends Father{
public static void method(){
//静态直接访问非静态都不行
/* System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);*/
Father obj = new Father();
System.out.println(obj.a);
// System.out.println(obj.b);//跨包的静态成员
//不能访问非静态的protected
// System.out.println(obj.c);//跨包不可见
// System.out.println(obj.d);//跨类不可见
System.out.println(e);
System.out.println(f);
// System.out.println(g);//跨包不可见
// System.out.println(h);//跨类不可见
}
public void fun(){
System.out.println(a);
System.out.println(b);
// System.out.println(c);//跨包不可见
// System.out.println(d);//跨类不可见
System.out.println(e);
System.out.println(f);
// System.out.println(g);//跨包不可见
// System.out.println(h);//跨类不可见
}
}
package com.atguigu.test01.access1;
?
class Mother {
}
package com.atguigu.test01.access1;
?
public class Daughter extends Mother{
?
}
package com.atguigu.test01.other;
?
//Mother类是缺省的，跨包不能使用
public class Daughter extends Mother{
?
}
package com.atguigu.test01.access1;
?
public class Fu {
Fu(){
}
}
package com.atguigu.test01.access1;
?
public class Zi extends Fu{
?
}
package com.atguigu.test01.other;
?
import com.atguigu.test01.access1.Fu;
?
public class Zi extends Fu{
Zi() {
super();
}
}
package com.atguigu.test01.access1;
?
public class Neighbor {
public static void main(String[] args) {
Fu f = new Fu();
}
}
package com.atguigu.test01.other;
?
import com.atguigu.test01.access1.Fu;
?
public class AnotherNeighbor {
public static void main(String[] args) {
Fu f = new Fu();
}
}
成员变量（field）私有化之后，提供标准的get/set方法，我们把这种成员变量也称为属性（property）。或者可以说只要能通过get/set操作的就是事物的属性，哪怕它没有对应的成员变量。
隐藏类的实现细节
让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。还可以进行数据检查，从而有利于保证对象信息的完整性。
便于修改，提高代码的可维护性。主要说的是隐藏的部分，在内部修改了，如果其对外可以的访问方式不变的话，外部根本感觉不到它的修改。例如：Java8->Java9，String从char[]转为byte[]内部实现，而对外的方法不变，我们使用者根本感觉不到它内部的修改。
使用 private 修饰成员变量
private 数据类型 变量名 ；
代码如下：
public class Chinese {
private static String country;
private String name;
private int age;
private boolean marry;
}
提供 getXxx方法 / setXxx 方法，可以访问成员变量，代码如下：
public class Chinese {
private static String country;
private String name;
private int age;
private boolean marry;
public static void setCountry(String c){
country = c;
}
public static String getCountry(){
return country;
}
?
public void setName(String n) {
name = n;
}
?
public String getName() {
return name;
}
?
public void setAge(int a) {
age = a;
}
?
public int getAge() {
return age;
}
public void setMarry(boolean m){
marry = m;
}
public boolean isMarry(){
return marry;
}
}
当局部变量与类变量（静态成员变量）同名时，在类变量前面加“类名."；
当局部变量与实例变量（非静态成员变量）同名时，在实例变量前面加“this.”
public class Chinese {
private static String country;
private String name;
private int age;
public static void setCountry(String country){
Chinese.country = country;
}
public static String getCountry(){
return country;
}
?
public void setName(String name) {
this.name = name;
}
?
public String getName() {
return name;
}
?
public void setAge(int age) {
this.age = age;
}
?
public int getAge() {
return age;
}
}
（1）定义矩形类Rectangle，
声明静态变量sides，初始化为4，表示矩形边长的总数量；
声明实例变量长和宽
全部私有化，并提供相应的get/set方法
（2）在测试类中创建Rectangle对象，并调用相应的方法测试
（2）测试类ObjectArrayTest的main中创建一个可以装3个学生对象的数组，并且按照学生成绩排序，显示学生信息
我们发现我们new完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要挨个为它们再赋值，太麻烦了。我们能不能在new对象时，直接为当前对象的某个或所有成员变量直接赋值呢。
可以，Java给我们提供了构造器。
在创建对象的时候为实例变量赋初始值。
注意：构造器只为实例变量初始化，不为静态类变量初始化
构造器又称为构造方法，那是因为它长的很像方法。但是和方法还有有所区别的。
【修饰符】 构造器名(){
// 实例初始化代码
}
【修饰符】 构造器名(参数列表){
// 实例初始化代码
}
代码如下：
public class Student {
private String name;
private int age;
// 无参构造
public Student() {}
// 有参构造
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
注意事项：
构造器名必须与它所在的类名必须相同。
它没有返回值，所以不需要返回值类型，甚至不需要void
如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
构造器是可以重载的，既可以定义参数，也可以不定义参数。
构造器的修饰符只能是权限修饰符，不能被其他任何修饰
（1）声明一个员工类，
包含属性：编号、姓名、薪资、性别，要求属性私有化，提供get/set，
提供无参构造器和有参构造器
提供getInfo()
（2）在测试类的main中分别用无参构造和有参构造创建员工类对象，调用getInfo
public class TestEmployee {
public static void main(String[] args){
//分别用无参构造和有参构造创建对象，调用getInfo
Employee e1 = new Employee();
System.out.println(e1.getInfo());
Employee e2 = new Employee("1001","张三",110000,‘男‘);
System.out.println(e2.getInfo());
e2.setSalary(120000);
System.out.println(e2.getInfo());
System.out.println("e1薪资：" + e1.getSalary());
}
}
class Employee{
private String id;
private String name;
private double salary;
private char gender;
//提供无参构造器和有参构造器
public Employee(){
}
public Employee(String id, String name){
this.id = id;
this.name = name;
}
public Employee(String id, String name, double salary, char gender){
this.id = id;
this.name = name;
this.salary = salary;
this.gender = gender;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;