Java基础——引用类型作为形参与返回值

一、具体类名作为形参与返回值

1.方法的形参是类名，其实需要的是该类的对象

比如有一个具体的猫类，我使用另一个类使用猫类的方法

public class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }
}

那么在调用的时候

public class CatDemo {
    public static void main(String[] args) {
        CatOperator c=new CatOperator();
       //需要创建Cat类的对象，因为useCat方法的形参是Cat类型的参数
       Cat c1=new Cat();
        c.useCat(c1);
    }
}
​

2.方法的返回值是类名，其实返回的是类的对象

public class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }
    public Cat getCat(){
        //因为返回类型为Cat,则返回值一定为Cat类型
        //创建对象
        Cat c=new Cat();
        return c;
    }
}

那么在调用的时候

public class CatDemo {
    public static void main(String[] args) {
        CatOperator c = new CatOperator();
        Cat c1 = new Cat();
        c.useCat(c1);
        System.out.println(\"---------------------\");
        Cat c2 = c.getCat();//new cat
        c2.eat();
    }
}

二、抽象类名作为形参与返回值

1.方法的形参是抽象类名，实际上需要的是该抽象类的子类对象

public class AnimalOperator {
    //抽象类名作为形参，实际需要的是子类的对象
    public void useAnimal(Animal a){ // Animal a=new Dog()
        a.eat();
    }

public class AnimalDemo {
    public static void main(String[] args) {
        //创建操作类对象
        AnimalOperator a=new AnimalOperator();
        //因为抽象类不能直接实例化需要创建子类使用多态进行处理
        Animal a1=new Dog();
        a.useAnimal(a1);
        }
       }

2.方法的返回值是抽象类名，返回的是该抽象类的子类对象

public class AnimalOperator {
    //抽象类名作为形参，实际需要的是子类的对象
    public void useAnimal(Animal a){ // Animal a=new Dog()
        a.eat();
    }
    public Animal getAnimal(){
        Animal a=new Dog();
        return a;
    }
}
​

/*测试类
*
* */
​
public class AnimalDemo {
    public static void main(String[] args) {
        //创建操作类对象
        AnimalOperator a=new AnimalOperator();
        //因为抽象类不能直接实例化需要创建子类使用多态进行处理
        Animal a1=new Dog();
        a.useAnimal(a1);
        System.out.println(\"----------------------\");
        Animal a2=a.getAnimal();
        a2.eat();
    }
}
​

三、接口名作为形参与返回值

1.方法的形参是接口名，需要的是该接口的实现类对象

2.方法的返回值是接口名，需要的是该接口的实现类对象

/*定义接口
* */
public interface jumpping {
    //定义抽象方法
    void jumpping();
}
​

​
/*接口操作类
 * */
public class JumppingOperator {
    public void useJumpping(jumpping j){
        j.jumpping();
    }
    public jumpping getJumpping(){
        jumpping j=new Cat();
        return j;
    }
​
}
​
​

public class Cat implements jumpping{
    //重写抽象方法
​
    @Override
    public void jumpping() {
        System.out.println(\"毛调高\");
    }
}
​
​

/*测试类
​
* */
public class JumppingDemo {
    public static void main(String[] args) {
        //创建操作类对象
        JumppingOperator j=new JumppingOperator();
        //创建子类对象实现接口
        jumpping j1=new Cat();
        j.useJumpping(j1);
        System.out.println(\"-------------------\");
        jumpping j2 = j.getJumpping();
        j2.jumpping();
​
​
    }
}
​

来源：https://www.cnblogs.com/CYan521/p/16022960.html
本站部分图文来源于网络，如有侵权请联系删除。