1、static

通常来说，当创建类时，就是描述那个类的对象的外观与行为，除非用new创建那个类的对象，否则，实际上并未会的任何对象。只有执行new来创建对象时，数据存储空间才被分配，其方法才供外界调用。
但是有两种情形上述方法是无法解决的。
1、只想为一个特定的数据分配一块存储域，而不去考虑究竟要创建多少对象，甚至更本就不想创建任何对象；
2、希望某个方法不与包含它的类的任何对象关联在一起。也就是说，即使没有创建任何对象，也能够调用这个方法。
通过static关键字是可以解决上述两种情形的

静态变量和静态方法

只需把static关键字放在定义之前，就可以把字段或方法定义为static，例如：

public class StaticTest{
     private static int i= 0;
    
    private static void fun(){
        System.out.println("this is static method");
    }
}

静态变量无论创建多少对象都只有一份存储空间，静态变量可以通过对象引用，也可以通过类名直接引用（推荐），这样的逻辑同样也适用于静态方法；因为一个static字段对每个类来说都只有一份存储空间，而非static字段对每个对象都有一份存储空间，所以当static作用于某个字段时，肯定会改变数据的创建方式，但是static作用于某个方法时差别却没这么大，和其他方法一样static方法也可以创建和使用本类的对象。static方法一个重要的用法就是在不创建任何对象的前提下就可以调用它。

静态代码块

静态代码块有static关键字加{}组成，静态代码块执行优先级高于main方法高于构造方法，例如：

public class StaticTest {

    public static void main(String[] args){
        System.out.println("this is main");
    }

    static {
        System.out.println("this is static coding block");
    }

}  
输出：  
this is static coding block
this is main

2、this

在如下示例中，相同类型的两个对象a和b 调用了同一个方法peel(),对于peel()方法来说如何知道他是被a调用了还是被b所调用呢？

public class BananaPeel {

    public static void main(String[] args){
       Banana a = new Banana();
       Banana b = new Banana();
       a.peel(1);
       b.peel(2);
    }

}
 class Banana{
    public void peel(int i){
        System.out.println("peel:"+i);
    }
}

为了能简便、面向对象的语法来编写代码——即“发送消息给对象”，编译器做了一些幕后工作。它暗自把“所操作对象的引用”作为第一个参数传递给被调用的方法peel()。所以上述两个调用在内部原理上变成了这样：

Banana.peel(a,1);
Banana.peel(b,2);

如果你希望在方法内部获得对当前对象的引用。由于这是编译器内部传入的，所以没有标识符可用。但是为此有个专门的关键字：this。this关键字只能在方法内部使用，表示对“调用方法的那个对象的引用”，this的用法和其他对象的引用并无不同。但要注意，如果在方法内部调用另一个类的另一个方法，就不必使用this，直接调用即可。当前方法中的this引用会自动应用于同一个类中的其他方法。只有需要明确指出当前应用的引用时，才需要使用this关键字
当需要返回当前对象的引用时，就可以return this;

public class Leaf {
    int i = 0;
    Leaf increment(){
        i++;
        return this;
    }

    private void print(){
        System.out.println("i= "+i);
    }

    public static void main(String[] args){
        Leaf leaf = new Leaf();
        leaf.increment().increment().increment().print();
    }

}

输出：i=3

this关键字对于将当前对象传递给其他方法也很有用：

public class PassingThis {

    public static void main(String[] args){
        new Person().eat(new Apple());
    }

}
 class Person{
    public void eat(Apple apple){
        Apple peeled = apple.getPeeled();
        System.out.println("Yummy");
    }
}

class Apple{
    Apple getPeeled(){
      return Peeler.peel(this);
    }
}

class Peeler{
    static Apple peel(Apple apple){
        return apple;
    }
}

输出：Yummy

为了确保整个过程所操作的Apple是同一个，Apple中的getPeeled()方法必须使用this，如果在这里使用new Apple();重新创建一个Apple的话，最终返回给Person的Apple就不是Person希望得到的被处理过的Apple了。即：人把他的苹果交由外部切成块再给他，这个过程中所处理的苹果要保证是人交出去的苹果而不是又重新生成一个苹果切成块给他。

在构造器中使用this

通常写this的时候，都是指“这个对象”或是“当前对象”，而且它本身表示对当前对象的引用，在构造器中，如果为this添加了参数列表，那么就有了不同的含义。这将产生对符合此参数列表的某个构造器的明确调用；这样调用其他构造器就有了直接的途径

public class Flower {

    private int petalCount = 0;
    private String s = "initial value";

   public Flower(int petals) {
        petalCount = petals;
        System.out.println("Constructor int arg only petalCount=" + petals);
    }

    public Flower(String ss) {
        System.out.println("Constructor int arg only s=" + ss);
        s = ss;
    }

    public Flower(String s,int petals) {
        this(petals);
        //this(s);            //使用this只能调用一个构造器，而且必须放在最起始处
        this.s = s;
        System.out.println("String&int args " );
    }

    public Flower() {
        this("hi",47);
        System.out.println("default Constructor ");
    }

    private void printPetalCount(){
        System.out.println("petalCount:"+petalCount+" s:"+s);
    }

    public static void main(String[] args){
        Flower flower = new Flower();
        flower.printPetalCount();
    }

}
输出：
Constructor int arg only petalCount=47
String&int args 
default Constructor 
petalCount:47 s:hi

注意：使用this只能调用一个构造器，而且必须放在最起始处；除构造器外，其他任何方法都不能调用构造器；当方法参数名与成员变量名相同时，可使用this.变量名 来表示成员变量

3、this与static

可以把static方法理解为没有this的方法。在static方法内部不能调用费static方法，除非传递一个对象到static方法中（不推荐）；但是非static方法可以调用static方法，并且可以在没有创建任何对象的情况下，仅通过类名来调用static方法。

参考自《Java编程思想》