【Java】面向对象程序三板斧——如何优雅设计包、封装数据与优化代码块？

🎁个人主页：User_芊芊君子
🎉欢迎大家点赞👍评论📝收藏⭐文章
🔍系列专栏：【Java】内容概括

【前言】

在Java编程中，类和对象是面向对象编程的核心概念。而包（Package）、封装（Encapsulation）以及代码块（Code Block）作为重要的语言特性，在组织代码结构、保障数据安全和控制代码执行流程等方面发挥着关键作用。本文将通过详细的代码示例和图解，带大家深入理解这些特性。

一、包（Package）——代码的“收纳盒”

1.定义

• 包（Package）是Java中⼀个组织类的⽅式,⽤于防⽌类名冲突和提⾼代码的可读性。包允许将类组织在⼀个层次结构中,类似于⽂件系统中的⽬录。
• 包是对类、接⼝等的封装机制的体现，是⼀种对类或者接⼝等的很好的组织⽅式。类似于文件夹。

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导入

 java.util.Date date = new java.util.Date();

上面的写法就比较麻烦了，我们可以直接使用import导入包

import java.util.Date;

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

快捷方式：输入Date,回车即可

方法三：使用 import java.util.*导入，就可以使用java.util中的其他类

import java.util.*;

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

建议显示的指定要导入的类名，否则容易出现冲突，如下图：当有两个包都有Date类时，编译器就不知道该引入哪个包中的类了

3.自定义包

3.1 基本规则

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

3.2 使用 IDEA 创建包过程

• 在 IDEA 中先新建⼀个包: 右键 src -> 新建 -> 包
  注意：包名要小写
  
• 输入包名
  
• 出现 Package 语句

package com.bit.demo1;

public class TestDame {
}

3.3 常见的包

• java.lang:系统常⽤基础类(String、Object),此包从JDK1.1后⾃动导⼊。
• java.lang.reflect:java 反射编程包;
• java.net:进⾏⽹络编程开发包。
• java.sql:进⾏数据库开发的⽀持包。
• java.util:是java提供的⼯具程序包。(集合类等) ⾮常重要
• java.io:I/O编程开发包。

3.4 包访问权限

如果我们在定⼀个类的时候，如果没有指定成员变量/成员⽅法的访问权限，此时默认的访问权限就是包访问权限。

package com.bit.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.bit.dame2;

import com.bit.demo1.Computer;

import javax.swing.*;

public class Tes {
    public static void main(String[] args) {
        Computer computer = new Computer("华为","英特尔","8G","三星");
        System.out.println(computer.brand);
        System.out.println(computer.screen);
        System.out.println(computer.cpu);
        System.out.println(computer.memory);

    }
}

• public 修饰符

public修饰的成员在哪里都能访问，它的权限是最大的

 public String screen; //屏幕

 System.out.println(computer.screen);

• private 修饰符

只能在当前类中使用

• 默认修饰符

只能在dema1包中使用

二、封装

1. 什么是封装

• ⾯向对象程序三⼤特性：封装、继承、多态。⽽类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。
• 封装就像是把东西放在⼀个盒⼦⾥，并且控制谁可以打开这个盒⼦，以及如何使⽤盒⼦⾥的东西。在编程中，它指的是将数据（属性）和操作这些数据的⽅法（函数）包装在⼀个单元（通常是类）内。
• ⽐如：对于电脑这样⼀个复杂的设备，提供给⽤⼾的就只是：开关机、通过键盘输⼊，显⽰器，USB插孔等，让⽤⼾来和计算机进⾏交互，完成⽇常事务。
• 对于计算机使⽤者⽽⾔，不⽤关⼼内部核⼼部件，⽐如主板上线路是如何布局的，CPU内部是如何设计的等，⽤⼾只需要知道，怎么开机、怎么通过键盘和⿏标与计算机进⾏交互即可。因此计算机⼚商在出⼚时，在外部套上壳⼦，将内部实现细节隐藏起来，仅仅对外提供开关机、⿏标以及键盘插孔等，让⽤⼾可以与计算机进⾏交互即可。
• 封装：将数据和操作数据的⽅法进⾏有机结合，隐藏对象的属性和实现细节，仅对外公开接⼝来和对象进⾏交互

2. 代码演示

package com.bit.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 String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void Boot(){
        System.out.println("开机~~~");
    }
    public void PowerOff(){
        System.out.println("关机~~~");
    }
    public void SurfInternet(){
        System.out.println("上网~~~");
    }
}

package com.bit.dame2;

import com.bit.demo1.Computer;

import javax.swing.*;

public class Tes {
    public static void main(String[] args) {
        Computer computer = new Computer("华为","英特尔","8G","三星");
        System.out.println(computer.getCpu());
        System.out.println(computer.screen);
        System.out.println(computer.getMemory());

    }
}

