1、封装概述

       封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

封装的优点

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

2、封装性的使用

public class Main {

    public static void main(String[] args) {
        Student student = new Student();
        student.name="皮皮虾";
        student.age=20;
        
        student.show();
    	student.age=-5;
        student.show();
    }

}


class Student{
    String name;
    int age;

    public void show() {
        System.out.println("name："+name+",age:"+age);
    }

}

上述代码表面上看没有什么问题，但在实际开发中对于属性肯定会有一些限制，例如：年龄不能为负数

解决方法

• 提供getter和setter方法获取属性和给属性赋值，且在该方法中可以设置条件判断
• 使用权限修饰符来注销掉原来的例如student.age=20; 这种赋值方法。

public class Main {

    public static void main(String[] args) {
        Student student = new Student();

        student.setAge(5);
        student.show();
        student.setAge(-2);
        student.show();
    }

}


class Student{
    private String name;
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
    	//条件判断
        if (age >= 0){
            this.age = age;
        }else {
            this.age = 0;
        }

    }

    public void show() {
        System.out.println("name："+name+",age:"+age);
    }

}

3、封装的作用

• 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。
• 对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

4、四种权限修饰符

      Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

• public : 对所有类可见。使用对象：类、接口、变量、方法

• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

通过以下表来说明访问权限：

对于class的权限修饰符只可以用public和default(缺省)
public类可以在任意地方被访问
default类只可以被同一包内部的类访问

5、四种权限修饰符测试

在同一包下，创建Main类和test类

Main.java

public class Main {

    String defaultName;
    private String privateName;
    public String publicName;


    private void privateMethod() {
        defaultName = "1";
        privateName = "2";
        publicName = "3";
    }

    public void publicMethod() {
        defaultName = "1";
        privateName = "2";
        publicName = "3";
    }

     void defaultMethod() {
        defaultName = "1";
        privateName = "2";
        publicName = "3";
    }
}

test.java

在另一个包下就建立test02类

test02.java

在另一个包下，原先的私有结构、缺省声明的结构都无法使用。

觉得不错的小伙伴可以点赞关注和收藏哦！

Java学习路线目录索引

大家好，我是卷心菜，大二学生一枚，本篇主要讲解Java面向对象的三大特征之一：封装性。如果您看完文章有所收获，可以三连支持博主哦~，嘻嘻。

一、设计思想

• 封装性的思想：以类为载体，将类的属性、行为(可以理解为Java中的方法)封装起来，对使用者隐藏其具体实现细节，只对外公开简单的接口。大白话就是说，该隐藏的隐藏，该暴露的暴露。
• 封装性的目的：便于外界调用，避免外部操作对类内部数据的影响，从而提高系统的可扩展性、可维护性。

二、权限修饰符

Java中有四种权限修饰符，作用范围从小到大依次是：

• private
• 缺省(就是什么都不写)
• protected
• public

用代码体现就是：

public class One {
    private int age;
    String name;
    protected String major;
    public char gender = '男';
}

三、作用范围

刚刚讲过了，这四种权限修饰符有不同的作用范围，那么它们的作用范围到底是什么呢？

四、使用细节

4种权限可以用来修饰类及类的内部结构：

属性、方法、构造器、内部类

注意：修饰类的话，只能使用：缺省、public，不然就会出现编译型异常

总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

五、代码举例

编写一个类，有四个成员变量，其中一个权限修饰符为public，其余都是private，都有对应的getter()和setter()：

public class One {
    private int age = 20;
    private String name = "cabbage";
    private String major = "计算机科学与技术";
    public char gender = '男';
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getMajor() {
        return major;
    }
    public void setMajor(String major) {
        this.major = major;
    }
    public char getGender() {
        return gender;
    }
    public void setGender(char gender) {
        this.gender = gender;
    }
}

最后写一个测试类：

public class TestDemo {
    public static void main(String[] args) {
        One one = new One();
        one.gender = '女';
        one.setAge(21);
        one.setName("hello");
        one.setMajor("大数据");
        System.out.println(one.gender);
        System.out.println(one.getAge());
        System.out.println(one.getName());
        System.out.println(one.getMajor());
    }
}

运行结果：

从代码和运行结果可以看出，属性gender权限修饰符作用范围最大，在测试中，可以直接通过"对象.方法"来改变属性值，这样就不符合封装性的思想，破坏了封装性；其它的三个属性值的改变，都是通过setter()和getter()来修改的，确保了封装性思想的落实：隐藏该隐藏的。

