接口在JAVA中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。
一个类通过继承接口的方式，来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
简单讲，比抽象类更加抽象的表现形式，就是接口。
一：定义接口
1：我们定义一个接口，然后用一个类来实现他：
csharp
public class T01 {
public static void main(String[] args) {
student stu = new student();
stu.eat();
stu.drink();
}
}
/**
* 人 接口
*/
interface person
{
/**
* 吃 抽象方法
*/
public abstract void eat();
/**
* 喝 抽象方法
*/
public abstract void drink();
}
class student implements person
{
/**
* 实现接口 吃方法
*/
public void eat()
{
System.out.println("学生吃！");
}
/**
* 实现接口 喝方法
*/
public void drink()
{
System.out.println("学生喝！");
}
}控制台输出：
学生吃！
学生喝！
2：定义一个抽象类，来实现接口，再定义一个普通类来继承抽象类
csharp
public class T01 {
public static void main(String[] args) {
teacherOne tea = new teacherOne();
tea.eat();
tea.drink();
}
}
/**
* 人 接口
*/
interface person
{
/**
* 吃 抽象方法
*/
public abstract void eat();
/**
* 喝 抽象方法
*/
public abstract void drink();
}
/**
* 抽象类 实现 接口
*/
abstract class teacher implements person {
}
class teacherOne extends teacher
{
/**
* 实现接口 吃方法
*/
public void eat()
{
System.out.println("教师一吃！");
}
/**
* 实现接口 喝方法
*/
public void drink()
{
System.out.println("教师一喝！");
}
}控制台输出：
教师一吃！
教师一喝！
二：接口特点
1：接口不能创建对象。
2：除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
三：接口成员特点
1：成员变量
接口中的所有变量都是自定义静态常量
csharp
public class T01 {
public static void main(String[] args) {
// 调用接口person中的成员变量a
System.out.println(person.a);
}
}
/**
* 人 接口
*/
interface person
{
// 第一种写法
public static final int a = 1;
// 第二种写法
static final int b = 2;
// 第三种写法
final int c = 3;
// 第四种写法
int d = 4;
/**
* 吃 抽象方法
*/
public abstract void eat();
/**
* 喝 抽象方法
*/
public abstract void drink();
}控制台输出：
1
2：成员方法
接口中的所有方法都是抽象方法（这句话对初学者来说，是没有问题的，但是这句话是不严谨的）
默认修饰符：public abstract
csharp
/**
* 人 接口
*/
interface person
{
/**
* 吃 抽象方法
*/
void eats();
/**
* 吃 抽象方法
*/
abstract void eat();
/**
* 喝 抽象方法
*/
public void drinks();
/**
* 喝 抽象方法
*/
public abstract void drink();
}以上四种写法都可以，但是，推荐还是写全了吧。
3：构造方法
接口中没有构造方法
四：接口与接口，类与类，接口与类之间的关系
1：类与类：继承关系，单继承，不可多继承。
csharp
/**
* 父类
*/
class fu
{
public void aaa()
{
System.out.println("父类重写！");
}
}
/**
* 子类
*/
class zi extends fu
{
/**
* 重写父类方法
*/
@Override
public void aaa()
{
System.out.println("子类重写！");
}
}2：类与接口，实现关系：支持单实现，也支持多实现。
csharp
public class T01 {
public static void main(String[] args) {
teacher tea = new teacher();
tea.drink();
tea.eat();
tea.run();
tea.zou();
}
}
/**
* 人 接口
*/
interface person
{
/**
* 吃 抽象方法
*/
public abstract void eat();
/**
* 喝 抽象方法
*/
public abstract void drink();
}
/**
* 男人 接口
*/
interface personMen extends person
{
/**
* 跑 抽象方法
*/
public abstract void run();
}
/**
* 女人 接口
*/
interface personWomen extends person
{
/**
* 走 抽象方法
*/
public abstract void zou();
}
/**
* 教师类 同时实现 男人接口，女人接口
*/
class teacher implements personMen,personWomen
{
/**
* 吃 抽象方法
*/
public void eat()
{
System.out.println("教师类实现吃方法！");
}
/**
* 喝 抽象方法
*/
public void drink()
{
System.out.println("教师类实现喝方法！");
}
/**
* 跑 抽象方法
*/
public void run()
{
System.out.println("教师类实现跑方法！");
}
/**
* 走 抽象方法
*/
public void zou()
{
System.out.println("教师类实现走方法！");
}
}控制台输出：
教师类实现喝方法！
教师类实现吃方法！
教师类实现跑方法！
教师类实现走方法！
3：接口与接口：继承关系，支持单继承，也支持多继承
csharp
public class T01 {
public static void main(String[] args) {
student stu = new student();
stu.drink();
stu.eat();
stu.run();
stu.zou();
stu.study(); }
}
/**
* 人 接口
*/
interface person
{
/**
* 吃 抽象方法
*/
public abstract void eat();
/**
* 喝 抽象方法
*/
public abstract void drink();
}
/**
* 男人 接口
*/
interface personMen extends person
{
/**
* 跑 抽象方法
*/
public abstract void run();
}
/**
* 女人 接口
*/
interface personWomen extends person
{
/**
* 走 抽象方法
*/
public abstract void zou();
}
/**
* 学生接口，继承男人接口，女人接口
*/
interface studentInterface extends personMen,personWomen
{
/**
* 学习 抽象方法
*/
public abstract void study();
}
class student implements studentInterface
{
/**
* 吃 抽象方法
*/
public void eat()
{
System.out.println("学生类实现吃方法！");
}
/**
* 喝 抽象方法
*/
public void drink()
{
System.out.println("学生类实现喝方法！");
}
/**
* 跑 抽象方法
*/
public void run()
{
System.out.println("学生类实现跑方法！");
}
/**
* 走 抽象方法
*/
public void zou()
{
System.out.println("学生类实现走方法！");
}
/**
* 学习 抽象方法
*/
public void study()
{
System.out.println("学生类实现走方法！");
}
}控制台输出：
学生类实现喝方法！
学生类实现吃方法！
学生类实现跑方法！
学生类实现走方法！
学生类实现走方法！
五：我们什么时候使用接口，什么时候使用类（包含抽象类）
当两个类之间存在必须是的关系的时候，就必须要使用类（抽象类）。
接口是额外扩展的功能，本身该类不具备这个功能，而且是不必须是的关系，就需要去实现这样的接口了。
csharp
/**
* 人 抽象类
*/
abstract class person
{
/**
* 喝 抽象方法
*/
public abstract void drink();
}
/**
* 司机接口
*/
interface siji
{
/**
* 开车 抽象方法
*/
public abstract void kaiche();
}
/**
* 工人 是 人，所以需要喝水
*/
class worker extends person
{
public void drink()
{
System.out.println("喝水");
}
}
/**
* 司机工人 是 人，所以需要喝水，也需要具备司机的能力，但是，司机的能力不是所有的工人都需要具备
*/
class workerSiJi extends worker implements siji
{
public void drink()
{
System.out.println("喝水");
}
public void kaiche()
{
System.out.println("开车！");
}
}解释一下上方的代码：
定义一个抽象类person，其中有一个抽象方法drink，人必须要喝水。
定义一个司机接口，其中有一个抽象方法kaiche，司机需要会开车。
定义一个工人类，工人是人，必须要喝水，因此需要继承抽象类person。
定义一个司机工人类，司机工人也是人，必须要喝水，需要继承抽象类person，但是司机也需要会开车，因此需要实现siji接口。
以上大概就是java中接口的使用。
有好的建议，请在下方输入你的评论。