Java面向对象-封装

原创已于 2024-02-19 19:19:16 修改 · 2k 阅读

39 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2024-02-19 19:18:05 首次发布

本文详细介绍了封装在Java中的重要性，包括封装的概念、实现步骤、封装带来的好处，以及如何通过访问权限控制和包的使用来加强封装。还涵盖了静态修饰符的使用，如静态代码块、变量和方法。

封装

前言

理解封装的作用、使用封装、使用Java中的包、掌握访问修饰符，理解访问权限

一、封装的介绍

面向对象三大特征之一——封装

		// 使用无参构造方法创建Penguin类对象
        Penguin penguin1 = new Penguin();
        // 给penguin1对象属性赋值
        penguin1.name = "QQ";
        penguin1.health = 100;
        penguin1.love = 100;
        //调用方法输出penguin1对象的属性信息
        penguin1.printInfo();

        Penguin penguin2 = new Penguin();
        penguin2.name = "weiChat";
        penguin2.health = -50;
        // 对于赋予的值进行判断
        if(penguin2.health<0||penguin2.health>100){
            System.out.println("赋予的健康值不合理，默认赋值为80");
            penguin2.health = 80;
        }
        penguin2.love = -80;
        //对赋予的值进行判断
        if(penguin2.love<0||penguin2.love>100){
            System.out.println("赋予的亲密度值不合理，默认赋值为90");
            penguin2.love = 90;
        }

例如上述代码属性随意访问，不合理的赋值，所以使用封装就可以很好的解决这一问题

1、封装的概念

将类的某些信息（属性）隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

2、封装的两大原则

1）把尽可能多的东西隐藏起来，对外提供便捷的接口

2）把所有的属性藏起来

二、封装的实现

1、封装步骤

1）修改属性的可见性

2）创建公有的getter/setter方法

3）在getter/setter方法中加入属性控制语句

2、封装的好处

1）便于使用者正确使用系统，防止错误修改属性

2）有助于系统之间的松耦合（耦合是两个或多个模块之间的相互关联，模块之间的耦合度越高，维护成本越高。因此，在系统架构的设计过程中，应减少各个模块之间的耦合度，以提高应用的可维护性），提高系统独立性

3）提高软件的可重用性

4）降低了构建大型系统的风险

3、实现封装代码案例

public class Penguin {
    // 定义属性 用private修饰
    private String name;
    private int health;
    private int love;

    public Penguin() {
    }

    public Penguin(String name, int health, int love) {
        this.name = name;
        this.health = health;
        this.love = love;
    }

    // 因为name、health、love被隐藏在类的内部，外部程序不能直接访问，所以提供公共的get/set方法给外部程序直接访问这些属性
    // 获取name、health、love值
    public String getName(){ // get是返回值
        return name;
    }

    public int getHealth(){
        return health;
    }

    public int getLove(){
        return love;
    }

    // 设置name、health、love值
    public void setName(String name){
        this.name=name;
    }

    public void setHealth(int health){
        // 对传递过来的health值进行判断
        if(health<0||health>100){
            System.out.println("你赋予的健康值不合理，默认赋值为80");
            this.health=80;
            return; // 如果健康值不合理为负值或大于一百，则赋值为80并返回
        }
        this.health=health; // 如果健康值合理，则直接赋值
    }

    public void setLove(int love){
        // 对传递过来的love值进行判断
        if(love<0||love>100){
            System.out.println("你赋予的亲密度值不合理，默认赋值为90");
            this.love = 90;
            return;
        }
        this.love=love; 
    }

    // 定义方法输出Penguin属性信息
    public void printInfo(){
        System.out.println("昵称："+this.name+"，健康值："+this.health+"，亲密度："+this.love);
    }
}

public class PenguinTest {

    public static void main(String[] args) {

        Penguin penguin1 = new Penguin();
        // 给属性赋值
        // name、health、love都被private修饰，隐藏在类的内容，不能直接访问
        //penguin1.name = "QQ";
        //penguin1.health = 100;
        //penguin1.love = 90;
        //System.out.println(penguin1.name);
        //System.out.println(penguin1.health);
        //System.out.println(penguin1.love);

        // 调用setXxx()方法进行赋值
        penguin1.setName("QQ");
        penguin1.setHealth(100);
        penguin1.setLove(90);

        System.out.println(penguin1.getName());
        System.out.println(penguin1.getHealth());
        System.out.println(penguin1.getLove());

        penguin1.printInfo();

        System.out.println("--------------------------");

        Penguin penguin2 = new Penguin();
        penguin2.setName("weChat");
        penguin2.setHealth(-30);
        penguin2.setLove(-50);
        System.out.println(penguin2.getName());
        System.out.println(penguin2.getHealth());
        System.out.println(penguin2.getLove());

        System.out.println("--------------------------");

    }
}

三、包的概念和使用

1、包的概念

package 包

例如Windows树形文件系统，文档分门别类，易于查找和管理；使用目录解决文件同名冲突问题

2、包的作用

1）允许类组成较小的单元（类似于文件夹），易于找到和使用相应的文件

2）防止命名冲突，区分名字相同的类

3）有助于实施访问权限控制

3、包的创建

1）包的创建语句必须是类中第一条语句，注释除外

2）一个Java文件中只有一个包的定义语句

3）包名由小写字母组成，不能以圆点开头或结尾

4）包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名

5）包名后续部分依不同机构内部的规范不同而不同

4、包的导入

为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类

package com.bdqn.demo06;

// import java.util.Arrays;
// import java.util.Scanner;

// 如果你需要导入某个包中大部分的类，你可以使用*表示所有类
// 注意：*只表示包中的所有的类，不包含包中子包里的类
import java.io.IOException;
import java.util.*;
import java.util.jar.JarFile;

public class Demo01 {

    public static void main(String[] args) throws IOException {
        // 使用java.util包中的Scanner类
        Scanner scanner = new Scanner(System.in);
        // 使用java.util包中的Arrays类
        int[] nums = {11,22,33};
        Arrays.sort(nums);

        // 使用java.util.jar.JarFile类
        JarFile jarFile = new JarFile("qwert");
    }
}

注意：

1）一个类同时引用了两个来自不同包的同名类，必须通过完整类名来区分

2）每个包都是独立的，顶层包不会包含子包的类

3）package和import的顺序是固定的

4）package必须位于第一行（忽略注释行）

5）只允许有一个package语句；其次是import，可以有多条语句；接着是类的声明

四、文件和类的关系

package com.bdqn.demo06;

// 一个Java文件中只能有一个public修饰的类，并且这个类的名称要和文件名称一致
// 一个Java文件中除了定义一个public修饰的类之外，还可以定义多个使用默认修饰符（什么都不写）修饰的类
public class Demo02 {
}

class Demo03{}
class Demo04{}

package com.bdqn.demo06;

// 在一个Java文件中可以只定义默认修饰符修饰的类，这个类的名称可以和文件名相同，也可以不同，最好定义成语文件名一致
class Demo3 {
}

class Demo05{}

class Demo06{}

/*
* 在日常开发过程中，一般一个Java文件中都只定义一个类
* */