Interface
1. A interface é um tipo de dados de referência
2. A interface é completamente abstrata (a classe abstrata é semi-abstrata) ou pode-se dizer que a interface é uma classe abstrata especial
3. A sintaxe da interface: [Lista de Modificadores] nome da interface {}
4. Interface Entre a interface e a interface e a classe suportam herança múltipla
5. A interface contém apenas constantes e métodos abstratos, portanto não há construtor
6. Todos os elementos na interface são publicamente modificados
7. Quando o método abstrato da interface é definido: public abstractmodificado O operador pode ser omitido
- Ao definir constantes na interface:
public static finalmodificadores podem ser omitidos - Ele será adicionado automaticamente quando o compilador compilar
Uso básico da interface
1. Classes e classes são chamadas de herança, e classes e interfaces são chamadas de implementações ("implementação" pode ser entendida como "herança")
- A herança é
extendsfeita com palavras - chave - A implementação é feita usando as
implementspalavras-chave
2. Quando uma classe não abstrata implementa uma interface, todos os métodos abstratos na interface devem ser implementados (substituídos)
interface MyMaths{
//这里要知道常量和方法都是省略了关键字的
double PI = 3.14;
int sum(int a ,int b);
int sub(int a, int b);
}
class MyMathsImpl implements MyMaths{
//方法覆盖（这里通常叫做实现）
public int sum(int a, int b){
return a + b;
}
public int sub(int a, int b){
return a - b;
}
}
public class InterfaceTest{
public static void main(String[] args){
//多态
MyMaths m = new MyMathsImpl();
int a = m.sum(1, 2);
System.out.println(a);
}
}
Uma classe pode implementar (herdar) várias interfaces?
Sim, esse mecanismo compensa as classes Java e as classes suportam apenas herança única.
interface A{
void m1();
}
interface B{
void m2();
}
interface C{
void m3();
}
class D implements A,B,C{
public void m1(){
System.out.println("m1...");
}
public void m2(){
System.out.println("m2...");
}
public void m3(){
System.out.println("m3...");
}
}
public class InterfaceTest{
public static void main(String[] args){
//多态
//父类型引用指向子类型对象
A a = new D();
B b = new D();
C c = new D();
//接口之间没有继承关系，是否可以强制类型转换（接口转型）
//属于骚操作，明明没有继承关系，还能转型，现阶段还是不要去记它，用处不大
B b1 = (B)a;
b1.m2();
//如果想让a调用m2方法，还是直接向下转换成D即可
D d = (D)a;
d.m2();
}
}
Independentemente da transformação para cima ou para baixo, deve haver um relacionamento de herança entre os dois tipos.Sem o relacionamento de herança, o compilador relatará um erro, mas esta frase não se aplica à interface.
Se você deseja que a referência de tipo pai chame um método específico para o subtipo, é melhor usar a sintaxe de converter a referência de tipo pai em um objeto de subtipo.
Transição entre interfaces sem herança
interface K{
}
interface M{
}
class E implements M{
}
public class InterfaceTest{
public static void main(String[] args){
M m = new E();
K k = (K)m;
}
}
Não há relação de herança entre a interface e a interface e não há relação de herança.Você também pode forçar a conversão de tipo, o compilador não relatará um erro, mas
observe que ClassCastException pode ocorrer em tempo de execução.
Se existirem herança e implementação, como o código deve ser escrito?
estende-se à frente dos implementos nas costas
class Animal{
}
//可飞翔的接口,接口通常提取的是行为动作
interface Flyable{
void fly();
}
class Cat extends Animal implements Flyable{
public void fly(){
System.out.println("飞翔的小猫");
}
}
//如果不想让它飞，可以不实现Flyable的接口
class Snake extends Animal{
}
//想飞就插入Flyable接口
class Pig extends Animal implements Flyable{
public void fly(){
System.out.println("飞翔的小猪");
}
}
public class Test{
public static void main(String[] args){
//多态
Flyable f = new Cat();
f.fly();
Flyable f1 = new Pig();
f1.fly();
}
}
Este exemplo incorpora o recurso "plugável" da interface, o que reduz a correlação entre os programas, que está desacoplando.
O papel das interfaces no desenvolvimento
- A interface é completamente abstrata,
- A programação orientada a resumo é modificada da seguinte maneira: programação orientada a interface
- Com a interface, é conectável. Pluggable significa que a força de expansão é muito forte, não soldada
- Existe um slot diretamente na placa-mãe e na memória.Este slot possui uma interface.Se o módulo de memória estiver com defeito, você poderá substituí-lo. Isso é chamado de alta escalabilidade (baixo acoplamento)
Para resumir uma frase:
Programação orientada a interface, que pode reduzir o grau de acoplamento do programa e fornecer a força de expansão do programa, em conformidade com o princípio OCP.O
uso da interface é inseparável do mecanismo polimórfico
//接口 -菜单
public interface FoodMeau {
public void shihongshi();
public void rousi();
}
//接口的实现
//西餐师傅
//厨师是接口的实现者
public class AmericanCooker implements FoodMeau{
public void shihongshi(){
System.out.println("西餐师傅做的西红柿炒蛋");
}
public void rousi(){
System.out.println("西餐师傅做的鱼香肉丝");
}
}
//中餐厨师
public class ChineseCooker implements FoodMeau{
public void shihongshi(){
System.out.println("中餐师傅做的西红柿炒蛋，超好吃的");
}
public void rousi(){
System.out.println("中餐师傅做的鱼香肉丝，超好吃的");
}
}
//接口的调用者 -顾客
public class Customer {
//顾客手里有一个菜单
//Customer has a FoodMenu
//记住：以后凡是能够使用 has a 来描述的，统一以属性的方式存在
//回顾：凡是能用 is a来描述的，都可以设置为继承
private FoodMeau foodMeau;
//Constructor
public Customer() {
}
public Customer(FoodMeau foodMeau) {
this.foodMeau = foodMeau;
}
//setting and getter
public FoodMeau getFoodMeau() {
return foodMeau;
}
public void setFoodMeau(FoodMeau foodMeau) {
this.foodMeau = foodMeau;
}
//提供点菜的方法
public void order(){
FoodMeau f = getFoodMeau();
f.shihongshi();
f.rousi();
}
}
public class Test {
public static void main(String[] args) {
//建立厨师对象
FoodMeau cooker1 = new ChineseCooker();
FoodMeau cooker2 = new AmericanCooker();
//建立顾客对象
Customer c = new Customer(cooker1);
//顾客点菜
c.order();
//如果想要点西餐
c.setFoodMeau(cooker2);
c.order();
}
}
A interface pode ser dissociada:
Qualquer interface possui um chamador e um implementador.A interface pode desacoplar o
chamador e o implementador.O chamador grava a chamada para a interface e o implementador grava a implementação para a interface.O
desenvolvimento de grandes projetos geralmente separa o projeto em um módulo. Para módulos, a
interface entre os módulos e os módulos é adotada para reduzir o grau de acoplamento.
