Java基础之static

static修饰符

修饰范围：方法、属性（变量）、类、代码块

static修饰方法

static修饰的方法叫做静态方法。可以使用类名.方法名的方式调用方法（Java推荐使用），也可以实例化类后再调用（会有警告）。

static方法在继承中的影响：静态方法，只能继承，不能重写

1.对于父类、子类中的方法均未被static修饰，那么在子类中是可以重写父类中的方法的（类似于普通的情况），即可以使用@Override标注。

package testDemo;
public class testStatic {
	public static void main(String[] args) {
		Parent p = new Child();
		Child c = new Child();
		p.out();
		c.out();
		
	}
}
class Parent 
{
	public void out() {
		System.out.println("this is parent");
	}
}
class Child extends Parent
{
	@Override
	public void out() {
		System.out.println("this is child");
	} 
	
}

2. 父类、子类中的同名方法都使用static修饰。在这种情况下，子类实际上会继承父类的out（）方法的，并隐藏父类的out()方法，即使子类中也有一个out()方法，并不是重写了父类的out()方法，只是可以看做子类的一个方法，因为如果显式地在代码中加入@Override标注，是会编译出错的。也就是说“静态方法，会被继承，不能重写”

在父类和子类中都存在由static修饰的同样名称的方法，在调用时，需要明确调用的主体是父类的引用还是子类的引用，父类型的引用则调用父类中的方法，子类型的引用则调用子类型中的方法。

package testDemo;
public class testStatic {
	public static void main(String[] args) {
		Parent p = new Child();
		Child c = new Child();
		
		//静态方法的调用方式为：类名.方法名，下面这行代码可以理解为Parent.out()
		p.out();
		
		//对于静态函数out()，子类和父类中都存在，那么子类继承并隐藏父类的out()方法，只是调用本身的out()方法
		c.out();
		
		//对于静态函数test().只是存在于父类中，子类会继承父类的test()方法，并且在使用的时候会调用父类的test()方法
		c.test();
		
	}
}
class Parent 
{
	public static void out() {
		System.out.println("this is parent");
	}
	
	 public static void test() {
		 System.out.println("只是隐藏了父类的方法");
	 }
}
class Child extends Parent
{	
	public static void out() {
		System.out.println("this is child");
	} 
	
}

结果：

3.父类中的方法使用static修饰，子类中的方法不用static修饰。会报错

package testDemo;
public class testStatic {
	public static void main(String[] args) {
		Parent p = new Child();
		Child c = new Child();
		p.out();
		c.out();		
	}
}

class Parent 
{
	public static void out() {
		System.out.println("this is parent");
	}
}
class Child extends Parent
{
	
	public void out() {
		System.out.println("this is child");
	} 
	
}

结果

4.父类中的方法不使用static修饰，子类中的方法使用static修饰。会报错

package testDemo;
public class testStatic {
	public static void main(String[] args) {
		Parent p = new Child();
		Child c = new Child();
		p.out();
		c.out();	
	}
}
class Parent 
{
	public void out() {
		System.out.println("this is parent");
	}
}
class Child extends Parent
{
	
	public static void out() {
		System.out.println("this is child");
	} 
	
}

结果

static修饰属性（变量）

由该类生成的所有对象，都共同使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。对于由static修饰的成员变量，可以直接使用类名.属性名的方式调用该属性值（Java推荐使用这种方式），也可以实例化类后再调用属性值（会有警告）。

静态变量在继承中的使用：

子类和父类拥有同名静态变量，子类会继承并隐藏父类的静态变量，那么子类名.变量名会调用子类自己的变量

子类中没有，而父类中存在静态变量，那么子类会继承父类的静态变量，子类名.变量名实际调用的是父类的静态变量

子类与父类有同名静态变量，但是子类没有与父类中同名的方法（在方法中使用了前面的同名静态变量），那么子类名.静态方法会调用父类的静态方法，并且其中使用的静态变量也是父类的。

在静态方法中不能访问非静态的成员变量，在静态方法可以访问静态的成员变量。

非静态方法可以访问静态的成员变量，也可以访问非静态的成员变量。

（静态的方法可以使用类名.方法名的方式被调用，非静态成员变量随着不同的实例化对象而不同，无法确定访问哪个值）

this是非静态的变量，所以不能在静态方法中使用this关键字。

package testDemo;

public class testStatic {
	public static void main(String[] args) {
		Parent p = new Child();
		Child c = new Child();
		
		//静态方法的调用方式为：类名.方法名，下面这行代码可以理解为Parent.out()
		p.out(); 
		
		System.out.println("#######################");
		//对于静态函数out()，子类和父类中都存在，那么子类继承并隐藏父类的out()方法，只是调用本身的out()方法
		c.out();
		System.out.println("#######################");
		//对于静态函数test().只是存在于父类中，子类会继承父类的test()方法，并且在使用的时候会调用父类的test()方法
		c.test();
		
	}
}

class Parent 
{
	static String pname = "both-parent";
	static String op = "only-parent";
	public static void out() {
		System.out.println("this is parent");
		System.out.println(pname);
	}
	
	 public static void test() {
		 System.out.println("只是隐藏了父类的方法");
		 System.out.println(pname);
	 }
}
class Child extends Parent
{	static String cname = "child";
    static String pname = "both-child";
	public static void out() {
		System.out.println("this is child");
		System.out.println(pname);
		System.out.println(cname);
		System.out.println(op);
	} 
}

结果

static修饰代码块

存在于类中，地位与成员变量、方法相同，格式为：

static

{

//代码内容

}

static代码块是在代码从硬盘加载到Java虚拟机的过程中执行的，所以先于类的构造函数（在生成类的实例化的时候才会被调用），并且执行一次。要想调用某个类来生成对象，首先需要将类加载到Java虚拟机上（JVM），然后由JVM加载这个类来生成对象。

类的静态代码块只会执行一次，是在类被加载的时候执行的，因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象的时候都会被调用类的构造方法，所以new一次就会调用构造方法一次。

如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层的类（最原始的父类）的静态代码块，一直执行到最底层类（最后的子类）的静态代码块。然后再去执行最顶层类的构造方法，一直执行到最底层类的构造方法。注意：静态代码块只会执行一次。

现在考虑更复杂的情况，就是在继承中，静态变量和静态方法会如何使用。