Java中形参和返回值

类名作为形参和返回值

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

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

public class CatOperator {
	//形参是类名
    public void useCat(Cat c){//需要该类的对象
        c.eat();
    }
    //返回值是类名
    public Cat getCat(){
        Cat c = new Cat();
        return c;//返回对象
    }
}

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

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

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

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

public class AnimalOperator {
    //形参是抽象类名
    public void useAnimal(Aniaml a){//需要的是该抽象类的子类对象
        a.eat();
    }
    //返回值是抽象类名
    public Aniaml getAnimal(){
        Aniaml a = new Cat();
        return a;//返回的是该抽象类的子类对象
    }
}

public class Demo {
    public static void main(String[] args){

        AnimalOperator ao = new AnimalOperator();
        Aniaml a1 = new Cat();
        ao.useAnimal(a1);

        Aniaml a2 = ao.getAnimal();
        a2.eat();
    }
}

输出：

猫吃鱼
猫吃鱼

接口名做为形参和返回值

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

public interface jumpping {
    void jump();
}

public class Cat implements jumpping{
    @Override
    public void jump(){
        System.out.println("猫跳了");
    }
}

public class jumppingOperator {
    //形参是接口名
    public void useJumpping(jumpping j){//实现类对象
        j.jump();
    }
    //返回值是接口名
    public jumpping getJmpping(){
        jumpping j = new Cat();
        return j;//实现类对象
    }
}

public class Demo {
    public static void main(String[] args){

        jumppingOperator jo = new jumppingOperator();
        jumpping j1 = new Cat();
        jo.useJumpping(j1);
        
        jumpping j2 =jo.getJmpping();
        j2.jump();
    }

}

输出：

猫跳了
猫跳了