Wie beherrscht man abstrakte Java-Klassen und -Schnittstellen?

abstrakte

abstrakte Einführung: Kann zum Ändern verwendet werden: Klassen (abstrakte Klassen), Methoden (abstrakte Methoden)

abstrakte modifizierte Klassen:

① Diese Klasse kann nicht instanziiert werden (dh Objekte dieser Klasse). kann nicht erstellt werden) )

②Obwohl es nicht selbst instanziiert werden kann, ruft die Unterklasse den Konstruktor der übergeordneten Klasse auf, daher muss es einen Konstruktor in der abstrakten Klasse geben

Abstrakte Änderungsmethode

①Abstrakte Methoden haben nur Methodendeklarationen und keine Methodenkörper. Die Klasse, in der sie sich befinden. Es muss eine abstrakte Klasse sein. Denn wenn eine Klasse nicht abstrakt ist, kann diese Klasse Objekte erstellen, und wenn sie Objekte erstellen kann, kann sie aufgerufen werden. Im Gegenteil: In abstrakten Klassen kann es keine abstrakten Methoden geben.

② Wenn die Unterklasse alle abstrakten Methoden der übergeordneten Klasse neu schreibt, kann sie instanziiert werden. Wenn nicht alle neu geschrieben werden, ist die Unterklasse ebenfalls eine abstrakte Klasse und muss mit abstrakt geändert werden.

③Abstract kann nicht zum Ändern privater Methoden, statischer Methoden, mit dem Schlüsselwort final geänderter Methoden und mit dem Schlüsselwort final geänderter Klassen verwendet werden.

Final kann eindeutig nicht vererbt werden, aber Abstract erfordert die Vererbung von Unterklassen und kann daher nicht verwendet werden. Wenn beide Methoden statisch sind, gelten die beiden Methoden nicht als überschrieben oder überschrieben, sodass Abstract zum Ändern statischer Methoden verwendet wird und nicht überschrieben werden kann .

Abstrakte Anwendung

Vorlagenmethoden-Entwurfsmuster. Bei der Implementierung eines Algorithmus in der Softwareentwicklung sind die Gesamtschritte sehr fest und häufig. Diese Schritte werden in der übergeordneten Klasse geschrieben, und einige flüchtige und unsichere Teile können für die Implementierung durch Unterklassen abstrahiert werden.

Anonymes Unterklassenobjekt der abstrakten Klasse

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(){
        ...
    }  
    });

endgültiges Schlüsselwort

endgültige geänderte Klasse: Diese Klasse kann nicht von anderen Klassen geerbt werden, z. B.: String, System, StringBuffer

endgültige geänderte Methode: Diese Methode kann nicht mehr überschrieben werden. Zum Beispiel: getClass() in der Object-Klasse

Statisches Finale wird verwendet, um Attribute zu ändern: globale Konstanten

Endgültige geänderte Variablen: Die Variable wird zu diesem Zeitpunkt als Konstante bezeichnet

Endgültige geänderte Attribute: Sie können die Position der berücksichtigen Zuweisung: explizite Formelinitialisierung, Initialisierung im Codeblock, Initialisierung im Konstruktor

Endgültige Änderung lokaler Variablen: Insbesondere beim Ändern des formalen Parameters mit final bedeutet dies, dass der formale Parameter eine Konstante ist. Wenn diese Methode aufgerufen wird, ist sie tatsächlich Parameter werden dem konstanten formalen Parameter zugewiesen. Nach der Zuweisung kann dieser formale Parameter nur im Methodenkörper verwendet, aber nicht neu zugewiesen werden

Schnittstelle

Die Schnittstelle wird mithilfe der Schnittstelle definiert, die in paralleler Beziehung zur Klasse steht Schnittstelle und Mitglieder in der Schnittstelle:

Schnittstellenbezogene Regeln

1 Alle Methoden in der Schnittstelle sind abstrakt.

