java内部类

内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YfQs2tp7-1614431226610)(D:\图片\未命名文件.png)]

成员内部类

public class Body {
    class head{
        
    }
}

概念：在一个类的内部再定义一个完整的类，被定义的类作为外部类成员使用

特点：

1. 内部类编译之后会生成独立的字节码

2. 内部类可以直接访问外部内的私有成员

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

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

5. 实例内部类时，必须依赖外部类

   public class Application {
       public static void main(String[] args) {
          Body body=new Body();
          Body.Head head=body.new Head();
          head.show();
       }
   }
   
   

   或

   public class Application {
       public static void main(String[] args) {
          //Body body=new Body();
          //Body.Head head=body.new Head();
          //head.show();
           Body.Head head=new Body().new Head();
           head.show();
       }
   }
   

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

   列：

   public class Body {
       private String name="张三";
       private int age=12;
       class Head{
           private String address="武汉";
           private String name="李四";
           public void show(){
               System.out.println(name);
               System.out.println(age);
               System.out.println(address);
           }
       }
   }
   

   若想访问外部属性需要添加前缀、

   public class Body {
       private String name="张三";
       private int age=12;
       class Head{
           private String address="武汉";
           private String name="李四";
           public void show(){
               System.out.println(Body.this.name);
               System.out.println(age);
               System.out.println(address);
           }
       }
   }
   

7. 成员内部类不能定义静态量，最多只能定义静态常量

   private static final String country="中国";
   

静态内部类

静态内部类使用static修饰，虽然在外部类里面定义，但与外部类同级别，也就是说该类与外部类无依赖关系。

如

public class Demofather {
    private String name="张三";
    private int age=21;
    static class Demoson{
        private String country="中国";
        private int tall=156;
        //静态成员
        private static int phone=11111;
        public void show(){
            //调用外部类的私有属性必须先将外部类实列化
            Demofather demofather=new Demofather();
            System.out.println(demofather.name);
            System.out.println(demofather.age);
            //调用静态类的私有属性
            System.out.println(country);
            System.out.println(tall);
            System.out.println(Demoson.phone);
        }
    }
}

public class Application {
    public static void main(String[] args) {
       //Body body=new Body();
       //Body.Head head=body.new Head();
       //head.show();
        Body.Head head=new Body().new Head();
        head.show();
        Demofather.Demoson demoson=new Demofather.Demoson();//此处Demofather后面没有加括号，表示此处实列化的类是Demoson,
        //Demofather表示Demoson是在Demofather里面的类
        demoson.show();

    }
}

注：只有静态内部类才能使用static修饰，期刊他的类不能使用static修饰。

局部内部类

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

2. 局部内部类访问外部类当前方法中的局部变量时，因为无法保障变量的生命周期与自身相同，变量必须修饰为final。

3. 限制类的使用范围

4. 方法里面的变量不能使用private等修饰

   package chapter01;
   
   public class Outer {
       //局部内部类
       private String name="闻某某";
       private int age=25;
       public void show(){
           String name="女朋友";
           int age1=24;
           class Inner{
               private String address="罗田";
               public void display(){
                   System.out.println(Outer.this.name);
                   System.out.println(Outer.this.age);
                   System.out.println("有一个"+name);
                   System.out.println(age1);
                   //此处访问存放局部内部类方法的私有属性
                   //此处的属性必须是常量
                   //JDK1.7时，要在属性前加final,JDK1.8后默认加了final
                   //因此此处不需要加final
                   System.out.println(address);
               }
           }
           Inner inner=new Inner();
           inner.display();
       }
   }
   

   使用局部内部类实现接口

   package chapter02;
   //接口
   public interface Usb {
       void service();
   }
   
   

   package chapter02;
   
   public class TestRun {
       public static void main(String[] args) {
          /* RunUsb runUsb=new RunUsb();
           runUsb.service();
   
           */
           //局部内部类实现接口
           class Fan implements Usb{
               @Override
               public void service(){
                   System.out.println("USB连接成功，风扇开始工作了......");
               }
           }
           Fan fan=new Fan();
           fan.service();
       }
   }      
   

   匿名内部类

   package chapter02;
   
   import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
   
   public class TestRun {
       public static void main(String[] args) {
          /* RunUsb runUsb=new RunUsb();
           runUsb.service();
   
           */
           //局部内部类实现接口
           /*class Fan implements Usb{
               @Override
               public void service(){
                   System.out.println("USB连接成功，风扇开始工作了......");
               }
           }
           Fan fan=new Fan();
           fan.service();
   
            */
           //创建匿名内部类
           Usb usb=new Usb() {
               @Override
               public void service() {
                   System.out.println("我有一个女朋友");
               }
           };//注意此处要加分号
           usb.service();
   
       }
   }
   
   

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