类名，抽象类名，接口名（作为形参和返回值）

1.类名作为形参和返回值

重点是面向过程中的类，抽象类和接口分别作为形参和返回值的问题
先创建一个Cat类

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

再创建一个CatOperator猫的操作类

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

最后创建猫的测试类CatDemo

public class CatDemo {
    public static void main(String[] args){
        CaOperator co=new CaOperator();
        Cat c=new Cat();
        co.useCat(c);
    }
}

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

方法的返回值类型是类名

public Cat getCat(){
 Cat c=new Cat();
 return c;
}

测试

 Cat c2=co.getCat();//new Cat();
        c2.eat();

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

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

• 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
  创建一个Animal抽象类

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

创建一个Animal操作类

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

测试类

public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();
        ao.useAnimal(a);
    }
}

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

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

Animal a2=ao.getAnimal();//new Cat
        a2.eat();

3.接口名作为形参和返回值

• 方法的形参是接口名，其实需要的是该接口的实现类对象
  定义一个接口

public interface Jumpping {
    void jump();
}

定义一个操作类

public class JumppingOperator {
    public void useJumpping(Jumpping j){//Jumpping j=new Cat();
        j.jump();
    }
}

定义一个用来实现接口的类

public class Cat implements Jumpping{
    public void jump(){
        System.out.println("猫可以调高了");
    }
}

定义一个测试类

public class JumppingDemo {
    public static void main(String[] args){
        JumppingOperator jo=new JumppingOperator();
        Jumpping j=new Cat();
        jo.useJumpping(j);
    }
}

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

public Jumpping getJumpping(){
        Jumpping c=new Cat();
        return c;
    }

Jumpping j2 = jo.getJumpping();//new Cat();
        j2.jump();

理想的咸鱼猿©个人笔记