【JavaSE】Java面向对象三特性之封装性

  Java基础，打破概念窗。

1.什么是封装

  面向对象三大特征：封装、继承、多态。
  封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
  封装简单说就是将一些细节信息隐藏起来，对于外界不可见，外界只管调用。

2.封装性在Java当中的体现

方法就是一种封装

将一些操作封装在方法里。

public class Demo02Method {
    public static void main(String[] args) {
        int[] array = {5, 15, 25, 20, 100};

        int max = getMax(array);
        System.out.println("最大值：" + max);//最大值：100
    }

    // 给我一个数组，我还给你一个最大值
    public static int getMax(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

关键字private也是一种封装

  一旦使用了private进行修饰，那么本类当中仍然可以随意访问。但是！超出了本类范围之外就不能再直接访问了。
  间接访问private成员变量，就需要通过成员方法访问，就是定义一对儿Getter/Setter方法。

• 必须叫setXxx或者是getXxx命名规则。
  • 对于Getter来说，不能有参数，返回值类型和成员变量对应；
  • 对于Setter来说，不能有返回值，参数类型和成员变量对应；

注意：对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。

举个例子说明间接访问的好处，我们定义一个Person类，它有姓名和年龄两个属性。
  问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来，年龄不能是负数。
  解决方案：用private关键字将需要保护的成员变量进行修饰。就不能直接访问该成员变量了。但可以通过调用setXxx方法访问，在方法中加入一些限制就可以解决设置不合理的数值。
  例子程序:

public class Person {
    String name; // 姓名
    private int age; // 年龄

    public void show() {
        System.out.println("我叫：" + name + "，年龄：" + age);
    }

    // 这个成员方法，专门用于向age设置数据
    public void setAge(int num) {
        if (num < 100 && num >= 9) { // 如果是合理情况
            age = num;
        } else {
            System.out.println("数据不合理！");
        }
    }

    // 这个成员方法，专门用于获取age的数据
    public int getAge() {
        return age;
    }
}

public class Demo03Person {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();//我叫：null，年龄：0

        person.name = "赵丽颖";
        //person.age = -20; // 直接访问private内容，错误写法！无法访问到
        person.setAge(20);
        person.show();//我叫：赵丽颖，年龄：20
    }
}

3.封装优化1——this关键字

  我们会遇到这样一个情况，当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。即局部变量会覆盖成员变量(全局变量)。在这种情况下，如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名，才能访问到本类当中的成员变量。

• this的含义：this代表所在类的当前对象的引用（地址值），即对象自己的引用。
• 理解this就是当前对象，“通过谁(对象)调用的方法，谁(对象)就是this。”

例子程序：

class Person1 {
    String name; // 我自己的名字

    // 参数name是对方的名字
    // 成员变量name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + "，你好。我是" + this.name);
        System.out.println(this);//Person1@14ae5a5
    }
}


public class Demo01Person {
    public static void main(String[] args) {
        Person1 person = new Person1();
        // 设置我自己的名字
        person.name = "王健林";
        person.sayHello("王思聪");//王思聪，你好。我是王健林

        System.out.println(person); // 地址值Person1@14ae5a5
    }
}

4.封装优化2——构造方法

  构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。(给对象的成员变量赋初始值。)
构造方法的格式：

public 类名称(参数类型 参数名称) {
	    方法体
}

注意事项：

1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2. 构造方法不能有写返回值类型，连void都不写
3. 构造方法不能return一个具体的返回值
4. 如果没有编写任何构造方法，那么编译器将会默认提供一个构造方法，没有参数、方法体什么事情都不做。
   * 像：public Student() {}
5. 一旦程序中编写了至少一个构造方法，那么编译器将不再提供默认的构造方法。
   * 有一个习惯，就算是编写了构造方法，还是会编写一个空参的构造方法。防止创建对象时，忘记传参的情况，程序报错；
6. 构造方法也是可以进行重载的。 重载：方法名称相同，参数列表不同。

例子程序：

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

使用这个类

public class Demo01Student {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("迪丽热巴");
        stu1.setAge(20);
        System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
        System.out.println("=================");

        Student stu2 = new Student("古力娜扎", 21);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        stu2.setAge(22);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }
}
/*输出结果：
姓名：迪丽热巴，年龄：20
=================
姓名：古力娜扎，年龄：21
姓名：古力娜扎，年龄：22
 */

5.标准类代码——JavaBean

JavaBean 是 Java语言编写类的一种标准规范。编写一个符合JavaBean的标准封装类，通常要拥有下面四个组成部分：

1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对儿Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法

这样标准的类就叫做Java Bean，下面用一个标准学生类展示：

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 无参数的构造方法
    public Student() {
        System.out.println("无参构造方法执行啦！");
    }

    // 全参数的构造方法
    public Student(String name, int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name;
        this.age = age;
    }

    // Getter Setter
    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;
    }
}

使用学生类

public class Demo02Student {
    public static void main(String[] args) {
        Student stu1 = new Student(); // 无参构造
        System.out.println("============");

        Student stu2 = new Student("赵丽颖", 20); // 全参构造
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        // 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
        stu2.setAge(21); // 改变年龄
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }
}
/*输出结果：
无参构造方法执行啦！
============
全参构造方法执行啦！
姓名：赵丽颖，年龄：20
姓名：赵丽颖，年龄：21
 */

欢迎点赞评论，指出不足，笔者由衷感谢o!