Java常用类之内部类

Java常用类之内部类

成员内部类、静态内部类、局部内部类、匿名内部类

概念：在一个类的内部再定义一个完整的类

特点：

编译之后可生成独立的字节码文件

内部类可直接访问外部类私有成员，而不破坏封装

可为外部类提供必要的内部功能组件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4ROXZmeJ-1623662648189)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210614122939151.png)]

// 身体
class Body{
  // 头部
  class Header{
    // 也会生成class文件
  }
}

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类

外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

当外部类、内部类存在重名属性时，会优先访问内部类属性

成员内部类里不能定义静态成员、可以包含静态常量(final)

//外部类
public class Outer {
    //实例变量
    private String name = "张三";
    private int age = 20;
    //内部类
    class Inner{
        private String address = "北京";
        private String phone = "10010";
        private String name = "李四";//当外部类、内部类存在重名属性时，会优先访问内部类属性
        //结果会显示李四而不是张三
//        private static final String city = "tianjin";//不能包含静态变量，但是可以在static后面田间final

        //方法
        public void show()
        {
            //打印外部类的属性
            System.out.println(name);//如果想要显示外部类的名字需要Outer.this.name
            System.out.println(age);
            //打印内部类的属性
            System.out.println(address);//也可以使用this.address
            System.out.println(phone);//也可以使用this.phone 效果相同
        }
    }
}

public class ApplicationOuter {
    public static void main(String[] args) {
        //创建一个外部类对象
        //Outer outer = new Outer();
        //常见内部类对象
        //Outer.Inner inner  = outer.new Inner();
        //一步到位
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

静态内部类

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

public class Outer {
    private String name = "zhangsan";
    private int age = 18;

    //静态内部类:和外部类相同
    static class Inner {
        private String address = "上海";
        private String phone  = "11";
        //静态成员
        private static int count  = 1000;
        public void show()
        {
            //调用外部类的属性
            //1.先创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //调用静态内部类的属性和方法(直接调用即可)
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}
public class Application {
    public static void main(String[] args) {
        //直接创建静态内部对象
        Outer.Inner inner  = new Outer.Inner();
        //调用方法
        inner.show();
    }
}

局部内部类

定义在外部类的方法中，作用范围和创建对象仅限于当前方法

public class Outer {
    private String name = "张三";
    private int age = 35;

    public void show() {
        //定义局部变量
        String address = "上海";
        //局部内部类:注意不能加任何访问修饰符
        class Inner {
            private String phone = "123123123";
            public void show2 () {
                //访问外部类的属性
                System.out.println(name);//省略Outer.this.name
                System.out.println(age);
                //访问内部类的属性
                System.out.println(phone);
                //访问局部变量
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();

    }
}
public class testOuter {
    public static void main(String[] args) {
        Outer outer  = new Outer();
        outer.show();
    }
}

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）

必须继承一个父类或者实现一个接口

定义了、实现类、创建对象的语法合并，只能创建一个该类的对象

优点：减少代码量

缺点：可读性较差

public interface Usb {
    void service();
}
public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("连接电脑成功");
    }
}
public class TestUsb {
    public static void main(String[] args) {
        //常见接口类的变量
        /*
        Mouse mouse = new Mouse();
        mouse.service();
        */
        //局部内部类
//        class Fan implements Usb{
//
//            @Override
//            public void service() {
//                System.out.println("风扇连接电脑成功");
//            }
//        }
        //使用局部内部类创建对象
//        Fan fan = new Fan();
//        fan.service();
        //使用匿名内部类优化(相当于创建了一个局部内部类)
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("风扇连接电脑成功");
            }
        };
        usb.service();
    }
}

标签：部类,Java,内部,之内,System,println,Outer,public,out
来源： https://blog.csdn.net/weixin_48281736/article/details/117908963