Java021——内部类

一、成员内部类

类中的东西都是成员，

1.1、成员内部类定义

定义成员内部类的格式：

class OuterClass {//外部类
	class InnerClass{//内部类（内部类实际是外部类的一个属性）
	
	}
}

示例

public class Outer {

    private static int radius = 1;
    private int count =2;

    class Inner {
        public void visit() {
            System.out.println("visit outer static variable:" + radius);
            System.out.println("visit outer variable:" + count);
        }
    }

    public static void main(String[] args) {
        Outer outer =new Outer();
        Outer.Inner inner = outer.new Inner();

        inner.visit();
    }
}

//输出
visit outer static variable:1
visit outer variable:2

编译上述代码会产生两个class文件：Outer.class和Outer$Inner.class。

创建内部类对象的格式：
外部类 outer = new 外部类();
外部类.内部类 inner = outer.new 内部类();

1.2、使用 this 关键字获取内部类与外部类的引用

如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用 this 关键字。

public class TheSameName {
	private int x = 7; // 外部类的x

	private class Inner {
		private int x = 9;// 内部类的x

		public void doit() {
			int x = 11; // 局部变量x
			this.x++; // 调用内部类的x
			TheSameName.this.x++; // 调用外部类的x
		}
	}
}

二、匿名内部类

匿名内部类就是没有名字的内部类

2.1、继承式的匿名内部类

public class Car {
    public void drive(){
        System.out.println("Driving a car!");
    }
    
    public static void main(String[] args) {
        Car car = new Car(){
            public void drive() {
                System.out.println("Driving another car!");
            }
        };
        car.drive();
    }
}

//输出
Driving another car!

• 匿名内部类不能有构造方法。
• 匿名内部类不能定义任何静态成员、静态方法。
• 匿名内部类不能是public,protected,private,static。
• 只能创建匿名内部类的一个实例。
• 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
• 因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

2.2、接口式的匿名内部类

interface Vehicle {
    public void drive();
}

class Test{
    public static void main(String[] args) {
        Vehicle v = new Vehicle(){
            public void drive(){
                System.out.println("Driving a car!");
            }
        };
        v.drive();
    }
}

//输出
Driving a car!

2.3、参数式的匿名内部类

class Bar{
    void doStuff(Foo f){
        f.foo();
    }
}

interface Foo{
    void foo();
}

class Test{
    static void go(){
        Bar b = new Bar();
        b.doStuff(new Foo(){
            public void foo(){
                System.out.println("foofy");
            }
        });
    }
}

2.4、抽象式的匿名内部类

abstract class Dog {
	String Color;

	public abstract void move();

	public abstract void call();
}

public class Demo {
	public static void main(String args[]) {
		Dog maomao = new Dog() {
			public void move() {
				System.out.println("四腿狂奔");
			}

			public void call() {
				System.out.println("嗷呜~");
			}
		};
		maomao.Color = "灰色";
		maomao.move();
		maomao.call();
	}
}

三、方法内部类

把类放在方法内

class Outer {
    public void doSomething(){
        final int a =10;
        class Inner{
            public void seeOuter(){
                System.out.println(a);//只能使用该内部类所在方法的final局部变量
            }
        }
        Inner in = new Inner();//方法内部类只能在定义该内部类的方法内实例化
        in.seeOuter();
    }
    public static void main(String[] args) {
        Outer out = new Outer();
        out.doSomething();
    }
}

//输出
10

(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。

四、静态内部类

class Outer {
    private static int radius = 1;

    static class StaticInner {
        public void visit() {
            System.out.println("visit outer static variable:" + radius);
        }
    }
    
     public static void main(String[] args){
         Outer.StaticInner inner = new Outer.StaticInner();
         inner.visit();
     }
}

//输出
visit outer static variable:1

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；

静态内部类的创建方式：
外部类.静态内部类 内部类名 = new 外部类.静态内部类()，
如下： Outer.StaticInner inner = new Outer.StaticInner();

五、为什么需要内部类

内部类（Inner Class）是指在一个类的内部定义的另一个类。在Java中，内部类可以嵌套在其他类中，在外部类的成员变量和方法中，可以直接访问内部类的成员，包括私有成员。以下是使用内部类的几个常见的理由：

1. 封装和隐藏：内部类可以将类隐藏在其他类的内部，只对外部类可见。这可以实现更好的封装性和模块化，隐藏内部类的实现细节，仅暴露必要的接口。

2. 访问外部类的成员：内部类可以直接访问外部类的成员，包括私有成员。这有助于实现更紧密的类之间的关系，方便数据共享和操作。

3. 实现多重继承：内部类可以在不引入多重继承的情况下实现多个接口，提供更灵活的设计选择。一个类可以实现多个接口，并且每个接口都可以有其自己的内部类，从而实现多重功能的组合。

4. 回调和事件处理：内部类常常用于实现回调和事件处理机制。例如，一个窗口类可以定义一个内部类来处理按钮的点击事件，内部类可以直接访问外部类的成员和方法，方便事件处理。

5. 代码组织和逻辑清晰：内部类可以将相关的类组织在一起，使代码更具可读性和可维护性。当内部类与外部类之间具有紧密的关系时，使用内部类可以提高代码的可读性，并且逻辑更清晰。

需要注意的是，内部类并不是必需的，很多情况下都可以通过其他方式来达到相同的效果。内部类的使用应该根据具体的需求和情况来决定，合理地使用内部类可以带来更灵活、更清晰的代码结构。

与君共享

👉👉👉👉👉最后，有兴趣的小伙伴可以点击下面链接，这里有我整理的完整Java学习博客内容，谢谢~ 🌹🌹🌹🌹🌹

《Java基础专栏完整学习》