【Java SE】封装

🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈

1. 封装

面向对象三大特性：封装、继承、多态
今天我们一起来看看封装这一特性，在类和对象中，主要研究的是封装特性。

1.1 封装是什么

比如，在生活中，我们经常会看电视，我们仅需将电视开机，用遥控器调到自己喜欢的频道，但是我们并不知道这些功能如何在电视机实现的，电视机只给我们提供接口，我们利用接口，按下电视机开关按钮或是调节遥控器与电视机交互，具体如何实现，我们无从知晓，这就是封装，将实现的细节隐藏起来。
【封装】把类的实现细节进行隐藏，对外只提供一些交互的接口，让数据和操作数据方法有机结合。
所以在生活中，需要我们多去观察，很多计算机的知识来源于生活，所以计算机也没有那么神秘啦~

1.2 封装的意义

封装有什么意义呢？
电视机的具体实现如果不进行封装，很容易损伤，造成功能无法实现的现象，同时，如果不将实现细节隐藏，很容易造成行业之间的恶性竞争，所以封装的意义重大。
因此，我们类比总结：
【封装的意义】在于提高程序的安全性、保护数据、隐藏代码的实现细节、统一接口以及实现松耦合，从而提高系统的可维护性和可扩展性。

1.3 访问修饰限定符

1.3.1 在Java中如何实现封装

主要是通过这两种方式进行封装：
【1.类】在Java中通过类把数据以及封装数据的方法结合在一起
【2.访问权限】访问权限是通过控制方法或者字段等能否在类外使用

1.3.2 各种访问修饰限定符

在Java中提供4种访问限定符

由上述表中可以清晰得出：
1）private 权限特别小，只能在当前类中使用
2）default 为默认权限。即什么都不写的话就是默认权限
3）protected 主要使用在继承中，因为涉及到子类
4）public则是“谁”都可以看到

2. 包

2.1 包的概念

在日常生活中，我们在使用电脑的时候，如果有太多个文件，我们就会创建一个文件夹，将这些文件放入文件夹中。
【概念】
在Java中包是将类、接口等封装起来，是一种对类或者接口等的很好的组织方式。
【意义】
1）可以更好管理类、接口，把类、接口收集为一组，方便类、接口的查找和使用
2）可以避免类名相同造成的冲突，即在同一工程中，处在不同的包内，允许存在相同名称的类
3）可以限定访问权限，拥有包访问权限的类才能访问某个包中的类
4）可以更好维护程序的结构

2.2 常见的包

1）java.lang:系统常用基础类(String、Object)【该包从JDK1.1后自动导入】
2）java.util:是java提供的工具程序包(集合类等) 【常用且非常重要】
3）java.lang.reflect:java反射编程包
4）java.net:进行网络编程开发包
5）java.sql:进行数据库开发的支持包 6）java.io:I/O编程开发包

2.3 导入包中的类

在Java中提供了非常多现成的类供我们使用，导入一个包的其中一个类，则我们可以直接使用类。
举一个栗子吧~比如要求当前的日期与时间毫秒数值
java.util 包中提供 Date 类来封装当前的日期和时间，使用 getTime() 方法获取当前日期到1970年1月1日经历的毫秒数值。
有两种方法：
1）直接在new对象写
使用格式：

java.util.类名 对象名 = new java.util.类名()；

具体代码：

