【Java】内部类（实例，静态，局部，匿名）

最新推荐文章于 2022-11-20 17:46:51 发布

pangpd

最新推荐文章于 2022-11-20 17:46:51 发布

阅读量158

点赞数

分类专栏： # 面向对象文章标签： java

本文链接：https://blog.csdn.net/weixin_43519707/article/details/107718553

版权

面向对象专栏收录该内容

27 篇文章 0 订阅

订阅专栏

一. 内部类定义

内部类：所谓内部类就是在一个类内部进行其他类结构的嵌套操作。
因此，在一个类中除了可以定义字段，方法以外，还可以定义类

1.1 为什么要使用内部类：

（1）增强封装，把内部类隐藏在外部类之内，不许其他类访问内部类。

（2）内部类能提高代码的可读性和可维护性，把小型类嵌入到外部类中结构上代码更靠近。
（3）内部类可以直接访问外部类的成员。

二. 四种内部类

根据使用不同的修饰符或者定位位置的不同，可以将内部类分为四种：
（1）实例内部类：内部类没有static修饰；

（2）静态内部类：内部类使用了static修饰；

（3）局部内部类：在方法中定义的内部类；

（4）匿名内部类：适合于仅使用一次使用的类，属于局部内部类的特殊情况；
在这里插入图片描述
我们可以将内部类看做外部类的一个成员，好比字段，那么内部类可以使用public/缺省/protected/private修饰，还可以使用static修饰。
但是外部类的访问修饰符只能使用public或者缺省修饰。

对于每个内部类来说：Java编译器会生成独立的.class文件，

成员内部类：外部类名 $ 内部类名
局部内部类：外部类名 $ 数字 $ 内部类名
匿名内部类：外部类名 $ 数字

2.1 实例内部类（没有使用static修饰）

没有使用static修饰内部类，说明内部类属于外部类的对象，不属于外部类本身。

实例内部类的创建：

Outter out =  new Outter(); // 创建外部类对象
Outter.Inner in = out.new Inner();  // 创建内部类对象

或者：

Outter.Inner in = new Outter().new Inner(); // 一次性创建内部类对象

实例内部特点：
（1）创建内部类对象：必须通过外部类对象创建；
【当存在内部类对象，一定存在外部类对象】

class Outter
{
	class Inner{}
}
class InnerClassDemo 
{	
	public static void main(String[] args) 
	{
		Outter out = new Outter();
		Outter.Inner in = out.new Inner();// 必须使用外部类.内部类来接受内部类对象
		System.out.println(in);	
	}
}

---------- 运行java ----------
Outter$Inner@15db9742

输出完成 (耗时 0 秒) - 正常终止

（2）内部类自动持有外部类的实例引用，内部类可以直接访问外部类成员；

class Outter
{
	String name = "hello";
	class Inner{
		void test(){
			System.out.println(name);
		}
	}
}
class InnerClassDemo 
{	
	public static void main(String[] args) 
	{
		Outter out = new Outter();
		Outter.Inner in = out.new Inner();
		in.test();
	}
}

---------- 运行java ----------
hello

输出完成 (耗时 0 秒) - 正常终止

（3）外部类不能直接访问内部类成员，必须通过内部类实例访问；

class Outter
{
	class Inner{
		private String innner = "InnerClass";
	}
	void print(){
		System.out.println( new Inner().innner);
	}
}
class InnerClassDemo 
{	
	public static void main(String[] args) 
	{
		Outter out = new Outter();
		out.print();
	}
}

---------- 运行java ----------
InnerClass

输出完成 (耗时 0 秒) - 正常终止

（4）实例内部类中不能定义静态成员，只能定义实例成员（非static修饰）

class Outter
{
	class Inner{
		static String name = "InnerClass"; //编译报错
		static public void test(){} //编译报错
	}
}
class InnerClassDemo 
{	
	public static void main(String[] args) 
	{
		Outter out = new Outter();
		Outter.Inner in = out.new Inner();
	}
}

