内部类（Java）

内部类

基本介绍

• 概念：在一个类的内部再定义一个完整类
• 特点：编译之后可生成独立的字节码文件；内部类可以直接访问外部类的私有属性，不破坏封装性
• 分类：成员内部类；静态内部类；局部内部类；匿名内部类

package Inten;
//头部
public class What {
    //内部类
    class Hello{

    }
}

内部类分类

成员内部类

基本介绍

• 在类的内部定义，与实例变量和实例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
• 当外部类和内部类存在重名属性时，会优先访问内部类的属性
• 成员内部类不能定义静态成员

运用实例

ChenYuan.java

package Inten;
//外部类
public class ChengYuan {
    //实例变量
    private String name="李同洲";
    private int age=18;
    //内部类
    class InterC{
        private String address="江西";
        private int tele=109;

        private String name="Li";

        //private static String contry="中国";static报错

        //方法
        public void show(){
            //打印外部类的属性(实例变量)，当内部属性和外部属性的名字相同时，如果不使用ChengYuan.this则表示的内部属性
            System.out.println(ChengYuan.this.name);
            System.out.println(ChengYuan.this.age);

            //打印内部类的属性
            System.out.println(address);//可以使用this.name
            //System.out.println(this.address);
            System.out.println(tele);
        }
    }
}

TestCheng.java

public class TestCheng {
    public static void main(String[] args) {
        //1.创建外部类对象
        ChengYuan chengyuan = new ChengYuan();
        //2.创建内部类对象
        ChengYuan.InterC interC=chengyuan.new InterC();

        //一步到位
        ChengYuan.InterC interC2=new ChengYuan().new InterC();

        interC.show();
    }
}

静态内部类

基本介绍

• 不依赖外部类对象，可直接创建或者通过类名访问，可声明静态成员

运用实例

JingTai.java

package Inten;
//外部类
public class JingTai {
    private String name="李同洲";
    private int age=18;
    //静态内部类
    static class InterJ {
        private String address = "江西";
        private int tele = 109;

        private static String contry="中国";

        public void show(){
            //调用外部类的属性值
            //1.先创建外部类对象
            JingTai jingTai=new JingTai();

            //2.调用外部类对象的属性
            System.out.println(jingTai.name);
            System.out.println(jingTai.age);

            //3.调用内部类对象的属性
            System.out.println(address);
            System.out.println(tele);

            //4.调用内部类的静态属性
            System.out.println(InterJ.contry);
        }
    }
}

TestJing.java

public class TestJing {
    public static void main(String[] args) {
        JingTai.InterJ interJ=new JingTai.InterJ();

        interJ.show();
    }
}

局部内部类

基本介绍

• 定义在外部方法中，作用范围和创建对象仅限于当前方法中
• 局部内部类访问当前方法的局部变量时，因无法保障变量的声明周期与自身相同，变量必须修饰为final
• 限制类的使用范围

运用实例

JuBu.java

public class JuBu {
    private String name="李同洲";
    private int age=18;

    public void show(){
        //定义局部变量
        String address="江西";

        //局部内部类：不能加任何访问修饰符
        class JuBuJ{
            //局部内部类属性
            private int phone=123456;
            private String emil="li@tongzhou";

            public void show2(){
                //访问外部类属性
                System.out.println(name);
                System.out.println(age);

                //访问内部类属性
                System.out.println(phone);
                System.out.println(emil);

                //访问局部变量；jak1.7要求（变量必须时常量final）；jdk1.8则会自动添加final
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        JuBuJ juBuJ=new JuBuJ();
        juBuJ.show2();
    }
}

TestJu.java

public class TestJu {
    public static void main(String[] args) {
        JuBu juBu=new JuBu();
        juBu.show();
    }
}

匿名内部类

基本介绍

• 没有类名的局部内部类（一切特征与局部内部类相同）
• 必须继承一个父类或者实现一个接口
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

运用实例

Usb.java

package Inten;
//接口
public interface Usb {
    //服务
    void service();
}

NiMing.java

package Inten;

public class NiMing implements Usb{

    @Override
    public void service() {
        System.out.println("连接成功");
    }
}

TestNi.java

package Inten;

public class TestNi {
    public static void main(String[] args) {
        /*//创建接口类型的变量
        Usb usb=new NiMing();
        usb.service();

        //局部内部类
        class fan implements Usb{

            @Override
            public void service() {
                System.out.println("开始工作");
            }
        }
        //使用局部内部类创建对象
        Usb usb1=new fan();
        usb1.service();*/

        //使用匿名内部类优化（相当于创建了一个局部内部类）
        Usb usb=new Usb() {
            @Override
            public void service() {
                System.out.println("开始工作");
            }
        };
        usb.service();
    }
}