Java封装

已于 2024-02-19 20:11:11 修改
阅读量349 收藏 8
点赞数 9
文章标签： java
于 2024-01-17 20:26:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76764006/article/details/135659577
版权

一、封装的介绍

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

        // 使用无参构造方法创建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、修改属性的可见性设为private，防止错误的修改
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("--------------------------");

    }
}

这样封装，对对象的部分属性合理赋值，减少了创建对象时对构造方法的使用直接赋值  

// 思考：通过有参构造方法创建对象
        Penguin penguin3 = new Penguin("yy",-100,-100);
        penguin3.printInfo();
        // 输出的结果还是不合理
        
        // 解决方式一：
        // 在构造方法中进行判断
        // 解决方法二：
        // 交给前端大冤种进行处理数据
        // 后续实参的输入应是从键盘进行获取
        // 可以在程序设计的前端进行判断再输入 

4、快速添加get\set

1）添加构造方法

Alt + Insert --->Constructor --->Ctrl + Enter --->创建无参构造方法

Alt + Insert --->Constructor --->Ctrl + A --->Enter --->创建包含所有参数的有参构造方法

2）添加get\set方法

Alt + Insert --->Getter and Setter --->Ctrl + A --->Enter --->添加所有属性的get/set方法

3）输出所有信息（重写）

Alt + Insert --->toString --->Ctrl + A --->Enter

 

三、包的概念和使用

1、包的概念

package 包

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

2、包的作用

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

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

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

3、包的创建

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

package com.learn.demo05; 

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

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

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

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

4、包的导入

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

package com.learn.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.learn.demo06;

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

class Demo03{}
class Demo04{}

package com.learn.demo06;

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

class Demo05{}

class Demo06{}

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

 

五、访问权限控制

1、回顾

1）属性隐藏

在类中，创建属性时用private修饰属性

2）包机制

调包就是获取类中的方法

2、类的访问控制

1）public修饰符：公有访问级别

2）默认修饰符：包级私有访问级别

package com.learn.demo07;

public class PublicClass01 { // public修饰符修饰的类
}

package com.learn.demo07;

class DefaultClass01 { // 默认修饰符修饰的类
}

 

package com.learn.demo07;

// import com.learn.demo08.DefaultClass02;
import com.learn.demo08.PublicClass02;

public class Test01 {

    public static void main(String[] args) {

        // 创建demo07包中的PublicClass01类对象
        PublicClass01 publicClass01 = new PublicClass01();
        System.out.println("publicClass01:"+publicClass01); // 输出地址值

        // 创建demo07包中的DefaultClass01类对象
        DefaultClass01 defaultClass01 = new DefaultClass01();
        System.out.println("defaultClass01:"+defaultClass01); // 输出地址值

        // 创建demo08包中的PublicClass02类对象
        PublicClass02 publicClass02 = new PublicClass02();
        System.out.println("publicClass02:"+publicClass02);

        // 在Demo07包中创建demo08包中的DefaultClass02类对象
        // DefaultClass02 defaultClass02 = new DefaultClass02();
        // 不能访问另一个包中默认修饰符修饰的类

    }
}

package com.learn.demo07;

// import com.learn.demo08.DefaultClass02;
import com.learn.demo08.PublicClass02;

class Test02 {

    public static void main(String[] args) {

        // 创建demo07包中的PublicClass01类对象
        PublicClass01 publicClass01 = new PublicClass01();
        System.out.println("publicClass01:"+publicClass01);

        // 创建demo07包中的DefaultClass01类对象
        DefaultClass01 defaultClass01 = new DefaultClass01();
        System.out.println("defaultClass01:"+defaultClass01);

        // 创建demo08包中的PublicClass02类对象
        PublicClass02 publicClass02 = new PublicClass02();
        System.out.println("publicClass02:"+publicClass02);

        // 创建demo08包中的DefaultClass02类对象
        //DefaultClass02 defaultClass02 = new DefaultClass02();

    }
}

package com.learn.demo08;

public class PublicClass02 {
}

 

package com.learn.demo08;

class DefaultClass02 {
}

 

默认修饰符称为包级私有，就是说只能在当前包中其它类可以访问，出了包就不行

类的访问控制总结：

在同一个包中无论是public还是默认修饰符修饰的类，都可以相互访问

访问另一个包中默认修饰符修饰的类就不行

3、类成员的访问控制
访问权限修饰符
修饰符\作用域同一个类中同一个包中子类中任何地方（其它包）
默认修饰符可以可以不可以不可以
public可以可以可以可以
private可以不可以不可以不可以
protected可以可以可以不可以

例1：

package com.learn.demo09;

public class Employee {
    // 定义属性，使用4种访问修饰符修饰不同的属性
    public String name;
    protected  int age;
    char gender;
    private String phone;

