内部类

内部类
概述
藏在类里的类. 内部类只为外部类服务.
内部类,可以看做是外部类的一个特殊的成员,,,和普通成员是同级的
2,特点
内部类想用外部类的资源,直接用
外部类想用内部类的资源,创建对象用

public class Test5_Inner {
    public static void main(String[] args) {
        //TODO 使用内部类的资源--创建内部类的对象
        //外部类名.内部类名 变量名=外部类对象.内部类对象
        Outer.Inner oi = new Outer().new Inner();
        oi.in();//使用内部类的资源

        new Outer().out();//通过匿名对象调用out()
    }
}
class Outer{//外部类
    String name;
    //TODO 1, 外部类想用内部类的资源?? --创建内部类对象来访问
    public void out(){
        new Inner().in();
    }

    class Inner{//内部类
        //TODO 2, 内部类使用外部类的资源?? --直接用
        public void in(){
            System.out.println(name);
        }
    }
}

1,模拟框架执行注解方法
import java.lang.reflect.Method;
//反射  注解方法
public class Test4 {
    public static void main(String[] args) throws Exception {
        Class c = Hello.class;
        //获取所有方法
        Method[] ms = c.getDeclaredMethods();
        Object oo = c.newInstance();
        //遍历数组,获取每个方法m
        for (Method m : ms) {
            //!!! 获取方法上面的注解--参数是注解类型的Class对象
            Deprecated d = m.getAnnotation(Deprecated.class);
            //判断谁有注解 就运行谁
            if(d != null){
                m.invoke(oo);
            }
        }
    }
}
class Hello{
    @Deprecated
    public void test(){
        System.out.println("test...");
    }
    public void show(){
        System.out.println("show...");
    }
}

匿名内部类
概述：通常使用 局部内部类 + 匿名对象完成

测试：匿名内部类--匿名对象+局部内部类
好处: 优化程序的继承结构

public class C1 {
    public static void main(String[] args) {
        //TODO 1, 直接创建接口对象--这个匿名对象没名字,一次只能执行一个任务
        new A(){
            //匿名内部类--直接创建接口的对象,并在匿名内部类里重写抽象方法
            @Override
            public void save() {
                System.out.println("数据增加成功");
            }
        }.save();//调用指定的方法

        //jdk1.8提供的lambda表达式
        A a = ()->{ System.out.println("数据增加成功");} ;
        a.save();

        //TODO 2, 直接创建接口对象--b是这个对象的名字,可以用b执行好几个任务
        B b = new B(){
            //匿名内部类--直接创建接口的对象,并在匿名内部类里重写抽象方法
            @Override
            public void save() {
                System.out.println("save");
            }
            @Override
            public void delete() {
                System.out.println("delete");
            }
        };
        b.save();
        b.delete();
        //TODO 3, 直接创建抽象类对象--需要重写所有抽象方法,至于普通方法想改才重写
        new C(){
            @Override
            public void save(){
                System.out.println("save..");
            }
        }.save();
    }
}
abstract class C{
    //抽象类里的方法可以是普通的或者是抽象的
    public abstract void save();
    public void get(){
        System.out.println("get");
    }
}
interface B{
    void save();//public abstract void save();
    void delete();
}
interface A{
    void save();//public abstract void save();
}
////2, 使用接口
//class B implements A{
//    //3,实现了接口后,需要重写接口里的 所有抽象方法,否则是一个抽象类
//    @Override
//    public void save() {
//        System.out.println("save");
//    }
//}