一、static关键字

1. 静态变量

• 在类中，用static声明的成员变量为静态成员变量。
• 它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化，
• 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享！！
• 可以使用”对象.类属性”来调用。不过，一般都是用“类名.类属性”。
  public static int count;

2. 静态方法

• 不需要对象，就可以调用(类名.方法名)
• 在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。

public static void count(){
  System.out.println("tt");
}

二、this关键字

this 关键字用来表示当前对象本身，或当前类的一个实例，通过 this 可以调用本对象的所有方法和属性。

1.使用this区分同名变量

public class Student {
    public String name;
    public int age;
    public String numid;
    public String major;

    public Student() {
        System.out.println("空构造器");
    }

    public Student(String name, int age, String numid, String major) { 
        this.name = name;
        this.age = age;
        this.numid = numid;
        this.major = major;
    }
}

2.作为构造方法初始化对象

相当于调用本类的其它构造方法，它必须作为构造方法的第一句。

public class Student {
    public String name;
    public int age;
    public Student() {
        this("小王",18)；
    }

    public Student(String name, int age) { 
        this.name = name;
        this.age = age;
    }
}

注意：

• 在构造方法中调用另一个构造方法，调用动作必须置于最起始的位置（首行）。
• 不能在构造方法以外的任何方法内调用构造方法。
• 在一个构造方法内只能调用一个构造方法。

3.作为参数传递

public class Demo{
    public static void main(String[] args){
        B b = new B(new A());
    }
}
class A{
    public A(){
        new B(this).print();  // 匿名对象
    }
    public void print(){
        System.out.println("Hello from A!");
    }
}
class B{
    A a;
    public B(A a){
        this.a = a;
    }
    public void print() {
        a.print();
        System.out.println("Hello from B!");
    }
}

三、代码块block

通过{ }自称作用域

1.普通代码块

它是最常见的代码块，是类中方法的方法体或在方法名后面。

public class CommonBlock {
    private int count;
    
    public void counting(){
        count = 5;
        {
            count++;
        }
        System.out.println(count);
    }
}

2.构造代码块

它是用来初始化成员变量，是初始化一个类的所有构造方法共用的特征，且仅运行一次。

public class CommonBlock {
    private int count;

    {
        count++;
        System.out.println("构造代码块执行了。。。");
    }

    public void counting(){
        {
            System.out.println("普通代码块执行了。。。");
        }
        System.out.println(count);
    }

    public static void main(String[] args) {
        CommonBlock c = new CommonBlock();
        c.counting();
    }
}

3.静态代码块

（经常用来初始化类，加载类信息时执行！）
如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块。

• 是在类初始化时执行，不是在创建对象时执行。
• 静态初始化块中不能访问非static成员。
  执行顺序：上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到我们的类的静态初始化块为止。（到继承再看）

public class TestStaticBlock { 
  static { 
    System.out.println("此处，可执行类的初始化工作！"); 
  }
  public static void main(String[] args) { 
    System.out.println("main方法中的第一句");
  } 
}