java内部类

什么叫内部类？

将一个类定义在另一个类里面或者一个方法里面，称为内部类
一般包含这几种：成员内部类、局部内部类、匿名内部类、静态内部类

1、成员内部类

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

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

这个Draw就是成员内部类，可以访问外部类的所有成员属性和成员方法，包括private和静态成员
成员内部类可以无条件访问外部类的成员，但外部类想访问成员内部类的成员就有限制 需要先创建一个成员内部类的对象 再通过对这个对象的引用来访问了

public class Circle {
    private double radius = 0;

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

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

    class Draw {
        public void drawSahpe() {
            System.out.println(radius);
        }
    }
}

2、局部内部类

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

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

3、匿名内部类

没有名字的内部类
举例，如果我们要实现一个简单的继承，本来应该这样写

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

如果child只使用一次 就显得很浪费 使用匿名内部类简化代码：

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

在接口上使用匿名内部类

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

Thread类的匿名内部类实现

public class CreatingThread03 {
    public static void main(String[] args) {
        // Thread匿名类，重写Thread的run()方法
        new Thread() {
            @Override
            public void run() {
                System.out.println(getName() + " is running");
            }
        }.start();

        // Runnable匿名类，实现其run()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running");
            }
        }).start();
        
        // 同上，使用lambda表达式函数式编程
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + " is running");
        }).start();
    }
}

4、静态内部类

静态内部类用static来修饰，不依赖于外部类，甚至在java虚拟机中比外部类先生成，所以也不能使用泛型

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