Java中的static关键字

---

笔试常考

类的初始化顺序：静态变量，静态块，实例变量，实力块，构造（在手机上用牛客刷选择题会遇见）

class InstanceTest{
   public InstanceTest(){
       System.out.println("实例变量");
   }
}
class StaticTest{
    public StaticTest(){
        System.out.println("静态变量");
    }
}

class A{
    private InstanceTest a=new InstanceTest();//实力案例
    private static StaticTest b=new StaticTest();
    static{
        //静态块  专门用来初始化静态变量
        System.out.println("静态块");
    }
    {
        System.out.println("实例块");
    }
   public A(){
        System.out.println("构造函数");
   }
}
public class TestOrder {
    public static void main(String[] args) {
        A a=new A();

    }
}

---

一、static修饰

static是一个修饰符，用于修饰类的成员变量，类的成员方法，还可以编写static代码块来优化程序性能。

1.变量（静态变量）

static修饰的变量称为静态变量
成员变量=实例+静态

静态变量和实例变量的区别是：
1）存储位置：静态变量:在方法区
			实例变量：在堆上
2）对象关系：静态变量：当且仅当在类初次加载时会被初始化，被所有对象共享
					 （与对象无关，与类有关，一个类只有一份静态变量）
			实例变量：实例化（new）一次，被初始化一次
					（就会有一份实例变量生成），各个对象拥有的互不影响

2.方法（静态方法）

static修饰的方法称为静态方法

静态方法和实例方法的区别：
1）静态方法：
	由于静态方法不依赖于任何对象就可以进行访问，因此静态方法没有this，
	它不依附于任何对象，所以在静态方法中不能访问类的非静态成员变量和非静态成员方法
	（非静态成员方法/变量都必须依赖具体的对象才能够被调用。）
2）实例方法：
	可以访问静态成员方法/变量

public class people { 
    private String name;//实例变量，成员变量
    private  int age;
    private static int count;//静态变量
    
    public people(String name, int age){//实例方法
        this.name=name;
        this.age=age;
    }
    public static int getCount(){//静态方法
       return count;
    }

}

3.内部类

static修饰的类只能为内部类，普通类无法用static关键字修饰
访问方式为（new 外部类名.内部类的方法() ）
普通内部类的访问方式为 （外部类对象.new 内部类方法()）

二、设计模式

1.单例模式

确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例

懒汉模式

//慢加载单例模式/懒汉模式
public class Singleton {
    // 私有构造
    private Singleton() {}
    private static Singleton single = null;
    public static Singleton getInstance() {
        if(single == null){
            single = new Singleton();
        }
        return single;
    }
}
    

饿汉模式

//饿汉/快加载单例模式
// 饿汉式单例
public class Singleton {
    // 私有构造
    private Singleton() {}
    private static Singleton single = new Singleton();
    // 静态工厂方法
    public static Singleton getInstance() {
        return single;
    }
}

synchronized双重锁

public class Singleton {
    private Singleton() {}

    private static Singleton single = null;
    // 双重检查
    public static Singleton getInstance() {
        if (single == null) {
            synchronized (Singleton.class) {
                if (single == null) {
                    single = new Singleton();
                }
            }
        }
        return single;
    }
}

2.工厂模式

工厂模式：不使用new创建对象，而是使用Factory模式；使用时可以随时设置变量，不用提前进行设置
（一个抽象产品类，可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类只能创建一个具体产品类的实例。）

3.抽象工厂模式

抽象工厂模式：使用迭代模式来创建对象；需要每次增加产品时，进行修改类方法。
（多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。 ）

4.迭代器模式

循环打印一个字符串集合，里面就用到了迭代器模式,简化遍历方式

public static void print(Collection coll){
	Iterator ite = coll.iterator();
	while(ite.hasNext()){
		String str = (String)ite.next();
		System.out.println(str);
	}

一般用到集合就需要用到迭代器
抽象容器：一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等

collection:基本的 集合接口   存储对象 List/Set/Queue
            List 有序允许重复的 Collection
            Set  无序不允许重复的 Collection
            Queue  ArrayDeque/循环数组和队列
                   PriorityQueue
            迭代器接口  遍历集合不需要了解底层数据结构
            Map接口  哈希表的 基本 接口 

三、类加载过程

双亲委派模型：优点：1）避免重复加载 2）安全性

参考：工厂模式和抽象工厂模式参考：http://www.blogjava.net/stevenjohn/archive/2014/12/28/421902.html