Java培训：类、接口作为参数和返回值详解

更新时间:2023-09-21 来源:黑马程序员浏览量:

　1.类作为方法参数

　　(1)基本思想

　　在编写程序中，会经常碰到调用的方法要接收的是一个类类型的情况，那么这时，要向方法中传入该类的对象。因为一个变量要想使用必须先赋值,才能使用,不赋值不能用,包括引用类型的变量,引用类型的变量其实是栈内存中的一块空间,必须在堆内存中开辟对应的空间,并将该空间的地址值赋值给变量后,该变量才能找到具体的空间,从而使用该空间的内容。

　　(2)代码演示

//测试类
public class Test {
    public static void main(String[] args) {
        //创建Person对象
        Person p = new Person("张三",18);//假设对象地址:0x111
        //调用method方法
        //调用方法时相当于:method(0x111)
        method(p);
    }

    /*
        定义一个方法method，用来接收一个Person对象，在方法中调用Person对象的show方法
        三要素:
        1.方法名称:method
        2.参数列表:Person p
        3.返回值类型:void
     */
    //当方法被调用时,Person p将接收调用者传递过来的对象的地址值
    //Person p = 0x111 = new Person("张三",18)
    public static void method(Person p){
        p.show();
    }
}

public class Person{
    private String name;//姓名
    private int age;//年龄
    //空参构造
    public Person() {
    }
    //满参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //setters and getters
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //展示信息的方法
    public void show(){
        System.out.println("我叫: "+name+", 年龄: "+age);
    }
}

运行结果

我叫: 张三, 年龄: 18

　　2.类作为方法返回值

　　(1)基本思想

　　写程序调用方法时，我们以后会经常碰到返回一个类类型的返回值，那么这时，该方法要返回一个该类的对象。

　　(2)代码演示

public class Test {
    public static void main(String[] args) {
        //调用getPerson方法，获取返回的Person对象
        //方法调用结束后:Person p = 0x111 = new Person("张三",18)
        Person p = getPerson();
        //调用p对象中的show方法
        p.show();
    }

    /*
        定义一个方法method，用来获取一个Person对象，在方法中完成Person对象的创建
        三要素:
        1.方法名称:getPerson
        2.参数列表:void
        3.返回值类型:Person
     */
    public static Person getPerson(){
        //创建Person对象
        Person p = new Person("张三",18);//假设对象地址:0x111
        return p;//return 0x111;
    }
}

public class Person{
    private String name;//姓名
    private int age;//年龄
    //空参构造
    public Person() {
    }
    //满参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //setters and getters
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //展示信息的方法
    public void show(){
        System.out.println("我叫: "+name+", 年龄: "+age);
    }
}

　　运行结果

我叫: 张三, 年龄: 18

　　3.抽象类作为方法参数

　　(1)基本思想

　　抽象类作为方法参数的情况也很多见。当遇到方法参数为抽象类类型时，要传入一个实现抽象类所有抽象方法的子类对象。因为抽象类,不能创建对象,必须创建子类,传递子类对象

　　(2)代码演示

//测试类
public class Test {
    public static void main(String[] args) {
        //创建Person类的子类Student对象
        //通过多态的方式，创建一个Person类型的变量，而这个对象实际是Student对象
        Person p = new Student("张三",18);//假设对象地址:0x111
        //调用method方法
        //调用方法时相当于:method(0x111)
        method(p);
    }

    /*
        定义一个方法method，用来接收一个Person类型的对象，在方法中调用Person类型对象的show方法
        三要素:
        1.方法名称:method
        2.参数列表:Person p
        3.返回值类型:void
     */
    //当方法被调用时,Person p将接收调用者传递过来的对象的地址值
    //Person p = 0x111 = new Student("张三",18)
    public static void method(Person p){////抽象类作为参数
        //通过p变量调用show方法,这时实际调用的是Student对象中的show方法
        p.show();
    }
}

