内部类

在java中可以将一个类定义在另一个类或一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

 

1.成员内部类

成员内部类是最普通的内部类，他的定义为位于另一个类的内部

class Circle{
    double radius = 0;

    public Circle(double radius){
        this.radius = radius;
    }
    
    class Draw{ //内部类
        public void drawSahpe(){
            System.out.println("drawshape");
        }
    }
}

这样看起来，类Draw像是Circle的一个成员，Circle称为外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态方法） 

class Circle{

    double radius = 0;
    private static int count = 1;

    public Circle(double radius){
        this.radius = radius;
    }

    class Draw{ //内部类
        public void drawSahpe(){
            System.out.println(radius);
            System.out.println(count);
        }
    }
}

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法的时候，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果咬访问外部类的同名成员，需要以下面的形式进行访问
外部类.this.成员变量
外部类.this.成员方法
虽然成员内部类可以无条件的访问外部类的成员，而外部类向访问成员内部类的成员却不是这么随心所欲了，在外部类中如果想要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问

class Circle{
    double radius = 0;

    public Circle(double radius){
        this.radius = radius;
        /*必须先创建成员内部类的对象再进行访问*/
        getDrawInstance().drawSahpe();
    }

    public Draw getDrawInstance(){
        return new Draw();
    }

    class Draw{ //内部类
        public void drawSahpe(){
            System.out.println(radius);
        }
    }
}

成员内部类是依附外部类而存在的，也就是说如果创建成员内部类的对象，前提是必须存在一个外部类对象，创建成员内部类的方式如下：

public class Test01 {

    public static void main(String[] args) {
        //第一种方式
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();
        
        //第二种方式
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}

class Outter{
    private Inner inner = null;

    public Outter(){

    }

    public Inner getInnerInstance(){
        if (inner == null)
            inner = new Inner();
            return inner;
    }
    class Inner{
        public Inner(){
            
        }
    }
}

内部类可以拥有private访问权限，protected权限，public访问权限及包访问权限，比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，
如果用public修饰，则任何地方都可以访问；如果使用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰

 

2.局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，他和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内

 

class People{
    public People(){

    }
}

class Man{
    public Man() {
    }

    public People getWoman(){
        class Woman extends People{
            int age = 0;
        }
        return new Woman();
    }

}

局部内部类就是像方法里面的一个局部变量一样，是不能有public，protected。private以及static修饰的

 

 

3.静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且他不能使用外部类的非static成员变量或者方法，因为在没有外部类的对象情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象

 

public class Test02 {
    public static void main(String[] args) {
        Outter.Inner inner = new Outter.Inner();
    }

}



class Outter{
    public Outter(){
        
    }
}
static class Inner{
    public Inner(){
        
    }
}

匿名内部类：

匿名内部类其实就是没有名称的内部类

一个接口的实现类作为方法参数传入，而是直接通过匿名内部类的形式传入一个接口类型参数，在你给你内部类中可以直接完成方法的实现

new 父类名（）{

public void method(){

System。out。println（“执行语句”）

}

}