java中的接口

 
接口---Interface：
    
               一个类只能有一个直接父类，但可以实现多个接口；
               【继承，实现，依赖--------->java中的几种关系】
               接口--->用于描述系统对外提供的服务，给调用者访问；
             public interface Phone{
                 public void Call();
                 public void TakePhoto();
                }
               
 接口中的约束：
                   1.接口如果有成员变量，那么它一定是public,static,final类型的常量，并且被显示初始值；
                        public static final int x=10;
                   2.通常接口用来定义方法，以表示能够提供的服务，接口中的方法默认都是public,abstract修饰的抽象方法；
                      public interface Phone{
                         public abstract void Call();//合法
                         public void Call();//合法
                         void Call();//合法
                        }
                  3.在接口中只能包含上述两点的：public,static,final类型的成员变量与public,abstract类型的方法，试图在接口定义实例变量，非抽象方法，
                    静态方法等，统统非法；
                       {
                             void method();//error-------在接口中定义能通过，但是是非法的
                             static void Call();//error
                             private void Call();//error
                       }
                  4.接口没有构造方法，试图在接口中定义构造方法，接口也不能实例方法，但可以声明接口类型和引用变量；
                      Phone phone =new Phone();//error
                      Phone phone=null;//ok
                  5.接口可以继承多个其他接口，这时候，它被称之为复合接口；
                      public interface Bsse{
                       public void callA();
                       }
                    public interface Sub  extends Base{
                           public void callB();
                       }
                    public interface SSub extends Base,Sub{
                           public void callC();   
                       }
               -----------------抽象类中可以有构造方法，接口中没有构造方法-----------------

接口的实现类：
                  一个类成为某个接口的实现类，使用关键字implements;
                   public class Sub implements Base{
                     public void Call(){
                          }
                    }

             1. 接口与实现类的在代码中的使用：
                Phone phone=new SyBamPhone();
                   phone.Call();
                 上述代码被称之为【系统间的接口交互（接口调用）】：系统A访问系统B，首先把引用变量声明B系统的接口类型，
                 然后引用变量调用系统B的接口中的实例方法；
            2.一个实现类可以实现多个接口，即一个实现类实现多个接口提供的方法；
                 public class A implements B,C{......}
            3.接口不存在一个接口实现另一个接口一说，实现指的是实现类与接口之间的关系；
                    public interface A{....}
                   public interface B implements A{........}///false
           4.如果一个实现类不能实现一个接口中的全部方法，那么这个类必须是抽象类，等待它的子类来实现；
            public interface A{
               public abstract void Call();
            public abstract void Send();
              }
                  
             public  abstract class B implements A{
                  public void Call(){........}
                }
          
             public class C extends B{
                 public void Send(){.................}
               }

      
           5.接口与实现类的命名规则：通常实现类名字为【接口名+Impl】;
                 public interface User{......}
                 public class UserImpl implements User{.........}
           6.一个类只能有一个直接父类，但可以同时实现多个接口，两者声明写在一起，顺序为extends implements;
             public class C extends B implements A{........}



抽象类与接口的比较：
             相同点：
                  1.代表系统的抽象层，即系统的上层描述，采用抽象的概念设计系统最大的用处是提供两个系统之间的松耦合；
                  2.自身都不能被实例；
                  3.都包含抽象方法，这些方法只用于描述系统所提供的服务，不提供具体的实现；
           不同点：
                 1.抽象类中能有非抽象方法，这些方法已经具体完成实现，可以直接被子类使用，而接口只能包含抽象方法；
                 2.一个类只能有一个直接父类，这个父类可以是抽象类，但一个类可以实现多个接口；
                 3.抽象类有构造方法，它的构造方法由子类调用，而接口没有构造方法；


接口与抽象类的使用原则：
             1.使用接口作为系统中对外交互的窗口，接口通常是系统中最高层次的抽象类型，系统与系统之间的交互，采用接口模式，提高两个系统之间的松耦合
             2.接口是外界依赖的服务；
             3.抽象类通常在系统中被设计与用于定制系统的扩展点，抽象类可以看做介于“最高抽象”与“具体实现”的半成品，因为它本身可以提供一部分实现；