public abstract class Person{
    private String name;//姓名
    private int age;//年龄
    //空参构造
    public Person() {
    }
    //满参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //setters and getters
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //展示信息的方法
    public abstract void show();
}

public class Student extends Person {
    public Student() {
    }

    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public void show() {
        System.out.println("我叫: "+getName()+", 年龄: "+getAge());
    }
}

运行结果

我叫: 张三, 年龄: 18

　　4.抽象类作为方法返回值

　　(1)基本思想

　　抽象类作为方法返回值的情况，这时需要返回一个实现抽象类所有抽象方法的子类对象。

　　(2)代码演示

//测试类
public class Test {
    public static void main(String[] args) {
        //调用getPerson方法，获取返回的Person类的子类对象
        //方法调用结束后:Person p = 0x111 = new Student("张三",18)
        Person p = getPerson();
        //调用p对象中的show方法,其实是Student类重写后的show方法
        p.show();
    }


    /*
        定义一个方法getPerson，用来获取一个Person类的子类对象，在方法中完成Person类子类对象的创建
        三要素:
        1.方法名称:getPerson
        2.参数列表:void
        3.返回值类型:Person
     */
    public static Person getPerson(){
        //创建Person对象
        Person p = new Student("张三",18);//假设对象地址:0x111
        return p;//return 0x111;
    }
}

　　运行结果

我叫: 张三, 年龄: 18

　　5.接口作为方法的参数

　　(1)基本思想

　　接口作为方法参数的情况是很常见的，经常会碰到。当遇到方法参数为接口类型时，那么该方法要传入一个接口实现类对象。

　　(2)代码演示

//测试类
public class Test {
    public static void main(String[] args) {
        //通过多态的方式，创建一个Smoke类型的变量，而这个对象实际是Student
        Smoke s = new SmokeableStudent();//假设地址值为:0x666
        //调用method方法
        //调用方法时相当于:method(0x666)
        method(s);
    }

    /*
        定义一个方法method，用来接收一个Smoke类型对象，在方法中调用Smoke对象的show方法
        三要素:
        1.方法名:method
        2.参数列表:Somke sm
        3.返回值类型:void
     */
    //当调用方法时,会传递该接口的实现类对象
    //Smoke sm = 0x666 = new SmokeableStudent()
    public static void method(Smoke sm){//接口作为参数
        //通过sm变量调用smoking方法，这时实际调用的是SmokeableStudent对象中的smoking方法
        sm.smoking();
    }
}

//接口
public interface Smoke{
    public abstract void smoking();//抽象方法
}
```



```
public class SmokeableStudent implements Smoke{
    @Override
    public void smoking() {
        System.out.println("课下吸口烟，赛过活神仙");
    }
}

运行结果

课下吸口烟，赛过活神仙

　　6.接口作为方法的返回值

　　(1)基本思想

　　接口作为方法返回值的情况。当遇到方法返回值是接口类型时，那么该方法需要返回一个接口实现类对象。

　　(2)代码演示

//测试类
public class Test {
    public static void main(String[] args) {
        //调用method方法，获取返回的会吸烟的对象
        //方法调用结束后:Smoke s = 0x666 = new SmokeableStudent()
        Smoke s = method();
        //通过s变量调用smoking方法,这时实际调用的是SmokeableStudent对象中的smoking方法
        s.smoking();
    }

    /*
        定义一个方法method，用来获取一个具备吸烟功能的对象，并在方法中完成吸烟者的创建
     */
    public static Smoke method(){
        //多态的形式创建对象
        Smoke sm = new SmokeableStudent();//假设地址值:0x666
        return sm;//相当于return 0x666
    }
}

//接口
public interface Smoke{
    public abstract void smoking();//抽象方法
}
```



```
public class SmokeableStudent implements Smoke{
    @Override
    public void smoking() {
        System.out.println("课下吸口烟，赛过活神仙");
    }
}

运行结果