java 接口不是不能new吗？

这叫匿名内部类，你后面的大括号实际上就是一个Runnable的实现类了 只不过这个类名和接口名称一样，所以是匿名的，别人地方也用不了
	
这种写法相当于先创建了一个匿名类,实现了这个接口,然后new一个这个匿名类的对象

	所以可以使用.
	
这个是等于创建了一个匿名内部类，这个类实现了该接口，并实现了该接口的run方法。

	与你定义一个类实现这个接口是等效的。

	不过这个就是没有类名。而且无法在其他地方new出对象。
	
java:使用匿名类直接new接口
	
java中的匿名类有一个倍儿神奇的用法，见下面代码示例:package com.dtqn.action;  public interface interFace {    void writeClass();}实现类package com.dtqn.action;  public class Program {      public static void main(String[] args) {        // TODO Auto-generated method stub        interFace say = new interFace(){              @Override            public void writeClass() {                // TODO Auto-generated method stub                            }                    };    }  }new接口用于简化代码用。。。。。。。。。

	 

//接口定义

interface Comparator{

   int compare(T o1,T o2);

   boolean equals(Object obj);

}




//对象类定义

public class User{

   private String name;

   private float  chinese;

   private float  math;

   private float  english;




   public Student(){

      super();

   }




   public Student(String name,float math,float english,float english){

      super();

      this.name=name;

      this.chinese=chinese;

      this.math=math;

      this.english=english;

   }




   public String toString(){

      return "Student [name=" + name + ", chinese=" + chinese + ", math=" + math + ", english=" + english +"]";

   }

}




//测试类

public class test {




public static void main(String[] args) {

// 创建带构造器的集合对象，使用匿名对象实现Comparator接口

TreeSet treeset=new TreeSet<>(new Comparator() {

//实现接口，重写了compare()方法，具体过程看不懂可以不看，对于理解无碍

public int compare(Student o1, Student o2) {

float num=o2.getChinese()+o2.getEnglish()+o2.getMath()-o1.getChinese()-o1.getEnglish()-o1.getMath();

num=num==0?o2.getName().compareTo(o1.getName()):num;

num=num==0?o2.getChinese()-o1.getChinese():num;

num=num==0?o2.getEnglish()-o1.getEnglish():num;

num=num==0?o2.getMath()-o1.getMath():num;

return (int)num;

}

});




treeset.add(new Student("zhangsan",30,40,86));

treeset.add(new Student("zhangsan1",32,60,80));

treeset.add(new Student("zhangsan2",30,45,30));

treeset.add(new Student("zhangsan3",30,10,80));

treeset.add(new Student("zhangsan4",60,43,80));

treeset.add(new Student("zhangsan1",32,60,80));

treeset.add(new Student("zhangsan1",32,61,79));

for(Student i:treeset)

System.out.println(i);




}

}


实现接口的方法：类实现：重写接口所有方法
                抽象子类：抽象子类继承接口
有朋友问：你的匿名对象实现接口怎么实现的？怎么还能直接new接口呢？
      答：匿名对象类实现接口使用了简化写法,在使用匿名内部类时会自动创建一个实现类，其实你不是new了那
            个接口，你是new了那个实现类！
      问：你的重写方法怎么没有全部重写接口的
            还记的上面那个临时创建的实现类吗，他全部重写了接口方法，只是方法体是空的。我虽然只重写了部
            分方法，但是其他方法已经被临时类重写了只不过是空方法而已！

我之前会有一个疑惑：

匿名内部类的格式：

new 父类/接口{

//重写父类/接口的方法

}

我看了这个我就奇了怪了，

new 不是创建对象吗？接口不是不能被实例化嘛？

父类自己都有run方法，干嘛还有重写？重写不是指重写自己的父类方法吗？

怎么回事？

原来匿名内部类整体=父类的子类/接口的实现类

利用了多态性，创建了一个没有名字的类，就是因为没有名字才要借助父类/接口来完成定义。【它没有其他亲人了】

接口的使用需要一个实现类的对象，有时候只需要使用一次，那么能不能跳过实现类的定义呢？同样的，一个父类的实现有时候也需要靠子类，这个子类的定义可以省略吗？
public interface MyInterface {
    void method();
}

下面是上面接口的实现类
public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method() {
        System.out.println("实现类覆盖重写了抽象方法");
    }
}

下面的main方法中，前半部分用上面写的实现类调用method方法，而后半部分用的就是一个匿名类，在｛｝中覆盖重写了接口中的抽象方法，而后可以直接通过接口类型的变量调用method方法。
public class Demo {
    public static void main(String[] args) {
        // 以往new实现类MyInterfaceImpl()来调用method方法
        MyInterfaceImpl myInerfaceimpl = new MyInterfaceImpl();
        myInerfaceimpl.method();
        MyInterface obj = new MyInterfaceImpl(); // 或者多态写法
        obj.method();
        // 今天学习了匿名内部类，不需要实现类
        MyInterface AnonymousObject = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类覆盖重写了抽象方法");
            }
        };
        AnonymousObject.method();
    }
}

//实现类覆盖重写了抽象方法
//实现类覆盖重写了抽象方法
//匿名内部类覆盖重写了抽象方法

格式解析：

接口名 对象名=new 接口名｛…｝

等号右边new代表创建对象的动作，接口名就是匿名内部类需要去实现的哪个接口的名称，｛…｝中是匿名内部类的内容，一般是对接口中所有抽象方法进行重写。
注意事项：

匿名内部类在创建对象的时候，只能使用唯一一次，想要再创建个对象，得整套再写一遍【 接口名 对象名2=new 接口名｛…｝】来获得第二个对象。
匿名内部类还可以以匿名对象的形式使用，这时候只能调用一次方法，再想用method()方法时已经找不到这个对象了，因为它是匿名的。如下代码：
匿名内部类是省略了【实现类/子类名称】，而匿名对象是省略了【对象名称】（如第2点）

        new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类覆盖重写了抽象方法");
            }
        }.method();