成员内部类

在 Java 中，成员内部类是定义在另一个类内部的类，被称为外部类。成员内部类可以访问外部类的所有成员，包括私有成员。

下面是成员内部类的基本结构和使用方法：

public class OuterClass {
    private int outerField;

    // 外部类的构造方法
    public OuterClass(int outerField) {
        this.outerField = outerField;
    }

    // 外部类的成员方法
    public void outerMethod() {
        System.out.println("Outer method");
    }
    public class InnerClass {
        private int innerField;

        // 内部类的构造方法
        public InnerClass(int innerField) {
            this.innerField = innerField;
        }

        // 内部类的成员方法
        public void innerMethod() {
            System.out.println("Inner method");
            // 内部类可以访问外部类的成员
            System.out.println("Outer field from inner method: " + outerField);
            // 内部类可以调用外部类的方法
            outerMethod();
        }
    }

public static void main(String[] args) {
    // 创建外部类的对象
    OuterClass outerObj = new OuterClass(10);

    // 创建内部类的对象
    InnerClass innerObj = outerObj.new InnerClass(20);
    //InnerClass innerObj=new OuterClass(10). new InnerClass(20);

    // 调用内部类的方法
    innerObj.innerMethod();
}
}

当外部类，内部类，内部类方法属性相同的的调用

package object;

public class Outer {
	 private int commonField = 5;

	    // 成员内部类
	    public class InnerClass {
	        private int commonField = 10;

	        public void displayFields() {
	            // 使用this关键字来引用内部类的字段
	            System.out.println("InnerClass commonField: " + this.commonField);
	            // 使用OuterClass.this来引用外部类的字段
	            System.out.println("OuterClass commonField: " + new Outer().commonField);//或者Outer.this.commonField
	        }
	    }

	    public static void main(String[] args) {
	        // 创建外部类对象
	        Outer outerObj = new Outer();
	        // 创建内部类对象
	        InnerClass innerObj = outerObj.new InnerClass();
	        // 调用内部类的方法显示字段
	        innerObj.displayFields();
}

}

内部方法改变外部属性

package object;


public class Outer2 {
	 private int commonField = 5;

	    // 成员内部类
	    public class InnerClass2 {
	        private int commonField = 10;

	        public void displayFields(Outer2 outer2) {//将outer2传递即可改变，内部方法改变外部属性，或者Outer.this.commonField可以直接改变，相当于传递
	            // 使用this关键字来引用内部类的字段
	            System.out.println("InnerClass commonField: " + this.commonField);
	            // 使用OuterClass.this来引用外部类的字段
	            System.out.println("OuterClass commonField: " + outer2.commonField++);
	        }
	    }

	    public static void main(String[] args) {
	        // 创建外部类对象
	        Outer2 outerObj = new Outer2();
	        // 创建内部类对象
	        InnerClass2 innerObj = outerObj.new InnerClass2();
	        // 调用内部类的方法显示字段
	        innerObj.displayFields(outerObj);
	        innerObj.displayFields(outerObj);
}

}

利用内部类做加法器

package object;

public class AddTest {
	 public class Summation {
	        private int operand1;
	        private int operand2;

	        // 内部类的构造方法
	        public Summation(int operand1, int operand2) {
	            this.operand1 = operand1;
	            this.operand2 = operand2;
	        }

	        // 内部类的成员方法，完成加法操作
	        public int add() {
	            return operand1 + operand2;
	        }
	    }
	public int adds(int operand1, int operand2) {
		
		return new Summation(operand2, operand2).add();// 调用内部类的方法完成加法
	}
}

静态内部类

public class OuterClass {
    private static int outerField = 10;

    // 静态内部类
    public static class StaticInnerClass {
        private int innerField;

        public StaticInnerClass(int innerField) {
            this.innerField = innerField;
        }

        public void displayFields() {
            // 在静态内部类中可以直接访问外部类的静态成员
            System.out.println("Outer field from inner class: " + outerField);
            // 访问内部类的成员
            System.out.println("Inner field: " + innerField);
        }
    }

    public static void main(String[] args) {
        // 创建静态内部类的对象
        StaticInnerClass innerObj = new StaticInnerClass(20);
        // 调用静态内部类的方法显示字段
        innerObj.displayFields();
    }
}