① 概念:是一种标准,是使用者和实现者都必须遵循的一种约定。
② 基本的语法:【重点】
a. 关键字: interface
b. 接口在编译之后会生成.class 文件
c. 接口不能创建对象,但是可以声明引用
d. 接口中没有构造方法
e. 接口中的所有属性都是公开的、静态的、常量
(public static final 修饰)
f. 接口中的所有方法都是公开、抽象方法(public abstract 修饰)
2. 实现类:【重点】① 语法: class 类名 implements 接口名{
//....
}
② 注意:实现类实现一个接口,必须实现接口中所有的方法,
否则实现类也必须是一个抽象类。
③ 使用:父类接口 引用名=new 实现类类名(实参);//多态的应用
3. 接口之间的继承关系【重点】
① 接口与接口之间是多继承关系:
interface 接口名 extends 父接口名1,父接口2{}
② 类同时可以实现多个接口(类与接口之间是多实现关系):
class 类名 implements 接口名1,接口名2{}
③ 类可以继承一个父类,同时实现多个父接口,但是必须是先继承后实现。
class 类名 extends 父类名 implements 父接口1,父接口2{}
4. 接口多继承的影响:【了解】
转换双方有一方为接口类型,编译一定通过,如果引用中存储的实际对象
和要转换的类型相匹配,则运行通过;如果引用中存储的实际对象类型和要
转换类型不匹配,则运行报错,错误信息:
java.lang.ClassCastException(类型转换异常)
5. 接口的好处 【重点理解】
① 扩充子类的能力:
Java是单继承,所有当父类中定义的方法不满足子类的功能需求时,
可以通过接口扩充子类的能力。通常:将主要功能放在父类中,
次要功能放在接口中。
package demo2017112;
/*
* 子类扩充 :父类中的方法不足以满足子类的需求,可以通过接口扩充子类的能力。通常主要功能放在父类里面,次要功能放在接口中。
*/
public class TestAnimal{
public static void main(String[] args){
Animal[] as={
new Dog(),
new Cat(),
new Dog(),
new Fish(),
new Cat(),
new Dog(),
new Fish()
};
for(int i=0;i<as.length;i++){
as[i].eat();
}
//统计Animal数组中会跑的动物
int count=0;
for(int i=0;i<as.length;i++){
if(as[i] instanceof Runnable){
/*Runnable ru=(Runnable)as[i]; //会跑的动物
ru.run();*/
}
count++;
}
int sum=0;
for(int i=0;i<as.length;i++){
if(as[i] instanceof Swimable){
sum++;
}
}
System.out.println("会跑的动物的个数:"+count);
//统计会游泳的个数。
System.out.println("会游泳的动物的个数:"+sum);
}
}
//接口:跑能力
interface Runnable{
void run();
}
//游能力
interface Swimable{
void swim();
}
class Animal{
public void eat(){}
public void sleep(){}
}
class Dog extends Animal implements Runnable,Swimable{
public void eat(){
System.out.println("狗吃骨头...");
}
public void run(){
System.out.println("Dog..running....");
}
public void swim(){
System.out.println("狗刨....");
}
}
class Cat extends Animal implements Runnable{
public void eat(){
System.out.println("猫吃鱼....");
}
public void run(){
System.out.println("Cat...running...");
}
}
class Fish extends Animal implements Swimable{
public void eat(){
System.out.println("鱼虾米...");
}
public void swim(){
System.out.println("水中鱼....");
}
}
接口定义之后,将接口的实现者和接口的使用者分离,借助多态,
降低各功能模块的耦合度,从而实现弱耦合。
package demo2017112;
/*
*
* 弱偶型
*/
public class TestRuoOuHe {
// String name;
public static void main(String[] args) {
// 买一个台灯
Lamp lll = new Lamp();
lll.setLight(new GreenLight());
lll.on();
}
}
// 定义了一个发什么光的接口
interface Light {
public abstract void shine();
}
//台灯类
class Lamp {
private Light light;
// 接口类型
public void setLight(Light light) { // Light light=new GreenLight();//多态
this.light = light;
}
// 开关
public void on() {
light.shine();
}
}
// 灯泡
class YellowLight implements Light {
public void shine() {
System.out.println("发黄光...");
}
}
// 白灯泡
class WhiteLight implements Light {
public void shine() {
System.out.println("发白光...Liang");
}
}
class GreenLight implements Light {
public void shine() {
System.out.println("冒绿光....");
}
}
6. 接口回调:【理解即可】
接口定义之后,先有接口的使用者,再有接口的实现者。
开发者通常关注的是实现者。