java学习笔记51--内部类

内部类不是在一个java源文件中编写俩个平行的俩个类,而是在一个类的内部再定义另外一个类。
我们可以把外边的类称为外部类,在其内部编写的类称为内部类。
内部类分为四种,成员内部类、静态内部类、局部内部类、匿名内部类

   1)成员内部类(实例内部类、非静态内部类)
       注:成员内部类中不能写静态属性和方法
       public class InstanceOutterClass{
           private String name;
           private static int age;
           public void say(){}
           public static void go(){}

public class InstanceInnerClass{}

}

   2)静态内部类
       注:静态内部类中可以写静态属性和方法
       public class StaticOutterClass{
           private String name;
           private static int num;
           public void say(){}
           public static void go(){}

public static class StaticInnerClass{}
}

   3)局部内部类
       //局部内部类是在一个方法内部声明的一个类
       //局部内部类中可以访问外部类的成员变量及方法
       //局部内部类中如果要访问该内部类所在方法中的局部变量,那么这个局部变量就必须是final修饰的
       public class LocalOutterClass{

           private String name;
           private static int age;
           public void say(){}
           public static void go(){}

public void test(final int j){
final int i = 10;

               class LocalInnerClass{
                   private String name;
                   private int age;

                   public void say(){
                       System.out.println(name);
                       System.out.println(this.name);
                       System.out.println(LocalInnerClass.this.name);

                       System.out.println(LocalOutterClass.this.name);
                       System.out.println(LocalOutterClass.age);

                       LocalOutterClass.this.say();
                       LocalOutterClass.go();

                       System.out.println(i);
                       System.out.println(j);
                   }

}

               LocalInnerClass lic = new LocalInnerClass();
               lic.say();
           }
       }

   4)匿名内部类
       //匿名内部类是最常用的一种内部类
       1)匿名内部类需要依托于其他类或者接口来创建
           如果依托的是类,那么创建出来的匿名内部类就默认是这个类的子类
           如果依托的是接口,那么创建出来的匿名内部类就默认是这个接口的实现类。
       2)匿名内部类的声明必须是在使用new关键字的时候
           匿名内部类的声明及创建对象必须一气呵成,并且之后能反复使用,因为没有名字。
           例如:
               A是一个类(普通类、抽象类都可以)
               依托于A类创建一个匿名内部类对象
               main:

                   A a = new A(){
                       //实现A中的抽象方法
                       //或者重写A中的普通方法
                   };
                   注:这个大括号里面其实就是这个内部类的代码,只不过是声明该内部类的同时就是要new创建了其对象,并且不能反复使用,因为没有名字。

           例如:
               B是一个接口
               依托于B接口创建一个匿名内部类对象
               B b = new B(){
                   //实现B中的抽象方法
               };

       3)匿名内部类除了依托的类或接口之外,不能指定继承或者实现其他类或接口,同时也不能被其他类所继承,因为没有名字。

4)匿名内部中,我们不能写出其构造器,因为没有名字。

5)匿名内部中,除了重写上面的方法外,一般不会再写其他独有的方法,因为从外部不能直接调用到。(间接是调用到的)

       public interface Work{
           void doWork();
       }
       public class AnonymousOutterClass{
           private String name;
           private static int age;
           public void say(){}
           public static void go(){}

           public void test(){
               final int i = 90;

               Work w = new Work(){
                   public void doWork(){
                       System.out.println(AnonymousOutterClass.this.name);
                       System.out.println(AnonymousOutterClass.age);
                       AnonymousOutterClass.this.say();
                       AnonymousOutterClass.go();

                       System.out.println(i);
                   }
               };
               w.doWork();
           }
       }

java学习笔记51--内部类

猜你喜欢