java继承与多态（6）引用类型用法总结

1 class作为成员变量

1. 1、2步骤创建weapon对象，并构造赋值保存在Weapon类的成员变量code中
2. 3、4 将此weapon对象传给hero中Weapon类的weapon变量，此时hero中的weapon就保存了DemoMain所构造的code值
3. 5步骤，得以实现weapon.getCode()

2 接口作为成员变量

Hero类，放Hero名和技能名skill

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;
    }
}

skill接口，里面放抽象方法，便于重写

public interface Skill {

    void use();
}

主类中先新建hero对象

    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");

2.1 单独定义实现类

实现类

public class SkillImpl implements Skill{
    @Override
        public void use() {
        System.out.println("q技能");
    }
}

    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");
        
        hero.setSkill(new SkillImpl());
        hero.attack();

2.2 使用匿名内部类

        // 使用匿名内部类
        Skill skill = new Skill() {
            @Override
            public void use() {
                System.out.println("使用匿名内部类：q技能");
            }
        };
        hero.setSkill(skill);
        hero.attack();

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

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

结果

我叫艾希开始释放技能：
q技能
释放技能完成
我叫艾希开始释放技能：
使用匿名内部类：q技能
释放技能完成
我叫艾希开始释放技能：
同时使用匿名内部类和匿名对象：q技能
释放技能完成

3 接口作为方法的参数或者其返回值

import java.util.ArrayList;
import java.util.List;

public class DemoInterface {

    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;
    }
}

注意： java.util.List是ArrayList所实现的接口，
List<String> list = new ArrayList<>();=ArrayList<String> list = new ArrayList<>();
左边List是实现类，右边ArrayList是接口类，这就是多态