接口的学习与使用

1.接口概述

接口在我们的生活中随处可见,例如:屋子里的五孔墙插,电脑USB接口

在这里我们思考一个问题:为什么不同厂家生产的五孔墙插,安装之后都可以正常使用呢?
就是因为他们生产时都是遵循着同样的规范生产出来的.
其实接口就是一组规范或者标准,只要符合规范,大家都可以使用.
Java中的接口更多的是对行为的抽象,它只规定有什么方法,自身不提供实现,由遵循规范的类来提供实现

接口的实现类: 实现接口的类称为接口的实现类

2.接口的定义

在Java中,使用Interface关键字来定义接口
接口定义的语法:

public interface 接口名{
	//静态常量;
	//抽象方法. 默认方法. 静态方法
}

2.1接口的示例:

public interface Driving{
	//开车
	public abstract void drive();
}

3.接口的实现类

类通过implements关键字实现接口
语法格式:

public class 类名 implements 接口名{
		//属性
		//方法
}

3.1接口的实现类示例

需求:设计教师、程序员类，教师能教课，程序员可以写代码，他们都会开车。

注意:千万不要定义一个司机（Driver）类，让教师和程序员继承于Driver，他们不满足is a的关系，不能滥用继承。(即,教师,程序员都不是一名司机)

父类Person

	//先给教师,程序员定义一个父类Person
public class Person{
	private String name;
	private int age;
	//定义getter,setter方法
	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 Person() {
			super();
		}
	public Person(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}
	
}

教师类

	//教师类
public class Teacher extends Person{
	//定义构造方法
	public Teacher(){
		super();	
	}
	public Teacher(String name,int age){
		super(name,age);
	}
	//教课
	public void teachCouse(){
	System.out.println(this.getName() + "正在授课");
	}

}

程序员类

//程序员
public class Programmer extends Person{
	//定义构造方法
	public Programmer(){
		super();	
	}
	public Programmer(String name,int age){
		super(name,age);
	}
	//写代码
	public void writeCode(){
	System.out.println(this.getName() + "正在写代码");
	}

}

驾驶接口Driving

public interface Driving{
	//开车
	public abstract void drive();
}

教师实现Driving接口

public class Teacher extends Person implements Driving{
	//定义构造方法
	public Teacher(){
		super();	
	}
	public Teacher(String name,int age){
		super(name,age);
	}
	//教课
	public void teachCouse(){
	System.out.println(this.getName() + "正在授课");
	}
	//方法重写
	@Override
	public void drive() {
	System.out.println("教师开车");
	}
}

程序员实现Driving接口

public class Programmer extends Person implements Driving{
	//定义构造方法
	public Programmer(){
		super();	
	}
	public Programmer(String name,int age){
		super(name,age);
	}
	//写代码
	public void writeCode(){
	System.out.println(this.getName() + "正在写代码");
	}
	//方法重写
	@Override
	public void drive() {
	System.out.println("程序员开车");
	}

}

测试代码

public class ClassTest{
		Teacher t = new Teacher("张三", 32);
		t.teachCouse();//自己的方法
		t.drive();//实现的接口中的方法
		Driving d = new Teacher("李四", 25);//多态
		d.drive();
		Programmer p = new Programmer("王五", 24);
		p.writeCode();//自己的方法
		p.drive();//实现的接口中的方法

}

运行结果:

4.接口的成员特点

接口可以包含自己的成员,包括属性和方法.(接口中可以包含属性,但是极少用到)

接口的成员特点将在如下代码中体现:
有如下接口，MyInterface

public interface MyInterface {
	int a = 10;
	public int b = 20;
	public static int c = 30;
	public static final int d = 40;
}

有如下实现类，MyInterfaceImpl

public class MyInterfaceImpl implements MyInterface {

}

测试代码：

