java中的四种内部类

成员内部类

• 成员内部类作为外部类的成员，能够无条件访问外部类的变量，即使是private的，但是外部类不能直接访问成员内部类中的变量，只能通过创建一个对象的方法去访问。
• 成员内部类在构造之前会先构造外部类

class Outter {
    private int age = 12;
      
    class Inner {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Outter.this.age);
        }
    }
}
  
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        Outter.Inner in = out.new Inner();
        in.print();
    }
}

局部内部类

• 定义在方法中或者一个作用域中的内部类，他的访问权限仅限于他的作用域。
• 局部内部类所在的函数的参数类型只能是final类型的。

class Outter {
 
    private int age = 12;
      
    public void Print(final int x) {    //这里局部变量x必须设置为final类型！
        class Inner {
            public void inPrint() {
                System.out.println(x);
                System.out.println(age);
            }
        }
        new Inner().inPrint();
    }
      
 
}
  
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        out.Print(10);
    }
}

静态嵌套类

• 在内部类的前面加上static
• 这样的内部类相当于是和外部类没有什么关系的，

class Outter {
    private static int age = 12;
    static class Inner {
        public void print() {
            System.out.println(age);
        }
    }
}
  
public class test1 {
    public static void main(String[] args) {
        Outter.Inner in = new Outter.Inner();
        in.print();
    }
}

匿名内部类

public abstract class Bird {  
    private String name;  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
      
    public abstract int fly();  
}  
  
public class Test {  
      
    public void test(Bird bird){  
        System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");  
    }  
      
    public static void main(String[] args) {  
        Test test = new Test();  
        test.test(new Bird() {  
              
            public int fly() {  
                return 10000;  
            }  
              
            public String getName() {  
                return "大雁";  
            }  
        });  
    }  
}  

如上图例子，匿名内部类的父类是一个抽象的类或者接口，而当子类去实现这个父类的时候，new的是这个父类的名字，这个子类的名字根本就没有出现，所以这也是匿名内部类的来由。
在匿名内部类中必须实现抽象的函数，可以重写父类的函数。

public class OutClass {  
    public InnerClass getInnerClass(final int age,final String name){  
        return new InnerClass() {  
            int age_ ;  
            String name_;  
            //构造代码块完成初始化工作  
            {  
                if(0 < age && age < 200){  
                    age_ = age;  
                    name_ = name;  
                }  
            }  
            public String getName() {  
                return name_;  
            }  
              
            public int getAge() {  
                return age_;  
            }  
        };  
    }  

在匿名内部类中虽然没有构造函数，但是可以通过构造代码块完成工作

• 匿名内部类不能有访问修饰符以及static修饰
• 匿名内部类是唯一一种没有构造函数的类，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。
• 匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
• 匿名内部类为局部内部类，几步内部类的所有的约束都对匿名内部类生效。
• 匿名内部类之所以叫匿名内部类是因为他是在你的类的函数中new了一个新的类。