一、具體類名作為形參與返回值

1.方法的形參是類名，其實需要的是該類的物件

比如有一個具體的貓類，我使用另一個類使用貓類的方法

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

那麼在呼叫的時候

public class CatDemo {
    public static void main(String[] args) {
        CatOperator c=new CatOperator();
       //需要建立Cat類的物件，因為useCat方法的形參是Cat型別的引數
       Cat c1=new Cat();
        c.useCat(c1);
    }
}
​
 

2.方法的返回值是類名，其實返回的是類的物件

public class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }
    public Cat getCat(){
        //因為返回型別為Cat,則返回值一定為Cat型別
        //建立物件
        Cat c=new Cat();
        return c;
    }
}

那麼在呼叫的時候

public class CatDemo {
    public static void main(String[] args) {
        CatOperator c = new CatOperator();
        Cat c1 = new Cat();
        c.useCat(c1);
        System.out.println("---------------------");
        Cat c2 = c.getCat();//new cat
        c2.eat();
    }
}
 

二、抽象類名作為形參與返回值

1.方法的形參是抽象類名，實際上需要的是該抽象類的子類物件

public class AnimalOperator {
    //抽象類名作為形參，實際需要的是子類的物件
    public void useAnimal(Animal a){ // Animal a=new Dog()
        a.eat();
    }

public class AnimalDemo {
    public static void main(String[] args) {
        //建立操作類物件
        AnimalOperator a=new AnimalOperator();
        //因為抽象類不能直接例項化需要建立子類使用多型進行處理
        Animal a1=new Dog();
        a.useAnimal(a1);
        }
       }
 

2.方法的返回值是抽象類名，返回的是該抽象類的子類物件

public class AnimalOperator {
    //抽象類名作為形參，實際需要的是子類的物件
    public void useAnimal(Animal a){ // Animal a=new Dog()
        a.eat();
    }
    public Animal getAnimal(){
        Animal a=new Dog();
        return a;
    }
}
​

/*測試類
*
* */
​
public class AnimalDemo {
    public static void main(String[] args) {
        //建立操作類物件
        AnimalOperator a=new AnimalOperator();
        //因為抽象類不能直接例項化需要建立子類使用多型進行處理
        Animal a1=new Dog();
        a.useAnimal(a1);
        System.out.println("----------------------");
        Animal a2=a.getAnimal();
        a2.eat();
    }
}
​

三、介面名作為形參與返回值

1.方法的形參是介面名，需要的是該介面的實現類物件

2.方法的返回值是介面名，需要的是該介面的實現類物件

/*定義介面
* */
public interface jumpping {
    //定義抽象方法
    void jumpping();
}
​

​
/*介面操作類
 * */
public class JumppingOperator {
    public void useJumpping(jumpping j){
        j.jumpping();
    }
    public jumpping getJumpping(){
        jumpping j=new Cat();
        return j;
    }
​
}
​
​

public class Cat implements jumpping{
    //重寫抽象方法
​
    @Override
    public void jumpping() {
        System.out.println("毛調高");
    }
}
​
​

/*測試類
​
* */
public class JumppingDemo {
    public static void main(String[] args) {
        //建立操作類物件
        JumppingOperator j=new JumppingOperator();
        //建立子類物件實現介面
        jumpping j1=new Cat();
        j.useJumpping(j1);
        System.out.println("-------------------");
        jumpping j2 = j.getJumpping();
        j2.jumpping();
​
​
    }
}
​