Java常用类内部类的学习（day8）

内部类

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

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

内部类的特点：

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

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

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

成员内部类

• 成员内部类是在类的内部定义，与实例变量、实例方法同级别的类。
• 当内部类访问外部类时，可以不受访问控制符的影响，直接访问属性与方法。
• 外部类不能直接使用内部类的成员和方法。可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
• 内部类是外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
• 内部类 对象名 = new 外部类().new 内部类()
  当外部类、内部类存在重名属性时，会优先访问内部类属性。
  引用外部变量或方法：类名.this.变量名、类名.this.方法名()
• 成员内部类不能定义静态成员static（但是可以包含静态常量final static）。

静态内部类

• 创建静态内部类对象不依赖外部类对象，可直接创建内部类 对象名= new 内部类();或通过类名访问，可声明静态成员。
• 静态内部类不能直接访问外部类的非静态成员，但可以通过new 外部类().成员的方式访问。
• 外部类的静态成员与内部类的成员名称相同，可通过类名.静态成员访问外部类的静态成员。
• 只有内部类才可以使用静态修饰，外部类不行。

局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。限制类的使用范围，只能在当前方法中使用。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。不能在方法内部类中创建可变的局部变量，jdk1.8自动添加final。
• 没有访问修饰符，但可以使用final或abstract修饰。
• 可以访问外围类的成员变量。类名.this.变量名
• 局部内部类内不能有静态声明，即不能使用关键字static。
• 在外部类方法中创建局部内部类对象才能调用局部内部类中方法。

匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）。
• 必须继承一个父类或者实现一个接口。但是两者不可兼得，同一时间只能继承一个类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
• 匿名内部类中是不能定义构造函数的。
• 匿名内部类中不能存在任何的静态成员变量和静态方法。
• 匿名内部类为局部内部类（即方法内部类），所以局部内部类的所有限制同样对匿名内部类生效。
• 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
• 当所在的方法的形参需要被内部类里面使用时，该形参必须为final。
  优点：减少代码量。
  缺点：可读性较差。

测试类

public class Text {
    public static void main(String[] args) {
        //调用成员内部类
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.show();

        Outer.Inner inner1 = new Outer().new Inner();
        inner1.show();
        //Inner inner1 = new outer().new Inner();

        //调用静态内部类
        Outer.Inner1 i = new Outer.Inner1();
        i.show1();

        //调用局部内部类
        Outer outer1 = new Outer();
        outer1.add();


        //创建一个接口类型的变量
        Usb usb = new Mouse();
        usb.server();

        //局部内部类
        class Fan implements Usb{
            @Override
            public void server() {
                System.out.println("连接电脑成功，风扇开始工作");
            }
        }
        //使用局部内部类创建对象
        Usb usb1 = new Fan();
        usb1.server();


        //匿名内部类
        //使用匿名内部类优化Fan类(相当于创建一个局部内部类)
        Usb usb2 = new Usb(){
            @Override
            public void server() {
                System.out.println("连接电脑成功，风扇开始工作");
            }
        };
        usb2.server();
    }
}

内部类

public class Outer {
    private String name = "赵磊";

    //成员内部类
      class Inner{
        private int age=10;

        public void show(){
            System.out.println(name);
            System.out.println(age);
        }
    }
    //静态内部类
    static class Inner1{
          private static String name = "李华" ;
          private  boolean  i=false ;
          public void show1(){
              System.out.println(name);
              System.out.println(i);

              System.out.println(new Outer().name);
          }
    }
    public void add(){
        int a =99;
        int b= 88;

          //局部内部类
          class A{
             private String phon="156";

             public void b(){
                 //访问内部类
                 System.out.println(this.phon);
                 //访问外部类
                 System.out.println(Outer.this.name);
                 //访问局部变量
                 System.out.println(a);
             }
          }
          //实例化A类，然后调用
        A a1 = new A();
          a1.b();

    }
}

接口

public interface Usb {
    public void server();
}

接口实现类

public class Mouse implements Usb{
    @Override
    public void server() {
        System.out.println("连接电脑成功，鼠标开始工作");
    }
}