JAVA学习——Java中的内部类

内部类的定义：

如果一个事务的内部包含另一个事务，那么这就是一个类内部包含另一个类：
例如：身体和心脏的关系，汽车和发动机的关系

1. 成员内部类

成员内部类的定义格式：

修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        // ...
    }
    // ...
}

注意：内用外，随便用，外用内，需要创建内部类对象

使用成员内部类的两种方式：

1. 间接方式：在外部类的方法当中，使用内部类；然后main方法只是调用外部类的方法
2. 直接方式,公式：
   外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
3. 可以在外部类外面实例一个外部类对象，然后使用外部类对象.内部类对象.内部成员变量/内部成员方法
   示例代码：

public class Body { // 外部类

    public class InClass { //成员内部类

        public void methodIn(){
            System.out.println ("内部类的方法");
            System.out.println ("外部类的成员变量" + num);
        }
    }

    private int num;
    InClass in = new InClass ();// 创建一个内部类对象

    public void methodOut(){
        System.out.println ("外部类的方法");
        InClass inClass = new InClass ();
        inClass.methodIn ();
    }
}

实现类：

public class Demo1InnerClass {

    public static void main(String[] args) {
        Body body = new Body ();
        body.methodOut ();
        System.out.println ("======================");
        Body.InClass inClass = new Body ().new InClass();//创建内部类对象
        inClass.methodIn ();//调用内部类方法
        System.out.println ("=======================");
		//在外部类外面实例一个外部类对象，
		//然后使用外部类对象.内部类对象.内部成员变量/内部成员方法
        body.in.methodIn ();
    }
}

如果出现了重名现象，那么格式是：外部类名称.this.外部成员变量

public class Outer {

    int num = 10; // 外部类的成员变量

    public class Inner {
        int num = 20; // 内部类的成员变量

        public void printNum(int num) {
            System.out.println (num); //内部类的局部变量
            System.out.println (this.num); // 内部类的成员变量
            System.out.println (Outer.this.num); //外部类的成员变量
        }
    }
}

2. 局部内部类（包含匿名内部类）

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，方法外面不能使用。

定义格式：

修饰符 class 外部类名称{
    修饰符 返回值类型 方法名称(参数列表) {
        class 局部类名称{
            //...
        }
    }
}

局部内部类如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】

备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：

1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走的，在栈内存当中。
3. 方法运行结束之后，会立刻出栈，局部变量会跟着消失。
4. new出来的对象会在堆当中持续存在，直到垃圾回收消失。
   示例代码：

public class Outer {

    public void methodOuter(){
        int num = 20;
        class Inner{
            public void printNum(){
                System.out.println (num);
                System.out.println ();
            }
        }
        Inner inner = new Inner ();
        inner.printNum ();
    }
}

匿名内部类：
如果接口的实现类（或者定义类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：

接口名称 对象名 = new 接口名称() {
    // 覆盖重写所有抽象方法
}

代码注解：

1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {…}是匿名内部类的内容

注意：

1. 匿名内部类：在【创建对象】的时候，只能使用唯一一次。
   如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的类。
2. 匿名对象：在【调用方法】的时候，只能调用唯一的一次。
   如果希望同一个对象，调用多次方法，那么必须给对象起名字。
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
   强调：匿名内部类和匿名对象是两回事

public class DemoMain {

    public static void main(String[] args) {

        // 使用匿名内部类，但不是匿名对象，对象名称叫obj
        MyInterface obj = new MyInterface () {
            @Override
            public void methodA() {
                System.out.println ("匿名内部类实现了方法A");
            }

            @Override
            public void methodB() {
                System.out.println ("匿名内部类实现了方法B");
            }
        };

        obj.methodA ();
        obj.methodB ();

        // 使用了匿名内部类，而且省略了对象名称，也是匿名对象。

        new MyInterface (){

            @Override
            public void methodA() {
                System.out.println ("匿名内部类实现了方法B-----222");
            }

            @Override
            public void methodB() {
                System.out.println ("匿名内部类实现了方法B-----222");
            }
        }.methodA ();
    }
}

类作为成员变量类型

public class Hero {

    private String name;

    private Weapon weapon; //装备类

    private Skill skill; //技能接口

    public Hero() {
    }

    public Hero(String name, Weapon code,Skill skill) {//传进的是类或几口的地址值
        this.name = name;
        this.weapon = code;
        this.skill = skill;
    }

    public void attract(){
        System.out.println (name + "正在使用" + weapon.getCode () + "攻击敌方"+"开始释放技能");
        skill.heroSkill ();
        System.out.println ("技能释放完毕");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}