Java 接口
q) Java为什么需要接口
接口的用法
Java 8接口特性
default方法可以解决兼容性问题和简单的解决多继承问题
接口中的静态方法可以用做保存常用方法
标记接口


java中的接口是类的蓝图。 它有静态常量和抽象方法。java中的接口是一种实现抽象的机制。 接口中只有抽象方法而不是方法体。接口用于在Java中实现抽象和多重继承。Java接口也表示IS-A关系。它不能像抽象类一样被实例化。

q) Java为什么需要接口

通过接口实现多继承
用于实现耦合

如下图所示，一个类扩展了另一个类，一个接口扩展了另一个接口，一个类实现了一个接口。



接口的用法
interface Printer{                                                                //打印机的接口
	void print();                                                        //打印机的打印方法
}

电脑来了
class  Computer implements Printer{                                           //computer连接了Printer的方法
	@override
	public void print(){
		System.out.println("我是电脑");                                        //把msg的方法打印出来
	}
}

手机来了
class SmartPhone implements Printer{                                   //手机连接了打印机
	@override
	public void print(){
		System.out.println（"我是智能手机"）；                           //手机的println()方法
	}
}

Java 8接口特性

Java 8以前的接口只能有抽象方法，不能有方法体

Java 8开始可以有方法体，但是只能是默认的方法体和静态方法

Q)为什么要加这两个特性呢？

A)简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。我们只需在方法名前面加个default关键字即可实现默认方法。该策略可以解决多继承的问题。
default方法可以解决兼容性问题和简单的解决多继承问题
Java8之前

HeadFirst Java 时，作者说，为了解决多重继承所引起的“致命方块问题”



所以Java不用多重继承，用多重实现，但是在多重实现中，这个问题解决了吗？还没有
interface CanonPrinter{
	void print();
}

interface DeliPrinter{
	void ptint();
}

有一个类两个接口都支持，但是当答打印的时候
class Computer implementsCannonPrinter,DeliPrinter{
	@override
	public void print(){
		System.out.println("This is computer！！！");
	}
	public static void main（String[] args）{
		new Computer.print();
	}
}

这个时候会出来个问题，你重写的打印的方法到底是实现了哪个接口的打印方法？

如果CannonPrinter接口和DeliPrinter接口的print()方法相同，那么编译器认为你同时都实现了两个接口的两个方法，并且运行哪个方法都可以，因为两个接口的print()方法都一样。

输出结果
This is computer！！！

如果同名方法只是参数类型不同呢？
interface CanonPrinter{
	void print(StringBuilder msg);
}

interface DeliPrinter{
	void ptint(String msg);
}

class Computer implementsCannonPrinter,DeliPrinter{
	@override
	public void print(String msg){
		System.out.println(msg);
	}

	@override
	public void print(StringBuilder msg){
		System.out.println(new StringBuilder(msg));
	}
	
	public static void main（String[] args）{
		new Computer.print("This is Computer!!!");
		new Computer.print(new StringBuilder("This is Computer!!!"))
	}
}

编译器可以准确区分，没有产生歧义，所以输出结果
This is Computer！！！
This is Computer！！！

如果print()方法返回参数不同呢？
interface CanonPrinter{
	String print();
}
interface DeliPrinter{
	StringBuilder ptint();
}

class Computer implementsCannonPrinter,DeliPrinter{
	@override
	public String print(){                             //如果只实现了CanonPrinter 的返回类型为String的print（），
		return "This is computer！！！";               //没有实现DeliPrinter的StringBuilder的print()方法,编译器会报错	                                                                         
	}                                                  //所以只实现一个接口的方法，是违背接口的规则的，不能通过编译。

	@override
	public int  print(){                                     //如果实现了两个方法，编译器则会报错，因为名字重复
		return new StringBuilder("This is computer！！！");  //当对象调用的时候，不知道调用的是哪个方法                                                                         
	}                                                        

	
	public static void main（String[] args）{
		new Computer.print();                                      //我调用的是哪个方法呢？
	}
}

