java基础概念-static

staitc静态，有静态方法，静态变量，静态块儿，静态类；

优点是什么呢？能够直接被调用；

=======================================

1、静态变量和静态方法

静态变量和静态方法和普通变量，普通方法最明显的区别是使用static修饰

静态变量和静态方法的好处呢？可以直接使用类名，方法名直接引用

2、静态方法和静态变量之间的引用

   1、静态方法能不能引用非静态资源？不能，new的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。

   2、静态方法里面能不能引用静态资源？可以，因为都是类初始化的时候加载的，大家相互都认识。

   3、非静态方法里面能不能引用静态资源？可以，非静态方法就是实例方法，那是new之后才产生的，那么属于类的内容它都认识。

3、静态块儿

静态代码块，在虚拟机加载类的时候就会加载执行，而且只执行一次；

非静态代码块，在创建对象的时候（即new一个对象的时候）执行，每次创建对象都会执行一次；

静态块儿的作用：有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块

4、static修饰类

这个用得相对比前面的用法少多了，static一般情况下来说是不可以修饰类的，如果static要修饰一个类，说明这个类是一个静态内部类（注意static只能修饰一个内部类），也就是匿名内部类。像线程池ThreadPoolExecutor中的四种拒绝机制CallerRunsPolicy、AbortPolicy、DiscardPolicy、DiscardOldestPolicy就是静态内部类

 

==========================================

涉及静态块儿的执行顺序：

public class A {

	 private static int a = B();
      
      static{
         System.out.println("Enter A.static block");
     }
      
     public static void main(String[] args){
         new A();         

     }     
     public static int B(){
         System.out.println("Enter A.B()");
         return 1;
     }
}

结果
Enter A.B()
Enter A.static block

执行顺序：静态变量加载（顺序加载，先加载静态变量，再加载静态代码块）---main入口

public class B {
	
	static {
		c=3;
		System.out.println(c);				
	}
	private static int c;
	
	
}

静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问；

public class Demo1 {
	static {
		System.out.println("Demo1 static block");
	}

	public Demo1() {
		super();
		System.out.println("Demo1 constructor");
	}	

}

public class Demo2 extends Demo1 {
	static {
		System.out.println("Demo2 static block");
	}

	public Demo2() {
		super();
		System.out.println("Demo2 constructor");
	}
	public static void main(String[] args) {
		new Demo2();
         new Demo2();
	}
	

}
执行结果
Demo1 static block
Demo2 static block
Demo1 constructor
Demo2 constructor
Demo1 constructor
Demo2 constructor

存在继承关系；创建对象

先执行父类的静态代码--再执行子类静态代码--父类构造器---子类构造器

public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }
     
    public Test() {
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new MyClass();
    }
}
 
class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}
 
 
class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }
     
    public MyClass() {
        System.out.println("myclass constructor");
    }
}
class Cd extends Test{
	static{
        System.out.println("Cd static");
    }
	
	
}
执行结果
test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

此代码见https://www.cnblogs.com/dolphin0520/p/3799052.html

执行顺序：main入口所在类涉及的类；先执行类的静态块，静态变量，再去执行动态变量，构造器，