在java中，接口是一切实现方法的来源，任何实现都离开不了接口，那么，一个标准的java接口写法是怎样的呢?下面，就让小编带你一起了解一下吧。
 
(一)接口
 
1、什么是接口。
 
接口就是一些方法特征的集合。一些功能的定义。
 
比如：能被打开，能被关闭，这是定义了一些功能。把这些功能放在一起，我们称它为接口。
 
(可以理解为一种特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示)
 
(二)接口的特点:
 
1、接口里面的方法不能有实现(规范，标准)(像是PCI插槽一样)，而且必须是public的，由实现它的类去实现(如果是private的话，那么子类就看不见，那么怎么去实现)
 
2. 接口不能实例化,只能用来充当子类的规则模版
 
3、接口中的方法默认为public,abstract，任何实现了接口的类必须重写接口的所有方法，不能少(否则当前类需要修饰为抽象类);
 
3、多个无关的类可以实现同一接口;(一个父类有多个子类)
 
4、一个类可以实现多个接口(这与单继承不一样!);
 
5、与继承相似，可以实现多态;
 
6、接口之间可以继承，而且是多继承;
 
(三)接口与接口之间具备扩展的概念
 
类------extends----->类 (只能继承一个类)
 
接口----extends----->接口 (可以继承多个)
 
接口---implements--->类 (可以实现多个接口)
 
(四)接口与抽象类的异同
 
不同点：
 
(1)抽象类一定要有is-a的关系，而接口没有。
 
(2)抽象类里面不一定都是抽象方法，接口一定是抽象方法
 
(3)父类的方法可重写，也可不写。但接口中定义的功能，子类一定要实现。
 
(4)继承是单继承，但接口是多继承，多实现
 
相同点：
 
(1)他们都可以定义变量来引用子类的对象，从而实现多态的功能。提高代码的可扩展性及维护性。
 
(2)他们都不能实例化， 但是类可以
 
优势：
 
1、抽象类中可以可以为部分方法提供默认的实现，从而避免在子类中重复实现它们，提高代码的可重用性，这是抽象类的优势所在;而接口中只能包含抽象方法
 
由于抽象类中允许加入具体的方法，因此扩展抽象类的功能，即向抽象类中添加一个具体的方法不会对子类造成影响。而对于接口，一旦接口公布就必须非常稳定，因为随意在接口中添加抽象方法会影响到所有实现类，这些类要么实现所有新增的方法，那么声明为抽象类
 
2、一个类只能继承一个直接的父类，这个父类有可能是抽象类;但一个类可以实现多个接口，这是接口的优势所在
 
接口具体实现：package fuxi;
 
/*
 
(1) 编写Animal接口，接口中声明run() 方法
 
(2) 定义Bird类和Fish类实现Animal接口
 
(3) 编写Bird类和Fish类的测试程序，并调用其中的run()方法
 
*/
 
public class fuxi
 
{
 
public interface Animal
 
{
 
void run();
 
}
 
class Bird implements Animal
 
{
 
public void run()
 
{
 
System.out.println("鸟不会游泳");
 
}
 
}
 
class Fish implements Animal
 
{
 
public void run()
 
{
 
System.out.println("鱼会游泳");
 
}
 
}
 
public fuxi()
 
{
 
// TODO Auto-generated constructor stub
 
System.out.println("生成对象时调用构造函数");
 
}
 
public static void main(String[] args)
 
{
 
// TODO Auto-generated method stub
 
fuxi Fuxi = new fuxi();
 
Bird bird = Fuxi.new Bird();
 
bird.run();
 
Fish fish = Fuxi.new Fish();
 
fish.run();
 
}
 
}
 
以上就是java接口的所有内容了，想了解更多相关java入门知识，快请一直关注我们的网站吧。
 
推荐阅读：

 
前言
 
java接口调用从调用方式上可以分为3类：同步调用，异步调用，回调；同步调用基本不用说了，它是一种阻塞式的调用，就是A方法中直接调用方法B，从上往下依次执行。今天来说说异步调用。
 
什么是异步调用？
 
我的理解就是在方法A中调用方法B，但是方法B很耗时，如果是同步调用的话会等方法B执行完成后才往下执行，如果异步的话就是我调用了方法B，它给我个返回值证明它已接受调用，但是它并没有完成任务，而我就继续往下执行。可能有表达不当的地方，欢迎指正。
 
再用一个生活中的例子吧：
 
异步调用就是你 喊 你朋友吃饭 ，你朋友说知道了 ，待会忙完去找你 ，你就去做别的了。
 
