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

2023-02-17 109

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 【Java SE】面向对象三大特性之封装

🐳何为封装？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

🐳访问限定符：

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符。

Java中四种访问限定符具体如下： 1、public为公开的，被public所修饰的成员可以在任何类中都能被访问到。可以修饰类，构造方法，数据成员，方法成员。

2、protected是受保护的，受到该类所在的包所保护。可以修饰数据成员，构造方法，方法成员，除外部类的其他类。

3、default表示不写修饰符时，是默认值。默认为在同一个包内可以访问，包外不能访问。可以修饰类，构造方法，数据成员，方法成员。

4、private是私有的，即只能在当前类中被访问到，可以修饰构造方法，数据成员，方法成员，除外部类的其他类。

注意：四种访问限定修饰符的大小为：public>protected>default>private

1. class Computer {
2. private String cpu; // cpu（私有）
3. private String memory; // 内存（私有）
4. public String screen; // 屏幕（共有）
5.     String brand; // 品牌---->default属性（系统默认）
6. public Computer(){
7. //无参构造方法
8.     }
9. //有参构造方法
10. public Computer(String brand, String cpu, String memory, String screen) {
11. this.brand = brand;
12. this.cpu = cpu;
13. this.memory = memory;
14. this.screen=screen;
15. 
16.     }
17. public void Boot(){
18.         System.out.println("开机~~~");
19.     }
20. public void PowerOff(){
21.         System.out.println("关机~~~");
22.     }
23. public void SurfInternet(){
24.         System.out.println("上网~~~");
25.     }
26. public void print(){
27.         System.out.println(this.brand+" "+this.cpu+" "+this.memory+" "+this.screen);
28.     }
29. 
30. }
31. 
32. 
33. public class Test {
34. public static void main(String[] args) {
35.         Computer computer=new Computer("HUAWEI","\ti5-6500","16.0 GB ","Mateview");
36.         computer.print();
37. //        System.out.println(computer.screen);
38. //        System.out.println(computer.brand);
39. //        System.out.println(computer.cpu);
40. //        System.out.println(computer.memory);
41. 
42. 
43.     }
44. }

私有成员不能在类外访问。

注意：一般情况下成员变量设置为private，成员方法设置为public。

🐳封装扩展之包

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

🐳如何导入包中的类？

Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的Date类。

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

但是这种写法比较麻烦一些, 可以使用 import语句导入包。

1. import java.util.Date;
2. public class Test {
3. public static void main(String[] args) {
4. Date date = new Date();
5. // 得到一个毫秒级别的时间戳
6.         System.out.println(date.getTime());
7.     }
8. }

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

1. import java.util.*;
2. public class Test {
3. public static void main(String[] args) {
4. Date date = new Date();
5. // 得到一个毫秒级别的时间戳
6.         System.out.println(date.getTime());
7.     }
8. }

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况，因为包中可能会存在名字相同的类，导致编译器并不能知道你所要用的是哪一个。

比如：

1. import java.util.*;
2. import java.sql.*;
3. public class Test {
4. public static void main(String[] args) {
5. // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
6. Date date = new Date();
7.         System.out.println(date.getTime());
8.     }
9. }

在这种情况下需要使用第一种方式来辨别所要用的类：

1. import java.util.*;
2. import java.sql.*;
3. public class Test {
4. public static void main(String[] args) {
5.         java.util.Date date = new java.util.Date();
6. 
7.         System.out.println(date.getTime());
8.     }
9. }

可以使用import static导入包中静态的方法和字段。

1. import static java.lang.Math.*;
2. public class Test {
3. public static void main(String[] args) {
4. double x = 30;
5. double y = 40;
6. // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
7. double result = sqrt(pow(x, 2) + pow(y, 2));
8.         System.out.println(result);
9.     }
10. }

🐳如何自定义包

1. 在 IDEA 中先新建一个包: 右键 src -> new -> package

2. 在弹出的对话框中输入包名, 例如TestDemo3

3. 在包中创建类, 右键包名 ->new-> Java Class, 然后输入类名即可。

4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了。

5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句。

🐳包的访问权限控制

1. package TestDemo;
2. 
3. public class Computer {
4.     private String cpu; // cpu（私有）
5.     private String memory; // 内存（私有）
6.     public String screen; // 屏幕（共有）
7.     String brand; // 品牌---->default属性（系统默认）
8.     public Computer(String brand, String cpu, String memory, String screen) {
9.         this.brand = brand;
10.         this.cpu = cpu;
11.         this.memory = memory;
12.         this.screen=screen;
13. 
14.     }
15.     public void Boot(){
16.         System.out.println("开机~~~");
17.     }
18.     public void PowerOff(){
19.         System.out.println("关机~~~");
20.     }
21.     public void SurfInternet(){
22.         System.out.println("上网~~~");
23.     }
24. 
25. }

Computer类在TesDemo这个包下面

下面我们在另一个包TestDemo1下面访问这个包：

1. package TestDemo1;
2. import TestDemo.Computer;//访问TestDemo中Computer类
3. public class Test {
4. 
5. public static void main(String[] args) {
6. Computer p = new Computer("HW", "i7", "8G", "13*14");
7.         System.out.println(p.screen);
8.         p.PowerOff();
9. //System.out.println(p.cpu);
10.     }
11. 
12. }