Java内部类

?目录

一、内部类

1.1内部类定义

1.2内部类格式

1.3 内部类访问特点

1.4内部类分类?

?二、成员内部类

2.1成员内部类定义位置

2.2外界创建成员内部类格式 ?

?三、局部内部类

3.1局部内部类定义位置

3.2 局部内部类访问特点

四、匿名内部类?

4.1匿名内部类存在前提

?4.2匿名内部类的格式

?4.3匿名内部类的本质

4.4匿名内部类在开发中的使用（应用）

五、嵌套内部类（静态内部类）

六、内部类的好处

---

一、内部类

1.1内部类定义

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

1.2内部类格式

/*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

class Outer {
    public class Inner {
        
    }
}

1.3 内部类访问特点

• 内部类可以直接访问外部类的成员，包括私有

• 外部类要访问内部类的成员，必须创建对象

 */
public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();   //外部类访问内部类，创建对象

        i.show();
    }
}

1.4内部类分类?

成员内部类、局部内部类、（特殊的局部内部类）匿名内部类、静态内部类?

?二、成员内部类

2.1成员内部类定义位置

在类中方法，跟成员变量是一个位置

2.2外界创建成员内部类格式 ?

• 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

• 举例：Outer.Inner oi = new Outer().new Inner();

注意： 当内部类不被public修饰被私有化private，这种格式就会失效，报错。我们最好的方法就是在外部类里面创建一个方法，并在方法中创建内部类对象，调用内部类的方法，然后在测试类里直接创建外部类对象并调用方法。（直接看代码！）

class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

?成员内部类的推荐使用方案：将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

?三、局部内部类

3.1局部内部类定义位置

在一个类的成员方法中。或者说，定义在一个成员方法的中的类就是局部内部类。

3.2 局部内部类访问特点

• 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

• 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

?代码展示：

class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

注意：?局部内部类如果要去访问局部变量，那么局部变量必须声明为final类型

四、匿名内部类?

4.1匿名内部类存在前提

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

?4.2匿名内部类的格式

格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

?4.3匿名内部类的本质

一个继承了该类或者实现了该接口的子类匿名对象

匿名内部类直接调用方法：

?代码展示：

nterface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

?匿名内部类的细节：

如果想要多次调用内部类的方法可以直接复制粘贴

?但是如果次数过多，就不方便了！这边可以通过多态的形式来直接调用！

Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

4.4匿名内部类在开发中的使用（应用）

interface Jumpping {
    void jump();
}
class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
class Dog implements Jumpping {
    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}
class JumppingOperator {
    public void method(Jumpping j) { //new Cat();   new Dog();
        j.jump();
    }
}
class JumppingDemo {
    public static void main(String[] args) {
        //需求：创建接口操作类的对象，调用method方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.method(j);

        Jumpping j2 = new Dog();
        jo.method(j2);
        System.out.println("--------");

        // 匿名内部类的简化
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
		// 匿名内部类的简化
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了");
            }
        });
    }
}

五、嵌套内部类（静态内部类）

静态内部类和成员内部类相比多了一个static修饰符。它与类的静态成员变量一般，是不依赖于外部类的。同时静态内部类也有它的特殊性。因为外部类加载时只会加载静态域，所以静态内部类不能使用外部类的非静态变量与方法。同时可以知道成员内部类里面是不能含静态属性或方法的。?

格式：?

class U {
    static class I {
        
    }
}

对象创建：静态内部类对象的创建一般是外部类.内部类 类名 = new 外部类.内部类();?

　生成静态内部类对象的方式为：
　OuterClass.InnerClass inner = new OuterClass.InnerClass();

class StaticInner {
    private static int a = 4;

    // 静态内部类
    public static class Inner {
        public void test() {
// 静态内部类可以访问外部类的静态成员
// 并且它只能访问静态的
            System.out.println(a);
        }
    }
}

public class StaticInnerClassTest {
    public static void main(String[] args) {
        StaticInner.Inner inner = new StaticInner.Inner();
        inner.test();
    }
}

注意：嵌套类和普通的内部类还有一个区别：普通内部类不能有?static?数据和?static?属性，也不能包含嵌套类，但嵌套类可以。而嵌套类不能声明为?private?，一般声明为?public，方便调用。?

由于学习原因静态内部类没有过多的介绍，感兴趣的朋友可以去学习一下，然后让我再去学习一哈！

六、内部类的好处

1. 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象那个的信息相互独立；
2. 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类；
3. 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏
4. 方便编写事件驱动程序；
5. 方便编写线程代码。?