深入了解Java内部类的用法

1 内部类分类和概念 java类的五大成员：属性，方法，构造器（构造方法），代码块，内部类内部类的分类：定义在外部类局部的位置（比如方法内）：局部内部类（有

1.内部类分类和概念

java类的五大成员：属性，方法，构造器（构造方法），代码块，内部类

内部类的分类：

定义在外部类局部的位置（比如方法内）：

局部内部类（有类名）
匿名内部类（无类名）

定义在外部类成员位置上：

成员内部类（没有static修饰）
静态内部类（有static修饰）

概念：在一个类的内部再定义一个完整的类，也会生成一个class文件

代码示例：

/**
 * 内部类
 */
public class InnerClass {
    private int n = 521;

    public InnerClass(int n) {
        this.n = n;
    }

    class Inner { // 内部类

    }
}

谨记：内部类很重要，java底层源码内部类使用场景很多！

2.局部内部类

class Outer001 { // 外部类
    private int n = 521;
    private void kaka() {
        System.out.println("我是外部类的方法！");
    }
    public void show() {
        // 局部内部类定义在外部类的局部位置，通常在方法中
        class Inner001 {
            // 局部内部类
            public void f() {
                // 可以直接访问外部类的所有成员，包含私有的
                System.out.println(n);
            }
        }
    }
}

不能添加访问修饰符，但是可以添加final

局部内部类的作用域只在定义它的方法或者代码块中

外部类使用内部类的方法，直接new即可：

public void show() {
    // 局部内部类定义在外部类的局部位置，通常在方法中
    final class Inner001 {
        // 局部内部类
        public void f() {
            // 可以直接访问外部类的所有成员，包含私有的
            System.out.println(n);
            kaka();
        }
    }
    // 外部类使用内部类的方法
    Inner001 inner001 = new Inner001();
    inner001.f();
}

外部其他类不能访问局部内部类！

外部类和局部内部类的成员重名时，默认遵循就近原则，如果想要访问外部类的成员，使用外部类名.this.成员进行访问

3.匿名内部类（重要）

匿名内部类其实有名字，它的名字是底层的JDK给分配的~系统分配该类名的时候会在外部类的基础上加上$1，存在多个内部类的，$后面的值进行递增

基于接口的匿名内部类

/**
 * 匿名内部类
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer002 outer002 = new Outer002();
        outer002.method();
    }
}

class Outer002 {
    private int n = 521;

    public void method() {
        // 基于接口的匿名内部类
        // tiger的编译类型是IA，运行类型就是匿名内部类！
        // 系统分配该类名的时候会在外部类的基础上加上$1，此处是Outer002$1
        // JDK底层在创建了匿名内部类之后，立即创建了一个实例，并且把地址返回给tiger
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("我是一只小老虎");
            }
        };
        tiger.cry();
        System.out.println(tiger.getClass());
    }
}

interface IA {
    public void cry();
}

输出：

我是一只小老虎
class seniorobject.innerclass.Outer002$1

注意：匿名内部类使用一次就不能再使用了！

基于类的匿名内部类

基于类的匿名内部类和基于接口的差不太多

Father类：

class Father {
    private String name;

    public Father(String name) {
        this.name = name;
    }
    public void test() {

    }
}

匿名内部类：

// 基于类的匿名内部类，加入大括号就摇身一变变成内部类了
Father jack = new Father("jack"){
    @Override
    public void test() {
        super.test();
        System.out.println("♪(^∇^*)");
    }
};
System.out.println(jack.getClass());

输出：

class seniorobject.innerclass.Outer002$2

一些细节

匿名内部类是类，同时，它也可以理解为是一个对象

匿名内部类可以访问外部类的所有成员，包括私有的

不能添加访问修饰符

定义域在定义它的方法或者代码块中，转瞬即逝！

外部其他类不能访问匿名内部类

外部类和匿名内部类成员重名时，参照局部内部类的方式即可

匿名内部类的最佳实践

当作实参直接传递，简洁高效

/**
 * 匿名内部类的最佳实践
 * 当作实参直接传递，简洁高效
 */
