从头开始学java--内部类

旧城等待， 2022-08-06 00:23 173阅读 0赞

## 一.内部类 ##

内部类，就是定义在一个类内部的类，其定义直接包容于另一个类中。内部类可以看成是外部类的成员，地位等同于类中其他成员。

为什么要用内部类呢？我们知道java是彻底面向对象，用对象封装一切，当一个类中包含了许多方法和字段时，许多方法字段在逻辑上相关，所以可以放在一起，就使用内部类进行封装。即我们描述一个事物时，事物中还有一个事物，那么内部的事物就用内部类来描述。

内部类编译后，内部类也会产生.class文件，命名为 外部类名$内部类名.class

//外部类
    class Outer
    {
    	private int value = 3;
    	
    	//内部类
    	class Inner
    	{
    		//内部类方法，可以直接访问外部类的成员，私有成员也可以访问
    		void function()
    		{
    			System.out.println("I can get Outer value: " + value);
    		}
    	}
    	
    	//外部类的方法，要想访问内部类的方法或成员，需要建立一个内部类的对象
    	void function2()
    	{
    		//建立内部类对象
    		Inner in = new Inner();
    		in.function();
    	}
    	
    }
    
    public class InnerTest {
    	public static void main(String[] args)
    	{
    		//创建外部类对象，调用方法
    		Outer out = new Outer();
    		out.function2();
    		//慧姐创建内部类对象，但是不常用，一般内部类都是私有化的，不创建对象
    		Outer.Inner in = new Outer().new Inner();
    	}
    }

这是一个成员内部类，即内部类定义在类中，无static修饰。

**要点：**

**1.成员内部类，可以访问外部类中的任何成员。外部类也可以访问内部类的成员和字段，但是需要事先创建内部类对象。**

**2.使用成员内部类的场景：当一个类要完成的功能比较多，并且部分方法字段功能相近，可以将其封装成内部类。**

**3.通常，成员内部类设为private修饰，不允许外界直接访问。**

## **二.静态内部类** ##

当类处在成员位置，且有static 修饰时，我们称之为静态内部类。

//外部类
    class Outer1
    {
    	// 外部类静态成员
    	private static int MAX_VALUE = 100;
    	//外部类静态方法
    	public static void printMaxValue()
    	{
    		System.out.println(MAX_VALUE);
    	}
    	
    	//静态内部类
    	static class Inner
    	{
    		//静态内部类的静态成员，有晶体成员，则内部类必须声明为静态
    		public static void printlnOuterValue()
    		{
    			System.out.println(MAX_VALUE);
    		}
    	}
    }
    
    public class InnerTest2 {
    	public static void main(String[] args)
    	{
    		//静态方法，直接通过类名调用方法
    		Outer1.Inner.printlnOuterValue();
    	}
    }

**要点：**

**1.当内部类中定义了静态成员时，内部类必须声明为静态内部类。当外部类的静态方法访问内部类时，内部类也必须是静态的。**

**2.静态内部类只能访问外部类的静态字段或者方法。**

**3.调用静态内部类的方法，一般直接通过外部类名.内部类名.方法名调用。**

## 三.本地内部类 ##

本地内部类是建立在方法中的一个类，与成员内部类相差不多，而且要创建对象，所以用的不多。

public class LocalInnerClassTest 
    {
    	public static void main(String[] args)
    	{
    		TestLocalInnerClass();
    	}
    	//一个使用了本地内部类的静态方法
    	private static void TestLocalInnerClass()
    	{
    		 // 定义于方法体内部的内部类，注意结尾括号后面的分号
    		class MyLocalInnerClass
    		{
    			private int field=100;
    			private void printValue()
    			{
    				System.out.println(field);
    			}
    		};   
    		//本地内部类也要实例化之后才能使用
    		MyLocalInnerClass localObj=new MyLocalInnerClass();
    		localObj.printValue();
    	}
    }

## 四.匿名内部类 ##

匿名内部类其实就是内部类的简化形式。他做好事不留名，所以就没名字啦！

例子：

abstract class InnerBase
    {
    	public abstract void function();
    }
    
    class Outer2
    {
    //建立内部类，继承父类。但是这样写太麻烦了，所以下面有简化写法，即匿名内部类
    //	class Inner extends InnerBase
    //	{
    //		public void function()
    //		{
    //			System.out.println("Inner class");
    //		}
    //	}
    	
    	
    	//匿名内部类
    	public void method()
    	{
    		//创建一个父类对象，并且覆写内部的function方法，并且通过该对象调用function方法
    		new InnerBase()
    		{
    			public void function()
    			{
    				System.out.println("匿名内部类!");
    			}
    		}.function();
    	}
    }
    
    public class InnerTest3 {
    	public static void main(String[] args)
    	{
    		Outer2 out = new Outer2();
    		out.method();
    	}
    
    }

**要点：**

**1.匿名内部类使用的前提是类必须继承一个类或者实现一个接口。**

**2.匿名内部类的 定义格式： new 父类（接口）\{覆写方法\}.方法。**

**3.匿名内部类的实质就是一个内部类的对象，实现和调用何在一起。简化了书写，但是不是很好理解。**

**4.匿名内部类的特点就是只是用一次。**

**![Center][]**

[Center]: /images/20220806/c099d67430d54bf6afbaeb6f9223b6f8.png