26. [uso] Tipo de referência

esboço

O desenvolvimento real, tipo de referência de uso é muito importante, mas também muito popular. Podemos entender o tipo básico de uso em outras referências ao tipo de mestre de uso.

tipos básicos pode ser usado como uma variável de membro como um método parâmetro, como o valor de retorno do método, é claro, um tipo de referência também é possível.

Classe como uma variável membro

classe personagem do jogo

Ao definir um papel de classe (personagem do jogo), como segue:

package test.demo09;
// 英雄
public class Role {
    int id; // 角色ID
    int blood; // 生命值
    String name; // 角色名称
}

Use inttipo representa id caráter e valor da vida, o uso de Stringtipo representa o nome. Neste momento, stringé em si um tipo de referência, semelhante ao constante usado por causa da maneira, por isso muitas vezes é negligenciado tipo de referência existe.

Se continuar a enriquecer esta definição de classe, para Roleaumentar a armas, equipamentos e outros desgaste propriedade, como nós escrevê-lo?

classe armas

A definição de classe de arma que irá aumentar a capacidade de ataque:

package test.demo09;
// 武器
public class Weapon {
    String name; // 武器名称
    int hurt; // 伤害值
    
	// 省略构造器和get/set
}

Classe de armadura

Definido classe de armadura desgaste, vai aumentar a capacidade de defesa, ou seja, para aumentar o valor da vida:

package test.demo09;
// 护甲
public class Armor {
    String name; // 护甲名称
    int protect; // 防御值

    // 省略构造器和get/set
}

implementação de código

O papel da classe

package test.demo09;
// 英雄
public class Role {
    int id; // 角色ID
    int blood; // 生命值
    String name; // 角色名称

    // 添加武器属性
    Weapon weapon;
    // 添加护甲属性
    Armor armor;

    // 提供get/set方法
    public Weapon getWeapon() {
        return weapon;
    }

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

    public Armor getArmor() {
        return armor;
    }

    public void setArmor(Armor armor) {
        this.armor = armor;
    }

    // 攻击方法
    public void attack() {
        System.out.println("Role使用"+ weapon.getName() +",造成"
                           + weapon.getHurt() +"点伤害");
    }
    // 穿戴护甲
    public void wear() {
        // 增加防御,就是增加blood值
        this.blood += armor.getProtect();
        System.out.println("穿上"+ armor.getName() +",生命值增加"
                           + armor.getProtect());
    }
}

categoria de teste

package test.demo09;

public class DemoMain {
    public static void main(String[] args) {
        // 创建Weapom对象
        Weapon w = new Weapon("AK-47",79);
        // 创建Armor对象
        Armor a = new Armor("防弹背心",35);
        // 创建Role对象
        Role r = new Role();

        // 设置武器属性
        r.setWeapon(w);
        // 设置护甲属性
        r.setArmor(a);

        // 攻击
        r.attack();
        // 穿戴护甲
        r.wear();
    }
}

resultados:

Role使用AK-47,造成79点伤害
穿上防弹背心,生命值增加35

Interface como uma variável membro

A interface é um método de embalagem para o jogo correspondente, as capacidades podem ser vistos como extensões de caracteres de jogo. Então, se você quer expandir as habilidades mais poderosas, que RoleRolepodem aumentar a interface como uma variável de membro, um conjunto diferente de habilidades.

interface

• Nós usamos uma interface como uma variável de membro para mudar a qualquer habilidade, este projeto é mais flexível, melhorando a escalabilidade do programa.

• Quando a interface como uma variável de membro, é operação de atribuição, de fato, um objeto de subclasse é atribuído à interface.

Abstratos métodos definem as habilidades de interface e de libertação

public interface Skill {

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

O papel da classe

public class Hero {

    private String name; // 英雄名称
    private Skill skill; // 英雄技能

    public void attack() {
        System.out.println("我叫" + name + ",开始释放技能");
//        new SkillImpl().use();
        skill.use(); // 调用接口中的抽象方法
        System.out.println("技能释放完毕");
    }

	// 省略构造器和get/set
}

categoria de teste

// 使用接口Skill接口作为成员变量类型
public class DemoGame {

    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("夜玫瑰");

        // 1. 使用单独定义的实现类
        hero.setSkill(new SkillImpl());
        hero.attack();
        System.out.println("=================");

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

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

        hero.attack();
    }
}

resultados:

我叫夜玫瑰,开始释放技能
Biu~ Biu~ Biu~
技能释放完毕
=================
我叫夜玫瑰,开始释放技能
pia~ pia~ pia~
技能释放完毕
=================
我叫夜玫瑰,开始释放技能
tu~ tu~ tu~
技能释放完毕

Uma interface como parâmetro e valor de retorno do método

• Interface como um parâmetro, passando o objeto de subclasse.

• Tipo de interface como o valor de retorno, para retornar ao seu objeto de subclasse.

Código demonstra:

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

/*
    接口作为方法的参数和返回值
		java.util.List正是ArrayList所实现的接口
 */
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));
        }
    }
    // List<String> list:进来的时候是空集合
    public static List<String> addNames(List<String> list) { 
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马尔扎哈");
        return list;
    }
}

resultados:

迪丽热巴
古力娜扎
马尔扎哈

FIM