static关键字

static翻译为“静态的”。
所有static关键字修饰的都是类相关的，类级别的。
所有static修饰的，都是采用“类名.”的方式访问。
static修饰的变量：静态变量
static修饰的方法：静态方法
变量根据声明的位置进行划分：
在方法体当中声明的变量叫做：局部变量。
在方法体外声明的变量叫做：成员变量。
成员变量又可以分为：实例变量和静态变量
静态的都是类相关的，访问时采用“类名.”的方式访问。不需要new对象。
不需要对象的残血即可访问，没有空指针异常的发生。
实例相关的，必须先有对象，才能访问，可能会出现空指针异常。
静态变量在类加载时初始化，不需要new对象，静态变量的空间开出来了。
静态变量存储在方法区。

java中的三大变量.png
什么时候变量声明为实例的，什么时候声明为静态的？
如果这个类型的所有对象的某个属性值都是一样的，不建议定义为实例变量，浪费内存空间。建议定义为类级别特征，定义为静态变量，在方法区中只保留一份，节省内存开销。
一个对象一份的是实例变量。
所有对象一份的是静态变量。
实例的：一定需要使用“引用.”来访问。
静态的：建议使用“类名.”来访问，但使用“引用.”也行（不建议使用“引用.”）。
静态的如果使用“引用.”来访问会让程序员产生困惑：程序员以为是实例的呢。
空指针异常只有在“空引用”访问“实例”相关的，都会出现空指针异常。
关于方法来说，什么时候定义为实例方法，什么时候定义为静态方法？
此方法一般都是描述了一个行为，如果说该行为必须由对象去触发。那么该方法定义为实例方法。
参考标准：
当这个方法体当中，直接访问了实例变量，这个方法一定是实例方法。
我们以后开发中，大部分情况下，如果是工具类的话，工具类当中的方法一般都是静态的。（静态方法有一个优点，是不需要new对象，直接采用类名调用，极其方便，工具类就是为了方便，所以工具类中的方法一般都是static的。）
工具类就是为了方便编程开发的一些类。

静态代码块

使用static关键字可以定义：静态代码块
静态代码块，语法：
static {
java语句;
java语句;
}
static静态代码块在类加载时执行，并且只执行一次，静态代码块有这样的特征/特点。
注意：静态代码块在类加载时执行，并且在main方法之前执行。
静态代码块一般是按照自上而下的顺序。
静态代码块有什么用？
第一：静态代码块不是那么常用 。（不是每一个类当中都要写的东西。）
第二：静态代码块这种语法机制实际上时SUN公司给我们java程序员的一个特殊的事课/时机。
这个时机叫做：类加载时机。
静态代码块和静态变量都是在类加载的时候执行的，时间相同，执行的顺序还是要看代码的先后顺序来决定谁先谁后。
到目前为止，遇到的所有的java程序，有哪些是有顺序要求的？
第一：对于一个方法来说，方法体中的代码是有顺序的，遵循自上而下的顺序执行。
第二：静态代码块1和静态代码块2是由先后顺序的。
第三：静态代码块和静态变量是有先后顺序的。

实例代码块

除了静态代码块之外，还有实例语句块。
实例语句块在类加载时并没有执行。
实例语句块语法：
{
java语句;
java语句;
}
只要是构造方法执行没必然在构造方法执行之前，自动执行“实例语句块”中的代码。
实际上这也是SUN公司为Java程序员准备一个特殊的时机，叫做对象构建时机。

this关键字

this是一个关键字，全部小写。是一个引用，保存内存地址指向自身。
一个对象一个this。
this是一个变量，是一个引用。this保存当前对象的内存地址，指向自身。
所以，严格意义上来说，this代表的就是“当前对象”
this存储在堆内存当中对象的内部。

从内存图上来看this.png

