抽象类是不能被实例化的，而接口比抽象类更加抽象，它不能有实现方法的，当接口或者抽象类作为一个参数传入时，会默认去找到子类作为对象参数传入进去；
同时
public interface CompareAble {//接口
public default Apple compare(Apple a1 , Apple a2){
return a1.getSize() > a2.getSize() ? a1 : a2;
}
}
这个没报错有点不现实吧，接口中是不能有具体的实现方法吧，接口中默认方法都是抽象方法，抽象方法是没有方法体的；

将类当成参数传入方法，其实就是将类的对象传入方法，如果是抽象类，其实就是将抽象类的子类的对象传入方法，如果是接口，其实就是将接口实现类的对象传入方法。

因为抽象类和接口是不能实例化成对象的，所以必须找它们的子类或实现类

将类当成参数传入方法，其实就是将类的对象传入方法，如果是抽象类，其实就是将抽象类的子类的对象传入方法，如果是接口，其实就是将接口实现类的对象传入方法。

因为抽象类和接口是不能实例化成对象的，所以必须找它们的子类或实现类

1. 普通类对象当成方法参数传入

public class Person{

　　public void eat(){

　　　　System.out.println("吃饭");

　　}

}

//方法

public static void operatePerson(Person p){　

　　p.eat();

}

//main调用方法,将person对象传入方法中

operatePerson(new person());

2. 抽象类作为方法参数传入

//抽象类

public abstract class Animal{

　　public abstratc void eat();

}

//Animal的子类

public class Cat extends Animal{

　　//重写方法

　　public void eat(){

　　　　System.out.println("猫吃鱼");

　　}

}

//main中的方法，这里要求传入Animal类，但Animal的类是一个抽象类，不能实例对象，所以只能传其子类。

function static void operateAnimal(Animal a){

　　a.eat();

}

//方法的调用

Animal a = new Cat();

operateAnimal（new cat());或operateAnimal(a);

当然，还要以通过内部类一次性传参

operateAnimal(

　　new Animal(){

　　　　//重写animal抽象方法

　　　　public void eat(){System.out.println("猫还吃饭");}

　　}

);

要求传入父类对象，但可以传入任意子类对象，这样就使得扩展性得到提高

operateAnimal(new Cat());

operateAnimal(new Dog());

operateAnimal(new Bird());

......

传入什么类，就调用什么类的功能，这就是多态的实现。

3. 接口实现类的对象当成方法参数传入

public interface Smoking{

　　public abstract void smoking();

}

//实现类

public class Student implements Smoking{

　　//实现接口方法

　　public void smoking(){

　　　　System.out.println("抽烟中....");

　　}

}

//main中定义方法，将接口实现类当方法参数传入

public static void operateSmoking(Smoking s){

　　s.smoking();

}

//方法的调用

Smoking s = new Student();

operateSmoking(s);或operateSmoking(new Student());

或用内部类传入

operateSmoking(

　　new Smoking(){

　　　　//重写接口方法

　　　　public void smoking(){

　　　　　　System.out.println("不准吸烟");

　　　　}

　　}

);

总结：类当成方法参数传入，其实就是传对象。抽象类和接口其实就是传其子类或实现类的对象。