Java 方法中返回值类型 java中返回值类型有哪些

目录

一、形参和返回值都是基本类型

二、类名作为形参和返回值

三、抽象类作为形参和返回值

四、接口作为形参和返回值

---

一、形参和返回值都是基本类型

这里比较简单，放一个不确定参数数量的例子玩玩：

package Demo;

public class Sum {
    public static void main(String[] args) {
        int s =sum(1,2,3,4);
        System.out.println(s);
    }
    public static int sum(int...nums){
        int ans=0; //局部变量必须手动初始化
        for(int i=0;i<nums.length;i++){
            ans+=nums[i];
        }
        return ans;
    }
}

对于可变参数的传递，其实传递的是一个数组。

二、类名作为形参和返回值

形参是类名时，参数要传递类的对象，返回值是类名时，返回的是该类的对象。

这里直接把类当做一个数据类型就可以，其实没什么区别。看一个小栗子：

创建一个学生类

package Demo;
/*    成员变量
        使用private修饰

    构造方法
        提供一个无参构造方法
        提供一个带多个参数的构造方法

    成员方法
        提供每一个成员变量对应的set方法和get方法
        提供一个显示对象信息的show方法
*/

public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student() {
    }  //无参数构造方法

    public Student(String name, int age) {
        this.age = age;
        this.name = name;
    }

    //提供age的get和set方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0) {
            System.out.println("你输入的年龄有误");
        } else {
            this.age = age;
        }
    }

    //提供name的get和set方法
    public String getName() {
        return name;
    }

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

    //提供一个显示成员信息的show方法
    public void show() {
        System.out.println("name:" + name + ", age:" + age);
    }
}

创建一个测试类，该测试类中包含一个学生初始化方法，它的形参是学生类，再定义一个创建学生对象的方法，它的返回值是学生类。

package Demo;

public class StudentDemo {
    public static void main(String[] args) {
        //创建一个学生对象
        Student s1 = new Student();

        //调用学生初始化方法
        studentInitialize(s1);

        //调用学生创建方法
        Student s2 = studentNew();

        //调用Student对象的show()方法
        s1.show(); //name:张楚岚, age:20
        s2.show(); //name:宝儿姐, age:18
    }
    public static void studentInitialize(Student s){
        s.setAge(20);
        s.setName("张楚岚");
    }

    public static Student studentNew(){
        Student s = new Student();
        s.setAge(18);
        s.setName("宝儿姐");
        return s;
    }
}

三、抽象类作为形参和返回值

形参是抽象类时，参数要传递该类的子类（具体类）的对象，返回值是抽象类时，返回的是该类的子类（具体类）的对象。

这里其实就是因为抽象类不能直接实例化，只能参照抽象类多态的形式实例化其子类（具体类）。再来一个小栗子：

1. 定义一个抽象人类：

package Demo;

public  abstract class People {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public People() {
    }

    public People(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

1. 定义一个学生类，继承自人类，包含一个show()方法：

package Demo;

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

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

    //提供一个显示成员信息的show方法
    public void show() {
        System.out.println("name:" + super.getName() + ", age:" + super.getAge());
    }
}

1. 创建一个测试类，该测试类中包含一个人类初始化方法，它的形参是人类，再定义一个创建人类对象的方法，它的返回值是人类：

package Demo;

public class StudentDemo {
    public static void main(String[] args) {
        //创建一个学生对象
        People p1 = new Student();

        //调用学生初始化方法
        peopleInitialize(p1);

        //调用学生创建方法
        People p2 = peopleNew();

        //向下转型，然后调用Student对象的show()方法
        Student s1 =(Student)p1;
        s1.show(); //name:张楚岚, age:20
        Student s2 = (Student)p2;
        s2.show(); //name:宝儿姐, age:18
    }
    public static void peopleInitialize(People p){
        p.setAge(20);
        p.setName("张楚岚");
    }

    public static People peopleNew(){
        People P = new Student();
        P.setAge(18);
        P.setName("宝儿姐");
        return P;
    }
}

四、接口作为形参和返回值

形参是接口时，参数要传递该接口的实现类（具体类）的对象，返回值是接口时，返回的是该接口的实现类（具体类）的对象。

这里其实就是因为接口不能直接实例化，只能参照接口多态的形式实例化其实现类（具体类）。欢迎大家在来一个小栗子。

五、不确定数量的类名作为形参

这里直接改写了上面的例子中peopleInitialize()方法，并且一次初始化了三个对象。

package Demo;

public class StudentDemo {
    public static void main(String[] args) {
        //创建一个学生对象
        People p1 = new Student();
        People p3 = new Student();
        People p4 = new Student();

        //调用学生初始化方法
        peopleInitialize(p1,p3,p4);

        //调用学生创建方法
        People p2 = peopleNew();

        //向下转型，然后调用Student对象的show()方法
        Student s1 =(Student)p1;
        s1.show(); //name:张楚岚, age:20
        Student s2 = (Student)p2;
        s2.show(); //name:宝儿姐, age:18
        Student s3 = (Student)p3;
        s2.show(); //name:宝儿姐, age:18
        Student s4 = (Student)p4;
        s2.show(); //name:宝儿姐, age:18
    }
    public static void peopleInitialize(People...p){
        for(int i = 0;i<p.length;i++){
            People pp=p[i];
            pp.setAge(20);
            pp.setName("张楚岚");
        }
    }

    public static People peopleNew(){
        People P = new Student();
        P.setAge(18);
        P.setName("宝儿姐");
        return P;
    }
}