简单的认识什么是内部类

简单了解什么是内部类

匿名内部类（最为重要）

• 如果接口的实现类（或者说父类的子类）只需要使用唯一的一次，那么就可以省略掉该类的定义，而该为使用【匿名内部类】
• 格式： 接口名称 对象名 = new 接口名称（）
  {
  //覆盖重写所有的抽象方法
  }

package 匿名内部类;

public interface MyInterface {
    public abstract void method();
}


//分割线

package 匿名内部类;

public class DemoMain {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface(){
            @Override
            public void method() {
                System.out.println("匿名方法");
            }
        };
        obj.method();
    }
}

注意事项

1. 匿名内部类的，在创建对象的时候，只使用唯一的一次。
2. 匿名内部类是省略了（实现类/子类），匿名对象省略了对象名。

成员内部类

• 成员内部类属于内部类里最普通的那个类，位置放在一个类的内部。

格式：

 修饰符 class 外部类名称{
          修饰符  class 内部类名称{
                //......
           }    
 }

如何使用成员内部类：

1. 间接：在外部的方法中，使用内部类，main只是调用外部类的方法。
2. 直接：
   格式–
   外部类名称.内部类名称 对象名 = new 外部类().new 内部类()

//外部内部类
public class Body{

      public class Heart{//成员内部类
         public void beat(){
         sout("心跳");
         }
  } 
public void methodBody(){
   sout("外部类方法");
   new Heart().beat();//间接调用
}    
}



//main方法
 public class main{
    psvm(){
     Body body = new Body();//外部类的对象
     body.methodBody();//通过外部类对象的方法间接调用内部类的Heart
     
     Body.Heart heart = new Body().new Heart();
     heart.beat();//直接调用
    }
 }

注意

• 内部类的同名变量名访问，如果出现了重名的现象，那么格式就会是：
  外部类名称.this.外部类成员变量名；

局部内部类

• 如果一个类定义在一个方法的内部–局部内部类。
• “局部”：只有当前所属的方法才能使用它，出了这个方法就使用不了

 格式：修饰符 class 外部内部类 {
           修饰符 返回值  外部内方法(参数){
                        class 内部类名称{
                                 //......
                                 }
                        }
           }
实例代码
public class LocationInner {
    private String outClassVar = "hello我是外部类的变量";

    // 定义一个外部类的方法
    public void outMethod() {
        final String inMethodVar = "hello我是方法中的局部变量"; // 定义局部变量

        // 定义内部父类
        class InnerBase {
            String baseVar = "内部父类InnerBase的变量";
        }

        // 定义内部子类
        class SubClass extends InnerBase { // 在方法中定义内部类
            public String subVar = "内部子类SubClass的变量";

            public void printInfo() {
                System.out.println("内部子类方法访问所在方法的所在类的信息：" + outClassVar);
                System.out.println("内部子类方法访问所在方法的局部变量：" + inMethodVar);
                System.out.println("内部子类方法访问父类的变量：" + baseVar);
                System.out.println("内部子类方法访问自己的变量：" + subVar);
                outClassVar = "新值"; // 允许修改所在外部类的变量。
                // inMethodVar = "新值"; //会报错，不可以修改所在方法的局部变量
            }
        }

        //subVar = "新值"; //会报错，方法中不能访问局部内部类的信息
        // 通过内部类对象来访问内部类的成员
        SubClass inner = new SubClass();
        System.out.println("方法中访问内部类变量：" + inner.baseVar);
        System.out.println("方法中访问内部类变量：" + inner.subVar);
        inner.printInfo();

    }
}
 // main类
public class Test {
    public static void main(String[] args) {
        LocationInner out = new LocationInner();
        out.outMethod();
    }
}

（内部类修饰符）注意事项：

1. 外部类：public/default；
2. 成员内部类：四个都可以写；
3. 局部内部类：什么都不写；
4. 如果局部内部类希望访问到所在方法的局部变量，那么这个局部变量必须是【有效final】