this只能使用在实例方法中。谁调用这个实例方法，this就是谁。所以this代表 的是当前对象。
“this.”在大部分情况下是可以省略的。
this可以使用在实例方法中，不能使用在静态方法中，因为，this代表当前对象，静态方法中不存在当前对象。
在实例方法中，或者构造方法中，为了区分局部变量和实例变量，这种情况下：this. 是不能省略的。
this除了可以使用在实例方法中，也可以使用在构造方法中。
新语法：通过当前的构造方法去调用零一个本类的构造方法，可以使用以下格式：
this(实际参数列表);
this();的作用是，代码复用
通过一个构造方法1去调用构造方法2，可以做到代码复用。
但需要注意的是：“构造方法1”和“构造方法2”都是在同一个类中 。
对于this()的调用只能出现在构造方法的第一行。

以后的代码都是封装，所有的类都是属性私有化，对外提供setter和getter方法。
构造方法无参数构造方法和有参数构造方法都定义。

对面向对象这的内容做一下总结：

/*
    到目前为止一个类当中可以出现的：
    类体{
        实例变量;
        实例方法;

        静态变量;
        静态方法;

        构造方法;

        静态代码块;
        实力语句块;

        方法(){
            局部变量
        }
    }
*/
public class ZongJie{
    //类加载机制中，是这样的：在程序执行之前，凡是需要加载的类全部加载到JVM当中。
    //先完成加载才会执行main方法。
    static{
        System.out.println("ZongJie类加载时执行！");
    }
    //入口
    //静态方法
    public static void main(String[] args){
        //局部变量
        int i = 100;

        //完成一个对象的一连串动作。
        //一个学生在教室先学习，学习完成后去餐厅吃饭。
        Student s1 = new Student();

        //先学习，所以调用学习这个实例方法。
        s1.study();

        Student s2 = new Student();
    }
}

//学生类
class Student{
    //静态代码块
    static{
        System.out.printlc("Student类加载时执行！");
    }

    //学号
    private int no;//实例变量
    //姓名
    private String name;//实例变量
    //静态变量 类级别的谁能够
    static String job = "学习";

    //实例语句块
    {
        System.out.println("实例语句块，构造方法执行一次，这里就执行一次！");
    }

    //构造方法
    //无参数构造方法
    public Student(){
        //假设调用无参数的构造方法，默认创建的学生学号是100，名字是张三
        this(100,"张三");//这里使用了this()
    }
    //有参数构造方法
    public Student(int no,String name){
        this.no = no;
        this name = name;
    }

    //封装
    //setter and getter 方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(String name){
        return name;
    }
    public void setNo(int no){
        this.no = no;
    }
    public int getNo(int no){
        return no;
    }

    //提供两个实例方法
    public void study(){
        //私有的是可以在本类中访问的。在其他类中必须使用set和get方法。
        //System.out.println(this.name + "正在努力学习！");
        //System.out.println(name + "正在努力学习！");

        //在实例方法中调用本类的其他实例方法
        System.out.println(this.getName() + "正在努力学习！");
        //System.out.println(getName + "正在努力学习！");

        //方法执行到此处表示学习完成了，接下来去吃饭。
        //this.eat();
        //this. 可以省略
        //编译器检测到eat()方法是实例方法，会自动在eat()方法前添加this.
        eat();
    }

    public vodi eat(){//实例方法
        System.out.println(this.getName() + "在餐厅吃饭呢！");

        //调用静态m1()方法
        //静态方法使用“类名.”的方式访问
        //Student. m1()

        //类名. 可以省略么？可以
        //java编译器会自动在m1()方法之前加“类名.”，因为检测到m1()方法是一个静态方法
        m1();
    }

    //提供两个静态方法
    public static void mi(){
        System.out.println("Student's m1 method execute!");
        //调用m2方法
        //Student.m2();
        m2();
    }
    public static vodi m2(){
        System.out.println("Student's m2 method execute!");
        System.out.println("工作性质：" + job);
        //编译器检测到job是一个静态变量，所以这里会自动在job前添加：Student.
        //System.out.println("工作性质：" + Student.job);
    }


}

程序再怎么变化，万变不离其宗，有一个固定的规律：
所有的实力相关的都是先创建对象，通过“引用.”来访问。
所有的静态相关的都是直接采用“类名.”来访问。

只要负责调用的方法a和被调用的方法b在同一个类当中：
this. 可以省略
类名. 可以省略