【Java】内部类

目录

概念：

内部类访问特点

示例代码：

运行结果：

内部类分类

1. 成员内部类

示例代码：

2. 静态内部类

示例代码：

 3. 方法内部类(局部内部类)

示例代码：

4. 匿名内部类

示例代码：

---

概念：

就是在一个类中定义一个类，就是为内部类。

比如：在一个类A的内部定义一个类B,类B就被称为内部类，类A相应的称为外部类

内部类定义格式：

内部类访问特点

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象

示例代码：

MayiktA.java

package com.面向对象.Demo33;

public class MayiktA { //外部类
    private int age = 10;
    public int code = 20;

    /**
     * 在类中定义的类——内部类
     */
    public class MayiktB { //内部类
        public void mayiktB() {
            // 在内部类中是可以直接访问到 外部类中 成员属性 包括（私有）
            System.out.println("内部类MayiktB-mayiktB()");
            System.out.println(age);
            System.out.println(code);
        }
    }

    // 在外部类中 想使用到内部类，则需要new 内部类 再通过内部类对象引用.内部类方法
    public void mayiktA() {
        MayiktB mayiktB = new MayiktB();
        mayiktB.mayiktB();
    }
}

Test01.java

package com.面向对象.Demo33;

public class Test01 {
    public static void main(String[] args) {
        MayiktA mayiktA = new MayiktA();
        mayiktA.mayiktA();
    }
}

运行结果：

---

内部类分类

成员内部类与局部内部类区别：

• 如果类定义在方法里面，该类就是为方法内部类或者局部内部类
• 如果类定义在方法外面，该类就是为成员内部类，如果加上了static 静态修饰 则该类是为静态内部类 

1. 成员内部类

按照内部类在类中的定义的位置不同，可以分为如下两种格式：

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

成员内部类，外界如何创建对象使用呢？

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

范例：MayiktA.MayiktB mayiktB = new MayiktA().new MayiktB();

在实际开发中是不会这样使用的。

因为一般内部类就是不让外界直接访问的。

成员内部类的常见修饰符 private 为了保证数据的安全性 

示例代码：

MayiktA.java

package com.面向对象.Demo34;

public class MayiktA { //外部类

    /**
     * 在方法外定义的 内部类 ————成员内部类
     */
    //private
    public class MayiktB { //内部类——成员内部类
        public void mayiktB() {
            System.out.println("内部类MayiktB——成员内部类-mayiktB()");
        }
    }

    public void mayiktA() {
        MayiktB mayiktB = new MayiktB();
        mayiktB.mayiktB();
    }
}

Test01.java

package com.面向对象.Demo34;

public class Test01 {
    public static void main(String[] args) {
        /**
         * 在外界如何访问到该类 内部类？
         * 格式: 外部类.内部类 name=new 外部类().new 内部类();
         */
        MayiktA.MayiktB mayiktB = new MayiktA().new MayiktB();
        mayiktB.mayiktB(); // 内部类MayiktB——成员内部类-mayiktB()
    }
    /**
     * 企业实际开发中
     * 外界不能直接 访问内部类
     * 通过私有private 形式 让外界 无法访问 内部类
     * 但是 在该外部类里是可以通过 new 内部类
     */
}

---

2. 静态内部类

有 static 关键字修饰的内部类为静态内部类；

静态内部类访问外部类的静态成员变量或方法必须是静态的。

访问格式：new MayiktA.MayiktB()

示例代码：

MayiktA.java

package com.面向对象.Demo35;

public class MayiktA {
    private static int code = 20;

    public static void show() {
        System.out.println("static内部类访问外部类中的方法，必须是static");
    }

    public static class MayiktB {
        public void mayiktB() {
            show();
            System.out.println(code);//内部类访问外部类的属性 该属性也必须是static
            System.out.println("static内部类MayiktB-mayiktB()");
        }
    }

    /**
     * 在内部类的外部类中 静态方法 如果访问 内部类
     * 则 该内部类必须是static 静态访问
     */
    public static void main(String[] args) {
        MayiktB mauiktB = new MayiktB();
    }
}

Test01.java

package com.面向对象.Demo35;

public class Test01 {
    public static void main(String[] args) {
        //外界如果访问 static内部类 ==> new 外部类.内部类
        MayiktA.MayiktB mayiktB = new MayiktA.MayiktB();
        mayiktB.mayiktB(); //static内部类MayiktB-mayiktB()
    }
}

---

 3. 方法内部类(局部内部类)

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用

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

示例代码：

MayiktA.java

package com.面向对象.Demo36;

public class MayiktA {
    private int age = 20;
    private int code = 30;

    /**
     * 在方法里面定义的内部类 就是为 局部内部类（方法内部类）
     */
    public void mayikt() {
        int num = 10;
        class MayiktB { //局部内部类（方法内部类）
            public void mayiktB() {
                System.out.println("局部内部类MayiktB-mayiktB()");
                System.out.println("局部内部类是可以直接访问外部类的成员");
                System.out.println(age);
                System.out.println(code);
                show();
                System.out.println("也可以访问方法内的局部变量");
                System.out.println(num);
            }
        }
        MayiktB mayiktB = new MayiktB();
        mayiktB.mayiktB();
    }

    /**
     * 局部内部类MayiktB 只能在该方法mayikt()里面访问，不能在外界（方法外面）访问
     */
//    public void show(){
//        MayiktB mayiktB = new MayiktB(); 局部内部类不能在外界（方法外面）访问
//        mayiktB.mayiktB();
//    }
    public void show() {}
}

Test01.java

package com.面向对象.Demo36;

public class Test01 {
    public static void main(String[] args) {
        MayiktA mayiktA = new MayiktA();
        mayiktA.mayikt();
    }
}

---

4. 匿名内部类

可以 new 出接口（实现类） 或者 抽象类（子类）

示例代码：

MayiktB.java

package com.面向对象.Demo37;

public interface MayiktB {
    /**
     * 抽象方法
     */
    void mayiktB();
}

MayiktC.java

package com.面向对象.Demo37;

public abstract class MayiktC {
    public abstract void mayiktC();
}

Test01.java

package com.面向对象.Demo37;

public class Test01 {
    public static void main(String[] args) {
        // 匿名内部类
        /**
         * 匿名内部类
         * 这里的接口为什么可以实例化？
         * 请看下篇博客
         */
        MayiktB mayiktB = new MayiktB() {
            //重写了 接口中的方法
            @Override
            public void mayiktB() {
                System.out.println("匿名内部类-mayiktB()");
            }
        };
        mayiktB.mayiktB(); //匿名内部类-mayiktB()
        /**
         * 使用匿名内部类 就不需要创建 实现类和子类
         * 直接通过 new 内部类的形式 简化不需要创建 实现类和子类
         */

//        new MayiktC(); //报错，抽象类是不可以直接new出来，可以使用下面的匿名内部类形式
        //底层实际上是创建 子类的
        MayiktC mayiktC = new MayiktC() {
            @Override
            public void mayiktC() {
                System.out.println("匿名内部类-mayiktC()");
            }
        };
        mayiktC.mayiktC();
    }
}

---

下一篇文章：匿名内部类开发使用场景