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

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