17_Java中的类作形参和返回值

Java中的形参和返回值

此处主要说明引用类型，总结下来就是在前面的规则下，做参数和返回值 就看能否自己创建对象

1、能就：传入本身对象，返回本身对象

2、不能就：传入子类（实现类）对象，返回子类（实现类）对象

一、类名作为形参和返回值

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

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

3、参考代码：

package com.itheima_01;
/*
猫类
 */
public class Cat {
    public void eat(){
        System.out.println("猫吃老鼠");
    }
}

package com.itheima_01;
/*
猫的操作类
 */
public class CatOperator {

    //类名作为形参，实际上是获得对应类的对象
    public void useCat(Cat c){//Cat 对象作为这个方法的形参
        c.eat();
    }

    //类名作为返回值，实际上就是返回对应的对象
    public Cat getCat(){
        Cat c = new Cat();
        return c;
    }
}

package com.itheima_01;
/*
测试类
 */
public class CatDemo {
    public static void main(String[] args){
        //创建操作类对象，并调用方法
        CatOperator co = new CatOperator();
        Cat c = new Cat();
        co.useCat(c);

        Cat c2 = co.getCat();
        c2.eat();
    }
}

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

1、方法的形参是抽象类名，其实需要的是该抽象类型的子类对象

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

3、参考代码：

package com.itheima_02;
/*
定义一个抽象的动物类
 */
public abstract class Animal {

    //抽象的eat()方法
    public abstract void eat();
}

package com.itheima_02;
/*
猫类
 */
public class Cat extends Animal{
    //重写抽象方法
    @Override
    public void eat(){
        System.out.println("猫吃老鼠");
    }
}

package com.itheima_02;
/*
动物类的操作类
 */
public class AnimalOperator {

    //抽象类做形参，其实传入的是该类的子类对象
    public void useAnimal(Animal a){    //Animal a = new Cat();
        //编译看左边，执行看右边
        a.eat();
    }

    //抽象类做返回值，其实就是返回对应 子类的对象值
    public Animal getAnimal(){
        Animal a = new Cat();
        return a;
    }
}

package com.itheima_02;
/*
测试类
 */
public class AnimalDemo {
    public static void main(String[] args){
        //创建操作类对象，并调用方法
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();   //只能通过多态的形式来创建对象
        ao.useAnimal(a); //对于抽象类，由于不能直接创建对象

        /*Cat c = (Cat) ao.getAnimal();   //可以用多态的知识 将返回的父类向下转型
        c.eat();*/

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

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

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

2、方法的返回值是接口名，其实返回的是该接口的实现类对象

3、参考代码：

package com.itheima_03;
/*
一个跳高接口
 */
public interface Jumpping {
    public abstract void jump();
}

package com.itheima_03;
/*
创建一个类来实现Jumpping接口
 */
public class Dog implements Jumpping{

    @Override
    public void jump(){
        System.out.println("狗可以跳高了");
    }
}

package com.itheima_03;
/*
接口的操作类
 */
public class JumppingOperator {

    //接口类作为形参，就是传入该接口的实现类
    public void useJumpping(Jumpping j){ //Jumpping j = new Dog();
        j.jump();
    }

    //接口类作为返回值，就是返回该接口的 实现类对象值
    public Jumpping getJumpping(){
        Jumpping j = new Dog();
        return j;
    }
}

package com.itheima_03;
/*
测试类
 */
public class JumppingDemo {
    public static void main(String[] args){
        //创建操作类对象，并调用方法
        JumppingOperator ju = new JumppingOperator();
        Jumpping j = new Dog();
        ju.useJumpping(j);

        Jumpping j2= ju.getJumpping();  //返回了new Dog()
        j2.jump();
    }
}