1.背景介绍
接口是什么？
接口，在Java中是一个抽象类型，是抽象方法的集合。接口通常以interface来声名。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口严格意义上来讲属于一个特殊的类，而这个类里面只有抽象方法和全局常量，就连构造方法也没有。
，比如我们约定某些英雄是物理系英雄，那么他们就一定能够进行物理攻击。实现某个接口，就相当于承诺了某种约定。所以实现某个接口，就必须提供那个接口中的方法，实现在语法上使用关键字implements
2.知识剖析
接口的特点：
1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)
2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
4、接口中没有构造方法,不能被实例化
5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类
8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.
Interface和Impl这种方式的好处是什么？
便于封装；降低耦合；对修改封闭，对拓展开放。
3.常见问题
接口使用原则：
1）接口必须要有子类，但此时一个子类可以使用implements关键字实现多个接口
2）接口的子类（如果不是抽象类），那么必须要覆盖重写接口中的全部抽象方法
3）接口的对象可以利用子类对象的向上转型进行实例化
4.扩展思考讨论
接口和抽象类的区别？
一个抽象类只能继承一个抽象父类，而接口可以继承多个接口
一个子类只能继承一个抽象类，却可以实现多个接口
接口实现的基础——对象转型和多态
对象转型
package fourth.com;
public class Quadrangle {
public static void draw(Quadrangle q){
System.out.println("hello world");
}
}
package fourth.com;
public class Parallelogram extends Quadrangle{
public static void main(String args[]){
Parallelogram p = new Parallelogram();//这就相当于"Quadrangle obj=new Parallelogram()"，就是把子类对象赋值给父类类型的变量，这就是向上转型
draw(p);
}
}
多态
package fourth.com;
public class Second {
private Second[] qtest = new Second[6];
private int nextIndex = 0;
public void draw(Second q){
if(nextIndex
qtest[nextIndex] = q;
System.out.println(nextIndex);
nextIndex++;
}
}
public static void main(String[] args) {
Second q = new Second();
q.draw(new Third());
q.draw(new Fourth());
}
}
package fourth.com;
public class Third extends Second{
public Third(){
System.out.println("正方形");
}
}
package fourth.com;
public class Fourth extends Second{
public Fourth(){
System.out.println("平行四边形");
}
}
5.编码实战
package fourth.Dao;
import fourth.com.student;
public interface studentDao {
public int addStudent(student student);
public int updateStudent(String name);
public int deleteStudent(String name);
public student findStudent(student student);
}
package fourth.imple;
import fourth.com.*;
import fourth.Dao.studentDao;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.PreparedStatement;
import java.sql.ResultSet;
public class createStudent implements studentDao{
@Override
public int addStudent(student student) {
Connection conn = null;
PreparedStatement ps = null;
int i= 0;
try {
conn = (Connection) mysqlConnect.getconnection();
String sql = "insert into student values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
ps = (PreparedStatement) conn.prepareStatement(sql);
ps.setInt(1,student.getId());
ps.setString(2,student.getCreate_at());
ps.setString(3,student.getUpdate_at());
ps.setString(4,student.getName());
ps.setString(5,student.getDailyLink());
ps.setInt(6,student.getQQ());
ps.setString(7,student.getOnlineNumber());
ps.setString(8,student.getMail());
ps.setInt(9,student.getPhone());
ps.setString(10,student.getEnrollmentTime());
ps.setString(11,student.getProfessionType());
ps.setString(12,student.getBrotherName());
ps.setString(13,student.getPromise());
i = ps.executeUpdate();
}catch (Exception e){
e.printStackTrace();
}finally {
mysqlConnect.free(null,ps, conn);
System.out.println("close mysqlConnection");
}
return i;
}
@Override
public int updateStudent(String name) {
Connection conn = null;
PreparedStatement ps = null;
int i = 0;
try {
conn = (Connection) mysqlConnect.getconnection();
String sql = "update student set promise = '一姐最胖' where name=?";
ps = (PreparedStatement) conn.prepareStatement(sql);
ps.setString(1,name);
i = ps.executeUpdate();
}catch (Exception e){
e.printStackTrace();
}finally {
mysqlConnect.free(null,ps, conn);
System.out.println("close mysqlConnection");
}
return i;
}
@Override
public int deleteStudent(String name) {
Connection conn = null;
PreparedStatement ps = null;
int i = 0;
try {
conn = (Connection) mysqlConnect.getconnection();
String sql = "delete from student where name=?";
ps = (PreparedStatement) conn.prepareStatement(sql);
ps.setString(1,name);
i = ps.executeUpdate();
}catch (Exception e){
e.printStackTrace();
}finally {
mysqlConnect.free(null,ps,conn);
System.out.println("close mysqlConnection");
}
return i;
}
@Override
public student findStudent(student student) {
Connection conn = null;
PreparedStatement ps = null;
student stu = null;
ResultSet rs = null;
try {
conn = (Connection) mysqlConnect.getconnection();
String sql = "select * from student where ID=? ";
ps = (PreparedStatement) conn.prepareStatement(sql);
ps.setInt(1,student.getId());
rs = ps.executeQuery() ;
stu = new student();
while (rs.next()){
stu.setId(rs.getInt(1));
stu.setCreate_at(rs.getString(2));
stu.setUpdate_at(rs.getString(3));
stu.setName(rs.getString(4));
stu.setDailyLink(rs.getString(5));
stu.setQQ(rs.getInt(6));
stu.setOnlineNumber(rs.getString(7));
stu.setMail(rs.getString(8));
stu.setPhone(rs.getInt(9));
stu.setEnrollmentTime(rs.getString(10));
stu.setProfessionType(rs.getString(11));
stu.setBrotherName(rs.getString(12));
stu.setPromise(rs.getString(13));
}
}catch (Exception e){
e.printStackTrace();
}finally {
mysqlConnect.free(null,ps,conn);
}
return student;
}
}
6更多讨论
1）接口有什么修饰符？
接口就是提供一种统一的”协议”，而接口中的属性也属于“协议”中的成员。它们是公共的，静态的，最终的常量。相当于全局常量。抽象类是不“完全”的类，相当于是接口和具体类的一个中间层。即满足接口的抽象，也满足具体的实现。
接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是公开(public)类型的,确保外部使用者能访问它们；
接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象(abstract)方法；
接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实例变量，只有静态（static）变量。
接口的中的变量是所有实现类共有的，既然共有，肯定是不变的东西，因为变化的东西也不能够算共有。所以变量是不可变(final)类型，也就是常量了。
2）为什么接口中的方法修饰符是public而不是static？
接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是公开(public)类型的,确保外部使用者能访问它们；
抽象类中的抽象方法（前面有abstract修饰）不能用private,static,修饰。原因：抽象方法没有方法体，是被用来继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即方法的方法体），抽象方法用static没有意义。接口是一种特殊的抽象类，所以用public而不是static
3）接口中可不可以有方法体？
Java8之前的版本中接口不能写方法体，但是在Java8开始就可以写了，使用default关键字