通过private对Computer中的成员变量进行隐藏，但是可以提供get或者set方法，让内外进行交互（这里编译器也可以自动生成），方法如下：

3. 封装的好处：

1. 降低代码的耦合性
   封装可以降低对象和对象之间的耦合度，当对象内部发⽣变化时，只需要修改对象内部即可，不会影 响到外部程序，因为公开的接⼝是不会发⽣改变的
2. 降低代码的复杂性
   封装是隐藏了对象内部的实现细节，只提供了公开的接⼝给外部，使⽤起来更加简单
3. 提⾼安全性
   封装可以隐藏对象的具体实现细节，阻⽌外部程序直接访问对象的内部状态，从⽽保护数据不被意外 修改或破坏

4. 访问限定符详解

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

• public修饰的成员变量，在所指定情况下均是可以正常访问的
• private修饰的成员变量，只能在当前类中来使⽤
• default表⽰什么修饰符都不加，此时只能在包当中才能被访问

三、static 关键字

1. static 修饰成员变量

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的

创建一个Student 类，其中包含两名学生的姓名，年龄和班级（一样），这时就可以用static修饰班级，如下代码：

package demo;

public class Student {
    public String name;
    public int age;
    public static String classRoom;//静态

}

package demo;

public class Test {
    public static void main(String[] args) {
        Student.classRoom = "1";
        Student student1 = new Student();
        student1.name = "lisa";
        student1.age  = 18;


        Student student2 = new Student();
        student2.name = "baby";
        student2.age = 20;
        System.out.println(Student.classRoom);
    }
}

执行结果：

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但⼀般更推荐使⽤类名访问
3. 类变量存储在⽅法区当中
4. ⽣命周期伴随类的⼀⽣(即：随类的加载⽽创建，随类的卸载⽽销毁)

2. 静态成员变量的访问

类名.静态成员变量的⽅式进⾏访问

 System.out.println(Student.classRoom);

3. static 修饰成员方法

Java中，被static修饰的成员⽅法称为静态成员⽅法，是类的⽅法，不是某个对象所特有的。静态成员⼀般是通过静态⽅法来访问的。

public static String getClassRoom(){
        return classRoom;
    }

System.out.println(Student.getClassRoom());

【静态⽅法特性】

1. 不属于某个具体的对象，是类⽅法
2. 可以通过对象调⽤，也可以通过类名.静态⽅法名(…)⽅式调⽤，更推荐使⽤后者
3. 不能在静态⽅法中访问任何⾮静态成员变量
4. 静态⽅法中不能调⽤任何⾮静态⽅法，因为⾮静态⽅法有this参数，在静态⽅法中调⽤时候⽆法传 递this引⽤

 public  void doClass(){
        System.out.println("学习");
    }
    public static String getClassRoom(){
        doClass();
    }

4.static 成员变量的初始化

就地初始化
在定义时直接给出初始值

pubilc class Student{
     private String name;
     private static String classRoom = "1"

四、代码块

使⽤ {} 定义的⼀段代码称为代码块

• 普通代码块
• 构造块（实例代码块）
• 静态块
• 同步代码块（

1.普通代码块

普通代码块就是定义在方法中的代码块

public static void main(String[] args) {
        int a = 0;
        System.out.println(a);
    }

2.构造代码块

定义在类中的代码块，也叫实例代码块，一般用于初始化实例成员变量

public class Student {
    //实例代码块
    {
        this.name = "lisi";
        this.age = 18;
        System.out.println("实例代码块执行");

    }

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println(student1.name);
        System.out.println(student1.age);
    }

执行结果

【执行顺序】

• 先执行实例代码块，再执行对应的构造方法
• 实例成员变量与实例代码块，谁在前先执行谁
• 当有静态代码块时，先执行静态代码块，再执行实例代码块

3.静态代码块

使⽤static定义的代码块称为静态代码块。⼀般⽤于初始化静态成员变量。

public class Student {
    //实例代码块
    {
        this.name = "lisi";
        this.age = 18;
        System.out.println("实例代码块执行");
    }
    //静态代码块
    static {
        System.out.println("静态代码块被执行");
    }
    public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println(student1.name);
        System.out.println(student1.age);
    }

执行结果

注意事项
• 静态代码块不管⽣成多少个对象，其只会执⾏⼀次
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
• 如果⼀个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执⾏(合并)
• 实例代码块只有在创建对象时才会执⾏

【总结】

• 包管理：遵循反向域名命名，合理划分模块
• 封装设计：属性私有，方法公开，增加数据校验
• 代码块使用：静态代码块用于类级初始化，实例代码块简化构造逻辑 通过掌握这些特性，开发者能够编写出结构清晰、安全可靠的Java程序。希望本文的示例和解析能帮助你更好地理解和应用这些核心概念！
  如果对某个知识点有疑问，欢迎在评论区留言交流！ 🚀