• Java中的封装的实现，访问限定符、包

    一. 封装

    封装是面向对象的三大特性之一； 面向对象程序三大特性：封装、继承、多态 。

    封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互（简单来说就是套壳屏蔽细节）。

    用生活中的实物来理解封装，比如电脑：

    对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。

    但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此 计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可 。

    二. 访问限定符(修饰符)

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

    public：公开的，可以理解为一个人的外貌特征，谁都可以看得到

    protected：受保护的，涉及到继承中的知识，继承博客中详细介绍

    default: 什么都不写时的默认权限，对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

    private：私有的，只有自己知道，其他人都不知道

    通过下面给出的代码示例理解封装：

    1. class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">class Person { 
    2.     private String name;
    3.     //private修饰的成员变量只能在本类中访问
    4.     private int age;
    5.  
    6.     String sex;
    7.     //这里不加修饰符即为默认权限，默认是default权限
    8.  
    9.     public  String  getName()  { 
    10.         return name;
    11.     }
    12.     //在其他类中不能直接访问name和age，
    13.     //但可以在本类中提供公开的（public修饰）访问方法和外界进行交互
    14.     //这里就是对成员变量进行了封装
    15.     public  void  setName(String name)  { 
    16.         this.name = name;
    17.     }
    18.  
    19.     public  int  getAge()  { 
    20.         return age;
    21.     }
    22.  
    23.     public  void  setAge(int age)  { 
    24.         this.age = age;
    25.     }
    26.  
    27.     public  void  show()  { 
    28.         System.out.println("姓名："+name+" 年龄: "+age);
    29.     }
    30.  
    31. }
    32.  
    33. public class Test { 
    34.  
    35.     public  static  void  main(String[] args)  { 
    36.         Person person = new Person();
    37.         //person.name = "bit";//不能直接进行访问
    38.         person.setName("XIN-XIANG荣");
    39.         person.setAge(21);
    40.         //通过提供Person类中提供的方法间接进行访问
    41.         System.out.println(person.getName()+" => "+person.getAge());
    42.     }
    43. }

    一般情况下成员变量设置为private，成员方法设置为public，通过这个例子就可以很好的理解封装了，这里对 类 内部的实现细节进行了隐藏/封装，对 外 只提供一些公开的方法供其他用户进行访问。

    【访问限定符的使用场景】：

    • 我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者.
    • 因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限；例如如果一个方法能用 private, 就尽量不要
      用 public.
    • 另外, 还有一种 简单粗暴 的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用, 不过最好写代码的时候思考该类提供的字段方法到底给 “谁” 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用)

    1. 包的概念

    在面向对象体系中，提出了一个软件包的概念，即： 为了更好的管理类，把多个类收集在一起成为一组，称为软件包 。 有点类似于目录。比如：为了更好的管理电脑中的图片，一种好的方式就是将相同属性的图片放在相同文件下，也可以对某个文件夹下的图片进行更详细的分类 。

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

    2. 导入包中的类

    2.1 导入方法一

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

    1. class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">public class Test1 { 
    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. }

    2.2 导入方法二

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

    1. class="prettyprint hljs typescript" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">import java.util.Date;
    2. public class Test1 { 
    3.     public static void main(String[] args) { 
    4.         Date date = new Date();
    5.         // 得到一个毫秒级别的时间戳
    6.         System.out.println(date.getTime());
    7.     }
    8. }

    2.3 导入方法三

    如果需要使用 java.util 中的其他类, 可以使用 import java.util.* ，这里可以导入java.util这个包中的所有类，但要注意不是一下子将所有类都导进来，在代码中用到谁就会导入谁。

    1. class="prettyprint hljs typescript" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">import java.util.*;
    2. public class Test1 { 
    3.     public static void main(String[] args) { 
    4.         Date date = new Date();
    5.         // 得到一个毫秒级别的时间戳
    6.         System.out.println(date.getTime());
    7.     }
    8. }

    但是 更建议显式的指定要导入的类名 . 否则还是容易出现冲突 的情况.

    1. class="prettyprint hljs typescript" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">import java.util.*;
    2. import java.sql.*;
    3. public class Test1 { 
    4.     public static void main(String[] args) { 
    5. // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
    6.         Date date = new Date();
    7.         System.out.println(date.getTime());
    8.     }
    9. }
    10.  
    11. // 编译出错
    12. //Error:(5, 9) java: 对Date的引用不明确
    13. //java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

    在这种情况下需要使用完整的类名

    1. "prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">import java.util.*;
    2. import java.sql.*;
    3. public class  Test1  { 
    4.     public  static  void  main(String[] args)  { 
    5.         java.util.Date date = new java.util.Date();
    6.         System.out.println(date.getTime());
    7.     }
    8. }

    2.4 导入静态的方法和字段

    1. class="prettyprint hljs cpp" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">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. // 静态导入的方式写起来更方便一些.
    7. // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
    8.         double result = sqrt(pow(x, 2) + pow(y, 2));
    9.         System.out.println(result);
    10.     }
    11. }
    12.  
    13. //对比正常的导入和使用
    14. import java.lang.Math;
    15. public class Test1 { 
    16.     public  static  void  main(String[] args)  { 
    17.         double x = 30;
    18.         double y = 40;
    19.         double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
    20.         System.out.println(result);
    21.     }
    22. }

    3. 自定义包

    3.1 基本使用规则：

    • 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
    • 包名需要尽量指定成唯一的名字, 通常会用公司域名的颠倒形式(例如com.bat.demo1 ).
    • 包名要和代码路径相匹配. 例如创建 com.bat.demo1 的包, 那么会存在一个对应的路径 com/bat/demo1 来存储代码
    • 如果一个类没有 package 语句, 则该类被放到一个默认包中

    3.2 IDEA中创键自定义包

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

    1. 在弹出的对话框中输入包名, 例如 com.bat.demo1 ，敲入回车即可

    1. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名回车即可.

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

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

    4. 不同包中的访问权限控制

    Computer类位于com.bat.demo1包中，TestComputer位置com.bat.demo2包中

    1. class="prettyprint hljs typescript" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">package com.bat.demo1;
    2.  
    3. public class Computer { 
    4.     private String cpu; // cpu
    5.     private String memory; // 内存
    6.     public String screen; // 屏幕
    7.     String brand; // 品牌
    8.  
    9.     public Computer(String brand, String cpu, String memory, String screen) { 
    10.         this.brand = brand;
    11.         this.cpu = cpu;
    12.         this.memory = memory;
    13.         this.screen = screen;
    14.     }
    15.  
    16.     public void Boot() { 
    17.         System.out.println("开机~~~");
    18.     }
    19.  
    20.     public void PowerOff() { 
    21.         System.out.println("关机~~~");
    22.     }
    23.  
    24.     public void SurfInternet() { 
    25.         System.out.println("上网~~~");
    26.     }
    27. }

    注意：如果去掉Computer类之前的public修饰符，Computer类为默认权限，只能在同一包中访问，代码也会编译失败

    5. 常见的包

    1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
    2. java.lang.reflect:java 反射编程包;
    3. java.net:进行网络编程开发包。
    4. java.sql:进行数据库开发的支持包。
    5. java.util:是java提供的工具程序包；(集合类等) 非常重要
    6. java.io:I/O编程开发包。
  • 相关阅读:
    浏览器本地存储webStroage
    爬虫实战：从HTTP请求获取数据解析社区
    数据结构与算法复习：第三十五弹
    进程控制——进程创建
    【注释和反射】获取class类实例的方法
    ES6 入门教程 20 Generator 函数的异步应用 20.4 Thunk 函数
    基于微信小程序的语言课学习系统设计与实现(源码+lw+部署文档+讲解等)
    Ubuntu18.04切换Python版本
    项目问题参考答案
    操作系统笔记（1）- 计算机硬件介绍
  • 原文地址：https://blog.csdn.net/Java_ttcd/article/details/126265891