    public static void main(String[] args) {

        // 创建Employee类对象
        Employee employee = new Employee();
        // 通过对象直接访问属性
        employee.name = "张三";
        employee.age = 20;
        employee.gender = '男';
        employee.phone = "13212345678";

    }
}

 如例1所示：四种修饰符修饰的属性在同一个类中均可访问

例2：

package com.learn.demo09;

public class EmployeeTest01 { // public修饰公共的类

    public static void main(String[] args) {

        // 创建Employee类对象
        Employee employee = new Employee();

        // 给employee对象属性赋值
        employee.name = "李四";
        employee.age = 20;
        employee.gender = '男';
        // phone属性使用private修饰，只能在本类中直接访问，出了本类就只能通过公共的getX/set方法访问
        // employee.phone = "13222221111"; 报错
    }
}

package com.learn.demo09;

class EmployeeTest02 { // 默认修饰符修饰的类

    public static void main(String[] args) {
        // 创建Employee类对象
        Employee employee = new Employee();

        // 给employee对象属性赋值
        employee.name = "李四";
        employee.age = 20;
        employee.gender = '男';
        // phone属性使用private修饰，只能在本类中直接访问，出了本类就只能通过公共的get/set方法访问
        // employee.phone = "13222221111";
    }
}

 

如例2所示：不同修饰符的类访问private修饰的属性都不可以

例3：

在不同包中

package com.learn.demo10;

import com.bdqn.demo09.Employee; // 导包

public class EmployeeTest03 {

    public static void main(String[] args) {

        // 创建demo09包中的Employee类对象
        Employee employee = new Employee();
        employee.name = "王五";
        // age使用了protected修饰，不能在其他包的直接访问
        // employee.age = 30;

        // gender使用了默认修饰符，属于包级私有，只能在同一个包中的类能访问
        // employee.gender = '男';

        // phone使用了private修饰符，只能在本类中直接访问，出了本类就不能直接访问
        // employee.phone = "13644556633";

    }
}

 

package com.learn.demo10;

import com.bdqn.demo09.Employee;

class EmpLoyeeTest04 { // 默认修饰符修饰的类

    public static void main(String[] args) {
        // 创建demo09包中的Employee类对象
        Employee employee = new Employee();
        employee.name = "王五";
        // age使用了protected修饰，不能在其他包的直接访问
        // employee.age = 30;

        // gender使用了默认修饰符，属于包级私有，只能在同一个包中的类能访问
        // employee.gender = '男';

        // phone使用了private修饰符，只能在本类中直接访问，出了本类就不能直接访问
        // employee.phone = "13644556633";
    }
}

 

如例3所示：无论是public修饰的类还是默认修饰符修饰的类，除了public修饰的属性，其它修饰符修饰的均不可以在不同包中进行访问

目前来看protected与默认修饰符呈现的效果一样

 

六、static修饰符

1、static修饰代码块

静态代码块，当Java虚拟机加载类时，就会执行该代码块

1）如果有多个静态块，按顺序加载

2）每个静态代码块只会被执行一次

package com.learn.demo11;

public class StaticDemo01 {
    /*
    * 静态代码块随着类的加载而加载执行
    * 一个类中可以有多个静态代码块，按照定义的顺序执行多个静态代码块
    * 静态代码块可用于一些数据的初始化操作（有些程序上来就需要一些数据，我们可以将这些数据定义在静态代码块中）
    * */
    static {
        System.out.println("我是静态代码块1");
    }
    
    static {
        for(int i =1;i<=10;i++){
            System.out.println(i);
        }
    }

    static {
        System.out.println("我是静态代码块2");
    }
}

package com.learn.demo11;

public class Test01 {

    public static void main(String[] args) {

        StaticDemo01 staticDemo01 = new StaticDemo01();
        // 输出结果
        // 我是静态代码块1
        // 输出1-10
        // 我是静态代码块2
    }
}

 

2、static修饰变量

成员变量

1）类变量（静态变量）

被static修饰的变量

在内存中只有一个拷贝

类内部，可在任何方法内直接访问静态变量

其它类中，可以直接通过类名访问

2）实例变量

没有被static修饰的变量

每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

package com.learn.demo11;

public class StaticDemo02 {
    // 定义一个类变量(静态变量)：使用Static修饰的变量
    static int num1 = 100;

    // 定义一个实例变量：没有使用static修饰的变量
    int num2 = 200;
}

 

package com.learn.demo11;

public class Test02 {