---------- 编译java ----------
InnerClassDemo.java:4: 错误: 内部类Outter.Inner中的静态声明非法
		static String name = "InnerClass";
		              ^
  修饰符 'static' 仅允许在常量变量声明中使用
InnerClassDemo.java:5: 错误: 内部类Outter.Inner中的静态声明非法
		static public void test(){}
		                   ^
  修饰符 'static' 仅允许在常量变量声明中使用
2 个错误

输出完成 (耗时 0 秒) - 正常终止

（5）如果实例内部类和外部类存在同名字段或方法abc，那么在内部类中：

abc 表示局部成员；
this.abc表示访问内部类成员；
外部类.this.abc表示外部类成员；

class Outter
{
	String name = "Outter";

	class Inner{
		String name = "Inner";
		public void printName(){
			String name = "Local";
			System.out.println(name);
			System.out.println(this.name);
			System.out.println(Outter.this.name);
		}
	}
}
class InnerClassDemo 
{	
	public static void main(String[] args) 
	{
		Outter out = new Outter();
		Outter.Inner in = out.new Inner();
		in.printName();
	}
}

---------- 运行java ----------
Local
Inner
Outter

输出完成 (耗时 0 秒) - 正常终止

2.2 静态内部类（使用static修饰）

特点:
（1）静态内部类的实例不会自动持有外部类的特定实例的引用（可以理解成它就属于当前外部类的一个静态成员），在创建内部类的实例时，不必创建外部类的实例。

Outter.Inner in = new Outter.Inner();

（2）静态内部类可以直接访问外部类的静态成员，如果访问外部类的实例成员，必须通过外部类的实例去访问。

class Outter
{

	String name = "name";
	static String staticName = "static name";  // 定义外部内的静态成员

	static class Inner{
		void printName(){
			System.out.println(staticName); // 静态内部类可直接访问外部类的静态成员
			System.out.println(new Outter().name); // 静态内部类必须使用外部类对象访问实例成员
		}
	}
}
class InnerClassDemo 
{	
	public static void main(String[] args) 
	{
		Outter.Inner in = new Outter.Inner();
		in.printName();
	}
}

---------- 运行java ----------
static name
name

输出完成 (耗时 0 秒) - 正常终止

（3）在静态内部类中可以定义静态成员和实例成员。

class Outter
{
	static class Inner{
		String name = "name"; // 实例成员 
		static String staticName = "static inner name"; // 静态成员
	}
}

（4）在测试类中，可以通过完整的类名直接访问静态内部类的静态成员。

class Outter
{
	static class Inner{
		static String name = "static inner name";
	}
}
class InnerClassDemo 
{	
	public static void main(String[] args) 
	{
		String name = Outter.Inner.name; // 通过完整的类名访问静态内部类中的静态成员
		System.out.println(name);
	}
}

---------- 运行java ----------
static inner name

输出完成 (耗时 0 秒) - 正常终止

2.3 局部内部类（打死都不使用）

局部内部类：在方法中定义的内部类,器可见范围是当前方法和局部变量是同一级别。
特点:
（1）不能使用public/private/protected/static修饰符；（可以把局部内部类当做局部变量，因为局部变量不能使用这些修饰符修饰）

（2）只能在当前方法中使用；

（3）和实例内部类一样，不能包含静态成员；

（4）局部内部类和实例外部类，可以访问外部类的所有成员；


class InnerClassDemo 
{	
	static String name = "outter class";
	public static void main(String[] args) 
	{
		class Inner
		{
			public void printName(){
				System.out.println(name);
			}
		}
		new Inner().printName();
	}
}

---------- 运行java ----------
outter class

输出完成 (耗时 0 秒) - 正常终止

（5）局部内部类访问的局部变量，局部变量必须使用fianl修饰。(JDK8中自动隐式加上了fianl，但是依然是常量，不能改变值) 、

class InnerClassDemo 
{
	public static void main(String[] args) 
	{
		String name = "local info"; // 编译时，会将name使用final修饰
		class Inner
		{
			public void print(){
				System.out.println(name);
			}
		}
		new Inner().print();
	}	
}

