面向对象-------接口(二十五)

一.接口的概述及其特点

* A:接口概述
    * 从狭义的角度讲就是指java中的interface
    * 从广义的角度讲对外提供规则的都是接口
* B:接口特点
    * a:接口用关键字interface表示    
        * interface 接口名 {}
    * b:类实现接口用implements表示
        * class 类名 implements 接口名 {}
    * c:接口不能实例化
        * 那么，接口如何实例化呢?
        * 按照多态的方式来实例化。
    * d:接口的子类
        * a:可以是抽象类。但是意义不大。
        * b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

class Demo1_Interface {
	public static void main(String[] args) {
		//Inter i = new Inter();	//接口不能被实例化,因为调用抽象方法没有意义
		Inter i = new Demo();		//父类引用指向子类对象
		i.print();
	}
}


interface Inter {
	public abstract void print();			//接口中的方法都是抽象的
}

class Demo implements Inter {
	public void print() {
		System.out.println("print");
	}
}

二.接口的成员特点

接口成员特点
    * 成员变量；只能是常量，并且是静态的并公共的。
            * 默认修饰符：public static final
            * 建议：自己手动给出。
    * 构造方法：接口没有构造方法。
    * 成员方法：只能是抽象方法。
            * 默认修饰符：public abstract
            * 建议：自己手动给出。

class Demo2_Interface {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.print();
		System.out.println(Inter.num);
	}
}

interface Inter {
	public static final int num = 10;
	//public Inter(){}				接口中没有构造方法
	/*public void print() {				接口中不能定义非抽象方法
	
	}*/

	public abstract void print();
}

class Demo /*extends Object*/ implements Inter {//一个类不写继承任何类,默认继承Object类
	public void print() {
		//num = 20;
		System.out.println(num);
	}

	public Demo() {
		super();
	}

}

三.类与类,类与接口,接口与接口的关系

class Demo3_Interface {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

interface InterA {
	public abstract void printA();
}

interface InterB {
	public abstract void printB();
}

interface InterC extends InterB,InterA {
}
//class Demo implements InterA,implements InterB {	//这么做不允许是非法的
class Demo extends Object implements InterA,InterB {
	public void printA() {
		System.out.println("printA");
	}

	public void printB() {
		System.out.println("printB");
	}
}

四.抽象类和接口的区别

    * 抽象类：
        * 成员变量：可以变量，也可以常量
        * 构造方法：有
        * 成员方法：可以抽象，也可以非抽象
    * 接口：
        * 成员变量：只可以常量
        * 成员方法：只可以抽象     
* B:关系区别
    * 类与类
        * 继承，单继承
    * 类与接口
        * 实现，单实现，多实现
    * 接口与接口
        * 继承，单继承，多继承     
* C:设计理念区别
    * 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
    * 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

五.猫狗示例加入跳高功能

    * 动物类：姓名，年龄，吃饭，睡觉。
    * 猫和狗
    * 动物培训接口：跳高

class Test1_Animal {
	public static void main(String[] args) {
		Cat c = new Cat("加菲",8);
		c.eat();
		c.sleep();

		JumpCat jc = new JumpCat("跳高猫",3);
		jc.eat();
		jc.sleep();
		jc.jump();
	}
}

abstract class Animal {
	private String name;				//姓名
	private 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 String getName() {		//获取姓名
		return name;
	}

	public void setAge(int age) {		//设置年龄
		this.age = age;
	}

	public int getAge() {			//获取年龄
		return age;
	}

	public abstract void eat();		//吃饭

	public abstract void sleep();		//睡觉
}

interface Jumping {				//跳高的接口
	public void jump();
}

class Cat extends Animal {
	public Cat() {}				//空参构造

	public Cat(String name,int age) {       //有参构造
		super(name,age);
	}

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

	public void sleep() {
		System.out.println("侧着睡");
	}
}

class JumpCat extends Cat implements Jumping {
	public JumpCat() {}			//空参构造

	public JumpCat(String name,int age) {  //有参构造
		super(name,age);
	}

	public void jump() {
		System.out.println("猫跳高");
	}
}