    public static void main(String[] args) {

        // 创建StaticDemo02类对象
        StaticDemo02 staticDemo02 = new StaticDemo02();
        // 通过对象名调用静态变量
        System.out.println(staticDemo02.num1); // 100
        // 通过类名调用静态变量
        System.out.println(StaticDemo02.num1); // 100
        // 通过对象名调用实例变量
        System.out.println(staticDemo02.num2); // 200
        // 修改静态变量值
        StaticDemo02.num1 = 1000;
        // 通过类名调用静态变量
        System.out.println(StaticDemo02.num1); // 1000
        // 通过对象名调用实例变量，修改实例变量值
        staticDemo02.num2 = 2000;
        // 通过对象名调用实例变量
        System.out.println(staticDemo02.num2); // 2000
        System.out.println("--------------------------------------");
        // 创建第二个StaticDemo02类对象
        StaticDemo02 staticDemo021 = new StaticDemo02();
        // 通过对象名调用静态变量
        System.out.println(staticDemo021.num1); // 1000
        // 通过类名调用静态变量
        System.out.println(StaticDemo02.num1); // 1000
        // 通过对象名调用实例变量
        System.out.println(staticDemo021.num2); // 200
        
        // 每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，所以输出还是200

    }
}

 

注意区分不同对象调用静态变量和实例变量对值的效果

静态变量共用，实例变量单独

static变量的作用

1）能被类的所有实例共享，可作为实例之间进行交流的共享数据

2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间

package com.learn.demo11;

import java.util.Calendar;

public class StaticDemo03 {

    // 如果多个对象中包含相同的常量值，可以将相同的常量值声明为静态常量值，从而只需要在内存中开辟一个空间，不需要在每个对象中的内存里都开辟一个常量空间，这样就可以节省内存空间
    static final int NUM =100;
    final static  String ADDRESS = "创智中心";
    
    public static void main(String[] args) {

        System.out.println(Math.PI); // PI圆周率

        Calendar calendar = Calendar.getInstance();
        
    }
}

 

3、static修饰方法

1）静态方法：可直接通过类名访问

静态方法中不能使用this和super

不能直接访问所属类的实例变量和实例方法

可直接访问类的静态变量和静态方法

2）实例方法：通过实例访问

可直接访问所属类的静态变量、静态方法、实例变量和实例方法

3）静态方法必须被实现

main()就是最常用的静态方法

package com.learn.demo11;

public class StaticDemo04 {
    // 定义实例变量
    public int num1 =100;
    // 定义静态变量
    public static int num2 =200;

    // 定义2个实例方法（不用static修饰）
    public void m1(){
        System.out.println("m1()方法");
        // 输出实例变量值
        System.out.println("num1="+num1);
        // 输出静态变量值
        System.out.println("num2="+num2);
        // 调用非静态方法
        m2();
        // 调用静态方法
        m4();
    }

    public void m2(){
        System.out.println("m2()方法");
    }

    // 定义2个静态方法
    public static void m3(){
        System.out.println("静态方法m3()");
        // 输出实例变量值,在静态方法中不能调用非静态变量
        // System.out.println("num1="+num1);
        // 输出静态变量值
        System.out.println("num2="+num2);
        // 调用非静态方法,静态方法中不能调用非静态方法
        // m2();
        // 调用静态方法m4
        m4();
    }

    public static void m4(){
        System.out.println("静态方法m4()");
    }

    /*
    * 总结：
    *   静态方法中只能调用静态变量和静态方法
    *   非静态方法中既可以调用非静态的变量和方法，也可以调用静态的变量和方法
    * */
}

七、练习题

1、模拟选民投票过程

一群选民进行投票，每个选民只允许投一次票，并且当投票总数达到100时，就停止投票

package com.learn.demo12;

public class Ticket {
    /*
    * 模拟实现选民投票过程：一群选民进行投票，每个选民只允许投一次票，并且当投票总数达到100时，就停止投票
     * */
    // 总票数为100是公用的常量
    static final int NUM = 100;

    // 每个选民投票都会修改投票数目的统计变量count，所以这个变量是多个对象共享的，可以声明为静态变量值
    static int count = 0;

    // 投票是记名投票，所以再声明一个姓名
    public String name;

    // 添加一个包含name属性的有参构造方法


    public Ticket(String name) {
        this.name = name;
    }

    // 模拟投票过程，这个过程可以定义一个方法
    public void ticket(){
        // 判断投票数量是否达到100票
        if(count<NUM){ // 当count等于99时，还能执行一次
            count++;
            System.out.println(name+"投了第"+count+"票，还剩余"+(NUM-count)+"票可以投");
        }else{
            System.out.println("投票已满，投票活动已经结束");
        }
    }

}
package com.learn.demo12;

public class Test {
    public static void main(String[] args) {
        // 张三来投票
        Ticket zhangsan = new Ticket("张三");
        zhangsan.ticket();

        // 李四来投票
        Ticket lisi = new Ticket("李四");
        lisi.ticket();

        // 通过循环的方式投递剩余98票
        for(int i =1;i<=98;i++){
            Ticket v = new Ticket("ticket"+i); // 修改投票人的姓名
            v.ticket();
        }

        // 王五来投票
        Ticket wangwu = new Ticket("王五");
        wangwu.ticket();

    }
}

 

 

 

 

