Java中接口和抽象类的区别详解，内附两个接口小案例

接口类和抽象类的区别：

• A：成员区别：
  抽象类：
  a:成员变量：可以是变量，也可以是常量
  b:构造方法：有
  c:成员方法：可以抽象，也可以非抽象
  接口：
  a:成员变量：只可以是常量
  b:构造方法：无
  c:成员方法：只可以抽象

• B：关系区别：
  类与类：继承，单继承
  类与接口：实现，单实现，多实现
  接口与接口：继承，单继承，多继承

• C：设计理念的区别：
  抽象类：被继承体现的是："is a "的关系。抽象类中定义的是该继承体系的共性功能
  接口：被实现体现的是："like a"的关系。接口中定义的是该继承体系的扩展功能

---

接口案例1：
猫狗案例：加入跳高的额外功能
代码示例如下：

/*
	猫狗案例：加入调高的额外功能
	
	分析：从具体到抽象
		猫：
			姓名，年龄
			吃饭，睡觉
		狗：
			姓名，年龄
			吃饭，睡觉
			
		由于有共性功能，所有我们抽取出一个父类
		动物：
			姓名，年龄
			吃饭();
			睡觉() {}
		
		猫：继承自动物
		狗：继承自动物
		
		跳高的额外功能是一个新的扩展功能，所以我们要定义一个借口
		接口：
			跳高
		部分猫：实现跳高
		部分狗：实现跳高
	
	实现：从抽象到具体
	
	使用：
		使用具体类
*/
//定义跳高接口
interface Jumping {
	//跳高功能
	public abstract void 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 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 void sleep() {
		System.out.println("睡觉觉了！");
	}
}
class Cat extends Animal {
	public Cat() {
		
	}
	public Cat(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
class Dog extends Animal {
	public Dog() {
		
	}
	public Dog(String name,int age) {
		super(name,age);
	}
	public void eat() {
		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("会跳高");
	}
}
class JumpDog extends Dog implements Jumping {
	public JumpDog() {
		
	}
	public JumpDog(String name,int age) {
		super(name,age);
	}
	public void jump() {
		System.out.println("会跳高");
	}
}
class InterfaceTest {
	public static void main(String[] args) {
		//使用具体类创建对象
		JumpCat jc = new JumpCat();
		jc.setName("阿华");
		jc.setAge(3);
		System.out.println("名叫"+jc.getName()+"的猫，今年"+jc.getAge()+"岁");
		jc.eat();
		jc.sleep();
		jc.jump();
		//方式二
		JumpCat jc1 = new JumpCat("阿旭",2);
		System.out.println("名叫"+jc1.getName()+"的猫，今年"+jc1.getAge()+"岁");
		jc1.eat();
		jc1.sleep();
		jc1.jump();
		System.out.println("----------");
		//对狗进行测试
		JumpDog jd = new JumpDog();
		jd.setName("阿鹰");
		jd.setAge(3);
		System.out.println("名叫"+jd.getName()+"的狗，今年"+jd.getAge()+"岁");
		jd.eat();
		jd.sleep();
		jd.jump();
		//方式二
		JumpDog jd2 = new JumpDog("阿冯",1);
		System.out.println("名叫"+jd2.getName()+"的狗，今年"+jd2.getAge()+"岁");
		jd2.eat();
		jd2.sleep();
		jd2.jump();
	}
}

接口案例2：
老师和学生案例，加入抽烟的额外功能
代码示例如下：

/*
	老师和学生案例，加入抽烟的额外功能
	
	分析：从具体到抽象
		老师：
			姓名，年龄，吃饭，睡觉
		学生：
			姓名，年龄，吃饭，睡觉
			
		由于有共性功能，我们提取出一个父类，人类
		
		人类：
			姓名，年龄
			吃饭();
			睡觉() {}
			
		抽烟的额外功能不是人或者老师，或者学生一开始就具备的，所以我们把它定义为接口
		
		抽烟接口。
		
		部分老师抽烟：实现抽烟接口
		部分学生抽烟：实现抽烟接口
		
	实现：从抽象到具体
	
	使用：具体类实现
*/
//定义抽烟接口
interface Smoking {
	public abstract void smoke();
}
abstract class Person {
	private String name;
	private int age;
	public Person() {
		
	}
	public Person(String name,int age) {
		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 void sleep() {
		System.out.println("睡觉觉");
	}
}
class Student extends Person {
	public Student() {
		
	}
	public Student(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("学生吃肉长个");
	}
}
class Teacher extends Person {
	public Teacher() {
		
	}
	public Teacher(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("老师吃点素的");
	}
}
//定义具体抽烟的人
class SomeStudent extends Student implements Smoking {
	public SomeStudent() {
		
	}
	public SomeStudent(String name,int age) {
		super(name,age);
	}
	public void smoke() {
		System.out.println("我是学生我会吸烟！");
	}
}
class SomeTeacher extends Teacher implements Smoking {
	public SomeTeacher() {
		
	}
	public SomeTeacher(String name,int age) {
		super(name,age);
	}
	public void smoke() {
		System.out.println("我是老师我会吸烟！");
	}
}
class InterfaceTest2 {
	public static void main(String[] args) {
		//测试
		SomeStudent ss = new SomeStudent();
		ss.setName("小猪佩奇");
		ss.setAge(18);
		System.out.println(ss.getName()+"今年"+ss.getAge()+"岁");
		ss.eat();
		ss.sleep();
		ss.smoke();
		System.out.println("-------------");
		//方式二
		SomeStudent ss1 = new SomeStudent("徐凤年",25);
		System.out.println(ss1.getName()+"今年"+ss1.getAge()+"岁");
		ss1.eat();
		ss1.sleep();
		ss1.smoke();
		System.out.println("-------------");
		//测试老师
		SomeTeacher st = new SomeTeacher();
		st.setName("张雪峰");
		st.setAge(58);
		System.out.println(st.getName()+"今年"+st.getAge()+"岁");
		st.eat();
		st.sleep();
		st.smoke();
		System.out.println("-------------");
		//方式二
		SomeTeacher st1 = new SomeTeacher("汤家凤",55);
		System.out.println(st1.getName()+"今年"+st1.getAge()+"岁");
		st1.eat();
		st1.sleep();
		st1.smoke();
		System.out.println("-------------");
	}
}