同步调用就是你 喊 你朋友吃饭 ，你朋友在忙 ，你就一直在那等，等你朋友忙完了 ，你们一起去。
 
异步调用有哪些角色？
 
调用者
 
取货凭证
 
真实数据
 
一个调用者在调用耗时操作,不能立即返回数据时,先返回一个取货凭证.然后在过一断时间后凭取货凭证来获取真正的数据.
 
异步调用的例子
 
连结调用者和真实数据之间的桥梁是取货凭证.我们先来看它的实现:
 
public class FutureTicket{
 
private Object data = null;
 
private boolean completed = false;
 
public synchronized void makeRealData(){
 
if(this.complited) return;
 
//获取数据的耗时操作.这里用Sleep代替
 
try{
 
Thread.sleep(10000);
 
}catch(Throwable t){}
 
this.data = "返回的数据内容";
 
this.completed = true;
 
notifyAll();
 
}
 
public synchronized Object getData(){
 
while(!this.completed)){
 
try{
 
wait();
 
}catch(Throwable t){}
 
}
 
return this.data;
 
}
 
public boolean isCompleted(){
 
return this.completed;
 
}
 
}
 
为了简单化说明(不把它们的关系开得复杂),这里用Objectb代替了真实数据.而真实的实现中我们应该把makeData放在一个真实数据的类中,然后提供一个方法返回真实数据.这样对于真实数据的处理和取货凭证解耦.
 
对于这个取货凭证,调用者的如何调用是异步调用的关键:
 
publc class Requester{
 
public FutureTicket request(){
 
final FutureTicket ft = new FutureTicket();
 
//在新线程中调用耗时操作
 
new Thread(){
 
public void run(){
 
ft.makeRealData();
 
}
 
}.start();
 
return ft;
 
}
 
}
 
在新线程中启动耗时操作后,不等待线程的完成立即返回提货单.
 
然后调用者可以根据ft.isCompleted()来调用getData()获取真实数据.当然对ft.isCompleted()测试可以按规定时间间隔轮巡(极低级的方案),也可以在条件不满足时wait(),然后等待makeData的notifyAll();这样你就完成了一个用JAVA模拟的异步操作。
 
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

 
因工作需要，在后台管理页面加入一个上传文件的模块，虽然接口的代码很简单，但实现期间遇到了一些比较有趣的坑，特记录下来。
 
需求
 
实现文件上传，并提供一个可供下载的路径。
 
想法
 
文件上传代码暂且不谈，先说说文件放在服务器什么位置比较合适。我首先想到的是两个地方：
 
tomcat的webapps/ROOT目录下，如果放在这个目录下，数量少了还好，一旦数量多了，必定会影响tomcat本身的运行速度。这个虽然可用但不可行。nginx的静态目录下，放在这个目录下则不会有什么影响。只需要在nginx中进行相应的配置即可。可用也可行。
 
java代码实现：
 
由于我们使用的是SSM框架，首先需要配置文件上传解析器。
 
虽然简单，但依旧遵从三层架构，Controller实现如下：
 
@Controller
 
@RequestMapping("/upload")
 
public class UploadApkController {
 
@Resource
 
private UploadApkService uploadApkService;
 
/**
 
* 上传Apk文件
 
* @param file
 
* @return
 
*/
 
@RequestMapping("/uploadApk")
 
@ResponseBody
 
public Map uploadApk(@RequestParam("file") CommonsMultipartFile file){
 
Map resultMap = new HashMap<>();
 
try {
 
uploadApkService.uploadApk(file);
 
resultMap.put("msg", "上传成功");
 
} catch (IOException e) {
 
e.printStackTrace();
 
resultMap.put("msg", "上传失败");
 
}
 
return resultMap;
 
}
 
}
 
Service接口：
 
public interface UploadApkService {
 
/**
 
* 上传Apk文件
 
* @param file
 
* @throws IOException
 
*/
 
public void uploadApk(CommonsMultipartFile file) throws IOException;
 
}
 
Service实现类：
 
public class UploadApkServiceImpl implements UploadApkService {
 
/**
 
* 上传Apk文件
 
* @param file
 
* @throws IOException
 
*/
 
public void uploadApk(CommonsMultipartFile file) throws IOException {
 
//这是我的nginx静态路径，使用时需改为自己的对应路径
 
String path="/data2/fphone/static/apk/"+file.getOriginalFilename();
 
File newFile=new File(path);
 
file.transferTo(newFile);
 
}
 
}
 
代码部分完成。
 
对接口进行测试。
 
