java内部类

内部类

类的内部再定义一个类

内部类用外部类随便访问，外部类用内部类要new对象

一个Java文件中只能有一个public修饰的类

1. 成员内部类：

   package oop.demo08;
   
   //如果出现重名现象，那么调用格式为  外部类名称.this.外部类成员变量名
   public class Person {
       int a = 10;//外部类成员变量
       public class V{
           int a =20;//内部类成员变量
           public void x(){
               int a = 30;//内部类局部变量
               System.out.println(a);//就近原则
               System.out.println(this.a);//内部类成员变量
               System.out.println(Person.this.a);//外部类成员变量
   
           }
   
       }
       public void v(){//间接调用
           V v = new V();
           v.x();
       }
   }
   class B{//内部类使用
       public static void main(String[] args) {
   //        1.间接方式：在外部类的方法中，使用内部类，然后mian只是调用外部类的方法
           Person person = new Person();//外部类对象
           person.v();//间接使用
   //       2.直接方式：外部类名称.内部类名称 对象名 = new 外部类名称（）.new 内部类名称（）；
            Person.V b= new Person().new V();
            b.x();
       }
   }
   

2. 静态内部类：

   内部类可以访问static，但是static的内部类不能访问非static属性

3. 局部内部类：方法里面写类!

   package oop.demo08;
   //局部内部类:如果希望访问所在方法的局部变量,那么这个局部变量必须是[有效final的]
   public class MyOuter {
       public void method(){
           final int num = 10;//所在方法局部变量
           //只要局部变量事实不变,那么关键字可以省略
           class MyInner{
               public void myInner(){
                   System.out.println(num);
               }
           }
       }
   }
   

   package oop.demo08;
   //如果一个类定义在一个方法内部，那么这就是一个局部内部类
   //"局部":只有当前所属的方法才能调用它,离开这个方法就不能调用
   public class Outer {
      public void meth(){
          class Inner{//局部的什么修饰符都不能有
              int num = 10;
              public void metdh(){
                  System.out.println(num);
              }
          }
          Inner inner = new Inner();
          inner.metdh();
      }
   }
   class DemoMain{//局部使用
       public static void main(String[] args) {
           Outer outer = new Outer();
           outer.meth();
       }
   }
   

4. 匿名内部类：

   package oop.demo08;
   
   /**
    * @author 
    * 解析
    * 1.new 代表创建对象
    * 2.接口名称就是匿名内部类需要实现哪个接口
    * 3.{}里面的才是匿名内部类的内容
    *
    * 注意
    * 1.在创建对象时,只能使用唯一一次.如果要多次使用,那么只能创建实现类
    * 2.匿名对象在调用方法时,只能调用唯一一次,如果希望调用多次,那么必须给对象名
    * 3.匿名内部类和匿名对象不是一回事
    *
    */
   public interface Student {
       public abstract void method();//抽象方法
   
   }
   class MyInter implements Student{
       @Override
       public void method() {
           System.out.println("重写");
       }
   }
   class Demo{
   //    如果接口的实现类(或者是的父类的子类)只需要使用唯一一次,那么这种情况下就可以省略改类的定义,改为使用匿名内部类
       public static void main(String[] args) {
           MyInter i = new MyInter();
           i.method();
   
           Student i1 = new MyInter();//多态:左边也可以是接口
   
   //        匿名内部类格式:接口名 对象名 = new 接口名称(){
   //        里面覆盖重写接口所有方法};
   
   //        匿名内部类:可以省略了中间的实现类
           Student student = new Student() {
               @Override
               public void method() {
                   System.out.println("重写");
               }
           };
           student.method();
   //    这是使用了匿名内部类,而且省略了对象名,也就是匿名对象
           new Student() {
               @Override
               public void method() {
                   System.out.println("重写");
               }
           }.method();
   
       }
   }