java类和对象——封装

秒速五厘米 2023-10-05 23:18 53阅读 0赞

#### 文章目录 ####

*  1.封装
 *   *  1.1 封装的概念
     *  1.2 访问限定符
     *  1.3 封装拓展之包
     *   *  1.3.1 包的概念
         *  1.3.2 导入包中的类
         *  1.3 3 自定义包
         *  1.3.4 包的访问权限控制举例
         *  1.3.5 常见的包

## 1.封装 ##

### 1.1 封装的概念 ###

面向对象程序三大特性：**封装、继承、多态**。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是**套壳屏蔽细节**。

*需要注意的是封装、继承、多态是面向对象编程语言的三大特性，而不是java的。*

比如计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

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

### 1.2 访问限定符 ###

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

Java中提供了四种访问限定符：  
![f885d87fdddb448a8f6212e4c0160f60.png][]  
比如：  
public：可以理解为一个人的外貌特征，谁都可以看得到  
default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了  
private：只有自己知道，其他人都不知道  
**【说明】**

*  protected主要是用在继承中，继承部分详细介绍
 *  default权限指：什么都不写时的默认权限
 *  访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

**private** 是私有的、**default** 是默认的、**protected** 是受保护的、**public** 是公开的。

private只能在当前类内部中使用，public不管在哪里都可以使用。

class Person{
        
        private String name;//这条语句是封装好的，看不到
        public int age;
        
        public void setName(String name) {
        
            this.name = name;
        }
    
        public void showName(String name) {
        
            System.out.println(name + "->" + age);
        }
    
        public String getName() {
        
            return this.name;
        }
    }
    public class Work {
        
        public static void main(String[] args) {
        
            Person person = new Person();
            person.setName("zhangsan");
            System.out.println(person.getName());
        }
    }

**name**只能在类内部进行访问，

在使用的时候不添加任何的权限符就是default权限。

String name;//默认权限

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

### 1.3 封装拓展之包 ###

#### 1.3.1 包的概念 ####

为了更好的管理类，把**多个类收集在一起成为一组**，称为软件包。

![b38dea356b89449988f6a2412fd0ca66.png][]  
包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。

在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

#### 1.3.2 导入包中的类 ####

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

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

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

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

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

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

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

import java.util.*; 
    import java.sql.*;
    public class Test {
        
        public static void main(String[] args) {
         
            // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义,      编译出错
            Date date = new Date();       
            System.out.println(date.getTime()); 
        } 
     }
     // 编译出错 Error:(5, 9) java: 对Date的引用不明确 java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

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

import java.util.*; 
    import java.sql.*;
    public class Test {
        
        public static void main(String[] args) {
         
            java.util.Date date = new java.util.Date();    
            System.out.println(date.getTime()); 
        }
    }

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

import static java.lang.Math.*;
    public class Test {
        
      public static void main(String[] args) {
        
          double x = 30;
          double y = 40; // 静态导入的方式写起来更方便一些. 
         // doubleresult = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
    double result = sqrt(pow(x, 2) + pow(y, 2)); System.out.println(result); } }

**注意事项:**  
import 和 C++ 的 \#include 差别很大，C++ 必须 \#include 来引入其他文件内容, 但是 Java 不需要。import 只是为了写代码的时候更方便.，import 更类似于 C++ 的 namespace 和 using。

#### 1.3 3 自定义包 ####

**基本规则**

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

**操作步骤**

1.  在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包。  
    ![在这里插入图片描述][b087dd9bb26e461691dd42d6ad71b609.png]
2.  在弹出的对话框中输入包名, 例如 com.work.demo2。  
    ![在这里插入图片描述][0e071b81c3de40648907427f22381705.png]
3.  在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可。  
    ![cc9bb3f21d6b42ebbf9c447bd6b29978.png][]
4.  此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了。  
    ![74021ba096594d7199efef38efe21026.png][]
5.  同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句。  
    ![e5462a1c1e424278b83747cde3efc955.png][]

#### 1.3.4 包的访问权限控制举例 ####

package com.work.demo1;
    
    public class Computer {
        
        private String cpu; // cpu
        private String memory; // 内存
        public String screen; // 屏幕
        String brand; // 品牌
        public Computer(String brand, String cpu, String memory, String screen) {
        
            this.brand = brand;
            this.cpu = cpu;
            this.memory = memory;
            this.screen = screen;
        }
        public void Boot(){
        
            System.out.println("开机~~~");
        }
        public void PowerOff(){
        
            System.out.println("关机~~~");
        }
        public void SurfInternet(){
        
            System.out.println("上网~~~");
        }
    }

package com.work.demo2;
    import com.work.demo1.Computer;
    
    public class TestComputer {
        
        public static void main(String[] args) {
        
            Computer p = new Computer("HW", "i7", "8G", "13*14"); System.out.println(p.screen);
            System.out.println(p.cpu);// 报错：cup是私有的，不允许被其他类访问
            System.out.println(p.brand);//报错：brand是default，不允许被其他包中的类访问
        }
    }

*注意*：**如果去掉Computer类之前的public修饰符，代码也会编译失败**。

#### 1.3.5 常见的包 ####

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

[f885d87fdddb448a8f6212e4c0160f60.png]: https://img-blog.csdnimg.cn/f885d87fdddb448a8f6212e4c0160f60.png
[b38dea356b89449988f6a2412fd0ca66.png]: https://img-blog.csdnimg.cn/b38dea356b89449988f6a2412fd0ca66.png
[b087dd9bb26e461691dd42d6ad71b609.png]: https://img-blog.csdnimg.cn/b087dd9bb26e461691dd42d6ad71b609.png
[0e071b81c3de40648907427f22381705.png]: https://img-blog.csdnimg.cn/0e071b81c3de40648907427f22381705.png
[cc9bb3f21d6b42ebbf9c447bd6b29978.png]: https://img-blog.csdnimg.cn/cc9bb3f21d6b42ebbf9c447bd6b29978.png
[74021ba096594d7199efef38efe21026.png]: https://img-blog.csdnimg.cn/74021ba096594d7199efef38efe21026.png
[e5462a1c1e424278b83747cde3efc955.png]: https://img-blog.csdnimg.cn/e5462a1c1e424278b83747cde3efc955.png