Java SE知识点四：面向对象之：封装 和 static成员

1. 封装

1.1 什么是封装

什么是Java中的封装，通俗的来讲就是屏蔽代码细节，给代码套上一个外壳。

举一个简单的例子：电脑主机里面有很多硬件，封装就是讲这些内部硬件遮住，装上机箱，只显示我们用到的比如开机键，各种插孔等。

要了解Java的封装，我们就必须了解几个访问限定符。

1.2 访问限定符

Java 中主要通过类和访问权限来实现封装，其中类可以将数据和封装数据的方法结合在一起，而访问权限则决定了这些数据是否能直接在类外使用。

Java中有四种访问限定符：

public：相当于没有限定，在任何范围都可以访问。

private：只能在同一个包中的同一个类中访问。（可以通过get和set方法修改）

class Student{
    private String name;  // private修饰的成员变量，只能在该类中进行修改
    public int age;

    public String getName() { //鼠标右键生成 改变private的方法
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

default：（默认，不需要在代码中写出）在同一个包中的同一类或不同类都可以访问。

protected：（继承）同一个包的同类或不同类，以及不同包的子类中都可以访问。（后面会提到继承的父类和子类）

所以， 封装的意义在于：对类的成员进行隐藏，通过限定符private，只对外类提供公开的接口，从而达到隐藏类的实现细节，实现安全性。

1.3 封装：包

包简单来说就是组织管理类的，相当于一个文件夹里面有各种类，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

其中，Java中以及提供了许多现成的类供我们使用，我们只需要导入对应的包和包中对应的类：

import java.util.Date;

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

可以使用 java.util.Date 导入 java.util 这个包中的 Date 类。还有很多系统自带的类，这里就不一一举例了。

除了系统自带的包之外，我们也可以自定义包：

src -- 新建 -- 软件包（package）

然后在包中就可以创建自己写的类了，文件第一行会自动标注包的名字。

2. static修饰

2.1 static修饰成员变量

static 修饰的成员变量，称为静态成员变量 ，静态成员变量最大的特性： 不属于某个具体的对象，是所有对象所共 享的 。

举个例子：我们定义一个学生类，现在类里面有成员变量：姓名，年龄，学号，班级。这样我们可以实例化许多学生，但现在有一个问题是这些学生都是一个班的，那每次实例化都要重复赋值班级，代码就不是很简洁。

class Student{
    public String name;
    public String gender;
    public int age;
    public String classRoom;
    // ...
}
public class TestStudent{
    public static void main(String[] args) {
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, "Bit306");
        Student s2 = new Student("Han MeiMei", "女", 19, "Bit306");
        Student s3 = new Student("Jim", "男", 18, "Bit306");
    }
}

所以，使用static修饰成员变量，成为所有对象共享的变量。

class Student{
    public String name;
    public String gender;
    public int age;
    public static String classRoom = "Bit306"; //static修饰
}

public class TestStudent{
    public static void main(String[] args) {
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18);
        Student s2 = new Student("Han MeiMei", "女", 19);
        Student s3 = new Student("Jim", "男", 18);
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}

2.2 static修饰成员方法

一般类中的成员变量都设置为private，那么怎么在类外访问该private变量呢？

可以将private加上static，然后成员方法是public + static，通过静态成员方法来返回静态private变量。

class Student{
// ...
    private static String classRoom = "Bit306";
// ...
    public static String getClassRoom(){
        return classRoom;
    }
}

public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }
}

static方法有以下特性：

静态方法不属于任何具体对象，是类的方法；

可以通过对象调用，也可以通过类名.静态方法名()来调用；

不能在静态方法中直接访问任何非静态成员变量 和 非静态方法，因为静态方法里不能使用 this 。

2.3 static成员方法初始化

static成员方法的初始化有两种，一是就地初始化，二是代码块初始化。

就地初始化前面也说过，就是在创建变量的时候直接赋值，就像上面的班级一样。

代码块初始化需要我们了解什么是代码块。

3. 代码块

所谓代码块，也就是代码中的一块区域，一般用花括号来分隔{ }

3.1 普通代码块

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

public class Main{
    public static void main(String[] args) {

        { //直接使用{}定义，普通方法块
        int x = 10 ;
        System.out.println("x1 = " +x);
        }
        
        //出了代码块的区域就需要重新定义
        int x = 100 ;
        System.out.println("x2 = " +x);
    }
}

这种情况比较少见，只是用来理解代码块的意思。

3.2 构造块

构造代码块，也称作实例代码块，是指定义在类中的不加修饰符的代码块。（一般用作初始化成员变量）

class Student{
    //成员变量
    private String name;
    private String gender;
    private int age;
    private double score;

    public Student() {
        System.out.println("I am Student init()!");
    }

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}

3.3 静态块

静态代码块，就是在实例代码块前面加上 static 修饰，一般用来初始化静态成员变量。

class Student{
    //成员变量
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;

    public Student() {
        System.out.println("I am Student init()!");
    }

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

    //静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }

    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}

这里有一些注意事项：

1 静态代码块只会执行一次，不管生成多少对象。

2 如果一个类包含多个静态代码块，编译器按照先后顺序执行。

3 实例代码块只有在创建对象时才会被执行，而静态代码块只要类被加载就会执行。

4 关于执行顺序：静态代码块 > 实例代码块 > 构造方法

小结：

这一章主要写了面向对象的三大特性之一：封装，以及 static 的作用。后面会写剩下的两大特性：继承 和 多态。