26. [uso] tipo de referencia

contorno

El desarrollo actual, tipo de referencia de uso es muy importante, pero también muy populares. Podemos entender el tipo básico de su uso en otras referencias a maestra de tipo de uso.

Tipos básicos se pueden usar como una variable miembro como un método de parámetros, como valor de retorno del método, por supuesto, un tipo de referencia también es posible.

Clase como una variable miembro

clase de personaje del juego

Cuando se define una clase de papel (personaje del juego), de la siguiente manera:

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

Uso inttipo representa Identificación del carácter y el valor de la vida, el uso de Stringtipo representa el nombre. En este momento, stringes en sí mismo un tipo de referencia, similar a la constante usada por la forma, por lo que a menudo se pasa por alto el tipo de referencia existe.

Si continuamos enriquecer esta definición de clase, para Roleaumentar la armas, equipos y otro desgaste propiedad, cómo lo escribimos?

clase de armas

La definición de la clase de arma que aumentará la capacidad de ataque:

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

Clase de armadura

Definido clase de armadura desgaste, aumentará la capacidad de defensa, es decir, para aumentar el valor de la vida:

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

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

la implementación del código

El papel de la clase

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

Categoría de prueba

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 variable miembro

La interfaz es un método de envasado para el juego correspondiente, las habilidades puede ser visto como una extensión de los personajes del juego. Por lo tanto, si desea ampliar las habilidades más poderosas, que RoleRolepodemos aumentar la interfaz como una variable miembro, un conjunto diferente de habilidades.

interfaz

• Utilizamos una interfaz como una variable miembro a modificar en cualquier habilidad, este diseño es más flexible, mejorando la escalabilidad del programa.

• Cuando la interfaz como una variable miembro, es operación de asignación, de hecho, un objeto de la subclase se asigna a la interfaz.

Los métodos abstractos definen las capacidades de interfaz y de liberación

public interface Skill {

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

El papel de la clase

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
}

Categoría de prueba

// 使用接口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~
技能释放完毕

Una interfaz como parámetro y valor de retorno del método

• Interfaz como un parámetro, pasándole el objeto de subclase.

• Interfaz tipo que el valor de retorno, para volver a su objeto de subclase.

Código muestra:

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:

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

FINAL