面试题

重写 override 要遵循的规则

1. 参数列表必须与被重写方法相同
2. 返回类型必须与被重写方法相同
3. 重写方法不能比被重写方法有更严格的访问级别
4. 不能重写被标识为final的方法
5. 重写方法不能抛出新的异常或比被重写方法声明的检查异常更广的检查异常，但可以抛出更少，更有限或者不抛出。

---

内部类有四种

• 成员内部类
• 静态内部类
• 匿名内部类
• 局部内部类

范例：

• 成员内部类

    class Outclass{
    	private int num = 3;
    
    	class Inner{
    
    	int num = 4;
    	public void show(){
    		int num = 5;
    		System.out.println(num);//num = 5
    		System.out.println(this.num);//num = 4
    		System.out.println(Outclass.this.num);//num = 3
    		}
    	}
    }
  
    public class demo {
  
    	public static void main(String[] args) {
    	
    		// TODO Auto-generated method stub
    		Outclass.Inner inner = new Outclass().new Inner();
    		inner.show();
    	}
    }
  

• 静态内部类

    class Outclass{
    	private static int num = 3;
    
    	static class Inner{
    		int num = 4;
    		
    		 void show(){		
    			System.out.println("show() num " + num);
    		}
    		 static void show2(){
    			 System.out.println("show()2 num " + Outclass.num);
    		 }
    	}
    }
  
    public class demo {
  
    	public static void main(String[] args) {
    
    		Outclass.Inner inner = new Outclass.Inner();
    		inner.show();
    		inner.show2();//Outclass.Inner.show2();
    	}
    }
  

• 匿名内部类

    public class demo {
  
    public static void main(String[] args) {
  
    // TODO Auto-generated method stub
    String []names = new File("E:/pdf").list(new FilenameFilter(){
  
    	@Override
    	public boolean accept(File dir, String name) {
    		// TODO Auto-generated method stub
    		return name.endsWith("pdf");
    	}
    	
    });
    for(String temp:names)
    	System.out.println(temp);
    }
    }
  

应用场景

1. 成员内部类：List集合中实现了Itr()的私有成员内部类

2. 静态内部类：安卓gen文件下的R.java中利用静态内部类实现直接调用所需的部件

3. 匿名内部类：

4. 局部内部类：当创建一个类只为了给某一方法使用，并且方法中也只使用这个类一次时，采用局部内部类的方法。

    class InnerUserTest{
    	public int Demo(){
    		final int num = 1;
    		//局部内部类中要使用外面的局部变量，则变量必须采用final关键字，现在可以不用了
    		class Inner implements Interface{
    			public int method(){
    				return num + 1;
    			}
    		}
    		int result = new Inner().method();
    		return result;
    	}
    }
   
    public class demo {
    
    	public static void main(String[] args) throws Exception{
    	InnerUserTest iut = new InnerUserTest();
    	System.out.println(iut.Demo());
    	}
    }
   

为什么局部内部类中要使用外面的局部变量，则变量必须采用final关键字

方法存在栈中，Inner对象存储在堆中，方法执行完后，普通的局部变量销毁，而Inner对象不一定销毁（当方法返回的是一个Inner对象），若Inner对象的方法中用到了外部的局部变量，则产生了矛盾。采用final关键字，定义为常量，保存在常量池中，避免这个问题。

内部类优化单例模式

利用私有静态内部类，解决饿汉模式中调用普通静态方法也会创建对象以及在懒汉模式中判断代码的不优雅的问题。

class SingletonDemo{
	private SingletonDemo(){
		System.out.println("SingletonDemo is created");
	}
	//静态内部类，用来实现真正单例
	private static class SingletonHolder{
		private static SingletonDemo instance = new SingletonDemo();
	}
	//此方法获取实例
	public static SingletonDemo getInstance(){
		return SingletonHolder.instance;
	}
	
	public static void otherMethod(){
		System.out.println("---调用其他方法并不会产生对象---");
	}
}

public class demo {
	
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		System.out.println(SingletonDemo.getInstance());
		SingletonDemo.otherMethod();
	}
}