说到static我自己也是非常的敏感，因为自己学过c++，所以对于static这个关键字很是熟悉，但是在Java中static的含义有很多种。接下来谈谈我对Java的关键字static的理解吧！

Java中static的方法
  1. 静态，不需要实例化，直接调用。
  2. 类变量和类方法也叫静态变量和静态方法。
public class opp02 {
    public static void main(String[] args) {
        //由类产生对象的过程叫实例化
        //下面过程为实例化调用
        //调用
        Boy s1 = new Boy("曾骏毅",12);
        System.out.print(s1.name+","+s1.age+"岁 ");
        s1.eat();
        s1.sport();
        Boy s2 = new Boy("潘学良",10);
        System.out.print(s2.name+","+s2.age+"岁 ");
        s2.eat();
        s2.sport();

        System.out.println("------");
        //静态，不需要实例化，直接调用
        System.out.println("类型："+Boy.people);
        Boy.hobby();
    }
}

class Boy{
    String name;  //实例变量
    int age;

    //构造方法，相当于c++中的构造函数
    public Boy(String name,int age) {
        this.name=name;
        this.age=age;
    }
    //实例方法
    public void eat() {
        System.out.print("辣条"+" ");
    }
    public void sport() {
        System.out.println("羽毛球"+" ");
    }

    //类变量和类方法也叫静态变量和静态方法
    //特点：不需要实例化就可以访问
    static String people = "亚洲人";
    static void hobby() {
        System.out.println("看小说");
    }
}
Java中static代码块
  1. static代码块只执行一次。
  2. 程序运行首先运行的是static代码块，其次是匿名代码块，最后是构造器。
public class oop06 {
    //代码块

    //其次是匿名代码块
    {
        System.out.println("匿名代码块");
    }
    //最先执行，并且只执行一次
    static {
        System.out.println("静态代码块");
    }
    //在最后是构造器
    public oop06(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        oop06 oop06 = new oop06();
        System.out.println("===============");
        oop06 oop061 = new oop06();

    }
}

下面是运行结果图

static与final的区别

成员变量 (能否修改值)

final：
final成员变量表示常量，只能被赋值一次，赋值后不能再被改变
staic：
被static修饰的成员变量独立于该类的任何对象, static 修饰的变量可以被赋值多次

类 （类是否可以不用初始化就访问）

　　final：

　　　　final类不能被继承，没有子类，final类中的方法默认是 final 的

　　static：

　　　　static 类也不能被继承，可以不用初始化而访问

　　

方法

　　final：

　　　　final 方法不能被子类的方法重写，但可以被继承

　　　　final 不能用于修饰构造方法

　　　　* ：private 不能被子类方法覆盖，private类型的方法默认是final类型的

　　static：

　　　　static 方法可以被继承，但是不能重写

　　　　被static修饰的成员方法独立于该类的任何对象, 不依赖类特定的实例，被类的所有实例共享。

　　　　只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

　　　　static方法是不在对象上执行的方法，不需要类的实例化，可以直接通过类调用。

　　　　

final 和 static 一起用

修饰成员变量

　　static final用在变量上相当于一个”全局变量“，一旦初始化后就不能被修改，并且可以通过类名调用，整个类共享一个

修饰类

　　表明方法不能被子类修改（可以被继承被调用），并且可以通过类名调用

单例模式

设计模式是软件开发人员在软件开发过程中，总结出来的一般问题的解决方案，通常代表了最佳的实践思路。常见的设计模式有 23 种，本小节就介绍其中较为简单的一种——单例模式。
单例模式是指：无论创建了多少个引用，在堆中仅仅只有一个实例对象。

图片描述
实现单例模式的核心思路是将构造方法私有化，即使用 private 修饰构造方法，然后利用 static 成员变量的“一次性”，如下所示。
danlimoshi.png
实现单例模式的核心思路是将构造方法私有化，即使用 private 修饰构造方法，然后利用 static 成员变量的“一次性”，如下所示。

public class Singleton {
    private Singleton() {
    }
}

这样做的目的，就是为了防止其他类直接通过构造方法实例化多个对象，从而破坏单例模式的规则。但显然，使用 private 将构造方法“屏蔽”后，其他类就得另想办法获取 Singleton 的对象。通常，可以给该类再设置一个私有的 Singleton 属性，然后通过 getter 方法限制只能实例化出一个 Singleton 对象，并将此对象暴露给外部的类访问，详见以下程序所示。

public class Singleton {
    private static Singleton instance;

    //构造方法私有化
    private Singleton() {
    }

    //限制只能实例化一个Singleton对象
    public static Singleton getInstance() {
        if (instance == null) {
             instance = new Singleton();
        }
        return instance;
    }
}

之后，不论有多少对象调用 getInstance()方法，实际都只返回了同一个实例（因为静态成员 instance 只有 1 份，而且根据代码逻辑，一旦 instance 非 null，就不再创建新对象），详见以下程序。

class TestSingleton{
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

结果如下：
danlimoshi2.png