Java-内部类-匿名内部类

内部类概述和访问特点

概述
把类定义在其他类的内部，这个类就被称为内部类。
访问特点
内部类可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。
位置分类
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。

class B{
    //成员位置：类中方法外
    class A {
       //成员内部类

    }

    public void show(){
        class C{
            //局部内部类
        }
    }

成员内部类

格式

 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
 

成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意事项: a:静态内部类访问的外部类数据必须用静态修饰。
b: 成员方法可以是静态的也可以是非静态的
成员内部类被静态修饰后的访问方式:

外部类名.内部类名 对象名 = new 外部类名.内部类名();

public class MyTest {
    public static void main(String[] args) {
             Outer.Inner inner= new Outer().new Inner();
      inner.neiShow();
      System.out.println(inner.bb);
            Outer outer = new Outer();
        outer.test();
    }
}

class Outer{
    int num=20;
    private int aa=100;
    //定义成员内部类
    class Inner{
        int bb=20;
        public void neiShow(){
            System.out.println("这是内部类的show方法");
            System.out.println(num);
            System.out.println(aa);
            waiShow();
            waiTest();
        }

        public void neiTest(){
            System.out.println("这是内部类的test方法");
        }
    }


    public void waiShow(){
        System.out.println("这是外部类的show方法");
    }

    private void waiTest(){
        System.out.println("这是外部类私有的方法");
    }

    public void test(){
        //创建内部类的对象
        Inner inner = new Inner();
        System.out.println(inner.bb);
        inner.neiTest();
    }
}

局部内部类

访问局部变量
A.可以直接访问外部类的成员
B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
JDK1.8之后，final会默认加上，不用手动去加

public class MyTest2 {
    public static void main(String[] args) {
        Wai wai = new Wai();
        wai.waiShow(400);
    }
}

class Wai {
    int num = 100;

    public void waiShow(final int a) {
        final int bb = 20; //局部变量
        //定义局部内部类
        //当局部内部类，去访问外部类的局部变量，这个局部变量必须加fianl 使这个局部变量成为一个常量
        //JDK1.8 默认就加上了
        class Nei {
            public void neiShow() {
                System.out.println(num);
                System.out.println(bb);
                System.out.println(a);
            }
        }

        Nei nei = new Nei();
        nei.neiShow();
    }
}
~

匿名内部类

匿名内部类:
就是局部内部类的简化写法。
前提：
存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
格式：

 new 类名或者接口名(){
  重写方法;
 } ;
*

本质
是一个继承了该类或者实现了该接口的子类匿名对象。

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

        new AA() {
            @Override
            public void show() {
                System.out.println("重写了抽象类中的show方法222222");
            }
        }.show();


       // set(bb);

    }

    public static void  set(AA aa){
        aa.show();
    }
}

abstract class AA{
    public abstract void show();
}