引用类型用法总结

Posted 2020-11-23 wurengen

引用类型用法总结

实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。

class作为成员变量

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

定义自定义类

package demo04;

public class Car {
    private String name;
    private String color;

    public Car(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public Car() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

使用自定义类作为类的成员变量

package demo04;

public class Student {
    private  String  name;
    private  Car  car;
    public void game(){
        System.out.println("我的名字是"+name+"我买了一辆"+car.getColor()+"的"+car.getName());
    }

    public Student(String name, Car car) {
        this.name = name;

        this.car = car;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }
}

定义测试类

package demo04;

public class Test {
    public static void main(String[] args) {
        //类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象
        Student student = new Student("张三",new Car("玛莎拉蒂","金色"));
        student.game();
    }
}

代码执行后的结果

interface作为成员变量

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

定义接口

package demo05;

public interface FaShuSkill {
    //接口中的抽象方法
    public abstract void faShuAttack();
}

定义使用接口作为成员变量的类

package demo05;

public class Role {
    //接口作为成员变量
    FaShuSkill fs;

    public FaShuSkill getFs() {
        return fs;
    }

    public void setFs(FaShuSkill fs) {
        this.fs = fs;
    }

    // 法术攻击
    public void faShuSkillAttack() {
        System.out.print("发动法术攻击:");
        fs.faShuAttack();
        System.out.println("攻击完毕");
    }

}

定义测试类

package demo05;

public class Test {
    public static void main(String[] args) {
        // 创建游戏角色
        Role role = new Role();
        // 设置角色法术技能
        role.setFs(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("纵横天下");
            }
        });
        role.faShuSkillAttack();
        // 更换技能
        role.setFs(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("天下无双");
            }
        });

        // 发动法术攻击
        role.faShuSkillAttack();
    }
}

代码执行后的结果

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

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

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

代码举例

package demo06;

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

public class Test {
    public static void main(String[] args) {
        // 创建ArrayList集合,并添加数字
        ArrayList<Integer> srcList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            srcList.add(i);
        }
        /*获取偶数集合 因为getEvenNum方法的参数是List,而ArrayList是List的子类, 所以srcList可以传递 */
        List list = getEvenNum(srcList);
        System.out.println(list);
    }

    public static List<Integer> getEvenNum(List<Integer> list) {
        // 创建保存偶数的集合
        ArrayList<Integer> evenList = new ArrayList<>();
        // 遍历集合list,判断元素为偶数,就添加到evenList中
        for (int i = 0; i < list.size(); i++) {
            Integer integer = list.get(i);
            if (integer % 2 == 0) {
                evenList.add(integer);
            }
        }
        /*返回偶数集合
        因为getEvenNum方法的返回值类型是List,而ArrayList是List的子类, 所以evenList可以返回 */
        return evenList;

    }
}

代码执行后的结果

类作为方法参数与返回值

• 类作为方法参数：要向方法中传入该类的对象。
• 类作为方法返回值：该方法要返回一个该类的对象
• 抽象类作为方法参数：要传入一个实现抽象类所有抽象方法的子类对象
• 抽象类作为方法返回值：返回一个实现抽象类所有抽象方法的子类对象