Comment maîtriser les classes et interfaces abstraites Java ?-javaDidacticiel-php.cn

abstract

introduction abstraite : peut être utilisée pour modifier : des classes (classes abstraites), des méthodes (méthodes abstraites)

classes abstraites modifiées :

① Cette classe ne peut pas être instanciée (c'est-à-dire des objets de cette classe ne peut pas être créé) )

②Bien qu'elle ne puisse pas être instanciée par elle-même, la sous-classe appellera le constructeur de la classe parent, il doit donc y avoir un constructeur dans la classe abstraite

méthode de modification abstraite

①Les méthodes abstraites n'ont que des déclarations de méthode et pas de corps de méthode. La classe dans laquelle ils se trouvent. Il doit s'agir d'une classe abstraite. Parce que si une classe n’est pas abstraite, alors cette classe peut créer des objets, et si elle peut créer des objets, elle peut être appelée. Au contraire, il ne peut y avoir de méthodes abstraites dans les classes abstraites.

② Si la sous-classe réécrit toutes les méthodes abstraites de la classe parent, elle peut être instanciée. Si toutes ne sont pas réécrites, alors la sous-classe est également une classe abstraite et doit être modifiée avec abstract.

③Abstract ne peut pas être utilisé pour modifier des méthodes privées, des méthodes statiques, des méthodes modifiées avec le mot-clé final et des classes modifiées avec le mot-clé final.

Final ne peut clairement pas être hérité, mais abstract nécessite un héritage de sous-classe, il ne peut donc pas être utilisé, car si les deux méthodes sont statiques, les deux méthodes ne sont pas considérées comme remplacées ou remplacées, donc abstract est utilisé pour modifier les méthodes statiques et ne peut pas être remplacé .

Application abstraite

Modèle de conception de méthode de modèle. Lors de l'implémentation d'un algorithme dans le développement de logiciels, les étapes globales sont très fixes et courantes. Ces étapes sont écrites dans la classe parent, et certaines parties volatiles et incertaines peuvent être résumées pour être implémentées par des sous-classes.

Objet de sous-classe anonyme de la classe abstraite

public static void main(String[] args){
    //匿名对象
    eat(new son());
    //非匿名类的非匿名对象
    son John=new son();
    eat(John);
    //匿名子类对象
    father f=new father(){//抽象类造对象必须要重写方法，了解看得懂就ok了。
        @Override
        public void work() {
        }
        @Override
        public void info(father i) {
        }
    };
}
//普通方法
public static void eat(father f){
    System.out.println("吃饭");
}
//父类
public abstract static class father{
    String name;
    int age;
    public abstract void work();//抽象方法不能有方法体
    public abstract void info(father i);
}
//子类
public class son extends father{//继承
    String name;
    int age;
    @Override
    public void work(){
        System.out.println("上学");
    }
    @Override
    public void info(father i) {
        System.out.println("name:"+i.name+" age:"+i.age);
    }
}
//接口的匿名对象
非匿名的对象可以被多次调用，匿名的对象只能使用一次
Computer com=new Computer();//创建了接口的非匿名实现类（子类）的非匿名对象，类和对象都是有名的
Flash flash = new Flash();
//2.创建了接口的非匿名实现类的匿名对象，对象匿名了
com.transferData(new Printer());
//3创建了接口的匿名实现类的非匿名对象,就是类是匿名的，就不知道是接口中的哪个实现类，所以 需要重写方法进行说明
USB  phone = new USB{
    public void start(){
        ...
    }
};
//4.创建了接口的匿名实现类的匿名对象
com.transferData(new USB(){
    public void start(){
        ...
    }  
    });

Copier après la connexion

mot-clé final

classe finale modifiée : cette classe ne peut pas être héritée par d'autres classes, telles que : String, System, StringBuffer

méthode modifiée finale : cette méthode ne peut plus être remplacée, par exemple : getClass() dans la classe Object

static final est utilisé pour modifier les attributs : constantes globales

variables finales modifiées : la variable à ce moment est appelée une constante

attributs finaux modifiés : vous pouvez considérer l'emplacement du affectation : initialisation explicite de la formule, initialisation dans les blocs de code, initialisation dans les constructeurs

modification finale des variables locales : notamment lors de la modification du paramètre formel avec final, cela indique que le paramètre formel est une constante. Lorsque cette méthode est appelée, les paramètres réels sont. affecté au paramètre formel constant. Une fois attribué, ce paramètre formel ne peut être utilisé que dans le corps de la méthode, mais il ne peut pas être réaffecté

Interface

L'interface est définie à l'aide de l'interface, qui est en relation parallèle avec la classe

Définition de l'interface. et les membres de l'interface :

Règles liées à l'interface

1. Toutes les méthodes de l'interface sont abstraites.

2. Même si les membres de l'interface ne sont pas explicitement marqués comme publics, ils sont de type accès public

3 Les variables de l'interface sont marquées comme public static final par défaut, donc les variables définies dans l'interface. sont des constantes statiques globales.

4. Vous pouvez définir une nouvelle interface et utiliser extends pour hériter d'une interface existante.

5 Vous pouvez définir une classe et utiliser des implémentations pour implémenter toutes les méthodes dans une interface.

6. Vous pouvez définir une classe abstraite et utiliser des implémentations pour implémenter certaines méthodes dans une interface.

Caractéristiques des interfaces

1. Les interfaces ne peuvent pas être instanciées

2. Les classes d'implémentation doivent implémenter toutes les méthodes de l'interface

3. classe couvre toutes les méthodes abstraites de l'interface, vous pouvez créer une instance ; si la classe ne couvre pas toutes les méthodes abstraites de l'interface, la classe est toujours une classe abstraite. Les classes Java peuvent implémenter plusieurs interfaces - compensant les lacunes de l'héritage unique

la classe AA étend BB implémente CC, DD, EE

Les interfaces peuvent être héritées les unes des autres et l'héritage multiple est possible. L'utilisation d'interfaces reflète le polymorphisme. Une interface est une spécification, une programmation pour les interfaces.
Similarités et différences entre les classes abstraites et les interfaces

Similarités : elles ne peuvent pas être instanciées, les deux peuvent contenir des méthodes abstraites

Différences :

1 Expliquer la définition et la structure interne des classes et interfaces abstraites (java7, java8)

. 2. Classe : héritage unique, interface : héritage multiple.

Exercices sur les classes abstraites et les interfaces

 abstract class Door {
    //开门
    public abstract void openDoor();
    //关门
    public abstract void closeDoor();
}
 interface Lock {
    public static final int num = 200;
    //开锁
    public abstract void openLock();
    //上锁
    public abstract void closeLock();
}
class LockDoor extends Door implements Lock {
    public void openDoor() {
        System.out.println("开门");
    }
    public void closeDoor() {
        System.out.println("关门");
    }
    public void openLock() {
        System.out.println("开锁");
    }
    public void closeLock() {
        System.out.println("上锁");
    }
  }
public class TestLockDoor {
    public static void main(String[] args) {
        LockDoor lockDoor = new LockDoor();
        lockDoor.openLock();
        lockDoor.openDoor();
        lockDoor.closeDoor();
        lockDoor.closeLock();
    }
}

Copier après la connexion

Application des interfaces

Deux modèles de conception

-Modèle de proxy

La conception du proxy consiste à fournir un proxy pour d'autres objets afin de contrôler l'accès à cet objet

Scénario d'application : proxy de sécurité, proxy distant, chargement paresseux

Classification : proxy statique, proxy dynamique

-Modèle d'usine

réalise la séparation des créateurs et des appelants

interface A{
    int x=0;
}
class B{
    int x=1;
}
class C extends B implements A{
    public void pX(){
        System.out.println(x);
    }
    public static void main(String[] args){
        new C().pX();
    }
}
//问题：编译期不知道是要输出哪个x
System.out.println(super.x);//这个调用的是父类中的
System.out.println(A.x);//这个调用的是接口中的

Copier après la connexion

Nouvelles fonctionnalités d'interface dans java8

JDK8 : En plus des constantes globales et des méthodes abstraites, vous peut également définir des méthodes statiques et des méthodes par défaut (modification du mot-clé par défaut)

public interface CompareA{  
  public static void method1(){
  //静态方法        
  System.out.println("CompareA:北京");   
   }   
    public default void method2(){
    //默认方法        
    System.out.println("CompareA:上海");   
     }
  }

Copier après la connexion

Les méthodes statiques définies dans l'interface ne peuvent être appelées que via l'interface, interface.method.

En implémentant l'objet de la classe, vous pouvez appeler la méthode par défaut, object.method dans l'interface.

Si la classe d'implémentation remplace la méthode par défaut dans l'interface, la méthode remplacée sera toujours appelée lors de son appel

Si la classe parent héritée par la sous-classe (ou la classe d'implémentation) et l'interface implémentée déclarent le même nom et le même Paramètres Méthode, si la sous-classe ne remplace pas cette méthode, elle appellera la méthode dans la classe parent - principe de priorité de classe

如果实现类实现了多个接口，而这个多个接口中定义了同名同参数的默认方法，在实现类没有重写方法的情况下会报”接口冲突“错误，此时需要重写。

如何在子类（或者实现类）调用父类、接口中被重写的方法？接口.super.方法。

内部类

需要关注的问题：如何实例化成员内部类的对象：外部类Person，静态内部类Brain，非静态内部类Lungs，静态成员内部类：new 外部类.内部类()

Person.Brain brain=new Person.Brain();

Copier après la connexion

非静态成员内部类：先造对象，对象.new 内部类()

Person p=new Person();
p.Lungs lungs=p.new Lungs();

Copier après la connexion

如何在成员内部类中区分调用外部类的结构

形参直接调，所在类的用this.结构，外部类的用外部类.this.结构

成员内部类和局部内部类在编译以后都会生成字节码文件

成员内部类：外部类.内部类名.class

局部内部类：外部类.数字内部类名.class

在局部内部类的方法中，如果调用局部内部类所在的方法中的局部变量，该局部变量必须用final关键字修饰(JAVA8之后可以不写出来，但仍然还是final的)

public void Person(){
    int num=10;
    class AA{//局部内部类
        public void show(){//局部内部类的方法
            num=20;//试图修改会报错
            System.out.println(num);//调用局部内部类所在的方法中的局部变量
        }
    }
}

Copier après la connexion

开发中局部内部类的使用

常用的局部内部类：

//方式一
public Comparable getCompareble(){
    class MyComparable implements Comparable{//局部内部类

        public int compareTo(Object o){
            return 0;
        }
    }
    return new MyComparable();
}
//方式二
public Comparable getCompareble(){
    return new Comparable(){

        public int CompareTo(Object o){
            return 0;
        }
    };
}

Copier après la connexion

Java允许将一个类A声明在另一个类B中，A为内部类，B为外部类

内部类的分类：成员内部类、局部内部类（方法内，代码块内，构造器内）

成员内部类

作为外部类的成员：可以调用外部类的结构，可以被static修饰

作为一个类：可以定义属性、方法、构造器，可以用final、abstract修饰，可以被继承