方法参数类型及返回值类型；链式编程

最新推荐文章于 2022-10-25 23:18:55 发布

满眼星陈ya

最新推荐文章于 2022-10-25 23:18:55 发布

阅读量452

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.youkuaiyun.com/weixin_62520622/article/details/121532993

版权

本文详细介绍了Java编程中类、抽象类和接口作为参数及返回值类型的应用。通过实例展示了值传递和引用传递的区别，解释了多态在类和抽象类中的体现，并探讨了接口在方法参数和返回值中的使用。同时，文章还涵盖了链式编程的概念及其在实际代码中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、类名作为形式参数

基本类型作为参数传递：属于值传递，传递的是值，形参的改变，不影响实参
引用类型作为参数传递：属于引用传递，传递的是地址值，形参的改变会影响实参

当你以后看到一个方法的形参要一个‘ 类 ’类型，你就传递一个该类的对象

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.num=20;
//传递一个该类对象
        set(student);
        student.show(30);//30
        System.out.println(student.num);
    }
//形参需要一个‘类’类型
    public static void set(Student student){
        student.num=200;
    }
}


class Student{
    int num=10;
    public void show(int num){
        this.num=num;
    }
}

2、抽象类名作为形式参数

当你以后看到一个方法的形参要一个‘抽象类 ’类型，你就传递一个该抽象类的子类对象

public class MyTest1 {
    public static void main(String[] args) {
        B b = new B();
        //传递该抽象类的子类对象
        set(b);
        System.out.println(b.num);
    }
    //方法的形参要一个'抽象类'类型
    public static void set(A a){//多态 A a=b；
        //多态的形式访问成员变量，编译看左边，运行也看左边
        a.num=30;
    }
}

abstract class A{
    int num=10;
    public abstract void show(int a);
}

class B extends A{
    int num=20;
    @Override
    public void show(int a) {
        this.num=a;
    }
}

3、接口名作为形式参数

当你以后看到一个方法的形参要一个‘接口’ 类型，你就传递一个该接口的子类对象

public class MyTest2 {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参，要一个接口类型，你就传递一个接口的子类对象。
       C c = new C();
        test(c);
        c.show(50);
        System.out.println(c.num); //50
        System.out.println(Myinterface.num);//200
    }

    public static void test(Myinterface myInterface) { //MyInterface myInterface=b  //多态
        System.out.println(myInterface.num);//200
    }
}

interface Myinterface{
    //默认修饰符
    public static final int num = 200;
    public abstract void show(int a);
}
class C implements Myinterface{
    int num = 30;
    @Override
    public void show(int a) {
        this.num = a;
    }
}

4、类名作为返回值类型

当你以后看到一个方法的返回值类型，是一个类类型，你就返回一个该类的对象

public class MyTest1 {
    public static void main(String[] args) {
        Student student = getStudent(20);
        student.num=30;
        Student s1 = student.show(40);
        System.out.println(student.num);
        System.out.println(s1.num);
    }
    //如果你以后看到一个方法的返回值类型，是一个'类 '类型，你就返回该类的对象。
    public static Student getStudent(int num){
        Student student = new Student();
        student.num=num;
        return student;
    }
}
class Student{
        int num=10;
        public Student show(int a){
            this.num=a;
     //this 代表一个该类的引用，哪个对象调用这个方法,方法中的this就代表谁
            return this;
        }
}

5、抽象类名作为返回值类型

当你以后看到一个方法的返回值类型是一个抽象类类型，你就返回一个该抽象类的子类对象

public class MyTest2 {
    public static void main(String[] args) {
        AA aa = test(120);  //多态AA aa=bb
        System.out.println(aa.num); //20
        aa.show();
    }
    //当你以后看到一个方法的返回值类型要一个 '抽象类 '类型，返回该类的子类对象
    public static AA test(int a) {
        BB bb = new BB();
        bb.num = a;
        return bb;
    }
}

abstract class AA {
    int num = 20;
    public abstract void show();
}

class BB extends AA {
    int num = 30;
    @Override
    public void show() {
        System.out.println(num); //120
    }
}

6、接口名作为返回值类型

当你以后看到一个方法的返回值类型是一个接口类型，你就返回一个该接口的子类对象

public class MyTest {
    public static void main(String[] args) {
        MyInterface anInterface = getInterface(); // 多态MyInterface anInterface =aa
        System.out.println(anInterface.num);//20
        //向下转型
        AA aa= (AA) anInterface;
        System.out.println(aa.num);//90
    }
    //当你以后看到一个方法的，返回值类型是一个 接口类型，你就返回该接口的子类对象。
    public static MyInterface getInterface(){
        AA aa = new AA();
        aa.num=90;
        return aa;
    }
}

interface MyInterface{
   public static final int num=20;
}

class AA implements MyInterface{
    int num=100;
}

7、链式编程

当你调用完一个方法后，这个方法会返回一个对象，你就可以紧接着打点，继续调用该对象的方法

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        Student student1 = student.getStudent(new Student(), 20);
        int num1 = student1.getNum();
        System.out.println(num1); //20
        //链式编程:当你调用完一个方法后，这个方法会返回一个对象，你就可以紧接着打点，继续调用该对象的方法。
        int num = new Student().getStudent(new Student(), 20).getNum();
        System.out.println(num);//20
    }
}
class Student{
    int num=200;
    public Student getStudent(Student student,int a){
        Student s1 = new Student();
        s1.num=a;
        return s1;
    }
    public int getNum(){
        return this.num;
    }
}