这是之前测试的截图，状态为OK即为上传成功。 下面进行下载测试，输入nginx静态地址，显示如下：  出现问题。思考后认为可能是权限不够，进入nginx静态目录下，执行命令：
 
ls -all apk
 
显示如下：  发现zrx.apk权限为640，对于其他人并没有读的权限。我nginx的配置如下：  所以通过nginx并没有读取这个文件的权限。有些人可能会说将nginx的user调整为root，但我建议不要给nginx太大的权限。所以采用另一种方式解决这个问题。
 
解决权限问题
 
既然不决定提高nginx的权限，那么只能将上传文件的权限由640改为644。查看tomcat的bin目录下的catalina.sh文件：  将这里的0027改为0022即可，0022代表权限为644。 权限修改完成，再次进行测试，调用接口上传文件，检查文件权限：
 
发现文件权限为644。继续尝试输入路径进行下载：  文件果然开始正常下载，验证了我们的思路是正确的。到此问题解决。如果有什么不明白或者发现问题的，欢迎评论或者私信我，谢谢各位！

 
接口与实现
 
1 接口
2 实现接口
3 接口回调
4 理解接口
5 接口与多态
6 接口变量做参数
7 abstract类与接口的比较
8 面向接口编程

 
1 接口
 
为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口
 
使用关键字interface来定义接口。接口的定义和类的定义很相似，分为接口的声明和接口体。
 
 
接口声明
 ——使用关键字interface来声明
 ——格式: interface 接口名字
 
 
接口体
 —— 接口体中包含常量定义和方法定义两部分。接口体中只进行方法的声明，不提供方法的实现，且用分号结尾。
 
 
例如：
 
interface Printable {
    final int MAX = 100;
    void add();
    float sum(float x, float y);
}
 
 
 
1 接口中变量自动是 public、static、final
 2 接口中的方法默认是 public abstract
 3 接口也产生class文件
 4 接口中的方法不能被static和final修饰，因为要重写所有接口中的方法
 5 接口中没有构造方法
 
 
2 实现接口
 
1、一个类通过使用关键字implements声明自己实现一个或多个接口。*
 如: class A implements Printable,Addable
 2、如果一个非抽象类实现了某个接口，那么这个类必须重写该接口的所有方法，而且方法的访问权限一定要显示地用public来修饰。
 3、接口可以通过继承产生新的接口。
 4、Java提供的接口都在相应的包中，通过import语 句不仅可以引入包中的类，也可以引入包中的接口，
 例如:import java.io.*;
 5、如果一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类，也就是说，抽象类既可以重写接口中的方法，也可以直接拥有接口中的方法。
 程序可以用接口名直接访问接口中的常量，但是一个类实现了该接口，那么可以在类体中直接使用该接口中的常量。
 6、定义接口时，如果关键字interface 前面加上public关键字,就称这样的接口是-一个public接口。public 接口可以被任何一个类实现。如果一一个接口不加public修饰，就称作友好接口，友好接口可以被与该接口在同一包中的类实现。
 7、如果父类实现了某个接口，那么子类也就自然实现了该接口，子类不必再显式地使用关键字implements声明实现这个接口。
 8、接口也可以被继承，即可以通过关键字extends声明一个接口是另一个接口的子接口。
 由于接口中的方法和常量都是public的，子接口将继承父接口中的全部方法和常量。
 
例子1中 包含有China类、Japan 类和Computable接口，而且China和Japan类都实现了Computable接口
 
//Computable.java
public interface Computable {
   int MAX = 46;
   int f(int x);
}

//China.java
public class China implements Computable {  //China类实现Computable接口
   int number;
   public int f(int x) { //不要忘记public关键字
      int sum=0;
      for(int i=1;i<=x;i++) {
         sum=sum+i;
      }
      return sum;
   }
}

//Japan.java
public class Japan implements Computable { //Japan类实现Computable接口
   int number;
   public int f(int x) {
      return MAX+x; 
   }
}

//Test.java
public class Test {
   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));
   }
}
 
 
3 接口回调
 
接口回调是指:可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。实际上，当接口变量调用被类重写的接口方法时，就是通知相应的对象调用这个方法。
 
