内部类、匿名内部类

1.内部类

概述：把类定义在其他类的内部，这个类就被称为内部类

内部类访问特点

1.内部类可以直接访问外部类成员，包括私有的

2.外部类要访问内部类成员，需先创建对象

public class Outer {
    int num = 10;
    private int a = 100;
    //定义成员内部类
    class Inner {
        int b = 109;
        public void innerShow() {
            System.out.println("内部类的show方法");
        }
        //内部类可以直接访问外部类的成员，包括私有
        public void innerTest(){
            System.out.println(num);
            System.out.println(a);
            outerShow();
            outerTest();
        }
    }
public void outerShow() {
    System.out.println("这是外部类的show方法");
}
private void outerTest() {
    System.out.println("这是外部类的show方法");
}
//外部类，想要访问内部类的成员，得创建内部类的对象
public void method(){
    //创建内部类的对象
    Inner inner = new Inner();
    System.out.println(inner.b);
    inner.innerShow();
}
}
//测试类
public class MyTest {
    public static void main(String[] args) {
        Outer outer = new Outer();
        System.out.println(outer.num);
        outer.outerShow();
        System.out.println("----------------");
        //使用成员内部类的属性和方法
        //创建成员内部类的语法
        Outer.Inner inner=new Outer().new Inner();
        System.out.println(inner.b);
        inner.innerShow();
        System.out.println("---------------");
        outer.method();
    }
}
//输出
10

内部类分类

成员位置:在成员位置定义的类，被称为成员内部类
局部位置:在局部位置定义的类，被称为局部内部类
四、成员内部类

访问格式：外部类名.内部类名变量名 = new 外部类名().new 内部类名();

案例
//定义类
class Body {
//外部类，身体
    private boolean life= true;
    //生命状态
     public class Heart { 
     //内部类，心脏
    public void jump() {
         System.out.println("心脏噗通噗通的跳")
            System.out.println("生命状态" + life); //访问外部类成员变量
        }
    }
}
//访问内部类
public static void main(String[] args) {
    //创建内部类对象
    Body.Heart bh = new Body().new Heart();
    //调用内部类中的方法
    bh.jump();
}

2.成员内部类的修饰符

1.private 为了保证数据的安全性
2.static 为了方便访问数据

注意：静态内部类访问的外部类数据必须用静态修饰，成员方法可以是静态的也可以是非静态的

面试题

class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num); //30
            System.out.println(this.num); //20
            System.out.println(new Outer().num); //10
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }    
}

3、局部内部类

局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

定义格式
class 外部类 {
修饰符返回值类型方法名(参数) {
class 内部类 {
//其他代码
}
}
}
访问方式

在外部类方法中，创建内部类对象，进行访问

案例
public class MyTest {
    public static void main(String[] args) {
        }
}
class Wai {
    int b = 100;//成员变量
    public void show(final int a) {
        //局部变量
        final int num = 10;
        class Nei {
            public void neiShow() {
                //局部内部类，访问外部类的局部变量，局部变量必须加上final修饰，JDK1.8 默认就加上了
                System.out.println(num);
                System.out.println(a);
            }
        }
        //必须在外部类方法中创建内部类对象调用
        Nei n = new Nei();
        n.neiShow();
    }
}
//输出：
10
123

4、匿名内部类

匿名内部类的作用：临时定义某一指定类型的子类，定义后即刻创建刚刚定义的这个子类的对象

格式：

new 父类或接口(){

//进行方法重写

};

案例

public static void main(String[] args) {
    //匿名内部类：是局部内部类的简写
    //匿名内部类，本质上是一个对象，是谁的对象，是实现了该接口或继承了该抽象类的子类对象
    new AA(){
        @Override
        public void show() {
            System.out.println("重写了show方法");
        }
    }.show();
}
}
abstract class AA{
    public abstract void show();
}
//输出：重写了show方法

匿名内部类中this关键字

//要求在控制台输出”HelloWorld”
interface Inter {
    public static final int a = 23 ;
}
public class Test {
    public static void main(String[] args) {
        new Inter() {
            public void show() {
            // 这个this表示的是匿名内部类的这个对象
                System.out.println(this.a);
            }
        }.show();
    }
}//输出：23
匿名内部类面试题interface Inter1 {
    void show();
}
class Outer {
    //补齐代码
    //返回值是一个对象
    public static Inter1 method(){
        Inter1 in = new Inter1() {
            @Override
            public void show() {
                System.out.println("Helloworld");
            }
        };
        return in;
    }
}
class OuterDemo {
    public static void main(String[] args) {
    //链式代码需返回值是一个对象
        Outer.method().show();
    }
}

5、类中定义接口

public class MyTest {
    public static void main(String[] args) {
        //间接方式
        Outer outer = new Outer();
        outer.waiShow();
        //直接方式
    new Outer.Inner() {
        @Override
        public void show() {
            System.out.println("重写了接口中的show方法2");
        }
    }.show();
    Outer.Inner inner= new Outer.Inner() {
        @Override
        public void show() {
            System.out.println("重写了接口中的show方法3");
        }
    };
    inner.show();
}
}
class Outer{
    //成员内部接口
    interface Inner{
        void show();
    }
public void waiShow(){
    new Inner(){
        @Override
        public void show() {
            System.out.println("重写了接口中的show方法1");
        }
    }.show();
}
}
//输出：
重写了接口中的show方法1
重写了接口中的show方法2
重写了接口中的show方法3