【内部类&匿名内部类&反射&Lambda&Stream流的使用】

一、内部类和匿名内部类

匿名内内部类和lambda表达式主要的区别在于
1、匿名内部类他必须实现继承类的所有方法
2、匿名内部类在重写时有override标识，而lambda没有
3、lambda表达式继承的接口只能有一个抽象方法

在使用匿名内部类的过程中，我们需要注意如下几点：

• 1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
• 2、匿名内部类中是不能定义构造函数的。
• 3、匿名内部类中不能存在任何的静态成员变量和静态方法。
• 4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
• 5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

匿名内部类：在类的内部定义了一个新的类

内部类的分类：
静态内部类
实例内部类
局部内部类
实际上使用内部类编写代码，可读性太差

public interface Skill {
   
    void use(); // 释放技能的抽象方法
}

public class SkillImpl implements Skill {
   
    @Override
    public void use() {
   
        System.out.println("Biu~biu~biu~");
    }
}

public class Hero {
   
    private String name; // 英雄的名称
    private Skill skill; // 英雄的技能
    public Hero() {
   
    }
    public Hero(String name, Skill skill) {
   
        this.name = name;
        this.skill = skill;
    }
    public void attack() {
   
        System.out.println("我叫" + name + "，开始施放技能：");
        skill.use(); // 调用接口中的抽象方法
        System.out.println("施放技能完成。");
    }
    public String getName() {
   
        return name;
    }
    public void setName(String name) {
   
        this.name = name;
    }
    public Skill getSkill() {
   
        return skill;
    }
    public void setSkill(Skill skill) {
   
        this.skill = skill;
    }
}

使用匿名对象或者匿名内部类来实现调用

public class DemoGame {
   

    public static void main(String[] args) {
   
        Hero hero = new Hero();
        hero.setName("艾希"); // 设置英雄的名称

        // 设置英雄技能
        hero.setSkill(new SkillImpl()); // 使用单独定义的实现类

        //还可以改成使用匿名内部类
        Skill skill = new Skill() {
   
            @Override
            public void use() {
   
                System.out.println("Pia~pia~pia~");
            }
        };
        hero.setSkill(skill);
}

同时使用匿名内部类和匿名对象

        // 进一步简化，同时使用匿名内部类和匿名对象
        hero.setSkill(new Skill() {
   
            @Override
            public void use() {
   
                System.out.println("Biu~Pia~Biu~Pia~");
            }
        });

        hero.attack();
    }

二、反射

反射的主要原理是通过字符方式去调用相应的常量和方法：eg，把方法名和变量名卸载.properties文件中
        获取Class对象的方式：
            1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
            2. 类名.class：通过类名的属性class获取
            3. 对象.getClass()：getClass()方法在Object类中定义着。

     Class对象功能：
         * 获取功能：
         1. 获取成员变量们
             * Field[] getFields()    获取所有public修饰的成员变量
             * Field getField(String name)  获取指定public修饰的成员变量

             * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
             * Field getDeclaredField(String name)
         2. 获取构造方法们
             * Constructor<?>[] getConstructors()
             * Constructor<T> getConstructor(类<?>... parameterTypes)

             * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
             * Constructor<?>[] getDeclaredConstructors()
         3. 获取成员方法们：
             * Method[] getMethods           获取所有public修饰的方法
             * Method getMethod(String name, 类<?>... parameterTypes)

             * Method[] getDeclaredMethods()
             * Method getDeclaredMethod(String name, 类<?>... parameterTypes)

         4. 获取类名
             * String getName()

1、 获取成员变量们

Person.classs省略。。自己写
getFields()

public static void main(String[] args) throws Exception {
   

        //0.获取Person的Class对象
        Class personClass = Person.class;
        
        //1.Field[] getFields()获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
   
            System.out.println(field);
        }

getField()

        //2.Field getField(String name)
        Field a = personClass.getField("a");
        //获取成员变量a 的值
        Person p = new Person();
        Object value