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修饰的方法)
接口中不能包含构造方法,代码块,静态代码块。