20200805

局部内部类定义

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类

局部：只有当前所属的方法才能使用它，出了这个方法外面就不能用了

定义格式：

修饰符 class 外部类名称 {

           修饰符  返回值类型  外部类方法名称（参数列表）{

                   class  局部类名称{

                                 //......

                      }

             }

}

public class Outer {
    public void methodOuter(){
        class Inner{//局部内部类
            int num = 10;
            public void methodInner(){
                System.out.println(num);//10
            }
        }

        Inner inner = new Inner();
        inner.methodInner();
    }
}

public class Demo01Main {
    public static void main(String[] args) {
        Outer obj = new Outer();
        obj.methodOuter();//10
    }
}

小结：

定义一个类的时候，权限修饰符规则：

1.外部类：public  / (default)

2.成员内部类：public  / protected  / (default) / private

3.局部内部类：什么都不能写

匿名内部类

如果接口的实现类，或者是父类的子类只需要使用唯一的一次

那么这种情况下就可以省略掉该类的定义，而改为使用匿名内部类

匿名内部类的定义格式：

接口名称 对象名  =  new  接口名称（）{

        //覆盖重写所有抽象方法

}；

public interface MyInterface {

    void method();//抽象方法
}

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method() {
        System.out.println("实现类覆盖重写了方法");
    }
}

public class Demo02Main {
    public static void main(String[] args) {
        //MyInterfaceImpl impl = new MyInterfaceImpl();
        //impl.method();//实现类覆盖重写了方法

        //使用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法");
            }
        };
        obj.method();//匿名内部类实现了方法

    }
}

注意事项：

匿名内部类在创建对象的时候，只能使用唯一一次

匿名对象在调用方法的时候，只能调用唯一一次

如果希望同一个对象调用多次方法，那么必须给对象起个名字

匿名内部类是省略了实现类或者子类，但是匿名对象是省略了对象名称

强调：匿名内部类和匿名对象不是一回事！！！

类作为成员变量类型

//游戏当中的英雄角色类
public class Hero {
    private String name;//英雄名字
    private Weapon weapon;//武器
    private int age;//英雄的年龄

    public Hero() {
    }

    public Hero(String name, Weapon weapon, int age) {
        this.name = name;
        this.weapon = weapon;
        this.age = age;
    }

    public void attack(){
        System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方");
    }

    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Weapon {
    private String code;//武器的代号

    public Weapon(String code) {
        this.code = code;
    }

    public Weapon() {
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

public class Demo03Main {
    public static void main(String[] args) {
        //创建一个英雄名字
        Hero hero = new Hero();
        //为英雄起一个名字，并且设置年龄
        hero.setName("盖伦");
        hero.setAge(20);

        //创建一个武器对象
        Weapon weapon = new Weapon("多兰剑");
        //为英雄配备武器
        hero.setWeapon(weapon);

        hero.attack();//年龄为20的盖伦用多兰剑攻击敌方
    }
}

接口作为成员变量类型

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 interface Skill {
    void use();//释放技能的方法
}

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

public class Demo040Game {
    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("Bu~bu~bu");
            //}
        //};
        //hero.setSkill(skill);//艾希开始释放技能：
                            //Bu~bu~bu
                           //释放技能完成

        //进一步简化，同时使用匿名内部类和匿名对象
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Tu~tu~tu");
            }
        });//艾希开始释放技能：
          //Tu~tu~tu
         //释放技能完成

        hero.attack();//艾希开始释放技能：
                     //Biu~biu~biu
                    //释放技能完成
    }
}

接口作为方法的参数和返回值

import java.util.ArrayList;
import java.util.List;
//java.util.List正是ArrayList所实现的接口
public class Demo05Interface {
    public static void main(String[] args) {
        //左边是接口名称，右边是实现类名称，这就是多态写法
        List<String> list = new ArrayList<>();

        List<String> result = addNames(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }

    public static List<String> addNames(List<String> list){
        list.add("艾斯");
        list.add("萨博");
        list.add("路飞");
        list.add("乔巴");
        return list;
    }
}