封装的概念

封装是指将数据（属性）和相关的操作（方法）绑定在一起，形成一个独立的单元（即类）。封装后，对象的内部状态（属性）对外界是不可见的，只能通过对象提供的方法来访问和修改内部状态。这样可以保护对象的状态不被随意修改，提高数据的安全性。
也就类似于手机，产家把手机的各种零件都封装起来，只留下接口被外界使用，这样就很好的保护了手机的零件。

封装的实现

我们所要实现的效果就是，让外界拿不到类的内部属性，那么就需要使用private关键字来修饰成员变量，private是一个权限修饰符，可以修饰成员变量和成员方法，被private修饰的成员只能在本类中才能访问

可以明显的看到，当私有化成员变量的时候，在Text类中再访问这些变量就会报错，那么怎么访问呢
针对每一个私有化成员变量都需要写对应的get和set方法

public class Student {
    //private修饰成员变量，外界不可访问
    private String name;
    private int age;
    //
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }  
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

因为get和set方法是public修饰的，就相当与留给外界访问的接口，通过以上的代码就实现了对student类的一个封装

包的概念

其实包就是一个文件夹，类就是具体的文件，为了更好的管理类，把多个类收集在一起成为一组，就称为软件包

上面的包名中，每一个包就代表一个文件夹，com.sun也就是sun公司域名的反写

import 导包

import java.util.Arrays;
import java.util.Date;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(arr));
        Date date = new Date();
        System.out.println(date);
    }
}

例如上面的Date 类和 Array类，java默认会加载一个java.long包，我们要创建Date对象或者Array对象，或是要用到这些类有关的方法就需要导入相关的包名

如果不导包也有一种写法

//import java.util.Arrays;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(java.util.Arrays.toString(arr));
    }
}

但是这样写的话，每写一次就需要写一长串，导包之后就方便了很多，是不是感觉和C++中的using namespace 有些类似

#include <iostream>
  
int main() { 
    std::cout << "Hello, World!" << std::endl;
    return 0; 
}

如果不写using namespace std;的话，每次使用std（标准）命名空间中的名称，都加上std::前缀，所以为了方便就会这样写

#include <iostream>
using namespace std;
int main() { 
    cout << "Hello, World!" << endl;
    return 0;

java中的import也是类似的道理

导包中*的介绍

import java.util.*;
/*import java.util.Arrays;
import java.util.Date;*/
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(arr));
        Date date = new Date();
    }
}

这样写也是可以的 * 表示通配符，表示导入了java.util包下的所有类和接口
但是这样写虽然更简洁了，但是并不推荐这样写

例如上面的例子，util 和 sql 包底下都有Date类，这样就不知道写的是哪个包中的Date，所以编译器直接报错了，还是推荐导包的时候要导全

import static 导入包中的静态方法和字段

public class Demo {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        double res = Math.sqrt(Math.pow(x, 2)+ Math.pow(y, 2));
        System.out.println("两点之间的距离是："+res);
    }
}

当导入静态方法之后
import static java.lang.Math.*;
就可以省略掉之前的Math.

其实System.out也是静态方法
那么也可以类似的进行静态导入

不过以上方法并不常用

static关键字的使用

static修饰符用于声明类的静态成员，包括静态变量（也称为类变量）和静态方法（也称为类方法）。当static修饰一个成员变量时，这个变量就变成了类级别的一个属性，而不是实例级别的。

static 修饰成员变量

先看一个例子

创建对象后开始调试：

换成public修饰成员变量className后：

可以看出，通过static修饰的成员变量被单独提出来，已经不属于对象了，并且存放在方法区当中，而对象是存在于堆内存中的
那么既然不属于对象了，怎么去访问呢

仍然可以通过对象名访问，但是并不推荐这种写法，因为static修饰的成员变量已经和对象没有关系了，推荐使用类名进行访问
通过static就可以把对象的公共属性设置成静态变量，通过类名访问。

static修饰方法

类似的，static修饰的成员方法称为静态方法，也是不依赖与对象的，通过类名调用

public class Text {
    public static void main(String[] args) {
        System.out.println(add(1, 1));
    }
    public static int add(int x, int y) {
        return x + y;
    }
}

我们在写方法的时候前面都是加上了static修饰，如果去掉就会报错，因为已经不是静态方法了，就要依赖与对象的创建，需要创建类的对象，再通过对象去调用方法

public class Text {
    public static void main(String[] args) {
        Text text = new Text();
        System.out.println(text.add(1, 1));
    }
    public int add(int x, int y) {
        return x + y;
    }
}

注意：
1.静态方法中不能用this关键字
2.静态方法中不能调用非静态的变量和方法
3.非静态方法可以使用静态方法或变量

静态成员变量的初始化

就地初始化

static int a = 1;

通过get set 方法初始化

public static void setClassName(String className) {
        Student.className = className;
    }
    public static String getClassName() {
        return className;
    }

构造方法初始化

public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        className = "1";
    }

代码块初始化

static String className;
    static {
        className = "101";
    }

代码块

静态代码块

静态代码块定义在类中但在任何方法之外，并使用static关键字修饰。它们仅在类首次被加载到JVM时执行一次。静态代码块常用于初始化静态变量或执行只需执行一次的代码。

static {
        classNum = 1;
        System.out.println("静态代码块执行，一般用来初始化静态变量···");
    }

非静态代码块/实例化代码块/构造代码块

初始化代码块也称为实例初始化块或非静态初始化块。它们定义在类中但在任何方法之外。当创建类的实例时，这些代码块会被执行，且每次创建新实例时都会执行。它们通常用于初始化实例变量。

{
        this.age = 1;
        System.out.println("构造代码块执行，一般用来初始化实例变量···");
    }

加载顺序

我们来看输出结果：

如果再加上构造方法的话顺序就变成了，先加载静态代码块，再加载构造代码块，最后才是构造方法

所以我们创建一个类之后尽量按照先写字段，再写静态代码块，构造代码块，构造方法
最后还有一个注意事项

public class Text {
    public static void main(String[] args) {
        Teacher teacher1 = new Teacher("张三", 30);
        System.out.println(Teacher.getClassNum());
        System.out.println("========");
        Teacher teacher2 = new Teacher("李四", 35);
        System.out.println(Teacher.getClassNum());
    }
}

这也就是开始说的，静态代码块仅在类首次被加载到JVM时执行一次