java 基本类型 引用_语法重点

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

Java引用类型

引用数据类型：数组，类(String)，接口。

class作为成员变量

类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。

Role.java

package referenceType2;
public class Role { 

private String name;
private int blood;
private Weapon weapon;
private Armour armour;
public Role(String name, int blood) { 

this.name = name;
this.blood = blood;
// this.armour = armour;
}
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 Armour getArmour() { 

return armour;
}
public void setArmour(Armour armour) { 

this.armour = armour;
}
public void attack() { 

System.out.println(weapon.getName() + " ------ " + weapon.getDamage());
}
public void defend() { 

System.out.println(armour.getName() + " ------- " + armour.getProtect());
}
public void life() { 

//不写this.getName()也可以了，默认this调用
System.out.println(getName() + "的初始生命值 = " + blood);
System.out.println("穿上防弹衣后生命值 = " + (this.blood + armour.getProtect()));
System.out.println("穿上防弹衣，挨了一刀");
blood += armour.getProtect() - weapon.getDamage();
System.out.println(getName() + "的剩余生命值 = " + blood);
}
}

Weapon.java

package referenceType2;
public class Weapon { 

private String name;
private int damage;
public Weapon(String name, int damage) { 

this.name = name;
this.damage = damage;
}
public String getName() { 

return name;
}
public void setName(String name) { 

this.name = name;
}
public int getDamage() { 

return damage;
}
public void setDamage(int damage) { 

this.damage = damage;
}
}

Armour.java

package referenceType2;
public class Armour { 

private String name;
private int protect;
public Armour(String name, int protect) { 

this.name = name;
this.protect = protect;
}
public String getName() { 

return name;
}
public void setName(String name) { 

this.name = name;
}
public int getProtect() { 

return protect;
}
public void setProtect(int protect) { 

this.protect = protect;
}
}

Test.java

package referenceType2;
public class Test { 

public static void main(String[] args) { 

Weapon weapon = new Weapon("刀(伤害)", 80);
Armour armour = new Armour("Bulletproof Vest(增加防护)", 50);
Role role = new Role("张三", 100);
//Role role = new Role("张三",100,armour);
role.setWeapon(weapon);
role.setArmour(armour);
//打印武器伤害
role.attack();
//打印防弹衣保护
role.defend();
System.out.println("");
role.life();
}
}

interface作为成员变量

接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能。如果想扩展更强大技能，我们在Role中，可以增加接口作为成员变量，来设置不同的技能。

我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

set()方法中可以传入匿名内部类

Role.java

package referenceType3;
public class Role { 

MagicAttack magicAttack;
public void setMagicAttack(MagicAttack magicAttack) { 

this.magicAttack = magicAttack;
}
public void skillAttack(){ 

magicAttack.magicAttack();
}
}

MagicAttack.java(接口)

package referenceType3;
public interface MagicAttack { 

void magicAttack();
}

Test.java

package referenceType3;
public class Test { 

public static void main(String[] args) { 

Role role = new Role();
//set()方法中传入匿名内部类
role.setMagicAttack(new MagicAttack() { 

@Override
public void magicAttack() { 

System.out.println("火雨");
}
});
role.skillAttack();
System.out.println("");
System.out.println("更换技能。。。");
System.out.println("");
//更换技能攻击
role.setMagicAttack(new MagicAttack() { 

@Override
public void magicAttack() { 

System.out.println("闪电链");
}
});
role.skillAttack();
}
}

interface作为方法参数和返回值类型

接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。

ArrayList类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所以，当我们看见List 接口作为参数或者返回值类型时，当然可以将ArrayList的对象进行传递或返回。

1.List接口做参数类型,返回值也是List接口类型
2.方法参数，返回值类型的List如果用List< Integer>泛型表示的话，集合获取元素时就不用强转了

package referenceType4;
import java.util.ArrayList;
import java.util.List;
public class Test { 

public static void main(String[] args) { 

ArrayList<Integer> aList = new ArrayList<>(10);
/** * 错误写法，foreach中不能用list.add(i) * for (Integer i : aList) { aList.add(i); }*/
for (int i = 1; i <= 10; i++) { 

aList.add(i);
}
aList.add(0);
aList.add(-1);
aList.add(-2);
aList.add(-3);
aList.add(-4);
System.out.println("aList = " + aList);
//List list = new Test().getEvenNum(aList);
List list = getEvenNum(aList);
System.out.println("list = " + list);
}
//获取集合中所有偶数方法
//不写静态方法也可以
// public List getEvenNum(List list){ 

//List接口做参数类型,返回值也是List接口类型
public static List getEvenNum(List list) { 
    
// public static List<Integer> getEvenNum(List<Integer> list) { 

List<Integer> evenNumList = new ArrayList<>();
for (int i = 0; i < list.size(); i++) { 

//加List泛型后就不用强制转换了
// Integer integer = list.get(i);
Integer integer = (Integer) list.get(i);
//Integer integer = list.get(i);
/** * if (integer % 2 == 0) { evenNumList.add(integer); }*/
//按位与更快
if ((integer & 1) != 1) { 

evenNumList.add(integer);
}
}
return evenNumList;
}
}