public class ClassTest {
public static void main(String[] args) {
	MyInterface my = new MyInterfaceImpl();
	System.out.println(my.a);
	//说明a被static修饰了
	System.out.println(MyInterface.a);
	//my.a = 100;//final修饰的变量不能改值
	System.out.println(my.b);
	//说明b被static修饰了
	System.out.println(MyInterface.b);
	//my.b = 200;//final修饰的变量不能改值
	System.out.println(my.c);
	System.out.println(MyInterface.c);
	//my.c= 300;//接口中的属性默认是 public static final修饰
	System.out.println(my.d);
	//因为d是static修饰的，所以可以用类名访问。
	System.out.println(MyInterface.d);
	//my.d= 400;//final修饰的变量不能改值
	}
	
}

运行结果:

通过测试，我们发现 a 隐含了修饰符 public、final和static，b 隐含了修饰符 static、final，c 隐含了修饰符 final。

4.1接口中的方法

1.接口中不能有构造方法,初始化代码块,静态代码块!!!
2.接口不是类,它只声明接口中有什么方法,但是自身不实现。只定义不实现的方法也叫做抽象方法，用关键字abstract修饰 ，接口在声明方法是public abstract可以省略。
3.如果不定义范围类型,默认为 public abstracr

示例如下：

public interface MyInterface {
	int a = 10;
	public int b = 20;
	public static int c = 30;
	public static final int d = 40;


	//接口只定义包含什么方法，但是自身不实现。
	public abstract void method1();
	public void method2();
	void method3();
}

实现类MyInterfaceImpl

public class MyInterfaceImpl implements MyInterface {
	@Override
	public void method1() {
	System.out.println("method1");
	}
	@Override
	public void method2() {
	System.out.println("method2");
	}
	@Override
	public void method3() {
	System.out.println("method3");
	}
}

测试代码：

public class ClassTest {
	public static void main(String[] args) {
		my.method1();
		my.method2();
		my.method3();
		}
}

运行结果：

5.接口中定义静态方法和默认方法

1.从Java8开始，接口中可以定义静态方法和默认方法。静态方法和默认方法不再是方法的声明而是有方法体。

2.接口中的静态方法和类中的静态方法不同。接口中的静态方法只能用接口名调用，不能用对象调
用。类中的静态方法，既可以用类名调用，也可以用对象调用。

3.接口中的默认方法，必须用default关键字修饰。被default关键字修饰的方法不再是抽象方法，可
以给出默认实现。之所以这么设定，是避免了接口中增加新方法影响已有实现类的使用。（如果没有默认实现
，所有已有的实现类，都必须实现新增的方法。）

示例：
接口 MyInterface

public interface MyInterface {
	//1. 静态方法。
	public static void staticMethod() {
	System.out.println("我是接口中的静态方法");
	}
	//2. 默认方法
	public default void defaultMethod() {
	System.out.println("我是接口中的默认方法，默认方法必须要加default关键字");
	}
}

实现接口MyInterface

public class MyInterfaceImpl implements MyInterface {
	public static void staticMethod() {
		System.out.println("子类的静态方法");
	}
		//重写接口中的默认方法
		@Override
	public void defaultMethod() {
		System.out.println("重写了接口中的默认方法");
	}
}

测试代码:

public class ClassTest {
	public static void main(String[] args) {
		MyInterface my = new MyInterfaceImpl();
		MyInterface.staticMethod();
		MyInterfaceImpl.staticMethod();
		//my.staticMethod();//接口中的静态方法，只能用接口名调用，不能用对象调用。（类中的
		//静态方法既可以用类名调用，也可以用对象调用，推荐使用类名调用）
		my.defaultMethod();//默认方法是对象方法，用对象来调用。
		}
}

运行结果：

6.接口总结

接口中可以包含属性：必须是public static final 修饰的属性，即静态常量，变量名命名时大写

接口中可以包含方法：
1.public abstract 修饰的抽象方法
2.静态方法（public static修饰的方法）
3.默认方法（public default修饰的方法）

接口中不能包含构造方法，代码块，静态代码块。