接口
使用关键字interface来定义一个接口，和类的定义方法很相似分为接口声明和接口体。
interface Printable {
final int MAX = 100;
void add();
float sum(float x, float y);
}
接口体中包含常量的声明（没有变量）和抽象方法两部分。而且接口体中所有常量都是publicf访问权限，而且是static常量（允许省略public、final、static修饰符），所有抽象方法一定是pupblic访问权限（允许省略public、abstract等修饰符）。
interface Printable {
final int MAX = 100; //public static final int MAX=100;
void add(); //public abstract void add();
float sum(float x, float y);
}
实现接口
java中接口由类实现以便使用接口的方法。一个类需要在类声明中使用关键字implements声明该类实现一个或多个接口。如果实现多个接口，使用逗号隔开如：
class A implements B,C //B,C为接口类
如果一个非抽象类实现了某个接口，那么必须重写这个接口中的所有方法。需要注意的是，由于接口中的方法一定是public abstract方法，所以类在重写接口方法时不仅要去掉abstract修饰符、给出方法体，而且访问权限一定要明显的用public来修饰（否则降低了访问权限，这是不允许的）
如果一个类声明实现一个接口，但没有重写接口中的方法，那么这个类必定是抽象类。也就是说抽象类既可以重写接口中的方法，也可以重写接口中的方法。
java提供的接口都在相应的包中，通过import语句不仅可以引用包中的类，也可引入包中的接口，例如：
import java.io.*;
不仅引入了Java.io包中的类，同时也引入了该包中的接口。
接口基础代码：
import java.awt.*;
import java.io.*;
public class Test {
public static void main(String[] args) {
Bus bus101 = new Bus();
Taxi blueTaxi = new Taxi();
Cinema redStarCinema = new Cinema();
MoneyFare fare;
ControlTemperature temperature;
fare = bus101;
bus101.brake();
fare.charge();
fare = blueTaxi;
temperature = blueTaxi;
blueTaxi.brake();
fare.charge();
temperature.controlAirTemperature();
fare = redStarCinema;
temperature = redStarCinema;
fare.charge();
temperature.controlAirTemperature();
}
}
abstract class MotorVehicle {
abstract void brake();
}
interface MoneyFare {
void charge();
}
interface ControlTemperature {
void controlAirTemperature();
}
class Bus extends MotorVehicle implements MoneyFare {
void brake() {
System.out.println("公共汽车使用x刹车");
}
public void charge() {
System.out.println("公共汽车： 一元/张，不计算公里数");
}
}
class Taxi extends MotorVehicle implements MoneyFare, ControlTemperature {
void brake() {
System.out.println("出租车使用盘式刹车技术");
}
public void charge() {
System.out.println("出租车：2元/公里，起价三公里");
}
public void controlAirTemperature() {
System.out.println("出租车安装了Hair空调");
}
}
class Cinema implements MoneyFare, ControlTemperature {
public void charge() {
System.out.print("电影院：门票，十元/张");
}
public void controlAirTemperature() {
System.out.print("电影院安装了*空调");
}
}
接口参数
如果一个方法的参数是接口类型，我们可以将任何实现该接口的类的实例的引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法。如:
import java.awt.*;
import java.io.*;
interface SpeakHello {
void speakHello();
}
class Chinese implements SpeakHello {
public void speakHello() {
System.out.println("中国人习惯问候语：你好，吃饭了吗？");
}
}
class English implements SpeakHello {
public void speakHello() {
System.out.println("英国人习惯性问候语：你好，天气不错 ");
}
}
class KindHello {
public void lookHello(SpeakHello hello) { //接口回调
hello.speakHello(); //接口回调参数
}
}
public class Test {
public static void main(String[] args) {
KindHello kindHello = new KindHello();
kindHello.lookHello(new Chinese());
kindHello.lookHello(new English());
}
}
1.接口的定义及简单理解
接口（ Interface ）：确定了对特定对象所能发出的请求，或者对象接收消息的方式。
将“做什么”与“怎么做”分离；
接口中只声明方法（“做什么”，抽象方法）但不定义方法体（“怎么做”）；
接口只规定了类的基本形式，不涉及任何实现细节，实现一个接口的类具有接口规定的行为；
接口可看作使用类的“客户”代码与提供服务的类之间的契约或协议。
2.接口定义=接口声明+接口体
2.1 接口声明
[public] interface 接口名 [extends 父接口列表] { 接口体 }
public / default：任意类均可使用 / 与该接口在同一个包中的类可使用
一个接口可以有多个父接口，子接口继承父接口的所有常量和方法
2.2 接口体
接口体=常量定义+方法定义
常量默认具有public, final, static属性
类型 常量名=常量值;
方法默认具有public, abstract属性
返回类型 方法名 ([参数列表]);
1.常量不能为空白final的
2.父接口中的常量可被子接口中的同名常量隐藏，父接口中的方法可被子接口中的方法重写
3.接口中成员不能使用的修饰符：transient, volatile, synchronized, private, protected
3.接口的使用——用类实现接口
1.类声明中的implements关键字
2.类可以使用接口定义的常量
3.类必须实现接口定义的所有方法
4.一个类可以实现多个接口，例：
interface I1{ … }
interface I2{ … }
class Sup { … }
class C extends Sup implements I1,I2 { … }
5.Java的类继承只支持单继承（子类从单个父类继承），不支持多重继承（子类从多个父类继承）
---extends后的类名只能有一个
---类的继承关系形成树型层次结构
---接口的继承支持多重继承
6.类可以通过实现多个接口达到多重继承的效果
7.在进行单个父类与多个接口合并时，只有单个父类具有实现细节，从而避免代码冲突
8.通过继承扩展接口
---直接向接口中扩展方法可能带来问题：所有实现原来接口的类将因为接口的改变而不能正常工作
---不能向interface定义中随意增加方法，需要通过继承扩展接口，例如：
public interface StockWatcher {
final String sunTicker = "SUNW";
final String oracleTicker = "ORCL";
void valueChanged(String tickerSymbol, double newValue);
void currentValue(String tickerSymbol, double newValue);
}
public interface StockTracker extends StockWatcher {
void currentValue(String tickerSymbol, double newValue);
}
类实现接口
在Java语言中，接口由类来实现以便使用接口中的方法。 一个类需要类声明中使用关键字implements声明该类实现个或多个接口。 如果实现多个接口，用逗号隔开接口名，例如A类实现Pintable和Addable接口。
classA implements Printable,Addable
再如，Animal 的Dog子类实现Eatable和Sleepable接口。
classDog extends Aninal implements Eatable,Sleepable
重写接口中的方法
如果一个非抽象类实现了某个接口，那么这个类必须重写这个接口中的所有方法。需要注意的是，由于接口中的方法定是public abstract 方法，所以类在重写接口方法时不仅要去掉abstract 修饰符、给出方法体，而且方法的访问权限一定要明显地用public来修饰(否则就降低了访问权限，这是不允许的).实现接口的非抽象类实现了该接口中的方法，即给出了方法的具体行为功能。用户也可以自定义接口，一个Java源文件可以由类和接口组成。
下面的例子1中包含China类、Japan类和Compuable接口，而且China类和Japan类都实现了Computable接口。
Computable.java
public interface Computable{
int MAX=46;
int f(int x);
}
China.java
class China implements Computable{ //China类实现Computable接口
int number;
public int f(int x){ //不要忘记publie关键宇
int sum=0;
for(int i=0;i<=x;i++){
sum=sum+i;
}
return sum;
}
}
Japan.java
class Japan implements Computable { //Japan 类实现Computable接口
int number;
public int f(int x){
return MAX+x; //直接使用接口中的常量
}
}
Example6_1.java
public class Example6_1{
public static void main(String args[]){
China zhang;
Japan henlu;
zhang=new China();
henlu=new Japan();
zhang.number=32+Computable .MAX; //用接口名访问接口的常量
henlu.number=14+Computable.MAX;
System.out.println("zhang的学号"+zhang.number+",zhang 求和结果"+zhang.f(100));
System.out.println("henlu的学号"+henlu.number+",henlu 求和结果"+henlu.f(100));
}
}
如果一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类，也就是说，抽象类既可以重写接口中的方法，也可以直接拥有接口中的方法，例如:
interface Computable {
final int MAX = 100;
vo1d speak(String s);
int f(int x);
float g(float x,float y);
}
abstract classA implements Computable{
public int f(int x){
int sum 0:
for(int i=1;i<=x;i++) {
sum=sum+i;
}
return sum;
}
}
接口的细节说明
程序可以用接口名方问接口中的常量，但是如果个类实现了接口，那么该类可以直接在类体中使用该接口中的常量。
定义接口时，如果关键字interface前面加上外汇返佣public关键字，就称这样的接口是一个public接口。public接口可以被任何一个类实现。如果一个接口不加public修饰，就称作友好接口，友好接口可以被与该接口在同一包中的类实现。
如果父类实现了某个接口，那么子类也就自然实现了该接口，子类不必再显式地使用关键字implements声明实现这个接口，
接口也可以被继承，即可以通过关键字extends声明个接口是另个接口的 子接口。由于接口中的方法和常量都是public的，子接口将继承父接口中的全部方法和常量。
注: Java提供的接口都在相应的包中，通过import语向不仅可以引入包中的类，也可以引入包中的接口，例如:
importJava.io.*;
不仅引入了java.io包中的类，同时也引入了该包中的接口。