public class AnonymousInnerClassPractice {
    public static void main(String[] args) {
        f(new IL() {
            @Override
            public void show() {
                System.out.println("你好啊");
            }
        });
    }

    public static void f(IL il) {
        il.show();
    }
}

interface IL {
    void show();
}

4.成员内部类

定义在外部类的成员位置上：

实例：

/**
 * 成员内部类
 */
public class MemberInnerClass {
    public static void main(String[] args) {
        Outer003 outer003 = new Outer003();
        outer003.t();
    }
}

class Outer003 {
    private int n = 521;
    public String name = "dahe";

    class Inner003 { // 成员内部类
        public void say() {
            System.out.println(n + name);
        }
    }

    public void t() {
        // 使用成员内部类
        Inner003 inner003 = new Inner003();
        inner003.say();
    }
}

输出：

521dahe

可以访问外部类的所有成员，包括私有的

可以添加任意的访问修饰符

作用域为整个类体中

外部类想要使用成员内部类，创建对象调用即可！

外部其他类想要访问成员内部类，存在两种方式：

// 直接创建对象
Outer003.Inner003 inner003 = outer003.new Inner003();
// 注意：这里的outer003是外部类的对象实例

// 成员内部类的外部类创建一个返回内部类对象的公有方法
public Inner003 getInner003Instance() {
    return new Inner003();
}

// 外部其他类进行调用该共有方法
Outer003.Inner003 inner0031 = outer003.getInner003Instance();
inner0031.say();

外部类和成员内部类的成员重名时，参考局部内部类和匿名内部类即可

5.静态内部类

可以直接访问外部类的静态成员

可以添加任意的访问修饰符

作用域为整个类体

外部类想要访问静态内部类依然是创建对象访问

外部其他类想要访问静态内部类：

// 通过类名直接访问
Outer004.Inner004 inner004 = new Outer004.Inner004();
inner004.say();

// 静态内部类的外部类创建一个返回内部类对象的公有方法
// 返回静态内部类的对象实例
public Inner004 getInner004() {
    return new Inner004();
}

Outer004.Inner004 inner0041 = outer004.getInner004();
inner0041.say();

// 返回静态内部类的对象实例，但是是静态方法
public static Inner004 getInner004_() {
    return new Inner004();
}

// 静态内部类的外部类创建一个返回内部类对象的公有静态方法
Outer004.Inner004 inner0042 = Outer004.getInner004_();
inner0042.say();

整体代码示例：

/**
 * 静态内部类
 */
public class StaticInnerClass {
    public static void main(String[] args) {
        Outer004 outer004 = new Outer004();
        // 通过类名直接访问
        Outer004.Inner004 inner004 = new Outer004.Inner004();
        inner004.say();
        // 静态内部类的外部类创建一个返回内部类对象的公有方法
        Outer004.Inner004 inner0041 = outer004.getInner004();
        inner0041.say();
        // 静态内部类的外部类创建一个返回内部类对象的公有静态方法
        Outer004.Inner004 inner0042 = Outer004.getInner004_();
        inner0042.say();
    }
}

class Outer004 {
    private int n = 521;
    private static String name = "dahe";
    public static class Inner004 {
        public void say() {
            // 可以直接访问外部类的静态成员
            System.out.println(name);
        }
    }

    // 返回静态内部类的对象实例
    public Inner004 getInner004() {
        return new Inner004();
    }

    // 返回静态内部类的对象实例，但是是静态方法
    public static Inner004 getInner004_() {
        return new Inner004();
    }
}

外部类和成员内部类的成员重名时，遵循就近原则，如果想要访问外部类的成员，使用外部类名.成员即可

以上就是深入了解Java内部类的用法的详细内容，更多关于Java内部类的资料请关注好代码网其它相关文章！