Java 面向对象三大特性之三——接口（面试、学习、工作必备技能）

一、接口概述(interface)

二、接口的成员

三、继承和实现

四、单继承和多实现

五、接口的优点

六、接口与抽象类

七、接口的思想

八、接口案例——运动员

接口概述(interface)

定义：是抽象方法和常量值的集合。

本质：从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现

格式：–interface 接口名{}

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。(implements)

接口的定义：

package com.demo01;

public interface Interface1 {
	public static final float PI = 3.14f;
	
	public abstract void method();
}

看一个小例子：用接口实现多继承，多实现

package com.demo01;
/*
 * Java语言的继承是单一继承，一个子类只能有一个父类（一个儿子只能有一个亲爹）
 * Java语言给我们提供了一种机制，用于处理继承单一的局限性的，接口
 * 
 * 接口：接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的关系是实现，implements
 * interface
 * 
 * 格式：
 * 		interface 接口名 {
 * 
 * 		}
 * 
 */
public class InterfaceDemo {
	public static void main(String[] args) {
		BillGates gates = new BillGates();
		gates.code();
		gates.manage();
	}
}


//父类 定义接口
interface Boss {
	public void manage() ;
}

//父类 定义接口
interface Programmer {
	public void code() ;
}

//比尔盖茨
class BillGates implements Boss,Programmer {

	@Override
	public void code() {
		System.out.println("敲代码");
		// TODO Auto-generated method stub
		
	}

	@Override
	public void manage() {
		System.out.println("管理公司");
		// TODO Auto-generated method stub
		
	}
	
}

接口的成员

接口中的成员修饰符是固定的

–成员常量：public static final

接口里面定义变量是全局常量，而且上面三个关键字都可以省略,而且只能是 public static final

–成员函数：public abstract

接口里面定义的方法都是抽象的，而且上面的两个关键字也是可以省略的

–接口中的成员都是public的

看一个小例子，来理解上诉内容：

package com.demo01;
/*
 * 接口的成员特点：
 * 		只能有抽象方法
 * 		只能有常量
 * 		默认使用public&abstract修饰方法
 * 		只能使用public&abstract修饰方法
 * 		默认使用public static final来修饰成员变量
 * 
 * 建议：建议大家手动的给上默认修饰符
 * 
 * 注意：
 * 		接口不能创建对象（不能实例化）
 * 		类与接口的关系是实现关系，一个类实现一个接口必须实现它所有的方法

 */
public class InterfaceDemo2 {
	public static void main(String[] args) {
		// new 实际类的对象
		Animal a = new Cat();
		int n = Animal.num;
		a.eat();
		System.out.println(n);
	}
}


// 父类
interface Animal {
	public static final int num = 10;
	
	public abstract void eat();
}

// 子类

class Cat implements Animal {

	public void eat() {
		System.out.println("好好吃饭");
		
	}
	
}

继承和实现

类与类之间称为继承:因为该类无论是抽象的还是非抽象的,它的内部都可以定义非抽象方法,这个方法可以直接被子类使用,所以子类继承就可以应用了
类与接口是实现关系:因为接口中的方法都是抽象的,必须由子类实现才可以实例化,所以就用了这个关键字implements
接口与接口之间是继承关系:一个接口可以继承另一个接口,并添加新的属性和抽象方法,并且接口可以多继承
根据上面的接口的这些特点，我有一个经典例子，就是女明星认干爹

单继承和多实现

类只能单继承,而接口可以多实现
java将多继承机制进行改良,通过多实现接口的形式来体现
为什么不支持多继承呢?
因为你继承的多个父类中定义了相同的方法,而方法内容不同,jvm无法判断选择哪个个父类的方法,有安全隐患
而多实现就没有这个问题,即使是多个接口中都有相同的方法,但是他们都没有方法体
多实现的好处,一个类继承另一个类的同时可以实现多个接口,一个女星只能有一个亲爹,但是干爹就可以有很多了.多实现的好处是扩展了功能
接口的出现打破了单继承的局限性

接口的优点

接口是对外暴露的规则。
类与接口的关系是实现。
接口的出现降低耦合性。(实现了模块化开发,定义好规则,每个人实现自己的模块,大大提高了开发效率)。

