Java 常用类（内部类）

Java 常用类（内部类）

---

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

特点：

1. 编译之后可生成独立的字节码文件。
2. 内部类可直接访问外部类的私有成员，而不破坏封装。
3. 可谓外部类提供必要的内部功能组件。

package nblDemo;

// 身体
public class Demo01 {

    private String name;


    public static void main(String[] args) {
        System.out.println("你好");
    }

    // 头部
    class Header{
         public void show(){
             System.out.println(name);
         }
    }
}

1. 成员内部类

1. 在类的内部定义，与实例变量、实例方法同级别的类。
2. 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

测试类：

package com.exception;

public class TestOuter {
    public static void main(String[] args) {
        //1.创建一个外部类
//        Outer outer = new Outer();
        //2. 创建内部类对象
//        Outer.Inner inner = outer.new Inner();

        // 一步到位
        Outer.Inner inner = new Outer().new Inner();


        inner.show();
    }
}

外部类和内部类：

package com.exception;

// 外部类
package com.exception;

// 外部类
public class Outer {

    // 实例变量
    private String name="张三";
    private int age;

    // 内部类
    class Inner{
        private String address = "shenzhen";
        private String phone = "110";
        private String name = "里斯";

        public void show(){
            // 打印
            System.out.println(name);
            System.out.println(Outer.this.name);
            System.out.println(age);
            // 打印内部类属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

注意点：

内部类的属性和外部类的属性相同，会调用内部类的属性

假如想调用外部类的属性则需要，(外部类名)Outer.this.name(属性名)

成员内部类不能定义static(静态)成员，但是可以包含static final(静态常量)

2. 静态内部类

1. 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
2. 不能直接调用外部类属性。
3. 静态内部类可包含静态属性。

外部类：

package com.exception;

public class OuterDemo2 {
    private String name = "xxx";
    private int age = 18;

    // 静态内部类: 级别和外部类相同
    static class Inner{
        private String address = "shenzhen";
        private String phone = "111";

        // 静态内部类可以包含静态成员
        private static int count = 1000;
        public void show(){
            System.out.println(address);
            System.out.println(phone);

            // 访问内部类静态属性
            System.out.println(Inner.count);
            // 不能直接调用外部类属性

            // 访问外部类属性
            // 1.创建
            OuterDemo2 outer = new OuterDemo2();
            // 2.调用
            System.out.println(outer.name);
            System.out.println(outer.age);

        }
    }
}

调用：

package com.exception;

public class TestOuter {
    public static void main(String[] args) {
        OuterDemo2.Inner inner = new OuterDemo2.Inner();
        // 调用方法
        inner.show();
    }
}

3. 局部内部类

1. 定义在外部类的方法当中，作用范围和创建对象范围仅限于当前方法。
2. 局部内部类不能加任何访问修饰符。
3. 局部内部类想访问方法的变量的时候，这个变量必须是常量。

内部类：

package com.exception;

public class OuterDemo3 {
    private String name="pengyuyan";
    private int age = 32;
    public void show(){
        //定于局部变量
        final String address = "shenzhen";

        // 局部内部类: 注意不能加任何访问修饰符。
        class Inner{
            // 局部内部类属性
            private String phone ="1345";
            private String email = "pengyuyan@qq.com";
            public void show2(){

                // 访问外部类属性
                System.out.println(OuterDemo3.this.name);
                System.out.println(OuterDemo3.this.age);

                // 访问内部类
                System.out.println(this.phone);
                System.out.println(this.email);

                // 访问方法属性,jdk1.7要求 变量必须时常量,jdk1.8省略 会自动添加
                System.out.println(address);
            }
        }

        // 创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

调用：

package com.exception;

public class TestOuter {
    public static void main(String[] args) {
        OuterDemo3 outerDemo3 = new OuterDemo3();
        outerDemo3.show();
    }
}

4. 匿名内部类

1. 没有类名的局部内部类（一切特征都和局部内部类相同）
2. 必须继承一个父类或者实现一个接口。
3. 定义类、实现类、创建对象的语法合并，只能创建一个该类对象。

优点：减少代码量。
缺点：可读性差。

package com.exception;

public class TestOuter {
    public static void main(String[] args) {
        // 创建接口类型duix
//        USB usb = new Mouse();
//        usb.service();

        // 局部内部类
//        class Fan implements USB{
//            @Override
//            public void service() {
//                System.out.println("链接电脑成功，风扇开始工作了");
//            }
//        }

        // 使用局部内部类创建对象
//        USB usb = new Fan();
//        usb.service();

        // 匿名内部类


        USB usb = new USB() {
            @Override
            public void service() {
                System.out.println("你好我是匿名内部类");
            }
        };
        usb.service();
    }
}