WGL的day10

内部类

成员内部类

把一个类定义在一个类中作为一个成员

静态内部类

static 类

局部内部类

把一个类定义方法内部

匿名内部类

没有名字的类,接口,抽象类中使用较多

什么是内部类

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

  class Body{           //外部类
      class Head {
                 //内部类
      }
  }
  //生成Body.class和Body$Head.class文件
  

  • 特点:
    • 编译之后可生成独立的字节码文件
    • 内部类可直接访问外部类的私有成员,而不破坏封装

成员内部类

• 在类的内部定义, 与实例变量,实例方法同级的类
• 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象

package Class;

import org.w3c.dom.ls.LSOutput;

import javax.swing.*;

public class People {
    //实例变量
    private String name = "张三";
    private int age = 20;
    //内部类
    class Inner{                        
        
        private String name = "李四";     //名字相同,优先访问内部类**
        
        private String address = "北京";
        private String phone = "10086";
        public void show () {
                //打印外部类中的属性
                System.out.println(name); //优先访问内部类**
            
             //名字相同,访问外部类的name,外部类名+this
             System.out.println(People.this.name);
            
                System.out.println(age);
                //打印内部类中的属性
                System.out.println(address);
                System.out.println(phone);

            }

    }

}



package Class;

public class Test {

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

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

        inner.show();
    }
}

• 在类的内部定义, 与实例变量,实例方法同级别的类
• 成员内部类中不能定义静态成员,可以包含静态常量–final
• 外部类的一个实例部分,创建内部类的对象时.必须依赖外部类对象

Outer out = new Outer();
Inner in = out.new Inner();

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

静态内部类

• 不依赖外部类对象,可以直接创建或通过类名访问,可声明静态成员
• 只能直接访问外部类的静态成员(实例成员需实例化外部对象)
• Outer.Inner inner = new Outer.Inner();
• Outer.Inner.show();

package Class1;

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


    //静态内部类,和外部类相同
    static class Inner{
        private String address = "上海";
        private String phone = "110";
        //也可定义静态成员
        private static int count = 10000;

        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(Inner.count);

        }
    }
}

//==========================================

package Class1;

public class Test {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner= new Outer.Inner();
        //调用方法
        inner.show();
    }
}

局部内部类

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

package Class3;

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

    public void show(){
        //定义局部变量
        final String address = "深圳"; //jdk1.8后final可省略

        //局部内部类,不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "888";
            private String email = "@";

            public void show2(){
                //访问外部类的name
                System.out.println(name);
                //静态方法的话System.out.println(Outer.this.name);
                //访问内部类属性
                System.out.println(this.phone);
                System.out.println(this.email);
                //访问局部对象
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
    
    
   //=============================================================
    
    
package Class3;

import jdk.internal.org.objectweb.asm.tree.InnerClassNode;

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

匿名内部类

• 没有类名的局部内部类( 一切特征都与局部内部类相同 )

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

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

• 优点:减少代码量

• 缺点:可读性差

  //=========================定义接口
  package Class4_1;
  
  public interface USB {
      //在接口中定义一个服务方法
      void service();
  
  }
  //========================================================
  
  package Class4_1;
  
  public class Mouse implements USB{  //Mouse类可实现USB接口
      //重写接口方法
      @Override
      public void service() {
  
          System.out.println("连接电脑成功,鼠标开始工作...");
      }
  }
  
  //=========================================================
  
  package Class4_1;
  
  public class Test {
      public static void main(String[] args) {
          //创建接口类型的变量
          USB usb = new Mouse();  //Mouse是实现类,多态
          usb.service();
  
          //局部内部类
          class Fan implements USB{
  
              @Override
              public void service() {
                  System.out.println("连接成功,风扇转起来了~~~");
  
              }
          }
          //使用局部内部类创建对象
          USB fan = new Fan();
          fan.service();
  
  
          //使用匿名内部类来优化.可多次使用
          USB no = new USB() {
              @Override
              public void service() {
                  System.out.println("匿名内部类连接成功");
  
              }
          };
          no.service();
      }
  }