Java常用类~内部类

内部类

• 内部类的分类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

• 内部类的定义：

  在一个外部类里再定义一个完整的类，外部类不能用static修饰，只有内部类可以用static修饰。

• 内部类的特点：

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

• 实例：

package CommonClass.nbl.problem1;
// 外部类
public class Outer {
    // 定义一个属性
    private String name = "某某某";

    // 内部类
    class Inner{
        // 定义一个方法：打印外部类的属性
        public void printf(){
            System.out.println(name);
        }
    }
}

package CommonClass.nbl.problem1;
//测试类
public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.printf();
    }
}

1. 成员内部类

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

实例

• package CommonClass.nbl.problem2;
  
  public class TestOuter {
      public static void main(String[] args) {
          // 1.创建外部类对象
          Student student = new Student();
          // 2.创建内部类对象
          Student.ConInfo conInfo=student.new ConInfo();
          // 3.调用内部类对象的方法
          conInfo.printf();
      }
  
  }
  
  // 定义外部类
  class Student{
      // 定义实例变量
      private String name = "张三";
      private int age = 23;
  
      // 定义内部类
      class ConInfo{
          private String name = "李四";
          private String address = "茂名";
          private String CodePhone = "0668";
  
          // 方法
          public void printf(){
              // 打印外部类属性
              System.out.println("打印外部类属性"+Student.this.name);
              System.out.println("打印外部类属性"+age);
              // 打印内部类属性
              System.out.println("打印内部类属性"+name+"\t"+address+"\t"+CodePhone);
          }
      }
  }
  
  

结果

打印外部类属性张三
打印外部类属性23
打印内部类属性李四	茂名	0668

2.静态内部类

• 不依赖外部类对象(相当于外部类)，可直接创建或通过类名访问，可声明静态成员。
• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）

实例

package CommonClass.nbl.problem3;

public class Main {
    public static void main(String[] args) {
        //直接构建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        inner.printf();
    }
}

// 外部类
class Outer{
   // 属性
    private String name = "张三";
    private String phone = "110";

    // 静态内部类（级别与外部类相同）
    static class Inner{
        private String CodePhone = "0668";
        private String address = "茂名";
        // 静态成员
        private static int count = 1000;

        // 方法
        public void  printf(){
            System.out.println("访问外部类的方法");
            //调用外部类属性需要先构建外部类对象
            Outer outer = new Outer();
            System.out.println(outer.name+"\t"+outer.phone);
            System.out.println("访问内部类的方法");
            System.out.println(this.address+"\t"+CodePhone+"\t"+count);
        }
    }

}

结果

访问外部类的方法
张三	110
访问内部类的方法
茂名	0668	1000

3.局部内部类

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

实例

package CommonClass.nbl.problem4;

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

// 外部类
class Outer{
    private String name = "小红";
    public void study(){
        // 定义局部变量
        final String name = "小明";
        // 局部内部类
        class Inner{
            // 局部内部类属性
            private String address = "茂名";
            public void printf(){
                System.out.println(Outer.this.name);
                System.out.println(name);
                System.out.println(this.address);
            }
        }
        // 创建局部内部类对象
        Inner inner = new Inner();
        inner.printf();
    }
}

结果

小红
小明
茂名

4.匿名内部类

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

实例

package CommonClass.nbl.problem5;

public class Main {
    public static void main(String[] args) {
        Usb usb1 = new Mouse();
        usb1.service();

        //局部内部类
        class YeHuo implements Usb{
            @Override
            public void service() {
                System.out.println("串口连接成功，正在通讯中...");
            }
        }

        // 调用局部内部类
        Usb usb2 = new YeHuo();
        usb2.service();

        // 匿名内部类（相当一个局部内部类）
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("舵机连接成功，正在运作中...");
            }
        };
        usb.service();

    }
}

结果

电脑连接成功，已经开始运行...
串口连接成功，正在通讯中...
舵机连接成功，正在运作中...

() {
System.out.println(“舵机连接成功，正在运作中…”);
}
};
usb.service();

}

}

**结果**

```java
电脑连接成功，已经开始运行...
串口连接成功，正在通讯中...
舵机连接成功，正在运作中...