通过将属性声明为私有的private，再提供共有的public方法setter()和getter()来实现对属性的操作。来实现以下的目的：

• 隐藏类中不需要对外提供的实施细节
• 用户只需要通过实现定制好的方法访问数据，可以方便的加入控制逻辑，限制对属性的不合理操作
• 便于修改，增强代码的可维护性

谢谢阅读，一起进步，嘻嘻~

  概念（Idea；Notion；Concept）是人类在认识过程中，从感性认识上升到理性认识，把所感知的事物的共同本质特点抽象出来，加以概括，是自我认知意识的一种表达，形成概念式思维惯性。在人类所认知的思维体系中最基本的构筑单位。心理学上认为，概念是人脑对客观事物本质的反映。所以，想要学好知识，对概念的理解尤为重要。学好一门编程语言也是如此。
  但是，有些人说了：我对概念就不怎么上心，但是我也可以写出代码，实现我想要的功能。这话没错，但是在我们学习一门编程语言时往往会陷入一个误区：基础概念什么的知道就行，锻炼能力才是最终要的。殊不知，能力的提升是建立在基础之上的，经济基础决定上层建筑。所以我们今天就来聊聊Java语言中最基础的一个概念，Java类的三大特性之一：封装性。

1. 什么是封装性
  封装性，顾名思义，就是将一些东西打包成一个整体，用专业术语来讲就是：对用户隐藏其实现细节，使用该类的用户可以通过该类提供的接口来访问该类，使用户不能轻易的操作此数据结构，只能执行类允许公开的数据的一个小系统。
2. 使用封装的好处
  我们前面说到，使用该类的用户只能执行类允许公开的数据，这样一来就避免了外部操作对内部数据的影响，提高了程序的可维护性。下面通过几段代码来直观的看一下使用封装的好处。

class Person{
	//Person类的私有属性：姓名，年龄，性别
	private String name;
	private int age;
	private String sex;
	
	//用户可以通过以下方法访问或操作内部数据，如：姓名，年龄，性别
	public void setName(String n){
		name = n;
	}
	public void setAge(int a) {
		age = a;
	}
	public void setSex(String s) {
		sex = s;
	}
	
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public String getSex(){
		return sex;
	}
}

根据上述代码和图片我们可以看出，主方法中新建的对象不能直接访问Person类中的私有属性，只能通过该类留给我们的一些访问接口访问和操作内部数据，避免外部操作对内部数据的影响。
  我们再来设想一种情况：一个十分庞大的程序，有10000个对象具有这个Person类的属性，现在想将年龄由int改为String。对于以上情况如果不使用封装的话：

class Person{
	//Person类的属性：姓名，年龄，性别
	public String name;
	public int age;
	public String sex;
}

Person P = new Person();
P.age = 35;
P.name = "王二麻子";
P.sex = "男";
//..................................
//..................................(表示具有Person类的属性的对象还有很多个)

我们需要修改上万个位置，估计修改完之后我的表情应该是这样的

但是如果我们使用了封装就完全不一样了：

class Person{
	//Person类的私有属性：姓名，年龄，性别
	private String name;
	private String age;//将年龄改为String型
	private String sex;
//用户可以通过以下方法访问或操作内部数据，如：姓名，年龄，性别
	public void setName(String n){
		name = n;
	}
	public void setAge(int a) {
		age = String.valueOf(a);//改动
	}
	//后续代码省略...........
}

这样一来，我们就省了很多力气，提高了代码的可维护性，估计改代码的时候我的表情是这样的：

3. 对Java类封装性的理解
  其实对Java类的封装性的理解有很多方式，这里说说博主本人的理解吧！我是这样理解Java类的封装性的：使用Java类的封装性就好比是对快递进行打包，但是又不完全等于打包。因为我们对快递打包是越严密越好，可是我们把一个类严严实实的包装起来那这个类就是去其存在的意义了，可以说是一个“死类”，开发人员不能通过对外的接口来访问它，对开发人员来说这个类没有任何作用。
  试想一下：一座房子就像是一个类，里面的家具就是这个类私有的属性，墙就如同是封装，如果墙上没有安装门窗的位置，而是严严实实的一堵墙，那这座房子跟黑盒子没什么区别，同样，它也没有存在的意义。

特殊声明：本人并不是大佬，只是说一说自己在学习Java过程中的理解，文章有不正确的地方欢迎大家批评指正。最后希望大家不喜勿喷，营造良好的学习环境。
温馨提示：道路千万条，学习第一条。平时不学习，招聘两行泪！！！