原因：如果当前方法不是main方法,当前方法调用完毕后，当前方法的栈帧被销毁，方法内部的局部变量的空间全部销毁，然后局部变量内部类是定义在方法中的，而且在方法中会创建局部内部类对象，而局部内部类会去访问局部变量，当前方法被销毁时，还在堆内存，依然持有对局部变量的应用，但是方法被销毁的时候局部变量已经被销毁了。

此时出现在堆内存中，一个对象引用着一个不存在的数据，为避免该问题，我们使用final修饰局部变量，从而变成常量，永驻内存空间，即使方法销毁之后，该局部变量在内存中，用以调用。

2.3 匿名内部类

匿名内部类(Anonymous)：是一个没有名称的局部内部类，适合只使用一次的类。

在开发中经常有这样的类，只需要定义一次，使用一次就可以丢弃了；
此时：不应该白白定义在一个文件中.

在JavaSE/Android的事件处理中：不同的按钮点击之后，应该有不同的响应操作，首先使用匿名内部类。

特点：
（1）匿名内部类本身没有构造器，但是会调用父类构造器。

（2）匿名类尽管没有构造器，但是可以在匿名类中提供一段实例初始化代码块，JVM在调用父类构造器后，会执行该段代码。

（3）内部类处理可以继承类之外，还可以实现接口。

格式：

 new 父类构造器([实参列表]) 或 接口()
 { 
     //匿名内部类的类体部分
 }

注意： 匿名内部类必须继承一个父类或者实现一个接口，但最多只能一个父类或实现一个接口。

// 制定USB接口规范
interface IUSB
{
	void doWork();
}

// 鼠标
class Mouse implements IUSB
{
	public void doWork(){
		System.out.println("点击.....");
	}
}

// 打印机
class Print implements IUSB
{
	public void doWork(){
		System.out.println("打印数据.....");
	}
}

// 主板
class MotherBoard
{
	private static IUSB[] USB = new IUSB[6]; //假设主板只能接受6个设备
	private static int index = 0; // 表示插入主板设备的第几个位置（从0开始）

	// 在主板中插入外设
	public static void plugIn(IUSB usb){
		if (index == USB.length)
		{
			System.out.println("USB插口已经插满了！！");
			return ;
		}
		USB[index] = usb;
		index++;
	}

	// 开始工作
	public static void startDoWork(){
		for(IUSB usb:USB){
			if (usb != null)
			{
				usb.doWork();
			}
		}		
	}
}

class USBDemo 
{
	public static void main(String[] args) 
	{
		IUSB m = new Mouse();
		IUSB p = new Print();
		MotherBoard.plugIn(m); // 安装鼠标
		MotherBoard.plugIn(p); // 安装打印机
		
		// 安装USB键盘，假设键盘只适用一次
		// 创建一个IUSB的匿名实现类对象
		MotherBoard.plugIn(new IUSB(){
			 public void doWork(){
				System.out.println("插入键盘，输入文字");
			 } 
		});
		MotherBoard.startDoWork();
	}
}

成员内部类：外部类名 $ 内部类名

class Outter{
	class Inner{}
}

局部内部类：外部类名 $ 数字 $ 内部类名

class Outter{
	public void test(){
		class Inner{}
	}
}

匿名内部类：外部类名 $ 数字

class InnerClassDemo 
{
	public static void main(String[] args) 
	{
		new Outter(){};
	}	
}

在这里插入图片描述

pangpd

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Java】内部类（实例，静态，局部，匿名）

一. 内部类定义内部类：所谓内部类就是在一个类内部进行其他类结构的嵌套操作。因此，在一个类中除了可以定义字段，方法以外，还可以定义类1.1 为什么要使用内部类：（1）增强封装，把内部类隐藏在外部类之内，不许其他类访问内部类。（2）内部类能提高代码的可读性和可维护性，把小型类嵌入到外部类中结构上代码更靠近。（3）内部类可以直接访问外部类的成员。二. 四种内部类根据使用不同的修饰符或者定位位置的不同，可以将内部类分为四种：（1）实例内部类：内部类没有static修饰；（2）静态内部类：内部
复制链接

扫一扫

专栏目录