Java常见面试题汇总-----------Java基础（Final、Static、This和Super）

11. Final关键字

  1、final修饰类：当用final修饰一个类时，表明这个类不能被继承。 也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
  在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
  2、final修饰方法：“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。”
  因此，如果只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final的。注：类的private方法会隐式地被指定为final方法。
  3、final修饰变量：对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
  当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。

关键字final的好处小结

  1、final关键字提高了性能。JVM和Java应用都会缓存final变量。
  2、final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。
  3、使用final关键字，JVM会对方法、变量及类进行优化。
  4、对于不可变类，它的对象是只读的，可以在多线程环境下安全的共享，不用额外的同步开销。

12. Static关键字

static关键字的用途

  《Java编程思想》：“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
  这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是：
  方便在没有创建对象的情况下来进行调用（方法/变量）。
  很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
  static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。
  1）、static方法
  static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
  但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。
  因此，如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。
  2）、static变量
  static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
  static成员变量的初始化顺序按照定义的顺序进行初始化。
  3）、static代码块
  static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
  为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

static关键字的误区

  1）、static关键字会改变类中成员的访问权限吗？
  Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected（包括包访问权限）这几个关键字。
  2）、能通过this访问静态成员变量吗？
  虽然对于静态方法来说没有this，那么在非静态方法中能够通过this访问静态成员变量吗？主要考察队this和static的理解。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。
  3）、static能作用于局部变量么？
  在Java中切记：static是不允许用来修饰局部变量，这是Java语法的规定。
  4）、java中是否可以覆盖（override）一个private方法或者static方法？
  都不能
  覆盖，也就是我们常说的重写，是子类继承父类，且子类中的方法和父类中的方法，方法名相同，参数个数和类型相同，返回值相同。
  private修饰的方法，不能被继承，所以也不存在重写（覆盖）
  static修饰的方法，是静态方法，在编译时就和类名就行了绑定。而重写发生在运行时，动态绑定的。 何况static方法，跟类的实例都不相关，所以概念上也适用。
  5）、静态导包
  Static还有一种不太常用的用法，即静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。

常见的笔试面试题

1、下面这段代码的输出结果是什么？

public class TestMain {
	static {
		System.out.println("static block1");
	}
	
	public static void main(String[] args) {
		// 在执行main方法之前会首先加载这个类，所以即使main方法中没有语句，静态代码块还是会执行
	}
	
	static {
		System.out.println("static block2");
	}
}

2、下面这段代码的输出结果是什么？

public class Test1 extends Base {
	static {
		System.out.println("test static");
	}

	public Test1() {
		System.out.println("test constructor");
	}

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

class Base {
	static {
		System.out.println("base static");
	}

	public Base() {
		System.out.println("base constructor");
	}
}

  先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test1类，而在加载Test1类的时候发现Test1类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test1类，然后发现Test1类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test1()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。

3、下面这段代码的输出结果是什么？

public class Test2 {
	Person person = new Person("Test");
	static {
		System.out.println("test static");
	}

	public Test2() {
		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 Test2 {
	Person person = new Person("MyClass");
	static {
		System.out.println("myclass static");
	}

	public MyClass() {
		System.out.println("myclass constructor");
	}
}

  首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

4、下面这段代码的输出结果是什么？

public class Test3 {
	// 由于类只加载一次，所以看效果时只能执行一句
	public static void main(String[] args) {
		/**
		 * 只输出classB
		 * 但是当str没有final修饰时，会输出
		 * A
		 * B
		 * classB
		 */
		// System.out.println(B.str);
		
		/**
		 * 输出
		 * A
		 * C
		 * classC
		 */
		// System.out.println(C.str);
		
		/**
		 * 均输出
		 * A
		 * D
		 * 200
		 */
		// System.out.println(D.bb);
		// System.out.println(D.aa);
		
		/**
		 * 只输出200
		 */
		System.out.println(D.cc);
	}
}

class A {
	static {
		System.out.println("A");
	}
}

class B extends A {
	static {
		System.out.println("B");
	}
	
	public static final String str = "calssB";
}

class C extends A {
	static {
		System.out.println("C");
	}
	
	public static final String str = new String("classC");
}

class D extends A {
	static {
		System.out.println("D");
	}
	
	public static final int cc = 200;
	public static final Integer aa = 100;
	public static final Integer bb = new Integer(200);
}

总结：调用类的静态成员或方法，会引起类的初始化，调用类中常量成员则不会引起类的初始化。

13. this和super

  1、从本质上讲，this是一个指向本对象的指针，然而super是一个Java关键字，用来对父类进行调用。
  2、this：它代表当前对象的引用（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）。
  3、可以使用super关键字来引用父类（最近父类）的成员变量，方法与构造器。（用来访问直接父类中被隐藏的成员数据或函数，基类与派生类中有相同成员定义时，如：super.变量名、super.成员函数名（实参））。
  4、super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）。
  调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
  5、this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）。尽管可以用this调用一个构造器，但却不能调用两个。
  super()和this()类似，均需放在构造方法内第一行。区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它构造方法。
  this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。（而且从this和super都要求放在构造函数的第一行来看，它们也无法同时存在一个构造方法里面）。
  6、this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量，static方法，static语句块。