对之前的所有的代码进行总结

总结所有的变量怎么访问，总结所有的方法怎么访问！！！！ 总结一下到目前为止我们在一个类中都接触过什么了。

案例：

/*
    类体{
        实例变量;
        实例方法;
        
        静态变量;
        静态方法;
        
        构造方法;
        
        静态代码块;
        实例语句块;
        
        方法(){
            // 局部变量
            int i = 100;
        }
    }
*/
public class Review{ // 类
    // 类加载机制中，是这样的：在程序执行之前，凡是需要加载的类全部加载到JVM当中。
    // 先完成加载才会执行main方法
    static{    
        System.out.println("Review类加载时执行！");
    }
    
    // 静态变量 程序入口
    public static void main(String[] args){
        
        // 局部变量
        int i = 100;
        
        // 完成一个对象的一连串动作。
        // 一个学生在教室先学习，学习完成之后去餐厅吃饭。
        Student s1 = new Student();
        
        // 错误: 此处不允许使用 '空' 类型
    // System.out.println(s1.study());
        s1.study();
        
        Student s2 = new Student();
    }
}

// 学生类
class Student{
    
    static{    
        System.out.println("Studen类加载时执行！");
    }
    // 实例变量
    // 学号
    private int no;
    // 姓名
    private String name;
    
    // 学生会有静态变量吗？
    // 类级别的属性
    static String job = "学习";
    
    // 实例语句块
    {
        System.out.println("实例语句块，构造方法执行一次，这里就执行一次。");
    }
    
    // 封装
    // 实例方法 getter and setter
    public int getNo(){
        return no;
    }
    
    public void setNo(int no){
        this.no = no;
    }
    
    public String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    // 构造方法
    public Student(){
        // 假设调用无参数的构造方法，默认创建的学生学号是100,名字是zhangsan
        this(100,"zhagnsan"); // this() 在这里也使用了。
    }
    
    public Student(int no,String name){
        this.no = no;    // 这里使用了this
        this.name = name;
    }
    
    // 实例方法
    public void study(){
        
        // 私有的是可以在本类中访问的。在其他类中不行，必须使用getter setter方法
        
        // 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 void eat(){
        
        System.out.println(this.getName() + "在餐厅吃饭呢！！！");
        
        // 调用静态m1()方法
        // 静态方法使用"类名." 的方式访问
        // Student.m1();
        
        // 类名. 可以省略吗？ 可以
        // java编译器会自动在m1()方法之前添加“类名.”，因为检测到m1()方法是一个静态方法。
        
        m1();
    }
    
    
    // 静态方法
    public static void m1(){
        System.out.println("Student's m1 method execute!");
        m2();
    }
    
    public static void m2(){
        System.out.println("Student's m2 method execute!");
        // 编译器检测到job是一个静态变量，所以这里会自动在job前添加：Studen.
        System.out.println("工作性质：" + job);
    }
}

执行结果如下：

Review类加载时执行！

Studen类加载时执行！

实例语句块，构造方法执行一次，这里就执行一次。

zhagnsan正在努力的学习！

zhagnsan在餐厅吃饭呢！！！

Student's m1 method execute!

Student's m2 method execute!

工作性质：学习

实例语句块，构造方法执行一次，这里就执行一次。

 

案例2：

/*
    程序再怎么变化，万变不离其宗，有一个固定的规律：
        所有的实例相关的都是先创建对象，通过“引用.”来访问。
        所有的静态相关的都是直接采用“类名.”来访问。
    
    你有发现一些问题吗？
        总有一些是需要记忆的，在这些记忆的基础之上进行分析。
    
    大结论：
        只要负责调用的方法a和被调用的方法b在同一个类当中
            “this.”可以省略  
            “类名.” 可以省略
*/
public class Review02{
    
    int i = 100;
    
    static int j = 100;
    
    public void m1(){
        
        // 访问其他类中的静态方法。
        T.t1();
        
        // 访问其他类中的实例方法。
        T t = new T();
        t.t2();    
    }
    
    public void m2(){}
    
    public void x(){
        m1(); // this.m1();
        m2(); // this.m2();
        m3(); // Review02.m3();
        m4(); // Review02.m4();
        
        System.out.println(i); // System.out.println(this.i);
        System.out.println(j); // System.out.println(Review02.j);
    }
    
    public static void m3(){}
    
    public static void m4(){}
    
    // 问？ 你怎么分析这个程序？
    /*
        第一步：
            main方法是静态的，JVM调用main方法的时候直接采用的是“类名.”的方式，所以main方法中没有this。
        
        第二步：
            m1() 和 m2 方法是实例方法，按照java语法规则来说，实例方法必须先new对象，通过“引用.”的方式访问。
    */
    
    public static void main(String[] args){
        Review02 r1 = new Review02();
        r1.m1();
        r1.m2();
        // m1();
        // m2();
        m3(); // Review02.m3();
        m4(); // Review02.m3();
        
        // System.out.println(i);// 报错 错误: 无法从静态上下文中引用非静态 变量 i  因为在static类中，不能直接调用实例变量，需要先new对象，new对象。
        System.out.println(r1.i); // 这样就可以了。
        System.out.println(j);// System.out.println(Review02.j);
        
        // 看到这里，你是不是心里咯噔一下子，懵了，诶？？？？  实例变量，静态变量，傻傻分不清楚了。
        // 不是的  下面这个k大哥是局部变量，局部变量访问的时候是不需要“xxx.”的
        int k = 10000;
        System.out.println(k);
        
    }
}

class T{
    
    // 静态方法
    public static void t1(){
        
    }
    
    // 实例方法
    public void t2(){
        
    }
}