Java内部类的使用与特性-优快云博客

本文链接：https://blog.youkuaiyun.com/u010707039/article/details/48196377

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();
}