java8的接口的重新定义

	java8重新定义了接口

java8以后的接口里可以定义默认的方法

interface People
{
   int  num = 19;   //默认为public static final  
   
   void do1();        //默认为 public abstract
   
   default void do2(){     //默认方法用 default修饰
      System.out.println("do2");
   }
   
   
   static void say1(){               //public修饰静态方法
      System.out.println("say1");
   }


   private static void say2(){      //private静态方法
         System.out.println("say2");
   }


   static People getInstant(){           //工厂方法
         return new DefaultMethod1();
   }
}

public class DefaultMethod1 implements People {

         @Override
         public void do1(){         //如果接口没有 do1 方法的话，这里是不用重写的
            System.out.println("do1");
         }
         
         public static void main(String[] args) {

            int num = 20;
            System.out.println(num); //打印 20，接口中的 num 被 覆盖了


            People.getInstant().do1();    //打印 do1
            
            new DefaultMethod1().do2();   //打印 do2
            
             //new DefaultMethod1().say1(); //这里将报错，因为 接口的静态方法只能接口自己调用
         }
}

因为 java8 实现了 Default，所以可以理解为 间接的实现了 c++ 的 多继承
这里测试 继承多个接口时的问题：

interface A{
   default void m1(){
       System.out.println("i am m1 int the A");
    }
    
    default void m2(){
       System.out.println("i am m2 in the A");
    }
}

interface B{
            //与 接口 A 里重名的静态方法 m1
    default void m1(){
        System.out.println("i am m1 in the B");
    }
    
            //与接口 A 里重名的默认方法 m2
    default void m2(){
        System.out.println("i am m2 in  the B");
    }


    default void m3 (){
        System.out.println("i am m3 in the B");
    }
}

//A和B接口是互不相关的，这个时候，两个接口的方法有重复的，在实现类里必须重写或区分方法，否则编译器无法区分，将报错

public class DefaultMethod2 implements  A, B ,C ,D{   //继承两个接口

       public void m1(){
             A.super.m1();      //这里区分了 m1 ，调用了A的m1方法
       }
       
       public void m2(){
            B.super.m2();
       }
       
       public static void main(String[] args){
           DefaultMethod2 m  = new DefaultMethod2();
           m.m1();      //调用A的m1方法
           m.m2();      //调用B的m2方法
           m.m3();      //B接口的方法

           //这里将调用 D接口的do1方法， 可以看待D继承了C直接覆盖掉了C的方法
           m.do1();
    }
}
interface C{
    default void do1(){
        System.out.println("i am do1 in the C");
    }
}

interface D extends C{      //D继承 C 的情况
    default void do1(){
        System.out.println("i am do2 in the D");
    }
}