一、interface的基础知识

1. 接口使用interface来定义

2. Java中 接口和类是并列的两个结构

3. JDK7以前：只能定义全局变量和抽象方法：①全局常量：public static final的。 ②抽象方法: public abstract 的。 JDK8及以后： 除了定义全局变量和抽象方法以外，还可以定义静态方法、默认方法

4. 接口中不可以定义构造器 意味着接口不能实例化

5. Java开发中，接口通过让类去实现implement的方式去使用

如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以去实例化
如果实现类没有覆盖接口中的所有抽象方法，则此实现类仍为一个抽象类

6. java类可以实现多个接口----->弥补了java单继承的局限性

class AA extends BB implements CC,DD,EE

7. 接口与接口之间可以继承，而且可以多继承

二、接口不能实例化，为什么还会看到new interface？

举例一

FileFilter fileFilter = new FileFilter() {
public boolean accept(File pathname) {
String tmp = pathname.getName().toLowerCase();
if (tmp.endsWith("." + "vb")) {
return true;
}
return false;
}
};

解释：FileFilter是一个接口。但这里面用到了匿名内部类。FileFilter() {。。。}一大段实现了(implements)接口，而实现接口的类为匿名类，然后再用new创建匿名类的对象。

举例二

interface A {
    public void f();
}
public class Test {
    A a = new A() {public void f() {return;}};
}

解释：A a的时候只是声明a为A类型，而new A() {public void f() {return;}};的时候实际上产生了一个匿名类（如果你查看一下编译后的结果，会发现有一个Test$1.class的文件，这个就是匿名类，后面的数字是自动编号的），而a所指的具体对象就是Test$1这个类型的对象。

可以将上面的代码改写成普通的实现接口的方式

interface A {
    public void f();
}

class NiMingB implements A{
	public void f() {return;}
}

public class Test{
	NiMingB niming = new NiMingB();	
}

总结：接口无法直接创建对象，但是实现了接口的类可以创建对象，我们实现了某一个接口，就相当于创建了这个接口的一个子类，接口就是这个类的父类，而父类引用 是可以指向之类对象的。所以我们不是创建的不是接口对象，而是实现了该接口的类的对象，也就是接口的子类对象。

采用接口方式创建类的对象

与用类创建类的对象的方式相似，只是将第一个类名改为接口名。
若有

• 类student
• 接口Person
• 类student实现Person 即class student implements Person

则用类创建类的对象为

• student s1=new student();

用接口方式创建为

• Person p1=new student();

注： 用接口方式创建的类的对象，只能用对象名.方法名 访问接口中定义的方法，不能访问类中自己定义的属性和方法以及接口中的属性。

详见下面代码：

代码示例：

interface face01
{
    double pi=3.14;
    abstract void getArea();         //对face01接口定义两个抽象方法
    abstract void getLength();
}
class Circle implements face01 {
    double radius;
    Circle(double r)                      //用构造方法对半径赋值
    {
        radius = r;
    }

    public void getArea() {
        System.out.println("圆的面积为:" + radius * radius * pi);
    }

    public void getLength() {
        System.out.println("周长为:" + 2 * pi * radius);
    }
}
public class CSDN {
    public static void main(String[] args) {
    	System.out.println("--采用普通方式创建类的对象--");
        Circle c1=new Circle(5.5);
        c1.getArea();
        c1.getLength();
        System.out.println("--采用接口方式创建类的对象--");
        face01 c2=new Circle(7.6);
        c2.getArea();
        c2.getLength();
    }
    }

结果：

--采用普通方式创建类的对象--
圆的面积为:94.985
周长为:34.54
--采用接口方式创建类的对象--
圆的面积为:181.3664
周长为:47.728

Process finished with exit code 0

注：

1. 在该题中，若使用c2.radius对半径进行赋值，则会报错，不能运行。
2. 也不能用c2.pi对pi的值进行更改，因为接口中属性默认为公共的静态最终变量(即public static final)。

public interface Jiekou {
    public void s();
}
//实现接口的class
public class Jiekouimple implements jiekou{
    public void s();
}

public class Test(
    public static void main(String[] args) {
        Jiekou  jiekou = new Jiekouimple ();
}
)

接口是不能实例化的，即不能new一个接口出来,但是可以创建一个接口实现类的对象；

必须要重写接口中的方法

Jiekou jiekou = new Jiekou() {
    @Override
      public void s() {
        
    }
};

接口的使用规范：

1.接口中可以定义常量，不能定义变量，如果你在接口中定义属性，那么通过反编译可以看见他会自动用public static final 修饰，接口中的属性都是全局静态常量，接口中的常量必须在定义时指定初始值。

2.接口中所有的方法都是抽象方法，接口中方法都会自动用public abstract 修饰，即接口中只有全局抽象方法。

如：

public interface UserDao {
    String var = "常量1";
    Integer t = 23;
    User getById(Long id);
}

反编译后的：

package com.slef.dao;

import com.slef.model.User;

public abstract interface UserDao
{
  public static final String var = "常量1";
  public static final Integer t = Integer.valueOf(23);

  public abstract User getById(Long paramLong);
}