接口、形参和返回值

接口

概述
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中的接口更多的体现在对行为的抽象。

定义接口

public interface Jumpping { 
    public abstract void jump(); } 

类实现接口

public class Cat implements Jumpping{ 
    public void jump(){ 
    System.out.println("猫可以跳"); } } 

接口如何实例化？

Jumpping j=new Jumpping(); //报错，不能直接实例化 //可以参照多态的形式 Jumpping j=new Cat(); 

要是接口实现类不想重写接口中的方法，那么这个类就要定义为抽象类。

接口的成员特点

//接口 package myday; public interface Inter { 
    public abstract void eat(); } //实现类 package myday; public class InterImp implements Inter{ 
    //这种写法相当于： //public class InterImp extends Object implements Inter{} //因为接口中没有构造方法，所以实现类中的super();其实调用的是Object中的无参构造方法（空的） public InterImp() { 
    super(); } public void eat() { 
    System.out.println("啊啊啊"); } } 

//接口中： public void show(){ 
   };//报错，不能有非抽象方法 public abstract void show();//可以 void show();//可以，默认有修饰符public abstract 

//接口 package myday; public interface Inter { 
    public abstract void jump(); } //父类 package myday; public abstract class Animal { 
    public String name; public int age; public Animal() { 
    } public Animal(String name,int age) { 
    this.name=name; this.age=age; } public void setName(String name) { 
    this.name=name; } public void setAge(int age) { 
    this.age=age; } public String getName() { 
    return this.name; } public int getAge() { 
    return this.age; } public abstract void eat(); } //子类 package myday; public class Cat extends Animal implements Inter { 
    public Cat() { 
    } public Cat(String name,int age) { 
    super(name,age); } public void jump() { 
    System.out.println("猫跳高"); } public void eat() { 
    System.out.println("猫吃鱼"); } public void Catch() { 
    System.out.println("猫捉老鼠"); } } //测试 package myday; public class Demo { 
    public static void main(String[] args) { 
    Inter c1=new Cat(); c1.jump();//只能调用接口的重写方法 System.out.println("-----"); Animal c2=new Cat(); c2.setAge(15);//只能调用父类的重写方法 c2.setName("aaa"); System.out.println(c2.getAge()+","+c2.getName()); Cat c3=(Cat) c2; c3.Catch();//强转，可以调用子类的特有方法 } } 

类和接口的关系

类和类的关系：
继承关系，只能单继承，但是可以多层继承。
类和接口的关系：
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

接口和接口的关系：
继承关系，可以单继承，也可以多继承。

抽象类和接口的区别

门有开关功能和报警功能。但并不需要所有门都有报警功能，所以如果把这三个功能都放在接口或者抽象类中，是不符合实际需求的。
解决方案为，开关门功能为所有门都有的功能，放在抽象类，报警功能放在接口，当门需要该功能时只需要实现接口即可。

类名作为形参和返回值

类名作为形参

//猫 package myday; public class Cat { 
    public void eat() { 
    System.out.println("猫吃鱼"); } } //猫操作类 package myday; public class CatOp { 
    public void useCat(Cat c) { 
    c.eat(); } } //猫测试类 package myday; public class Demo { 
    public static void main(String[] args) { 
    Cat c=new Cat(); CatOp op=new CatOp(); op.useCat(c); } } 

类名作为返回值

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

抽象类名作为形参

//抽象类 package myday; public abstract class Animal { 
    public abstract void eat(); } //实现类 package myday; public class Cat extends Animal{ 
    public void eat() { 
    System.out.println("猫吃鱼"); } } //操作类 package myday; public class AnimalAll { 
    public void useAnimal(Animal d) { 
    //Animal类作为形参，也就是抽象类 d.eat(); } } //测试类 package myday; public class Demo { 
    public static void main(String[] args) { 
    AnimalAll ao=new AnimalAll(); Animal a=new Cat(); //抽象类不能直接创建对象 //所以要父类引用的方法创建对象传入方法 ao.useAnimal(a); } } 

抽象类作为返回值

//抽象类 package myday; public abstract class Animal { 
    public abstract void eat(); } //操作类 package myday; public class AnimalAll { 
    public void useAnimal(Animal d) { 
    d.eat(); } public Animal getAnimal() { 
    Animal a=new Cat(); return a;//返回的是Animal类（抽象类） //所以父类引用创建子类对象 } } //子类 package myday; public class Cat extends Animal{ 
    public void eat() { 
    System.out.println("猫吃鱼"); } } //测试类 package myday; public class Demo { 
    public static void main(String[] args) { 
    AnimalAll ao=new AnimalAll(); Animal a=ao.getAnimal(); a.eat(); } } 

接口名作为形参和返回值

//接口 package myday; public interface Inter { 
    void jump(); } //接口实现类 package myday; public class InterIm implements Inter{ 
    public void jump() { 
    System.out.println("猫跳高"); } } //操作类 package myday; public class Interop { 
    public void usejump(Inter j) { 
    //形参为接口类 //接口类不能直接定义对象 //所以利用多态的形式创建对象 j.jump(); } } //测试类 package myday; public class Demo { 
    public static void main(String[] args) { 
    Interop j=new Interop(); Inter a=new InterIm(); j.usejump(a); } } 

接口名作为返回值

//接口类 package myday; public interface Inter { 
    void jump(); } //接口实现类 package myday; public class InterIm implements Inter{ 
    public void jump() { 
    System.out.println("猫跳高"); } } //操作类 package myday; public class Interop { 
    public void usejump(Inter j) { 
    j.jump(); } public Inter getjump() { 
    Inter j=new InterIm(); return j; } } //测试类 package myday; public class Demo { 
    public static void main(String[] args) { 
    Interop j=new Interop(); Inter a=j.getjump();//new InterIm() a.jump(); } }