Java中接口的特点及其概述

1：接口概述：

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通过Java中的接口更多的体现在对行为的抽象。

接口的特点：

接口用interface关键字修饰。

public interface 接口名字{}

类和接口之间是实现关系, 用implements关键字表示。

public class 类名 implements 接口名{}

接口不能实例化

— 那接口如何实例化呢?可以通过多态的方式, 创建其子类对象, 来完成接口的实例化。

— 多态的形式：具体类多态，抽象类多态，接口多态。

— 多态的前提：有继承或者实现关系；重写父类所有的方法；有父（类/接口）引用指向（子/实现）类对象。接口的实现类：

— 1.要么重写父接口中所有的抽象方法。

— 2.要么是抽象类。

/**

* 接口

*/

public interface Jumpping {

//抽象方法

public abstract void jump();

}

*****这里接口中的抽象方法可以省略 public 和 abstract两个关键字。****

public class Cat implements Jumpping {

// 重写父类中的所有抽象方法

@Override

public void jump() {

System.out.println("猫要跳上楼顶............");

}

//子类成员方法

public void eat(){

System.out.println("猫吃鱼.....");

}

}

/**

* 测试类

*/

public class TestJumping {

public static void main(String[] args) {

//创建对象 测试接口多态

Jumpping j1 = new Cat();

j1.jump(); //猫要跳上楼顶............

//测试子类对象

Cat c1 = new Cat();

c1.eat(); //猫吃鱼.....

//向下转型

Cat c2 = (Cat)j1;

c2.eat(); //猫吃鱼..... 了解

}

}

接口的成员特点：

成员变量：

— 只能是常量 默认有修饰符：public static final构造方法：

— 接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在。一个类如果没有父类，默认继承自Object类

-成员方法：

— 只能是抽象方法 默认修饰符：public abstract

//接口类

public interface Study {

int a = 20; //这里的变量在接口中 相当于一个静态常量

final int c = 50;

static final int d = 50;

// 新特性 有一个静态方法

static void method1(){

System.out.println("我是JDK1.8的新特性: 接口中可以写静态方法");

}

//新特性 有一个默认方法

default void method2() {

System.out.println("我是JDK1.8的新特性: 接口中可以写默认方法");

}

//抽象方法 省略了 public abstract

void eat();

void code();

}

// 实现类

public class StudyImpl implements Study {

@Override

public void eat() {

System.out.println("学生要吃东西........");

}

@Override

public void code() {

System.out.println("吃完东西就好好敲代码..");

}

}

//测试类

public class TestStudy {

public static void main(String[] args) {

//接口多态写法

Study s = new StudyImpl();

s.eat(); //学生要吃东西........

s.code(); //吃完东西就好好敲代码..

}

}

类和接口之间的关系：

类和类之间的关系： 继承关系，只能单继承，但是可以多层次。类和接口之间的关系： 实实现关系, 可以单实现, 也可以多实现. 还可以在继承一个类的同时实现多个接口。接口与接口之间: 继承关系, 可以单继承, 也可以多继承。

抽象类和接口的区别（记忆）

成员区别：

抽象类

​ 变量,常量；有构造方法；有抽象方法,也有非抽象方法接口

​ 常量；抽象方法

关系区别：

类与类

​ 继承，单继承类与接口

​ 实现，可以单实现，也可以多实现接口与接口

​ 继承，单继承，多继承

设计理念区别

抽象类

​ 对类抽象，包括属性、行为接口

​ 对行为抽象，主要是行为

具体案例：

// 学习英语接口

public interface StudyEnglish {

void speakEnglish();

}

public 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 abstract class Player extends Person {

public Player() {

}

public Player(String name, int age) {

super(name, age);

}

}

public abstract class Coach extends Player {

public Coach() {

}

public Coach(String name, int age) {

super(name, age);

}

public abstract void teach();

}

public class BaskballCoach extends Coach implements StudyEnglish {

public BaskballCoach() {

}

public BaskballCoach(String name, int age) {

super(name, age);

}

@Override

public void teach() {

System.out.println("篮球教练教如何打篮球..");

}

@Override

public void eat() {

System.out.println("篮球教练吃玉米");

}

@Override

public void speakEnglish() {

System.out.println("篮球教练学习英语.....");

}

}

public class BaskballPalyer extends Player implements StudyEnglish {

@Override

public void eat() {

System.out.println("篮球运动员吃牛肉.......");

}

@Override

public void speakEnglish() {

System.out.println("篮球运动员学习英语....");

}

}

/**

* 测试类

*/

public class TestDemo01 {

public static void main(String[] args) {

BaskballCoach bbc = new BaskballCoach();

bbc.setName("波波维奇");

bbc.setAge(78);

System.out.println(bbc.getName()+" "+bbc.getAge());

bbc.eat();

bbc.speakEnglish();

bbc.teach();

System.out.println("-----------------------------");

BaskballPalyer bbp = new BaskballPalyer();

bbp.setName("刘阿福");

bbp.setAge(23);

System.out.println(bbp.getName() + " "+bbp.getAge());

bbp.eat();

bbp.speakEnglish();

}

}