形參和返回值

類名作為形參和返回值

• 方法的形參是類名，其實需要的是該類的物件
• 方法的返回值是類名，其實返回的是該類的物件

例項：

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("貓正在跳高");
    }
}