java --- Interfaz de programación orientada a objetos

1 Interfaz

1.1 Concepto:

• Debido a que Java no permite múltiples dentro de la herencia, por lo que si desea realizar la función de más de una clase, se puede lograr mediante la implementación de múltiples interfaces.
• tipo abstracto es Java Java clases abstractas e interfaces representados, es una manifestación concreta de la abstracción tenemos que ser levantado.
• POO programación orientada a objetos, si para aumentar la tasa de reutilización programa, el programa aumenta la capacidad de mantenimiento, programación extensibilidad, la interfaz debe estar orientada, la programación orientada a abstracto.
• El uso adecuado de las interfaces, clases abstractas son también útiles como un tipo abstracto en la parte superior de java nivel estructural.
• códigos de nombre de interfaz de la interfaz {...}

1.2 Características:

• Las interfaces son abstracta
• Crear la interfaz por palabra clave interface
• Por implementos permiten subclases para lograr
• Como se apreciará, la interfaz es una especial clase abstracta
• Interface rompió a través de las limitaciones de un solo java herencia
• Puede alcanzar más de entre las interfaces y clases, lata herencia múltiple entre las interfaces e interfaces
• La interfaz está fuera expuesta de las reglas, un conjunto de normas de desarrollo
• Interfaz de mejorar el programa de expansión de funciones, lo que reduce el acoplamiento! ! El acoplamiento hereditario fuerte! !

public class Test1_Interface {
    public static void main(String[] args) {
       //TODO  创建多态对象测试
    }
}

//接口可以看做是程序的一套规范规则
//通过interface关键字定义接口
interface Inter{
    //接口里可以有普通方法吗？？--- 不可以，都是抽象方法
    abstract public void save() ;
    abstract public void delete() ;
}

//接口的实现类  和 接口之间是  implements实现的关系
//实现类实现了接口后，有两条路可以选：是一个抽象的实现类   +  重写接口中的所有抽象方法
//abstract class InterImpl implements  Inter {
class InterImpl implements  Inter {
    @Override
    public void save() {
       System.out.println("正在保存您的数据...");
    }
    @Override
    public void delete() {
       System.out.println("正在删除您的数据...");
    }
}

---

Uso de interfaz 2

2.1 constructor:

• No hay ninguna interfaz al constructor.
• El valor por defecto cuando se crea una súper clase de implementación () del objeto, es el constructor predeterminado sin parámetros Objeto de la convocatoria.

//创建接口
interface Inter2{
   //1、接口里可以有构造方法吗？   ---  不能！！
//  public Inter2() {}   
}

2.2 variables miembro:

• No hay ninguna interfaz de variables miembro son constantes. Por lo tanto, cuando se define una variable no escribió modificadores, el valor predeterminado añadirá: public static final

método 2.3 miembro de:

• Interfaz de métodos en el valor por defecto todos somos abstracta, si no se indican en el resumen, se rellena automáticamente.

2.4 Uso complejo:

• Las limitaciones de la herencia simple en Java pueden ser resueltas a través de la interfaz.
• Interface puede alcanzar la herencia múltiple también puede ser más, incluso más que al mismo tiempo puede ser heredada alcanzado.

public class Test4_ComInter {
    public static void main(String[] args) {
       Interface1 in = new Interface1Impl();
       in.save();
       in.update();
    }
}

//创建接口1
interface Interface1{
    void save();
    void update();
}

//创建接口2
interface Interface2{
    void get();
    void delete();
}

//打破了java单继承的局限性，因为接口之间可以多继承，多个接口之间逗号隔开
interface Interface3 extends Interface1,Interface2{
    void add();
}

//接口还可以多实现吗？？---可以多实现，只不过接口之间逗号隔开
class ManyImpl implements  Interface1,Interface2{
    public void save() {}
    public void update() {}
    public void get() {}
    public void delete() {}
}

//接口可以继承的同时，多实现？？ -- 
class MoreImple extends ManyImpl  implements Interface1,Interface2  {
}

//创建实现类，使用3号接口的功能，需要重写几个方法呢？？---同时重写1号和2号和3号接口里的所有功能
class Interface3Impl  implements Interface3{
    @Override
    public void save() {  }
    @Override
    public void update() {  }
    @Override
    public void get() {  }
    @Override
    public void delete() {   }
    @Override
    public void add() {  }
}

//创建实现类
class Interface1Impl implements Interface1{
    @Override
    public void save() {
       System.out.println("save()...");
    }
    @Override
    public void update() {
      System.out.println("update()...");
    }
}