//分析:
Com com;//声明接口对象
ImpleCom obj = new ImpleCom();//实现接口子类对象
com = obj; //接口回调
 
 
interface  ShowMessage {
   void 显示商标(String s);
}
class TV implements ShowMessage {
   public void 显示商标(String s) {
      System.out.println(s);
   }
}
class PC implements ShowMessage {
   public void 显示商标(String s) { 
     System.out.println(s);
   }
}
public class Example {
   public static void main(String args[]) {
      ShowMessage sm;                  //声明接口变量
      sm=new TV();                     //接口变量中存放对象的引用
      sm.显示商标("长城牌电视机");      //接口回调。
      sm=new PC();                     //接口变量中存放对象的引用
      sm.显示商标("联想奔月5008PC机"); //接口回调
   } 
}

 
4 理解接口
 
理解的关键点是:
 (1)接口可以抽象出重要的行为标准，该行为标准用抽象方法来表示。
 (2)可以把实现接口的类的对象的引用赋值给接口变量，该接口变量可以调用被该类实现的接口方法，即体现该类根据接口里的行为标准给出的具体行为。
 
接口的思想在于它可以要求某些类有相同名称的方法，但方法的具体内容(方法体的内容)可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法(即所谓的方法绑定)。接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类。
 
例子3中，要求MotorVehicles类(机动车)的子类Taxi (出租车)和Bus(公共汽车)必须有名称为brake的方法(有刹车功能)，但额外要求Taxi类有名字为controlAirTemperature和charge的方法(有空调和收费功
 能)，即要求Taxi实现两个接口，要求客车类有名字为charge的方法(有收费功能)，即要求Bus只实现一个接口。
 
abstract class MotorVehicles {
   abstract void brake();
}
interface MoneyFare {
   void charge();
}
interface ControlTemperature {
   void controlAirTemperature();
}
class Bus extends MotorVehicles implements MoneyFare { 
    void brake() {
        System.out.println("公共汽车使用毂式刹车技术");
    }
    public void charge() {
        System.out.println("公共汽车:一元/张,不计算公里数");
    }
} 
class Taxi extends MotorVehicles implements MoneyFare,ControlTemperature { 
    void brake() {
        System.out.println("出租车使用盘式刹车技术");
    }
    public  void charge() {
        System.out.println("出租车:2元/公里,起价3公里");
    }
    public void  controlAirTemperature() { 
        System.out.println("出租车安装了Hair空调");
    }
}
class Cinema implements MoneyFare,ControlTemperature {
    public  void charge() {
        System.out.println("电影院:门票,十元/张");
    }
    public void controlAirTemperature() { 
       System.out.println("电影院安装了中央空调");
    }
}
public class Example{
   public static void main(String args[]) {
       Bus bus101 = new Bus();
       Taxi buleTaxi = new Taxi();
       Cinema redStarCinema = new Cinema();
       MoneyFare  fare;
       ControlTemperature temperature;
       fare = bus101;
       bus101.brake(); 
       fare.charge();
       fare = buleTaxi;
       temperature = buleTaxi;
       buleTaxi.brake();
       fare.charge();
       temperature.controlAirTemperature();
       fare = redStarCinema;
       temperature = redStarCinema;
       fare.charge();
       temperature.controlAirTemperature();
   }
}
 
5 接口与多态
 
可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可
 以回调类实现的接口方法。
 
例子：接口与多态
 
interface CompurerAverage {
   public double average(double a,double b);
}
class A implements CompurerAverage {
   public double average(double a,double b) {
      double aver=0;
      aver=(a+b)/2;
      return aver;
   }
}
class B implements CompurerAverage {
   public double average(double a,double b) {
      double aver=0;
      aver=Math.sqrt(a*b);
      return aver;
   }
}
public class Example {
   public static void main(String args[]) {
      CompurerAverage computer;
      double a=11.23,b=22.78;
      computer = new A();  
      double result = computer.average(a,b);
      System.out.printf("%5.2f和%5.2f的算术平均值:%5.2f\n",a,b,result);
      computer = new B();  
      result= computer.average(a,b);
      System.out.printf("%5.2f和%5.2f的几何平均值:%5.2f",a,b,result);
   } 
}
 
 
6 接口变量做参数
 
如果一个方法的参数是接口类型，我们就可以将任何实现该接口的类的实例的引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法。
 
例子：接口参数
 
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 Example {
   public static void main(String args[]) {
       KindHello kindHello=new KindHello();
       kindHello.lookHello(new Chinese());
       kindHello.lookHello(new English());
   }
}
 
 
7 abstract类与接口的比较
 
1. abstract类 和接口都可以有abstract方法。
 2.接口中只可以有常量,不能有变量;而abstract类中即可以有常量也可以有变量。
 3. abstract类 中也可以有非abstract方法，接口不可以。（Java1.8之后不成立）
 
8 面向接口编程
 
面向接口去设计程序，可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。