public class Solution {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

2）使用import语句

使用格式：

import java.util.类名；

具体代码：

import java.util.Date;
public class Solution {
    public static void main(String[] args) {
        Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

通过比较，我们发现，第一种写法较为麻烦，如果要new多个该对象，则java.util会重复写，显得较为冗余，一般，我们都使用ipmort语句导入包中的类。
【注意】
如果要导入java.util其它的多个类，可以直接使用

import.java.util.*;

这个并不是把所有的类都导入了，是要用哪个，则会有，即随用随取
但是一般最好还是写出具体的类名，多写几个import语句
如果导入多个包，而使用的类在这些包里都有，则编译器不知道使用的是哪一个包中类，则容易造成冲突

import java.util.Date;
import java.sql.Date;
public class Solution {
    public static void main(String[] args) {
        Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

将会出现编译出错：

原因： java.util 中的类 java.util.Date和java.sql 中的类 java.sql.Date 都匹配，对Date引用不明确
在这种情况下，我们必须写出使用的完整类名，避免冲突

2.4 自定义包

指定包：在文件的最上方加上一个 package 语句指定该代码在哪个包中
如果一个类没有 package 语句, 则该类被放到一个默认包中（一般都直接放在默认包中，学会使用自定义导入包）

package com.wan.test1;

【包名注意事项】
1）包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式(如 com.wan.test1 ).
2）包名要和代码路径相匹配，例如创建 com.wan.test1 的包, 那么会存在一个对应的路径 com/wan/test1 来存储
代码
具体操作步骤：

1.点击src右键->新建(即点击New)->导入包(即点击Package)
2.输入包名：com.wan.test1(包名注意规则)
3.点击该包，在该包内创建类
4.磁盘中目录结构已经被自动创建出来（同时在新创建的 Test.java 文件的上方， 就出现package 语句，即代表在这个包下）

【包的权限注意】
在上面了解到各修饰符的范围，比如现在在这个package com.wan.test1中有Student类
在package.com.wan.test2中有StudentTest类导入package com.wan.test1的Student类

public class Student {
    private int sno;//学号
    private int score;//分数
    public String name;//姓名
    String sex;//性别
    public Student(int sno,int score,String name,String sex) {
        this.sno = sno;
        this.score = score;
        this.name = name;
        this.sex = sex;
    }
}

package com.wan.test2;
import com.wan.test1.Student;

public class StudentTest {
    public static void main(String[] args) {
        Student sc = new Student(2022111,99,"张三","女");
    }
}

为什么会报错呢~
1.sno、score是被private修饰，私有的不能被其它类访问
2.sex未加修饰符，即是default修饰，不能被其它包内的类访问
3.Student类前必须有public，不然无法在 com.wan.test2包内使用

3. 深度理解private访问权限修饰符

3.1 使用原因

为什么需要使用private访问权限修饰符
1）private可以修饰成员方法、成员变量，被修饰的成员方法/变量只能在当前类使用
2）由上述知识，不难理解，在很多时候，我们需要封装以此提高安全性，可以隐藏类的实现细节，只提供对外开放的接口，实现对象之间的交互，而private通过访问权限，控制方法/字段不能在类外使用，体现封装的思想。

public class Student {
    private int sno;//学号
    String sex;//性别
    private int score;//分数
    public String name;//姓名


    public Student(int sno,int score,String name,String sex) {
        this.sno = sno;
        this.score = score;
        this.name = name;
        this.sex = sex;
    }

    private void attendClass() {
        System.out.println("上课啦！");
    }
}
class Test {
    public static void main(String[] args) {
        Student s1 = new Student(1,45,"张三","男");
        System.out.println(s1.sno);
        System.out.println(s1.score);
        System.out.println(s1.name);
        System.out.println(s1.sex);
		s1.attendClass();
    }
}

上述代码将会报错，由于学号，分数，方法attendClass()均被private修饰，在Test类不能进行访问。在生活中，我们需要将学号、分数这种隐私的信息隐藏起来。

3.2 使用方法

我们知道被private修饰的只能在当前类使用，如何让其它类使用到private修饰的成员变量呢？
1）得到private修饰的成员变量
方法：构造方法getSno()、getScore()，直接返回该值【即提供对外的接口来访问】
【注意】这些get方法需要用public修饰，如果仍然用private修饰则访问不到

public class Student {
    private int sno = 123;//学号
    String sex;//性别
    private int score = 11;//分数
    public String name;//姓名

    public int getSno() {
        return sno;
    }

    public int getScore() {
        return score;
    }

}

class Test {
    public static void main(String[] args) {
        Student student1  = new Student();
        System.out.println(student1.getSno());
        System.out.println(student1.getScore());
    }
}

2）对private修饰的成员变量赋值

public class Student {
    private int sno = 123;//学号
    String sex;//性别
    private int score = 11;//分数
    public String name;//姓名

    public int getSno() {
        return sno;
    }

    public int getScore() {
        return score;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    public void setScore(int score) {
        this.score = score;
    }

}

class Test {
    public static void main(String[] args) {
        Student student1  = new Student();
        System.out.println("修改前："+student1.getScore());
        student1.setScore(44);
        System.out.println("修改后："+student1.getScore());
    }
}

结果如下，修改成功

【快捷方法】如果使用的集成开发环境为IDEA，可以快速创建Getter和Setter，编译器会自动生成上述get()和set()方法
【步骤如下】
1.右键点击Generate
2.选择Getter/Setter

本期内容回顾：

本期内容就到这里结束啦！继续加油呀~