如果两个不同的接口各有同名且不同返回类型的方法，如果一个类想同时实现这两个接口，无解，在编译时就会报错，没有办法实现。除非把问题变得复杂，使用内部类。
interface CanonPrinter{
	String print();
}
interface DeliPrinter{
	StringBuilder ptint();
}

class Computer implements CannonPrinter{
	@override
	public String print(){                             
		return "This is computer！！！";               
	}                                                  

	@override
	public int  print(){
		return new StringBuilder("This is computer！！！");  
	}                                                        
	class MultiComputer implements DeliPrinter{
		@override
		public String print(){                            
			return "This is computer！！！"; 
		}                                                  

		@override
		public int  print(){
			return new StringBuilder("This is computer！！！");  
		}
	}
}

但是Java8新特性后
public class Java8Tester {
   public static void main(String args[]){
      Vehicle vehicle = new Car();
      vehicle.print();
   }
}
 
interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
    
   static void blowHorn(){
      System.out.println("按喇叭!!!");
   }
}
 
interface FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮车!");
   }
}
 
class Car implements Vehicle, FourWheeler {
   public void print(){
      Vehicle.super.print();
      FourWheeler.super.print();
      Vehicle.blowHorn();
      System.out.println("我是一辆汽车!");
   }
}

输出结果
我是一辆车!
我是一辆四轮车!
按喇叭!!!
我是一辆汽车!

这样你就可以区分使用哪个接口的方法。

同时default方法还可以解决兼容性。

当你在接口中添加一个方法时，需要所有实现它的类都实现它的抽象方法。就会带来不必要的操作，但如果使用默认方法，你只需在接口中添加好方法体，之后在需要实现的类中调用就可以了，减少了不必要的操作。

例如：
interface Printer{
	void print{}；
}

实现类
class computer implements Printer{
	@override
	public void print(){
		System.out.print("This is Computer");
	}
}
class SmartPhone implements Printer{
	@override
	public void print(){
		System.out.print("This is smartPhone");
	}
}

如果需要给接口添加一个方法
interface Printer{
	void print{}；
	default void println(){
		System.out.println("增加了Println()方法")
	};                                                                                   //新添加的方法
}

实体类需要实现
class Computer implements Printer{
	@override
	public void print(){
		System.out.print("This is Computer");
	}
	@override
	default void prinln(){
		System.out.println("This is println() for Computer");             //这里用，就在这里重写好了，其他实现了Printer的类就不用管了
	}
	
}
class SmartPhone implements Printer{
	@override
	public void print(){
		System.out.print("This is smartPhone");
	}
}

接口中的静态方法可以用做保存常用方法
我们知道常量可以用接口来保存

例如
interface addressCodeConstant{
	String CHINA = "CN";
	String AMERICA = "US";
}

同理常用方法，也就是常用工具方法可以用static来修饰

例如
interface getAddressCode{
	static String returnAdressCod(String country){
		switch （country）{
			case CHINA ：
				return CN;
			case AMERICA：
				return US;
			default:
				retrun null;
		} 	
	}
}

相当于
public final getAddressCode{
	public String returnAdressCod(String country){
    		switch （country）{
    			case CHINA ：
    				return CN;
    			case AMERICA：
    				return US;
    			default:
    				retrun null;
    		} 	
    	}
}

只不过以后的常用方法可以存储像常量一样存储在接口中了。
标记接口
没有成员的接口(仅定义一个空的接口)称为标记或标记接口。 例如：可序列化，可克隆，远程等。它们用于向JVM提供一些基本信息，以便JVM可以执行一些有用的操作。
//How Serializable interface is written?  
public interface Serializable{  

}

Java 接口



接口（interface)在java语言中就是一个抽象类型，但接口并不是一个抽象类，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类是描述对象的属性和方法。而接口却是包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。当类要实现接口中的方法时候，若这个类不是抽象类的话，这个类就要去实现接口中所有的方法、

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在Java中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
抽象类（abstract) ：若一个类是用abstract修饰，并且没有方法体的实现的话，就说明是个抽象类；

