Java内部类的一些总结

做为刚入门Java的小白，这两天看到内部类，这里作一个总结，如有错误，欢迎指正~

内部类是指在一个外部类的内部再定义一个类。类名不须要和文件夹相同。

内部类分为： 成员内部类、局部内部类、静态嵌套类、匿名内部类 。

1.成员内部类

成员内部类是最普通的内部类，它的定义为位于另外一个类的内部，形以下面的形式：

class Outter {
    private int age = 12;
     
    class Inner {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Outter.this.age);
        }
    }
}
 
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        Outter.Inner in = out.new Inner();
        in.print();
    }
}

运行结果：

局部变量：14
内部类变量：13
外部类变量：12

从本例能够看出：成员内部类，就是做为外部类的成员，能够直接使用外部类的全部成员和方法，即便是private的。虽然成员内部类能够无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么为所欲为了。在外部类中若是要访问成员内部类的成员，必须先建立一个成员内部类的对象，再经过指向这个对象的引用来访问：

class Outter {
    private int age = 12;
    public Outter(int age) {
        this.age = age;
        getInInstance().print();   //必须先建立成员内部类的对象，再进行访问!
    }
     
    private Inner getInInstance() {
        return new Inner();
    } 
    class Inner {
        public void print() {
            System.out.println("内部类没同名，因此直接调用外部类成员变量：" + age);
        }
    }
}
 
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter(10);
    }
}

运行结果：

内部类没同名，因此直接调用外部类成员变量：10

内部类能够拥有private访问权限、protected访问权限、public访问权限及包访问权限。

好比上面的例子，若是成员内部类Inner用private修饰，则只能在外部类的内部访问，若是用public修饰，则任何地方都能访问；若是用protected修饰，则只能在同一个包下或者继承外部类的状况下访问；若是是默认访问权限，则只能在同一个包下访问。

这一点和外部类有一点不同，外部类只能被public和包访问两种权限修饰。

我我的是这么理解的，因为成员内部类看起来像是外部类的一个成员，因此能够像类的成员同样拥有多种权限修饰。要注意的是，成员内部类不能含有static的变量和方法。由于成员内部类须要先建立了外部类，才能建立它本身的

2.局部内部类

局部内部类是定义在一个方法或者一个做用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该做用域内。

定义在方法里的内部类：

class Outter {

	private int age = 12;
	 
    public void Print(final int x) {	//这里局部变量x必须设置为final类型！
        class Inner {
            public void inPrint() {
                System.out.println(x);
                System.out.println(age);
            }
        }
        new Inner().inPrint();
    }
     

}
 
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        out.Print(10);
    }
}

运行结果：

10
12

本例中咱们将内部类移到了外部类的方法中，而后在外部类的方法中再生成一个内部类对象去调用内部类方法。若是此时咱们须要往外部类的方法中传入参数，那么外部类的方法形参必须使用final定义。

换句话说，在方法中定义的内部类只能访问方法中final类型的局部变量，这是由于在方法中定义的局部变量至关于一个常量，它的生命周期超出方法运行的生命周期，因为局部变量被设置为final，因此不能再内部类中改变局部变量的值。（这里看到网上有不一样的解释，尚未完全搞清楚==）

定义在做用域内的内部类：

class Outter {
　　private int age = 12;
　　public void Print(final boolean x) {	//这里局部变量x必须设置为final类型！
    	if(x){
    		 class Inner {
    	            public void inPrint() {
    	                System.out.println(age);
    	            }
    	        }
    		 new Inner().inPrint();
    	}       
    }
}
 
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        out.Print(true);
    }
}

运行结果：12

3.静态嵌套类

又叫静态局部类、嵌套内部类，就是修饰为static的内部类。声明为static的内部类，不须要内部类对象和外部类对象之间的联系，就是说咱们能够直接引用outer.inner，即不须要建立外部类，也不须要建立内部类。

class Outter {
	private static int age = 12;
	static class Inner {
        public void print() {
            System.out.println(age);
        }
    }
}
 
public class test1 {
    public static void main(String[] args) {
    	Outter.Inner in = new Outter.Inner();
        in.print();
    }
}

运行结果：

12

能够看到，若是用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具备局限性。

其次，由于内部类被静态化，所以Outter.Inner能够当作一个总体看，能够直接new 出内部类的对象（经过类名访问static，生不生成外部类对象都不要紧）

4.匿名内部类

匿名内部类应该是平时咱们编写代码时用得最多的，在编写事件监听的代码时使用匿名内部类不但方便，并且使代码更加容易维护。下面这段代码是一段Android事件监听代码：

scan_bt.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });
         
        history_bt.setOnClickListener(new OnClickListener() {       
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });

这段代码为两个按钮设置监听器，这里面就使用了匿名内部类。具体位置是这段：

new OnClickListener() {   
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        }

代码中须要给按钮设置监听器对象，使用匿名内部类可以在实现父类或者接口中的方法状况下同时产生一个相应的对象，可是前提是这个父类或者接口必须先存在才能这样使用。固然像下面这种写法也是能够的，跟上面使用匿名内部类达到效果相同：

private void setListener()
{
    scan_bt.setOnClickListener(new Listener1());       
    history_bt.setOnClickListener(new Listener2());
}
 
class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
}
 
class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
} 

这种写法虽然能达到同样的效果，可是既冗长又难以维护，因此通常使用匿名内部类的方法来编写事件监听代码。一样的，匿名内部类也是不能有访问修饰符和static修饰符的。

匿名内部类是惟一一种没有构造器的类。正由于其没有构造器，因此匿名内部类的使用范围很是有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。通常来讲，匿名内部类用于继承其余类或是实现接口，并不须要增长额外的方法，只是对继承方法的实现或是重写。