沐夏
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 封装
MRDOCMAN的博客
06-04 1939
Java 封装
Java封装实例
AD_plus的博客
05-17 4947
在面向对象程式设计方法中，封装（英语：Encapsulation）是指，一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 要访问该类的代码和数据，必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 适当的封装可以让程式码更容易理解与维护，也加强了程式码...
Java封装OkHttp3工具类
wh柒八九的博客
07-06 2700
本文来说下Java封装OkHttp3工具类 文章目录概述 概述
Java封装详解，很简单
热门推荐
weixin_47556601的博客
01-16 2万+
大家好，今天来给大家分享一下Java封装 面向对象有三大特征： 1.封装 2.继承 3. 多态 我们来讲Java封装，它也是Java面向对象的三大特征之一 封装 ，大白话的解释就是，把一个东西，装到箱子了，只留小小的口，用于外界访问 画一个图 就是该露的露，该藏的藏 我们在程序设计的过程中要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己来完成，不允许外部干涉，低耦合：就是， 仅暴露少量的方法给外部使用 封装（数据的隐藏） 通常，应禁止直接访问一个对象中数据的实际表示，而是应该通过操作接口来访问
Java 封装 继承 多态（深入理解）
2302_79806056的博客
03-08 3727
详细解析了面向对象编程（java）的三大特性：封装继承和多态（超详细）收藏精品，帮助加深理解
Java封装的详解
weixin_52984452的博客
10-29 1015
Java封装的详解
Java封装的四个关键字
yx1054885163的博客
06-02 1287
封装的关键字 1.private 表示私有，只能被自己访问使用 2.default 只能被同一个包内的类访问 3.protected 可以被同一项目内的同一个包和其他包访问 4.public 所有类都能访问
java封装原则
yononoy的博客
04-10 1226
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、封装的定义？二、封装的原则？三、封装的好处?四、如何更好的封装？ 一、封装的定义？ Java 封装 在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 二、封装的原则？ 对象代表什么，就封装代表的数据，并提供对象提供的行为。 例如：人骑自行车（显然人和自行车是对象，那么骑.
java封装
qq_45896330的博客
02-03 8167
目录java封装封装的作用和含义封装的实现—使用访问控制符封装的使用细节 java封装 封装的作用和含义 封装就是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。 程序设计要追求“高内聚，低耦合”。 高内聚就是类的内部数据操作细节自己完成，不允许外部干涉; 低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用。 编程中封装的具体优点： 1. 提高代码的安全性。 2. 提高代码的复用性。 3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。 4. “低耦合”：简化
java封装的作用_Java的封装性
weixin_39949506的博客
02-16 1886
描述封装性的概念与操作方法封装性是面向对象思想的三大特征之一(其他两个特性是继承和多态)。封装就是隐藏实现细节，仅对外提供访问接口。封装有：属性的封装、方法的封装、类的封装、组件的封装、模块化封装、系统级封装等等。如果属性没有进行封装，那么在本类之外创建对象后，可以直接访问属性。对于属性或方法来说，使用关键字private(访问权限修饰符)可进行封装，private表示私有的，私有的属性或者方法，...
浅谈java封装
09-03
封装是面向对象编程的核心概念之一，它在Java中扮演着至关重要的角色。封装的主要目的是保护数据，防止外部代码直接访问和修改对象的内部状态，从而提高代码的安全性和可维护性。下面我们将深入探讨封装的概念、原因...
Auto_adb:java 封装adb命令
06-18
标题 "Auto_adb:java 封装adb命令" 指出的是一个使用Java语言对Android Debug Bridge（ADB）工具的常用命令进行封装的项目。这个项目的主要目标是简化开发者在处理与Android设备交互时的操作流程，提高工作效率。在...
Java 封装基础知识
08-18
Java 封装基础知识 Java 封装是面向对象编程语言中的一种重要概念，它指的是将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问...
JAVA封装的简单例子.doc
09-30
JAVA 封装的简单例子 JAVA 中的封装是面向对象编程的一个基本概念，它允许将一个对象的属性和方法封装起来，使得外界无法直接访问对象的内部状态，从而提高了代码的安全性和可维护性。 在给定的例子中，我们可以...
Java封装统一的Result Model案例
08-24
Java 封装统一的 Result Model 案例 本文主要介绍了 Java 封装统一的 Result Model 案例，具有很好的参考价值，希望对大家有所帮助。在开发过程中，有时候会需要使用错误码+错误信息的形式，来返回某些业务操作的...
golang 接口
m0_70982551的博客
07-24 850
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 378
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 530
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 460
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值