Java基础--static关键字解析

static关键字的主要用途

修饰方法：令方法可以通过类名直接调用，而不用new一个对象调用。
修饰变量：由static修饰的变量被称为全局变量。初始化方式为：在类中从上到下先分配内存并赋默认值，然后再从上到下初始化

public class StaticTest {
	
	private static StaticTest myTest = new StaticTest();
	private static int number1;
	private static int number2 = 1;
	
	private StaticTest() {
		number1++;
		number2++;
	}
	
	public static void main(String[] args) {
		System.out.println(String.format("number1的值为：%d", number1));
		System.out.println(String.format("number2的值为：%d", number2));
	}
}

输出：
number1的值为：1
number2的值为：1

修饰静态代码块：在程序中先于构造方法执行，并只执行一次

class Father {
	
	static{
		System.out.println("父类的静态代码块被调用~~~~");
	}
	
	public Father() {
		System.out.println("父类的构造函数被调用~~~~");
	}
	
}

public class MyTest extends Father {
	
	static {
		System.out.println("子类的静态代码块被调用~~~~");
	}
	
	public MyTest() {
		System.out.println("子类的构造函数被调用~~~~");
	}
	
	public static void main(String[] args) {
		System.out.println("main方法被调用");
		new MyTest();
		new MyTest();
	}
}

输出：
父类的静态代码块被调用~~~~
子类的静态代码块被调用~~~~
main方法被调用
父类的构造函数被调用~~~~
子类的构造函数被调用~~~~
父类的构造函数被调用~~~~
子类的构造函数被调用~~~~

修饰静态内部类

外部类：相对于内部类而言，包含内部类的类叫做外部类
内部类：内部类的所有方法和属性都能被外部类使用，包括私有方法和属性。

public class OutClass {
	int out1 = 1;
	static int out2 = 1;

	void out() {
		System.out.println("非静态");
	}

	static void outstatic() {
		System.out.println("静态");
	}

	public class InnerClass {
		void InnerMethod() {
			System.out.println("InnerClass!");
			System.out.println(out1);
			System.out.println(out2);
			out();
			outstatic();// 静态内部类只能够访问外部类的静态成员
		}

		// static void inner(){}
		// static int i=1; 			//非静态内部类不能有静态成员（方法、属性）
	}

	public static class InnerstaticClass {
		void InnerStaticMethod() {
			System.out.println("InnerstaticClass");
			// System.out.println(out1);
			//out(); 					//静态内部类只能够访问外部类的静态成员
			System.out.println(out2);
			outstatic();
		}

		static void innerstatic() {
		}

		static int i = 1;// 静态内部类能有静态成员（方法、属性）
	}

	public static void main(String args[]) {
		OutClass a = new OutClass();
		OutClass.InnerstaticClass b = new OutClass.InnerstaticClass();// 创建静态内部类
		OutClass.InnerClass c = a.new InnerClass();// 创建非静态内部类
	}
}

总结一下（与非静态内部类对比）

静态内部类只能够访问外部类的静态成员，而非静态内部类都可以

只考虑访问权限，内部类可以访问外部类的所有属性与方法

静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)

静态导包：直接导入静态方法或变量，在代码中直接调用，无需前缀。
类似于c++中的namespace; 在c++中调用是std::cout，加上了using namespace std，就可以直接使用 cout。

import static java.lang.System.out;
import static java.lang.Integer.MAX_VALUE;

public class StaticTest {
	public static void main(String[] args) {
		out.println("使用System的静态变量PrintStream out的println方法");
		out.println("直接使用out打印Integer.MAX_VALUE" + MAX_VALUE);
	}
}

Java基础--static关键字解析

猜你喜欢