类名作为形参和返回值
- 方法的形参是类名,其实需要的是该类的对象
- 方法的返回值是类名,其实返回的是该类的对象
public class Cat {
public void eat(){
System.out.println("猫吃鱼");
}
public void jump(){
System.out.println("猫跳高");
}
}
public class CatOperator {
//类名作为形参
public void cateat(Cat c){
c.eat();
}
public void catJump(Cat c){
c.jump();
}
//类名作为返回值
public Cat getCat(){
Cat c = new Cat();
return c;
}
}
public class CatDemo {
public static void main(String[] args) {
CatOperator co = new CatOperator();
Cat c = new Cat();
co.cateat(c);
co.catJump(c);
Cat c1 = co.getCat(); //new Cat();
c1.jump();
co.cateat(c1);
}
}
显示结果:
猫吃鱼
猫跳高
猫跳高
猫吃鱼
抽象类名作为形参和返回值
- 方法的形参是抽象类名,其实需要的是该抽象类的子类对象
- 方法的返回值是抽象类名,其实返回的是该抽象类的子类对象
public abstract class Animal {
public abstract void eat();
}
public class AnimalOperator {
public void useAnimal(Animal a){ //Animal a = new Cat();
a.eat();
}
public Animal getAnimal(){
Animal a = new Cat();
return a;
}
}
- 抽象类不能直接实例化,这里需要采用多态的形式创建它的子类对象
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void jump(){
System.out.println("猫跳高");
}
}
//抽象类作为形参和返回值测试
public class AnimalDemo {
public static void main(String[] args) {
AnimalOperator ao = new AnimalOperator();
Animal c = new Cat();
ao.useAnimal(c);
Animal c1 = ao.getAnimal(); // new Animal
ao.useAnimal(c1);
}
}
显示结果:
猫吃鱼
猫吃鱼
接口类名作为形参和返回值
- 方法的形参是接口类名,其实需要的是该接口的实现类对象
- 方法的返回值是接口类名,其实返回的是该接口的实现类对象
public interface jump {
void jumping();
}
public class jumpOperator {
public void useJumpong(jump j){
j.jumping();
}
}
- 接口类不能直接实例化,这里需要采用多态的形式创建它的子类对象
public class Tiger implements jump {
@Override
public void jumping() {
System.out.println("老虎跳高");
}
}
//接口类作为形参和返回值测试
public class jumpDemo {
public static void main(String[] args) {
jumpOperator jo = new jumpOperator();
jump j = new Tiger();
jo.useJumpong(j);
}
}