Java内部类-CSDN博客

本文链接：https://blog.csdn.net/m0_47199890/article/details/119040499

一、什么是内部类？

可以将一个类的定义放在里另一个类的内部，这就是内部类。广义上我们将内部类分为四种：

成员内部类、静态内部类、局部（方法）内部类、匿名内部类

/**
*	我是一个外部类（外部是相对内部而言）
*/
public class Outer{
	/**
	*	我是一个内部类
	*/
	class Inner{
	//...
	}
}

二、为什么要用内部类？

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。——《Think in java》

也就是说内部类拥有类的基本特征。(eg：可以继承父类，实现接口)。在实际问题中我们会遇到一些接口无法解决或难以解决的问题，此时我们可以使用内部类继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。（注：内部类可以嵌套内部类，但是这极大的破坏了代码的结构，这里不推荐使用。）

/**
 1. Outer类继承了ClassA，实现了IFunctionA
*/
public class Outer extends ClassA implements IFunctionA { 
	/**
	*	Inner类继承了ClassB，实现了IFunctionB
	*/
	public class Inner extends ClassB implements IfunctionB {
	//
	} 
}

除了上面的优点之外还有如下四点：

内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
内部类提供了更好的封装，除了该外围类，其他类都不能访问。
创建内部类对象的时刻并不依赖于外围类对象的创建。

具体来说，内部类信息（属性、方法）可以和外部类重名；内部类是具有类的基本特征的独立实体；可以利用访问修饰符隐藏内部类的实施细节，提供了更好的封装；静态内部类使用时可直接使用，不需先创造外部类。

三、四种内部类

3.1 成员内部类

可以是任何的访问修饰符（就像成员方法一样）。
内部类的内部不能有静态信息。
内部类也是类,该继承继承，该重写重写，该重载重载，this和super随便用。
外部类如何访问内部类信息，必须new之后打点访问。
内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类.this.属性或者方法。
其它类如何访问内部类：

                 Outer outer = new Outer();
                 //创造内部类对象
                 Outer.Inner inner = outer.new Inner();
                 inner.innerShow();

外部类与内部类：

/**
 * 外部类、成员内部类的定义
 */
public class Outer {
    private int outerVariable = 1;
    private int commonVariable = 2;
    private static int outerStaticVariable = 3;
     
    // 成员方法
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }
    // 静态方法
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 内部类
     */
    public class Inner {
    
        private int commonVariable = 20;
        // 构造方法
        public Inner() {
        }
        // 成员方法，访问外部类信息（属性、方法）
        public void innerShow() {
            //当和外部类冲突时，直接引用属性名，是内部类的成员属性
            System.out.println("内部的commonVariable:" + commonVariable);
            //内部类访问外部属性
            System.out.println("outerVariable:" + outerVariable);
            //当和外部类属性名重叠时，可通过外部类名.this.属性名
            System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
            System.out.println("outerStaticVariable:" + outerStaticVariable);
            //访问外部类的方法
            outerMethod();
            outerStaticMethod();
        }
    }
    
    // 外部类访问内部类信息
    public void outerShow() {
        Inner inner = new Inner();
        inner.innerShow();
    }
}

其他类使用内部类：

/*
 *	其他类使用成员内部类
 */
public class Other {
    
    public static void main(String[] args) {
        //外部类对象
        Outer outer = new Outer();
        //创造内部类对象
        Outer.Inner inner = outer.new Inner();
        inner.innerShow();
        /*
        * 可在Outer中定义get方法，获得Inner对象,那么使用时，只需outer.getInnerInstance()即可。
        * public Inner getInnerInstance(Inner类的构造方法参数){
        *   return new Inner(参数);
        * }
        */
    }
}

3.2 静态内部类

内部可以包含任意的信息。
静态内部类的方法只能访问外部类的static关联的信息。(因为有static)
利用 Outer.Inner inner = new Outer.Inner();
这和成员内部类不同，不需要创建外部类对象就能创建内部类对象
然后利用 inner.成员信息(属性、方法)调用。
访问内部类的静态信息，直接外部类.内部类.静态信息就可以了。
静态内部类可以独立存在，不依赖于其他外围类。

/**
 * 外部类、内部类定义
 */
public class Outer {
    private int outerVariable = 1;
    private int commonVariable = 2;
    private static int outerStaticVariable = 3;

    static {
        System.out.println("Outer的静态块被执行了……");
    }
    public void outerMothod() {
        System.out.println("我是外部类的outerMethod方法");
    }
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }
    /**
     * 静态内部类
     */
    public static class Inner {
        private int innerVariable = 10;
        private int commonVariable = 20;
        static {
            System.out.println("Outer.Inner的静态块执行了……");
        }
        private static int innerStaticVariable = 30;

        public void innerShow() {
            System.out.println("innerVariable:" + innerVariable);
            System.out.println("内部的commonVariable:" + commonVariable);
            System.out.println("outerStaticVariable:"+outerStaticVariable);
            outerStaticMethod();
        }
        // 静态方法
        public static void innerStaticShow() {
        	//被调用时会先加载Outer类
            outerStaticMethod();
            System.out.println("outerStaticVariable"+outerStaticVariable);
        }
    }

    /**
     * 外部类的内部如何和内部类打交道
     */
    public static void callInner() {
        System.out.println(Inner.innerStaticVariable);
        Inner.innerStaticShow();
    }
}

其他类如何调用内部类

public class Other {

    public static void main(String[] args) {
        //访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。
        Outer.Inner.innerStaticShow();
        //访问静态内部类的成员方法
        Outer.Inner oi = new Outer.Inner();
        oi.innerShow();
    }
}