java参数传递之形参和返回值

1.类名作为形参

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

//创建一个猫类

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

//创建一个操作类，其方法的参数是猫类

public class Catoperation {
          
   
    public void useCat(Cat c){
          
   
        c.eat();
    }
}

//测试类，创建对象Catoperation()，Cat()，再调用方法

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

2.类名作为返回值

//猫类保持不变 //下面创建操作类

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

//测试类，创建对象Catoperation()，返回Cat，然后调用Cat()方法

public class Test {
          
   
    public static void main(String[] args) {
          
   
        Catoperation co=new Catoperation();
        Cat c2=co.getCat();
        c2.eat();
}

3.抽象类作为形参

方法的形参是抽象类名，实际需要该抽象类的子类对象 抽象类不能实例化，以多态的形式，创建它的子类对象进行传递继承重写实现，子类重写方法

//创建抽象类

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 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();
}
}

3.抽象类作为返回值

//抽象类，子类不变 //操作类

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

//测试类

public class AnimalDemo {
          
   
public static void main(String[] args) {
          
   
Animal a2 = ao.getAnimal(); //new Cat()
a2.eat();
    }
}

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

方法的形参/返回值 是接口，实际上是该接口的实现类方法

//接口

interface Jumpping {
          
   
void jump();
      }

//操作类

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

//实现类方法

class Cat implements Jumpping {
          
   
@Override
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);
     }
}