接口与抽象类

共性：都是不断抽取出来的抽象的概念
区别 1：

–与类的关系

区别 2：

–成员变量——接口里边的成员变量必须是常量，可以是变量，而抽象类中即可以有常量也可以有变量，因为接口中，他是靠别人来实现的，要变量没有意义。抽象类里边可以有具体的实现。

–成员方法——接口里边必须是抽象的方法，不能有具体的实现，抽象类中既可以有抽象的方法，也可以有具体的实现方法。

–构造方法——接口里边没有构造方法，因为他是没法new，没有自己的对象，抽象类里边有构造方法的，因为他是可以直接调用实现的。

看以下例子，来理解继承关系

package com.demo01;

import java.util.List;

/*
 * 
 * 类与类：继承关系，单一继承，多层继承
 * 类与接口：实现关系，多实现
 * 接口与接口的关系：继承关系，多继承
 */
public class InterfaceDemo3 {
	public static void main(String[] args) {
		List list;
	}
}

//接口继承了B接口
interface InterA extends InterB {
	public abstract void method();
}

// B接口
interface InterB {
	public abstract void function();
}
// 多层继承 
interface InterC extends InterA {
	
}

class Demo implements InterC,InterB,InterA {

	@Override
	public void method() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void function() {
		// TODO Auto-generated method stub
		
	}
	
}

接口的思想

(1) Collection和List是父子关系，在API中自己索引查看。

接口案例——运动员

需求及分析：

第一、构造人的类

package com.demo02;

public class Person {
	String name;//姓名
	int age;//年龄
	String gender;//性别
	
	//无参构造
	public Person() {}
	
	//有参构造
	public Person(String name,int age,String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	//吃
	public void eat() {
		System.out.println("吃饭");
	}
	
	//睡
	public void sleep() {
		System.out.println("睡觉");
	}
}

第二、抽象类——运动员

package com.demo02;

/**
 * 运动员
 */
public abstract class Player extends Person {
	//学习
	public abstract void study();
}

第三、抽象类——教练

package com.demo02;
/**
 * 教练
 */
public abstract class Coach extends Person {
	//教
	public abstract void teach();
}

第四、创建一个接口，接口中的方法是学习英语。

package com.demo02;

/**
 * 学习说英语
 */
public interface SpeakEnglish {
	public abstract void speak();
}

第五、乒乓球运行员——继承并且学习抽球

package com.demo02;
/**
 * 乒乓球运动员
 */
public class PingpangPlayer extends Player {

	@Override
	public void study() {
		System.out.println("学抽球");
	}
	
}

第六、篮球运动员——继承运动员，实现学英语的接口

package com.demo02;
/**
 * 乒乓球运动员
 */
public class PingpangPlayer extends Player {

	@Override
	public void study() {
		System.out.println("学抽球");
	}
	
}

第七、篮球教练——继承抽象类教练，并且实现方法，学英语

package com.demo02;
/**
 * 篮球教练
 */
public class BasketBallCoach extends Coach implements SpeakEnglish {

	@Override
	public void teach() {
		System.out.println("教扣篮");
	}

	@Override
	public void speak() {
		System.out.println("说英语");
	}
	
}

第八、乒乓球教练——实现一个方法

package com.demo02;
/**
 * 乒乓球教练
 */
class PingpangCoach extends Coach {

	@Override
	public void teach() {
		System.out.println("教抽球");
	}
	
}

写一个测试类来调用

package com.demo02;
/* 	
 * 	篮球运动员和教练
	乒乓球运动员和教练
	现在篮球运动员和教练要出国访问,需要学习英语
	请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
 */
public class InterfaceTest {
	public static void main(String[] args) {
		//创建篮球运动员对象
		BasketBallPlayer bbp = new BasketBallPlayer();
		bbp.name = "胡大海";
		bbp.age = 35;
		bbp.gender = "男";
		bbp.sleep();
		bbp.study();
		bbp.speak();
		System.out.println("-------------");
		//创建乒乓球教练对象
		PingpangCoach ppc = new PingpangCoach();
		ppc.name = "刘胖子";
		ppc.age = 40;
		ppc.gender = "男";
		ppc.sleep();
		ppc.teach();
		//ppc.speak();
	}
}