Java内部类的使用小结

Java内部类的使用小结

△概念：一个类定义在另一个类里面，就被成为内部类了。
△分类：
1，成员内部类：内部类定义在一个类的里面，与外部类的成员方法和成员变量处在同级，他以外部类的“成员”身份存在，符合成员一般属性：比如能被static、final、private等修饰符所修饰。
2，静态内部类：被static所修饰的内部类。
3，方法内部类：内部类定义在一个外部类的成员方法里面，与外部类里的成员方法里的局部变量同级，这叫方法内部类，他以该方法的“局部”身份存在，符合局部变量一般属性，比如不能被private修饰。
4，匿名内部类。

下面我们详细一点地说，我们关注两个问题：
1，访问规则：内部类和他所在的外部类的互相访问规则（访问成员变量以及成员方法）。
2，语法以及注意事项。

△成员内部类的访问规则以及语法
规则1，内部类可以直接访问外部类中的成员，甚至包括私有成员。

规则2，外部类要访问内部类的成员，必须创建内部类的实例对象。

语法以及注意事项：
1，在第三方的类里面创建某个类的内部类的语法：
外部类.内部类 变量名 = new 外部类名().内部类名();
注意我们看到是先创建了外部类，然后才创建内部类，我们可以这样理解，虽然内部类是一个类，但是他是外部类的一个成员，所以，你想得到外部类的的一个成员，得先创建外部类。

2，内部类访问外部类某个成员的语法是：
外部类.this.成员;
3，private可否拿来修饰一个类？可以，一般的类是不可以，但是能用来修饰内部类。
通过一段代码演示上面所说：

public class My
{
public static void main(String[] args)
{
System.out.println("Hello World!");
Out out = new Out();
out.outShow();
Out.In in = new Out().new In();//语法：new 外部类名().new 内部类名();
in.show();
}
}

class Out
{
private int out = 4;
class In
{
private int in1 = 0;
public void show(){
//内部类直接访问外部类私有成员
//Out.this.out可以写成out
System.out.println("out="+Out.this.out);
}
}
public void outShow(){
In in = new In();外部类要通过创建内部类的对象访问内部类的成员
System.out.println("in1="+in.in1);
}

}

△静态内部类的访问规则以及语法
规则1，静态内部类不可以访问外部类的非静态成员。
规则2，当外部类的静态方法想要访问内部类时，该内部类必须是静态的。
语法以及注意事项：
1，在第三方的类里面，想要访问某类的静态内部类里的成员：
外部类名.内部类名 变量名 = new 外部类名.内部类名();
变量名.成员名;
比如下面这段代码：
2，在外部的其他类里，访问某个类的静态内部类的静态成员：外部类名.内部类名.内部成员;
还是通过一段代码演示语法：

public class My
{
public static void main(String[] args)
{
System.out.println("Hello World!");
Out.In in = new Out.In();
in.show();//访问他的非静态的成员
Out.In.show2();//访问他的静态成员
}
}

class Out
{
private int out = 0;
static class In
{
private int in1 = 4;
public void show(){
System.out.println("in1="+in1);
}
static public void show2(){
System.out.println("静态方法");
}
}

}

△方法内部类的访问规则，语法以及注意事项

规则1：方法内部类可直接访问他所在方法的局部变量。
规则2：方法内部类可直接访问他所在的外部类的成员变量。
注意：他访问的局部变量必须是被final所修饰，否则的话不能访问，不过成员变量可以不是final的。
比如下面这段代码：

public class My
{
public static void main(String[] args)
{
System.out.println("Hello World!");
Out out = new Out();
out.outShow(4);
}
}

class Out
{
private int out1 = 3;//这是外部类的私有成员变量
public void outShow(final int a){//局部变量用final修饰
class In
{
public void show(){
System.out.println("ou1="+out1);//访问外部类的成员变量
System.out.println("a="+a);//访问所在方法局部变量
}
}
In in = new In();
in.show();
}

}

匿名内部类
△概念：其实就是内部类的简写形式，没有名字的内部类。
△定义匿名内部类的前提：
1，匿名内部类必须是继承一个类或者是实现接口。
2，匿名内部类相当于是个匿名子类对像。

先看代码根据代码来做解释：

public class My
{
public static void main(String[] args)
{
System.out.println("Hello World!");
new In(){
public void show(){
System.out.println("haha");
}
}.show();//注意.show()表示调用这个方法，如果不写就是仅仅覆写但没调用
}
}

abstract class In
{
private int out1 = 3;//这是外部类的私有成员变量
abstract public void show();

}

这段代码的意思是，定义一个类去继承In，然后覆写show()方法，然后调用子类show()方法，你一定要记住的是匿名内部类相当于是某个类的子类对象，上面那段代码他等价于下面这段代码：

public class My
{
public static void main(String[] args)
{
System.out.println("Hello World!");
Ins in = new Ins();
in.show();
//new In(){
//	public void show(){
//		System.out.println("haha");
//	}
//}.show();
}
}

abstract class In
{
private int out1 = 3;//这是外部类的私有成员变量
abstract public void show();

}

class Ins extends In
{
public void show(){
System.out.println("haha");
}
}

可以看到，简便很多，当你需将某抽象类当作参数进行传递，与此同时还要覆写某个方法，你就可以使用匿名内部类了，简单方便。现在再来举个例子，将匿名内部类当做参数进行传递：

public class My
{
public static void main(String[] args)
{
System.out.println("Hello World!");
Show show = new Show();
show.show(new In(){
public void in(){
System.out.println("我是匿名内部子类");
}
});
}
}

class Show
{
public void show(In in){
in.in();
}
}

abstract class In
{
abstract public void in();
}