面向对象---接口

一、接口的概念

接口:体现的是事务的扩展性功能(额外动作,后天经过学习等等)
 
接口格式(标识符:类,接口:见名知意)
   interface  接口名{
//抽象功能
   public abstract void jump() ;
}
接口的特点:不能实例化
接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{

  }

接口的子类如果是抽象类:没有意义,不能实例化

举个具体的例子大家体会一下：

//定义一个接口
interface AniamlTrain{
	//接口中的方法不能有方法体,只能是抽象方法
	public abstract void jump() ;
	public abstract void speak() ;
}
class Cat{}
//具体实现类
class JumpCatImpl extends Cat implements AniamlTrain{

	@Override
	public void jump() {
		System.out.println("部分猫就可以跳高了...");
	}

	@Override
	public void speak() {
		System.out.println("猫开口说话了...");
	}
}
public class Demo {
	
	public static void main(String[] args) {
		//创建对象
		AniamlTrain at = new JumpCatImpl() ;//接口多态(实际开发中用的最多)
		at.jump();
		at.speak(); 
	}
}

二、接口的成员特点

接口成员的特点:

   成员变量:是一个常量,不能更改,并且默认的修饰符：public static final

  构造方法:接口不存在构造方法

  成员方法:都是抽象方法，默认的修饰符:public abstract

接口和接口之间的关系:继承关系

interface Inter{
	public int num = 10 ;
	int num2 = 20 ;//默认的修饰符 public static final
	public static final int num3 = 200 ;
	//不能有无参构造
		//public Inter() {
		//		
		//}
	
	void method(); //默认的修饰符 public abstract
	
	public abstract void eat();
}

//子实现类
class InterImpl implements Inter{
	
	public void show() {
		System.out.println("show interimpl....");
	}

	@Override
	public void eat() {
		
	}

	@Override
	public void method() {
		
	}
}
//测试类
public class InterfaceDemo {

	public static void main(String[] args) {
		//创建实现类对象
		//接口多态
		Inter i = new InterImpl() ;
//		i.num = 100 ; //不能赋值:说明当前这个变量是一个常量:被final修饰
		System.out.println(Inter.num2); //这句话能调用,说明当前变量默认的修饰 static
		System.out.println(Inter.num);
	}
}

三、接口与抽象类的区别

1、成员的区别：

    成员变量：

            抽象类中的成员变量既可以是变量，也可以是常量

            接口中的成员变量只能是常量，默认修饰符：public static final

    构造方法：

            抽象类中有构造方法，可以是有参构造，也可以是无参构造（目的是对对象的初始化）

            接口中没有构造方法

    成员方法：

            抽象类中既可以有抽象方法，也可以有非抽象的方法

            接口中只能是抽象方法，默认修饰符：public abstract

2、类与类和类与接口的关系：

    类与类之间是继承关系，且只能实现单继承，不能多继承，但可以实现多层继承

    类和接口之间是实现关系，一个类继承的同时还可以实现多个接口

    接口和接口之间是继承关系，可以实现单继承，也可以实现多继承

3、设计原则的区别：

    抽象类：有继承关系，体现的是一种“is a”的关系，A是B的一种，或B是A的一种

    接口：类和接口之间是实现关系，体现的是一种“like a”的关系，是功能的拓展

四、接口和抽象类的综合案例

还是之前的猫狗案例，这次我们在之前的基础上给猫狗加入跳高的功能，那么由于跳高的功能不是所有的猫和狗都会跳高，所以显然在父类里加入跳高功能让子类继承是不太合适的，于是想到用接口（额外的拓展功能）来实现跳高功能

//抽象的动物类
public abstract class Animal {

	private String name ;
	private int age ;
	public Animal() {
		super();
	}
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//吃
	public abstract void eat();
	
	//睡
	public abstract void sleep() ;
}

public class Cat extends Animal {

	public Cat() {
		super();
	}

	public Cat(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("猫吃鱼....");
	}

	@Override
	public void sleep() {
		System.out.println("猫趴着睡觉....");
	}
	
	public void playGame() {
		System.out.println("猫玩游戏...");
	}

}

public class Dog extends Animal {
	
	public Dog() {
		super();
	}

	public Dog(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("狗吃猫...");
	}

	@Override
	public void sleep() {
		System.out.println("狗躺着睡觉...");
	}
	
	public void lookDoor() {
		System.out.println("狗躺着睡觉...");
	}
}

/**
 * 这是一个跳高的接口
 * @author Administrator
 *
 */
public interface Jump {
	
	//提供一个抽象功能
	public abstract void jump() ;
}

//跳高猫
public class JumpCat extends Cat implements Jump {
	
	public JumpCat() {
		super();
	}

	public JumpCat(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println("猫可以跳高了...");
	}
}

//跳高狗
public class JumpDog extends Dog  implements Jump {

	public JumpDog() {
		super();
	}

	public JumpDog(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println("狗可以跳高了...");
	}
}

//测试类
public class AnimalTest {
	
	public static void main(String[] args) {
		//可以使用功能最多的类
		//创建具体类对象
		//猫类
		JumpCat jc = new JumpCat("tom", 5) ;
		System.out.println(jc.getName()+"---"+jc.getAge());
		jc.eat();
		jc.sleep();
		jc.playGame();
		jc.jump(); 
		
		System.out.println("------------------");
		
		//狗类
		JumpDog jd = new JumpDog("bob", 2) ;
		System.out.println(jd.getName()+"---"+jd.getAge());
		jd.eat();
		jd.sleep();
		jd.lookDoor();
		jd.jump(); 
	}
}

至此，跳高猫和跳高狗的功能就实现了。