封装：

1.目的：保证对象中的实例变量无法随意修改/访问，只能通过我们自己设定的入口，出口（set / get）来间接操作；屏蔽类中复杂的结构，使我们程序员在主方法中关联对象写代码时，思路/代码格式更加清晰；

2.操作：将某些属性私有化（private修饰），再声明相应的 set ，get 方法，这样我们就可以通过 set / get 方法来 修改 / 访问 相应的私有属性了；

嘴上说不如举栗子：

class tool{
    private int a;
    private String b;
    private String c;
    public tool() {
    }
    public tool(int a, String b, String c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }
    public String getB() {
        return b;
    }
    public void setB(String b) {
        this.b = b;
    }
    public String getC() {
        return c;
    }
    public void setC(String c) {
        this.c = c;
    }
}
public class pra{
    public static void main(String[] args) {
        tool t1=new tool();
        //创建tool类型引用t1，并调用无参构造方法为t1在堆内存指向的对象中的三个实例变量赋初始值
        System.out.println(t1.getA()+t1.getB()+t1.getC()+"---第一次输出结果");
        //利用get方法访问对象中的三个私有属性
        t1.setA(100);
        t1.setB("是");
        t1.setC("100");
        //利用set方法修改对象中的三个私有属性
        System.out.println(t1.getA()+t1.getB()+t1.getC()+"---第二次输出结果");
        tool t2=new tool(100,"是","100");
        //创建tool类型引用t2，并调用有参构造方法为t2在堆内存指向的对象中的三个实例变量赋值
        System.out.println(t1.getA()+t1.getB()+t1.getC()+"---第三次输出结果");
    }
}

输出结果：

0nullnull---第一次输出结果
100是100---第二次输出结果
100是100---第三次输出结果

Process finished with exit code 0

静态变量的使用（static）：

1.什么时候选择声明静态变量：

对于同一类型的所有对象来说，一直不变的属性就声明为静态变量，就 类 中国人 来说，它其中的国籍属性除了中国，还能是什么？所以当一个类型的对象中的一个属性始终不变，或者说对于所有同类型的对象来说，此变量中储存的数据 都应该是一样的，这个时候我们就选择声明静态变量；

2.为什么要在符合条件的前提下，尽量使用静态变量：

还拿100个中国人举例子吧，如果我们把国籍声明为实例变量，那么我们创建 n 个中国人对象，就要在堆内存中占用 n 块大小相同的空间来储存同样的数据 “ 中国  ”，在可以达到相同的效果的前提下，选择占用内存大的代码是程序员的大忌！而如果我们将国籍声明为静态变量，那么我们无论创建多少个中国人对象，都只会在方法区内存中占用一块固定大小的内存空间来储存“ 中国 ”，以此来节省内存，因为静态变量不像实例变量那样属于“对象级别的变量”，它属于类级别的变量，所以无论对象是否创建，都不影响用“ 类名 . ”的方式来访问它。

辅助理解内存图：

实例方法 / 静态方法 的选择：

easy，在已经知道什么时候声明实例变量什么时候声明静态变量的前提下，方法体中需要实例变量的方法就声明为实例方法，反之方法体中不需要访问实例变量的方法就声明为静态方法；

代码块：

1.用途：代码块分为静态代码块和实例代码块，静态代码块执行时机---类加载时（优先于类体中的所有代码）；动态代码块执行时机---调用构造方法时（优先于方法体中的所有代码），并且静态代码块优先于实例代码块。所以我们可以通过输出结果来判断---什么时候哪个类体执行了 / 什么时候某个构造方法执行了；

2.格式及优先级顺序展示：

public class pra{
    static {
        System.out.println("静态代码块 a 执行了！");
    }
    {
        System.out.println("实例代码块 a 执行了！");
    }
    public static void main(String[] args) {
        pra t1=new pra();
    }
    public pra(){
        System.out.println("无参构造方法 执行了！");
    }
    static {
        System.out.println("静态代码块 b 执行了！");
    }
    {
        System.out.println("实例代码块 b 执行了！");
    }
}

运行结果1（将创建 pra 对象代码注释掉）与运行结果2（取消注释，还原为代码）：

静态代码块 a 执行了！
静态代码块 b 执行了！

Process finished with exit code 0  （结果一）

静态代码块 a 执行了！
静态代码块 b 执行了！
实例代码块 a 执行了！
实例代码块 b 执行了！
无参构造方法 执行了！

Process finished with exit code 0  （结果二）

随笔：

1. public ：啥都能访问 ；private 只有在声明它的类中可以访问 ；

2.空指针异常问题：这个问题我感觉没什么好说的，“ 引用 ”是一个储存对象地址的变量，如果它里面什么地址也没存（null），那在使用它时，就会出现空指针异常；

由于博主目前还没有将 Java-SE 的知识都学完

 原文：https://www.cnblogs.com/Burning-youth/p/15520014.html