概述
实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。
基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。
类作为成员变量
游戏角色类
在定义一个类Role（游戏角色）时，代码如下：
package test.demo09;
// 英雄
public class Role {
int id; // 角色ID
int blood; // 生命值
String name; // 角色名称
}
使用int 类型表示角色id和生命值，使用 String 类型表示姓名。此时，string本身就是引用类型，由于使用的方式类似常量，所以往往忽略了它是引用类型的存在。
如果我们继续丰富这个类的定义，给Role增加武器，穿戴装备等属性，我们将如何编写呢？
武器类
定义武器类，将增加攻击能力：
package test.demo09;
// 武器
public class Weapon {
String name; // 武器名称
int hurt; // 伤害值
// 省略构造器和get/set
}
护甲类
定义穿戴盔甲类，将增加防御能力，也就是提升生命值：
package test.demo09;
// 护甲
public class Armor {
String name; // 护甲名称
int protect; // 防御值
// 省略构造器和get/set
}
代码实现
角色类
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());
}
}
测试类
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();
}
}
结果：
Role使用AK-47,造成79点伤害
穿上防弹背心,生命值增加35
接口作为成员变量
接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能。所以，如果想扩展更强大技能，我们在RoleRole中，可以增加接口作为成员变量，来设置不同的技能。
接口
-
我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
-
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给该接口的一个子类对象。
定义接口和释放技能的抽象方法
public interface Skill {
void use(); // 释放技能的抽象方法
}
角色类
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
}
测试类
// 使用接口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();
}
}
结果：
我叫夜玫瑰,开始释放技能
Biu~ Biu~ Biu~
技能释放完毕
=================
我叫夜玫瑰,开始释放技能
pia~ pia~ pia~
技能释放完毕
=================
我叫夜玫瑰,开始释放技能
tu~ tu~ tu~
技能释放完毕
接口作为方法的参数和返回值
-
接口作为参数时，传递它的子类对象。
-
接口作为返回值类型时，返回它的子类对象。
代码演示：
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;
}
}
结果：
迪丽热巴
古力娜扎
马尔扎哈
END
