接口-概述、定义及特点、成员的特点、类和类-类和接口-接口和接口之间的关系、抽象类和接口的区别、接口标准案例

1 接口概述

• 为了体现实物功能的扩展性，java提供了借口来定义这些额外的功能，在接口中不给出具体的实现。

2 接口定义及特点

• 定义接口用 interface
  　　格式：interface 接口名{}
• 实现接口用 implements
  　　格式：class 类名 implements 接口名{}
• 接口不能实例化
  　　接口可以按照多态的方式，由具体的实现类实现实例化（接口多态）
• 接口实现类：
  　　可以是抽象类：可以不重写抽象方法，但是意义不大
  　　可以是具体类：必须重写所有抽象方法

1. 具体类多态　不用
2. 抽象类多态　常用
3. 接口多态　　常用

3 接口中成员的特点

• 成员变量
  　　只能是静态常量 public static final
• 构造方法
  　　没有构造方法，因为接口的描述的是扩展功能，没有具体的存在。
• 成员方法
  　　只能是抽象方法，public abstract

4 类和类，类和接口，接口和接口之间的关系

• 类和类：继承关系且只能单继承，可以多层继承
• 类和接口：实现关系，可以单实现，也可以多实现
• 接口和接口：继承关系，可以是单继承，也可以多继承

5 抽象类和接口的区别

• 成员区别
  　　抽象类：
  　　　　成员变量：可以是变量，可以是常量
  　　　　有构造方法
  　　　　成员方法：可以是抽象的，可以是非抽象的
  　　接口：
  　　　　成员变量：只能是静态的常量
  　　　　没有构造方法
  　　　　成员方法：只能是抽象的
• 关系区别
  　　类和类：继承关系，只能单继承，可以多层继承。
  　　类和接口：实现关系，可以单实现，也可以多实现。
  　　接口和接口：继承关系，可以单继承，也可以多继承。、
• 设计区别：
  　　抽象类：定义的是该继承体系中的共性内容
  　　　　被继承的，体现的是is a的关系
  　　接口：定义的是事物扩展的功能
  　　　　被实现的，体现的是like a的关系

6 接口标准案例

• 猫狗案例，加入额外的走钢丝功能

• 分析：从具体的到抽象
  　　具体：猫 狗
  猫：
  　　姓名，年龄。。。
  　　吃饭，睡觉， 抓老鼠
  狗：
  　　姓名，年龄。。。
  　　吃饭，睡觉， 看门
  由于存在共性内容：提取父类

  动物：
  　　姓名，年龄。。。
  　　吃饭()，睡觉(){}，

  猫继承动物
  　　添加特有方法
  狗继承动物
  　　添加特有方法

  走钢丝是一个额外扩展的功能，所以定义成接口
  动物接口：
  　　goLine();

  部分猫：
  　　继承猫
  　　实现接口
  部分狗：
  　　继承狗
  　　实现接口

• 实现：从抽象到具体

• 测试：使用具体类测试

public interface AnimalInter {
	
	public abstract void goLine();
}

public class SuperCat extends Cat1 implements AnimalInter{

	public SuperCat() {
		super();
		// TODO Auto-generated constructor stub
	}

	public SuperCat(String name, int age, String color) {
		super(name, age, color);
		// TODO Auto-generated constructor stub
	}
	
	@Override
	public void goLine() {
		System.out.println("猫走钢丝");
		
	}
}

public class SuperDog extends Dog1 implements AnimalInter{
	
	public SuperDog() {
		super();
		// TODO Auto-generated constructor stub
	}

	public SuperDog(String name, int age, String color) {
		super(name, age, color);
		// TODO Auto-generated constructor stub
	}

	public void goLine() {
		System.out.println("狗走钢丝");
	}
	
}

abstract public class Animal1 {
	
	private String name;
	private int age;
	private String color;

	public Animal1() {
		
	}
	
	public Animal1(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}

	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 String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}
	
	public abstract void eat();
	
	public void sleep() {
		System.out.println("睡觉");
	}

	@Override
	public String toString() {
		return "Animal1 [name=" + name + ", age=" + age + ", color=" + color + "]";
	}
}

public class Cat1 extends Animal1{
	
	public Cat1() {
		super();
	}

	public Cat1(String name, int age, String color) {
		super(name, age, color);
	}
	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}

	public void zls() {
		System.out.println("抓老鼠");
	}
}

public class Dog1 extends Animal1{

	public Dog1() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Dog1(String name, int age, String color) {
		super(name, age, color);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
	
	public void km() {
		System.out.println("狗看门");
	}
	
}

import com.tony.day15.domain.Cat1;
import com.tony.day15.domain.Dog1;
import com.tony.day15.domain.SuperCat;
import com.tony.day15.domain.SuperDog;

public class Demo2 {

	public static void main(String[] args) {
		// 测试普通猫
		Cat1 c = new Cat1("大橘",2,"橘色");
		c.eat();
		c.sleep();
		c.zls();
		System.out.println(c);
		
		// 测试超级猫
		SuperCat c1 = new SuperCat("加菲",1,"咖色");
		c1.eat();
		c1.sleep();
		c1.zls();
		c1.goLine();
		System.out.println(c1);
		
		// 测试普通狗
		Dog1 d = new Dog1("二哈",2,"黑");
		d.eat();
		d.sleep();
		d.km();
		System.out.println(d);
		
		// 测试超级狗
		SuperDog d1 = new SuperDog("边牧",1,"白");
		d1.eat();
		d1.sleep();
		d1.km();
		d1.goLine();
		System.out.println(d1);
	}

}