static面试题

转载请注明出处：http://mingnianshimanian.iteye.com/admin/blogs/2324016

汇总了一些关于static的资料，包括用法，特点，以及作用等。以及一些经典的面试题。如有错误请指出，欢迎共同学习进步。

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块。

 

1.static变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：

• 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
• 对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

 

2.static方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。
因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆。因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的。

 

3.static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。看下面的一个例子：

public class WangPan {
	
	private static String a;
	private String b;
	private static String c;
	private static String d;

	static {
		WangPan.a = "static--a";
		System.out.println(a);
		WangPan wang = new WangPan();
		wang.test();
		wang.b = "static--b";
		System.out.println(wang.b);
	}
	static {
		WangPan.c = "static--c";
		System.out.println(c);
	}

	public static void main(String[] args) {
		// to do something...
	}

	static {
		WangPan.d = "static--d";
		System.out.println(a);
	}

	public void test() {
		System.out.println("this is test");
	}
}

 

运行结果如下：

static--a
this is test
static--b
static--c
static--a

利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

 

4.static和final方法

static final用来修饰成员变量和成员方法，可简单理解为”全局常量“！对于变量，表示一旦给值就不可修改，并且通过类名可以访问。对于方法，表示不可覆盖，并且可以通过类名直接访问。

 

5.总结

• 方便在没有创建对象的情况下进行调用方法或变量;静态代码块以用来优化代码性能,只会在类加载的时候执行一次。
• 静态方法中不能访问非静态成员变量和方法,因为static方法中不能使用this。
• 非静态方法可以访问静态成员变量和方法。
• 类的构造器实际上也是静态方法。
• static 不允许用来修饰局部变量。
• 静态成员属于整个类，当系统第一次使用该类时就会为其分配内存空间直到该类被卸载才会进行垃圾回收。

看一个例子：

Test有一个静态变量和一个非静态变量：

public class Test {
	// 注意value是静态的成员变量
	static int value = 9;
	String aa = "test";
}

 另一个类中调用Test类变量：

public class WangPan {
	
	public static void main(String[] args) {
		System.out.println("=====静态成员变量可以直接通过类调用====="+Test5.value);
		Test5 test = new Test5();
		System.out.println("=====非静态成员变量要通过实例化对象调用====="+test.aa);
	}
}

 当Test类被加载时静态变量就会初始化，而非静态变量必须通过实例化对象才能调用。

 

6.关于static面试题(持续更新)

(1).有三个类分别是X，Y，Z：

public class X {

	Y y = new Y();
	static {
		System.out.println("111");
	}

	X() {
		System.out.println("222");
	}

	public static void main(String[] args) {
		new Z();
	}
}

 

public class Y {

	Y() {
		System.out.println("555");
	}
}

 其中Z类继承了X类：

public class Z extends X{

	Y y = new Y();
	static {
		System.out.println("333");
	}

	Z() {
		System.out.println("444");
	}
}

 运行结果如下：

111
333
555
222
555
444

分析：

1.首先分析一段程序的执行后的结果，我们得先找到程序的入口，然后才能着手分析。也就是main()方法。
2.我们发现main()方法在X类中，要执行main（）方法，还得先将X类加载到内存中。
3.X类加载完成后，会做什么事情呢？别急，先来看看static的作用，不知道吧。告诉你：static就是在类被第一次加载的时候执行，以后就不再执行。
4.知道了static的作用，那么X类被加载，那么就会先执行X类的静态属性和静态语句块（static），执行先后顺序看谁在前面就先执行谁。只在此时执行，以后都不会。
5.所以一个输出结果为111,没问题了吧。
6.X类的static语句块执行完了，就该执行main()方法啦。
7.new Z();此方法被执行。
8.既然new Z();那么Z类就要被加载。因为Z类继承X类。所以必须先加载X类才行。因为X类已经被加载。所以此时不用再加载X类了。Z类加载好了就要执行Z类的static语句块。
9.那么就会打印出333了吧。
10.都加在完后就要实例化对象了。
11.实例化Z之前，还得先实例化X对吧。因为子类的构造方法都会调用父类的构造方法。
12.那就先实例化X类吧。
13.执行X方法前还得先初始化对不。也就是获取所有属性。那么X类的属性Y就会获取。
14.即X类的Y y=new Y();要被执行。也就是会打印555。
15.接着执行System.out.println("222");
16.然后就是执行Z的构造方法。
17.同样先获取Z的属性Y y=new Y();打印555。
18.再执行System.out.println("444");

 

(2)一道选择题：

public class Test5 {
	// 注意value是静态的成员变量
	static int value = 9;

	public static void main(String[] args) throws Exception {
		new Test5().printValue();
	}

	private void printValue() {
		int value = 69;
		System.out.println(this.value);
	}
}

这个程序会有下面哪种结果？
A. 编译错误
B. 打印9
C. 打印69
D. 运行时抛出异常

分析：此题答案是9，static只是起到了疑惑的作用，去掉static一样打印9，this.value指的是当前对象的属性。如果去掉this就会是69。

 

(3)Test5中有2个静态变量，并重写了toString方法：

public class Test5 {
	private static int id;
	private static String name;

	public static int getId() {
		return id;
	}

	public static void setId(int id) {
		Test5.id = id;
	}

	public static String getName() {
		return name;
	}

	public static void setName(String name) {
		Test5.name = name;
	}

	@Override
	public String toString() {
		return "id:" + id + "," + "name:" + name;
	}

	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		List<Test5> list = new ArrayList<Test5>();
		for (int i = 0; i < 4; i++) {
			Test5 t = new Test5();
			t.setId(i + 1);
			t.setName("tom" + (i + 1));
			Test5.setId(i + 1);
			list.add(t);
		}
		System.out.println(list);
	}
}

输出结果为[id:4,name:tom4, id:4,name:tom4, id:4,name:tom4, id:4,name:tom4];list.size()=4,所以for循环中new了4个Test5对象，由于id和name是静态变量具有全局性，就是无论set多少次，都是最后一次set的值把前面的所有都覆盖。

而如果把静态变量改为非静态变量，就会输出：[id:1,name:tom1, id:2,name:tom2, id:3,name:tom3, id:4,name:tom4]