内部类

非静态内部类
非静态内部类 BattleScore “战斗成绩”
非静态内部类可以直接在一个类里面定义

比如：
战斗成绩只有在一个英雄对象存在的时候才有意义
所以实例化BattleScore 的时候，必须建立在一个存在的英雄的基础上
语法: new 外部类().new 内部类()
作为Hero的非静态内部类，是可以直接访问外部类的private实例属性name的。

package unstatic;

public class Hero {
    String name;
    float hp;

    class BattleScore{
        int kill;
        int die;
        int assist;

        public void legendary(){
            if(kill>8)
                System.out.println(name+"怪厉害");
            else
                System.out.println(name+"不太行");
        }


    }

    public static void main(String[] args) {
        Hero h=new Hero();
        h.name="哈哈哈";
        BattleScore b=h.new BattleScore();
        b.kill=10;
        b.legendary();


    }

}

总结：非静态内部类的存在，是只有外部类实例对象存在才有实际意义。而当你想访问内部类的时候，必须遵循内部类类名 内部类对象名=外部类对象名.new 内部类类名();

静态内部类
在一个类里面声明一个静态内部类
比如敌方水晶，当敌方水晶没有血的时候，己方所有英雄都取得胜利，而不只是某一个具体的英雄取得胜利。
与非静态内部类不同，静态内部类水晶类的实例化 不需要一个外部类的实例为基础，可以直接实例化
语法：new 外部类.静态内部类();
因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法
静态内部类实例化的时候不需要外部类的实例化。
除了可以访问外部类的私有静态成员外，静态内部类和普通类没什么大的区别

package abstractexercise;

public class Hero2 {
    public String name;
    protected float hp;

    private static  void battleWin(){
        System.out.println("赢了");
    }
    //敌方的水晶
    static class EnemyCrystal{
        int hp=0;

        //如果水晶的血量为0，则胜利
        public void checkIfVictory(){
            if(hp==0){
                Hero2.battleWin();
               

            }

        }
    }

    public static void main(String[] args) {
        //实例化静态内部类
        Hero2.EnemyCrystal crystal=new Hero2.EnemyCrystal();
        crystal.checkIfVictory();
    }

}

注意：静态内部类不能直接访问外部类的对象属性。
在内部类里面输出外部类的name属性会报错。
实例化静态内部类的格式：外部类名.静态内部类名 静态内部对象名=new 外部类名.静态内部类名();

匿名类
匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精练
通常情况下，要使用一个接口或者抽象类，都必须创建一个子类

有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。
既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。
这样的类，叫做匿名类

package niminglei;

public abstract class Hero {
    String name;
    float hp;
    float armor;
    int moveSpeed;

    public abstract void  attack();

    public static void main(String[] args) {
        ADHero adh=new ADHero();
        //通过打印adh，可以看到adh这个对象属于ADHero类
       
        System.out.println(adh);

        Hero h=new Hero() {
            @Override
            public void attack() {

            }
        };
        h.attack();
        System.out.println(h);
    }
}

关于内部类与匿名类声明位置：
内部类：非静态内部类、静态内部类、匿名类、本地类。
a)内部类(定义在一个类内部)：
1.静态内部类定义在类中，任何方法外，用static定义，静态内部类中可以定义静态或者非静态的成员。
2.匿名内部类是一种特殊的局部内部类，它是通过匿名类实现的。
3.内部类仍然是一个独立的类，在编译后内部类会被编译成独立的.class文件，只是在前面加上外部类的类名和$符号。
4.内部类是外部类的一个成员，内部类不能用普通的方式访问，内部类可以自由访问外部类的成员变量，无论是否是private的。
5.内部类的this引用：内部类中同样使用this.成员变量，如要使用外部类的成员变量，则使用外部类名.this.成员变量。

本地类可以理解为有名字的匿名类
内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。
本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for循环里等等地方

package niminglei;

public abstract class Hero1 {
    String name;
    float hp;
    float armor;
    int moveSpeed;

    public abstract void  attack();
    public static void main(String[] args) {



        //通过打印adh，可以看到adh这个对象属于ADHero类

        //System.out.println(adh);

     class h extends  Hero1{
         public void attack(){
             System.out.println("攻击");
         }
     }



        h h1=new h();
     h1.attack();
}
}

在匿名类中使用外部的局部变量
在匿名类中使用外部的局部变量，外部的局部变量必须修饰为final

为什么要声明为final，其机制比较复杂，请参考第二个Hero代码中的解释

注：在jdk8中，已经不需要强制修饰成final了，如果没有写final，不会报错，因为编译器偷偷的帮你加上了看不见的final

package outclassvariable;

public abstract class Hero1 {
    public abstract  void attack();

    public static void main(String[] args) {
        //在匿名内部类中使用外部的局部变量
        int damage=3;

        //这里使用本地类BigHero来模拟匿名类的隐藏属性机制

        //事实上的匿名类，会在匿名类里声明一个damage属性，并且使用构造方法初始化该属性的值
        //在attack中使用的damage，真正使用的是这个内部damage，而非外部damage

        //假设外部属性不需要声明为final
        //那么在attack中修改damage的值，就会被暗示为修改了外部变量damage的值

        //但是他们俩是不同的变量，是不可能修改外部变量damage的
        //所以为了避免产生误导，外部的damage必须声明为final,"看上去"就不能修改了
        class  BigHero extends Hero1{
            int damage;

            public BigHero(int damage) {
                this.damage = damage;
            }

            @Override
            public void attack() {
                damage=20;
                System.out.println("上涨攻击值");

            }
        }
        Hero1 h=new BigHero(damage);


    }
}

匿名类是使用在实例化某个类型的对象时（自身没有类名，超类一般为抽象方法或接口），实现某个对象的位置肯定在某个类里面（java万物皆类），匿名类的代码块里面可以定义变量，方法，具备类的特征。所以匿名类是属于内部类的.