形参和返回值

形参和返回值

类名作为形参和返回值

• 方法的形参是类名，其实需要的是该类的对象
• 方法的返回值是类名，其实返回的是该类的对象

实例：

package com.example.homework.MethodAndreturn;

/**
 * @author gaoqinghui
 * @date 2022/5/6 11:56
 */
public class MethodAndreturn {

    public static void main(String[] args) {
        CatOperator c1 = new CatOperator();
        Cat cat = new Cat();
        c1.useCat(cat);				//也可以两步合成一步c1.useCat(new Cat());

        Cat cat1 = c1.getCat();		//也可以两步合成一步c1.getCat().eat();
        cat1.eat();

    }
}

class Cat {
    public void eat (){
        System.out.println("猫吃鱼");
    }
}

//类名作为形参
class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }

//类名作为返回值    
    public Cat getCat(){
        Cat cat = new Cat();
        return cat; //也可以直接return new Cat;
    }
}

抽象类名作为形参和返回值

• 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
• 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

package com.example.MethodAndreturn.reuturn02;

/**
 * @author gaoqinghui
 * @date 2022/5/6 12:16
 */
public class AnimalDemo {
    public static void main(String[] args) {

        AnimalOperator op = new AnimalOperator();
        //因为不能直接实例化一个抽象类
        // 所以我们要创建一个子类继承这个抽象类然后用多态来使用该c
        Animal a = new Cat();   //多态
        op.useAnimal(a);

        Animal animal = op.getAnimal();
        animal.eat();
    }
}

class AnimalOperator {
    public void useAnimal(Animal a){       //Animal a = new Cat();
        a.eat();
    }

    public Animal getAnimal(){
        Animal aa = new Cat();
        return aa;
    }
}

abstract class Animal {
    public abstract void eat();
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

接口名作为形参和返回值

• 方法的形参是接口名，其实需要的是该接口的实现类对象
• 方法的返回值是接口名，其实返回的是该接口的实现类对象

package com.example.MethodAndreturn.reuturn03;

/**
 * @author gaoqinghui
 * @date 2022/5/6 12:41
 */
public class JumppingDemo {
    public static void main(String[] args) {
        JumppingOperator operator = new JumppingOperator();
        Jumpping cat = new Cat();               //因为不能直接实例化一个接口，
                                                    // 所以我们要创建一个子类实现了这个接口然后用多态来使用该接口
        operator.useJupping(cat);

        Jumpping jummping = operator.getJummping();
        jummping.jump();

    }
}

 interface Jumpping {
    void jump();
}

 class JumppingOperator {

    public void useJupping(Jumpping j){//Jumpping j = new Cat();
        j.jump();
    }

    public Jumpping getJummping(){
        Cat cat = new Cat();
        return cat;
    }
}

 class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫正在跳高");
    }
}