2. Auch wenn die Mitglieder in der Schnittstelle nicht explizit als öffentlich gekennzeichnet sind, sind sie standardmäßig als öffentliche, statische, endgültige Variablen gekennzeichnet sind globale statische Konstanten.

4. Sie können eine neue Schnittstelle definieren und Extends verwenden, um eine vorhandene Schnittstelle zu erben.

5 Sie können eine Klasse definieren und Implements verwenden, um alle Methoden in einer Schnittstelle zu implementieren.

6. Sie können eine abstrakte Klasse definieren und Implementierungen verwenden, um einige Methoden in einer Schnittstelle zu implementieren.

Eigenschaften von Schnittstellen

1. Implementierende Klassen müssen alle Methoden der Schnittstelle implementieren

3. Variablen in Schnittstellen sind statische Konstanten Die Klasse deckt alle abstrakten Methoden in der Schnittstelle ab. Sie können eine Instanz erstellen. Wenn die Klasse nicht alle abstrakten Methoden in der Schnittstelle abdeckt, ist die Klasse immer noch eine abstrakte Klasse. Java-Klassen können mehrere Schnittstellen implementieren – was die Mängel der Einzelvererbung ausgleicht. Die Klasse AA erweitert BB und implementiert CC, DD und EE. Schnittstellen können voneinander geerbt werden, und eine Mehrfachvererbung ist möglich. Die Verwendung von Schnittstellen spiegelt Polymorphismus wider. Eine Schnittstelle ist eine Spezifikation, Programmierung für Schnittstellen.

Ähnlichkeiten und Unterschiede zwischen abstrakten Klassen und Schnittstellen

Ähnlichkeiten: Sie können nicht instanziiert werden, beide können abstrakte Methoden enthalten

Unterschiede:

1. Erklären Sie die Definition und interne Struktur abstrakter Klassen und Schnittstellen (java7, java8)

2. Klasse: Einzelvererbung, Schnittstelle: Mehrfachvererbung.

Übungen zu abstrakten Klassen und Schnittstellen

 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();
    }
}

Anwendung von Schnittstellen

Zwei Entwurfsmuster

-Proxy-Muster

Proxy-Design dient dazu, einen Proxy für andere Objekte bereitzustellen, um den Zugriff auf dieses Objekt zu steuern

Anwendungsszenario: Sicherheits-Proxy, Remote-Proxy, Lazy Loading

Klassifizierung: statischer Proxy, dynamischer Proxy

-Factory-Muster

realisiert die Trennung von Erstellern und Aufrufern

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);//这个调用的是接口中的

Neue Schnittstellenfunktionen in Java8

JDK8: Zusätzlich zu globalen Konstanten und abstrakten Methoden, You kann auch statische Methoden und Standardmethoden definieren (Standardschlüsselwortänderung)

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

Die in der Schnittstelle definierten statischen Methoden können nur über die Schnittstelle interface.method aufgerufen werden.

Durch die Implementierung des Objekts der Klasse können Sie die Standardmethode object.method in der Schnittstelle aufrufen.

Wenn die Implementierungsklasse die Standardmethode in der Schnittstelle überschreibt, wird die überschriebene Methode weiterhin aufgerufen, wenn sie aufgerufen wird.

Wenn die von der Unterklasse (oder Implementierungsklasse) geerbte übergeordnete Klasse und die implementierte Schnittstelle denselben Namen und dasselbe deklarieren Parameter Methode: Wenn die Unterklasse diese Methode nicht überschreibt, ruft sie die Methode in der übergeordneten Klasse auf – Klassenprioritätsprinzip

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

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

内部类

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

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

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

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

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

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

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

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

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

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

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

开发中局部内部类的使用

常用的局部内部类：

//方式一
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;
        }
    };
}

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

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

成员内部类

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

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

this.name//内部类的属性

Person.this.name//外部类的属性

Das obige ist der detaillierte Inhalt vonWie beherrscht man abstrakte Java-Klassen und -Schnittstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!