形参和返回值

形参和返回值

类名作为形参和返回值

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

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

 public class Cat {
     public void eat(){
         System.out.println("猫吃鱼");
     }
 }
 ​
 public class CatOperator {
     public void useCat(Cat c) {     //Cat c = new Cat();
         //方法的形参是类名，其实是需要的是该类对象
         c.eat();
     }
 ​
     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.useCat(c);
         Cat c2 = co.getCat();   //new Cat();
         c2.eat();
     }
 }

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

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

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

   public abstract class Animal {
    ​
        public abstract void eat();
    }
    ​
    public class Cat extends Animal{
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    ​
    public class AnimalOperator {
    ​
        public void useAnimal(Animal a){    //Animal a = new Cat();
            //方法的形参是抽象类名，其实需要的是该抽象类的子类对象
            a.eat();
        }
        public Animal getAnimal(){
            //方法的返回值是抽象类名，其实返回值是该抽象类的子类对象
    //        Animal a = new Cat();
    //        return a;
            return new Cat();
        }
    }
    ​
    public class AnimalDemo {
        public static void main(String[] args) {
            //创建操作类对象，并调用方法
            AnimalOperator ao=new AnimalOperator();
            Animal a=new Cat(); //多态形式创建子类对象
            ao.useAnimal(a);
    ​
            Animal a2 = ao.getAnimal(); //new Cat();
            a2.eat();
        }
    }

   接口名作为形参和返回值

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

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

      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){    //Jumpping j = new Cat();
               //方法的形参是接口名，其实需要的是该接口的实现类对象
               j.jump();
           }
       ​
           public Jumpping getjump(){
               //方法的返回值是接口名，其实返回的是该接口的实现类对象
       /*        Jumpping j = new Cat();
               return j;*/
               return new Cat();
           }
       }
       ​
       public class JumppingDemo {
           public static void main(String[] args) {
               //创建操作类对象，并调用方法
               JumppingOperator jo=new JumppingOperator();
               Jumpping j = new Cat();
               jo.useJumpping(j);
       ​
               Jumpping j2 = jo.getjump();
               j2.jump();
           }
       }