还有若有空可以去看看runoob.com网站，那也有很多的资源；

在java8以后，接口中可以添加使用default或者static修饰的方法，在这里我们只讨论default方法，default修饰方法只能在接口中使用，在接口中被default标记的方法为普通方法，可以直接写方法体。

 

实现类会继承接口中的default方法
如果接口A中有default方法：

public interface A {
	public default void a(){
		System.out.println("这是A");
	}
}

Test类实现接口A：

public class Test implements A{
	
}

那么Test类将会继承接口A中的a方法：

public class Test2 {
	public static void main(String[] args) {
		Test t = new Test();
		t.a();
	}
}

2.如果一个类同时实现接口A和B，接口A和B中有相同的default方法，这时，该类必须重写接口中的default方法

 


为什么要重写呢？是因为，类在继承接口中的default方法时，不知道应该继承哪一个接口中的default方法。


接口A：

public interface A {
	public default void a(){
		System.out.println("这是A");
	}
}

接口B：

public interface B {
	public default void a(){
		System.out.println("这是B");
	}
}

Test类：



 

 

 

3.如果子类继承父类，父类中有b方法，该子类同时实现的接口中也有b方法（被default修饰），那么子类会继承父类的b方法而不是继承接口中的b方法

接口A：

public interface A {
	public default void b(){
		System.out.println("AAA");
	}
}

类C：

public class C {
	public void b(){
		System.out.println("CCC");
	}
}

子类：

public class Test extends C implements A{
	
}

测试类：



说明子类继承的b方法为父类C中的b方法，不是接口中的default b(){}方法。

 

很早之前的了，没有什么参考价值，大家看看热闹就好😄

前段时间 做了个学校的春萌项目，其中用到vue连接后端java接口。

先上后端接口代码：
package controller;

import net.sf.json.JSONObject;
import util.DBUtil;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

@WebServlet(name = "login",urlPatterns = "/login")
public class login extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session = request.getSession(true);
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        DBUtil dbUtil = new DBUtil();
        Connection connection = dbUtil.getConnection();
        PreparedStatement preparedStatement;
        ResultSet rs;
        String psw="";
        String sql = "select password from `user` where username=?";
        try {
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1,Integer.parseInt(username));
            rs = preparedStatement.executeQuery();
            while (rs.next()){
                psw = rs.getString("password");
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }
        if (password.equals(psw)){
            session.setAttribute("username",username);
            response.getWriter().print("true");
        }
        else
        response.getWriter().print("false");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}


前端调用：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
    <script src="node_modules/vue/dist/vue.js"></script>
    <!--axios基于promise-->
    <script src="node_modules/axios/dist/axios.js"></script>
    <script src="login.js"></script>
    <script src="https://cdn.bootcss.com/vue-resource/1.5.1/vue-resource.min.js"></script>
    <link rel="stylesheet" href="login.css">
</head>
<body>
<div class="login_interface"  id="interface_height">
    <img src="ic_login_logo.png" alt="" class="login_logo">
    <span id="login_head">智慧图书管理平台</span>
    <div class="login_input">
        <img src="ic_login_number.png" alt="" class="login_number">
        <input type="text" value="请输入账号" id="input_number" v-model="username">
    </div>
    <div class="login_input" id="add_top">
        <img src="ic_login_password.png" alt="" class="login_number">
        <input type="text" value="请输入密码" id="input_password" v-model="password">
    </div>
    <button class="login_unselected" id="tick"></button>
    <span id="remember_password">记住密码</span>
    <button id="registered_now"><a href=""><span style="color: grey">立即注册</span></a></button>
    <button id="login" @click="login()">登录</button>
</div>
<script>
    new Vue({
        el:'#interface_height',
        data:{
            username:'',
            password:''
        },
        methods:{
            login:function () {
                this.$http.post('login',{username:this.username,password:this.password},{emulateJSON:true}).then(function(res){
                    console.log(res.data);
                    window.location.href = 'index.html';
                },function(res){
                    console.log(res.status);
                });
            }
        },
        created:function(){
        }
    })
</script>
</body>
</html>