


Compréhension approfondie des classes abstraites et des interfaces en Java
Nov 27, 2019 pm 04:43 PMJe crois que tout le monde ressent cela?: il y a trop de similitudes et trop de différences entre les classes abstraites et les interfaces. Ces deux éléments confondent souvent les débutants Que ce soit dans la programmation réelle ou lors des entretiens, les classes abstraites et les interfaces sont particulièrement importantes ! J'espère qu'après avoir lu cet article, tout le monde pourra comprendre sereinement les deux...
Cours abstrait tel que je le comprends
1. Les classes abstraites ont la même saveur que les classes
1) Les classes abstraites peuvent être utilisées comme les classes pour hériter.
2), les classes abstraites peuvent avoir tous les composants qu'une classe peut avoir [y compris les constructeurs, les composants de modification statique, etc.]
Les classes abstraites sont telles que leur nom les définit, elles sont aussi une classe A
2. Méthode abstraite
Il faut bien conna?tre avant de parler des différents charmes Méthode abstraite :
1), la méthode abstraite n'a pas de corps de méthode
2), la méthode abstraite doit être modifiée avec abstract
mot-clé
3), la classe avec la méthode abstraite doit C'est une classe abstraite
4). La méthode abstraite doit être public
ou protected
Par défaut, elle est par défaut public
. méthodes
3. Le charme étrange des classes abstraites et des classes
1), les classes abstraites doivent être modifiées avec le mot-clé abstract , et les classes avec des modifications abstraites C'est une classe abstraite !
2), les classes abstraites peuvent ou non avoir des méthodes abstraites
3), bien que les classes abstraites aient des constructeurs, elles ne peuvent pas être utilisées pour créer directement des instances d'objet
4), les classes abstraites ne peuvent pas être utilisées final
, private
Modification
5) Les classes abstraites externes ne peuvent pas être modifiées avec Static, mais les classes abstraites internes peuvent être déclarées avec static. Le code pour comprendre cette phrase est le suivant?:
//定義一個抽象類A abstract class A{ //定義一個內部抽象類B static abstract class B{ //static定義的內部類屬于外部類 public abstract void saoMethod(); } } class C extends A.B{ public void saoMethod(){ System.out.println("======saoMethod方法執(zhí)行了======"); } } public class StaticDemo { public static void main(String[] args) { A.B ab = new C();//向上轉型 ab.saoMethod(); } } 運行結果: ======saoMethod方法執(zhí)行了======
Certaines chaussures pour enfants sont tellement déroutantes C extends A.B
De quel genre d'opération cool s'agit-il ? Oui, lorsque la classe abstraite interne déclarée à l'aide de static
est équivalente à une classe abstraite externe, le nom de la classe est exprimé sous la forme "classe externe. classe interne" lors de l'héritage. Ce genre d'opération cool est vraiment s?r et maigre.
La classe abstraite est une classe spéciale. Il y a une différence essentielle entre la classe abstraite et la classe ordinaire
4. Les classes abstraites existent pour l'héritage. Si vous définissez une classe abstraite mais n'en héritez pas, la classe abstraite que vous créez n'aura aucun sens?!
Bien que les classes abstraites aient des constructeurs, elles ne peuvent pas être directement être. instancié, la création d'un objet implique une transformation vers le haut, principalement pour être appelé par ses sous-classes Il y a aussi la phrase selon laquelle les classes abstraites ne peuvent pas avoir de méthodes abstraites, c'est juste une chose importante à retenir Concept, être je m'en souviendrai s?rement ! Dans le développement réel, les classes abstraites ont généralement des méthodes abstraites, sinon la classe abstraite perdra son sens et ne sera pas différente d'une classe ordinaire !
Si une classe ordinaire A hérite d'une classe abstraite B, alors la sous-classe A doit implémenter toutes les méthodes abstraites de la classe parent B. Si la sous-classe A n'implémente pas la méthode abstraite de la classe parent B, la sous-classe A doit également être définie comme une classe abstraite, c'est-à-dire une classe abstraite.
L'interface telle que je la comprendsL'interface peut être considérée comme un cas particulier de classe abstraite. La classe abstraite et l'interface sont deux. trop de similitudes et trop de différences. En revanche, une interface s’apparente davantage à une abstraction du comportement !
1. Caractéristiques de l'interface1), la
méthode dans l'interface est par défaut public abstractType, si le type variable membre dans l'interface n'est pas écrit, sa valeur par défaut est public static final. 2) L'interface n'a pas de méthode de construction 3) L'interface peut implémenter un "héritage multiple". Une classe peut implémenter plusieurs interfaces. Le format d'implémentation consiste à les séparer directement par des virgules.
Les interfaces ne peuvent contenir que des variables
Si elles ne sont pas écrites, la valeur par défaut est Modification avec public static final
. entra?nera un échec de compilation. Toutes les méthodes de l'interface public static final
private
seront implicitement désignées comme des méthodes
, en utilisant d'autres mots-clés, tels que public abstract
public abstract
private, protected, static, final Modifications telles que car ne parviendra pas à compiler.
De nombreux articles sur Internet disent que toutes les méthodes des interfaces sont des méthodes abstraites. Le blogueur est revenu en arrière et a fait des recherches et a découvert qu'en fait. , ce n'est pas suffisant, sérieusement, regardons simplement un programme simple
.package InterfaceDemo; interface AA{ //接口AA default void hh(){ System.out.println("123"); }; } class BB implements AA{ //實現(xiàn)接口 } public class InterfaceDesign { public static void main(String[] args) { AA a=new BB(); //通過實現(xiàn)類創(chuàng)建實例 a.hh(); } } 運行結果: 123
顯然hh
方法并不是抽象方法,但是這樣設計就失去接口的意義了,實際開發(fā)中不會出現(xiàn)這樣的代碼,確實有點專牛角尖的韻味,所以我也不否認網上的言論,只是覺得不夠嚴謹,我覺得大家還是注意一下比較好...如果面試官聽到你這樣的回答,可能對你刮目相看,會認為你是一個對知識極度向往、探索以及有個人思維想法的學習者 ~說白了,就是杠精,這里杠精是褒義詞~
抽象類和接口本質區(qū)別
抽象類和接口本質區(qū)別主要從語法區(qū)別和設計思想兩方面下手
1、語法區(qū)別
1.抽象類可以有構造方法,接口中不能有構造方法。
2.抽象類中可以有任何類型成員變量,接口中只能有
public static final
變量3.抽象類中可以包含非抽象的普通方法,接口中的可以有非抽象方法,比如
deaflut
方法4.抽象類中的抽象方法的訪問類型可以是
public
,protected
和(默認類型,雖然eclipse
下不報錯,但應該也不行),但接口中的抽象方法只能是public
類型的,并且默認即為public abstract
類型。5.抽象類中可以包含靜態(tài)方法,接口中不能包含靜態(tài)方法
6.抽象類和接口中都可以包含靜態(tài)成員變量,抽象類中的靜態(tài)成員變量的訪問類型可以任意,但接口中定義的變量只能是
public static final
類型,并且默認即為public static final
類型。7.一個類可以實現(xiàn)多個接口,但只能繼承一個抽象類。
2、設計思想區(qū)別
對于抽象類,如果需要添加新的方法,可以直接在抽象類中添加具體的實現(xiàn)(相當于寫普通類的普通方法并添加方法體的實現(xiàn)代碼),子類可以不進行變更;而對于接口則不行,如果接口進行了變更,則所有實現(xiàn)這個接口的類都必須進行相應的改動。這一點應該很好理解。
從設計角度來講抽象類是對一種對類抽象,抽象類是對整個類整體進行抽象,包括屬性、行為。而接口是對行為的抽象,接口是對類局部(行為)進行抽象。從某一角度來講,接口更像是抽象的抽象!
怎么理解上面這段話呢?
理解二者設計思想的區(qū)別從程序員宜春和花姑娘(一頭可愛的小母豬)的故事開始,程序員宜春每天過著三點一線的生活,不是吃就是睡覺,閑暇之余還會敲敲代碼,而花姑娘就厲害了,每天都是一點一線的生活,不是吃就是睡覺,閑暇之余不是吃就是睡覺。程序員宜春和花姑娘都過著幸福安逸的生活,突然有一天,風起云涌,天射大便~天色大變~,萬惡的產品經理來需求了,要設計一個程序員宜春和花姑娘的一個程序,要求使用抽象類或者接口去設計,這個時候你會怎么去設計,下面給出兩個設計方案...
方案一:使用抽象類設計,分別設計eat、sleep、qiaoDaiMa
方法,具體代碼如下:
abstract class Myclass{ public abstract void eat(); public abstract void sleep(); public abstract void qiaoDaiMa(); }
方案二:使用接口設計,分別設計eat、sleep、qiaoDaiMa
方法,具體代碼如下:
interface Myclass{ public abstract void eat(); public abstract void sleep(); public abstract void qiaoDaiMa(); }
顯然,不管是哪個類繼承抽象類或者實現(xiàn)上面的接口,都會出現(xiàn)同樣的狀況:重寫它們的抽象方法。
如果有一百個程序員宜春,上面的設計都是很好地得到解決。但是到花姑娘身上就不管用了,花姑娘不會敲代碼這種高端操作?。∫话賯€花姑娘都重寫的qiaoDaiMa
方法都沒有意義啊,顯然這樣設計有問題。
從上面可以看出,eat、sleep
對于qiaoDaiMa
方法不是同一范疇內的行為(方法)。實際上我們可以這樣設計:定義一個抽象類,包含eat、sleep
方法,再定義一個接口包含qiaoDaiMa
方法,具體代碼如下:
abstract class Myclass{ public abstract void eat(); public abstract void sleep(); } interface MyclassTwo{ public abstract void qiaoDaiMa(); } class YiChun extends Myclass implements MyclassTwo{ @Override public void eat() { } @Override public void sleep() { } @Override public void qiaoDaiMa() { } }
我們只要讓一百個程序員宜春繼承抽象類并實現(xiàn)接口就好了,而花姑娘就直接繼承抽象類就好了。這樣一設計,堪稱完美...
同樣的,這樣講述是很不負責的,為啥捏?因為你會發(fā)現(xiàn),這樣設計不管是抽象類還是接口好像沒有什么區(qū)別,剛才的抽象類換成接口,接口換成抽象類,實現(xiàn)效果也一致,代碼如下:
interface Myclass{ public abstract void eat(); public abstract void sleep(); } abstract class MyclassTwo{ public abstract void qiaoDaiMa(); }
所以,為了講解清晰設計思想區(qū)別,程序員宜春和花姑娘的故事不得不繼續(xù)講下去...
我們都知道,可愛的小母豬一般都是粉色的對吧,這個時候我們的產品經理又改需求了。啥?產品經理家中一百只小豬有一只是黑白sai的,額...
萬惡的產品經理只會無理改需求,可是產品經理永遠不會知道他一味逼程序員,程序員自己都不知道自己有多優(yōu)秀!
我們都知道,可愛的小母豬一般都是粉色的對吧,這個時候我們的產品經理又改需求了。啥?產品經理家中一百只小豬有一只是黑白sai的,額...
萬惡的產品經理只會無理改需求,可是產品經理永遠不會知道他一味逼程序員,程序員自己都不知道自己有多優(yōu)秀!
那么這個時候,我們都知道,抽象類和接口都是可以有成員變量的,只不過接口比較苛刻只能是public static final
正是因為這一點!抽象類和接口的設計精髓就在這里了,這個時候我們這樣設計:
interface Myclass{ public abstract void eat(); public abstract void sleep(); } abstract class MyclassTwo{ String color="red"; public abstract void qiaoDaiMa(); }
讓宜春類這樣設計
package AbstractTest; interface Myclass { public abstract void eat(); public abstract void sleep(); } abstract class MyclassTwo { String color = "red"; public abstract void qiaoDaiMa(); } class YiChun extends MyclassTwo implements Myclass { @Override public void eat() { } @Override public void sleep() { } @Override public void qiaoDaiMa() { } } public class AbstractDemo { public static void main(String[] args) { YiChun yc = new YiChun(); } }
然而宜春對于color
這個屬性可以是不理睬的,可以當做不存在,除非宜春不嫌棄自己也是一只紅sai佩奇哈哈哈....
而花姑娘類就要注意了!然后讓產品經理家中的100只小豬設計代碼如下;
package AbstractTest; interface Myclass { public abstract void qiaoDaiMa(); } abstract class MyclassTwo { String color = "red"; public abstract void eat(); public abstract void sleep(); } class Pig extends MyclassTwo { @Override public void eat() { } @Override public void sleep() { } } public class AbstractDemo { public static void main(String[] args) { Pig p = new Pig (); String color = "blackWhite"; System.out.println(color); } }
其余的99只花姑娘就直接不用動了也就是不需要String color = "blackWhite"
;這一句代碼,它的color
屬性默認是red
了...
這個時候抽象類和接口就不能更換了,從而抽象類和接口的設計思想就很清晰了,你何識著咩啊~
本文來自?java入門?欄目,歡迎學習!
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undress AI Tool
Images de déshabillage gratuites

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
échangez les visages dans n'importe quelle vidéo sans effort grace à notre outil d'échange de visage AI entièrement gratuit?!

Article chaud

Outils chauds

Bloc-notes++7.3.1
éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Pour gérer correctement les transactions JDBC, vous devez d'abord désactiver le mode de validation automatique, puis effectuer plusieurs opérations, et enfin vous engager ou randonner en fonction des résultats; 1. Appelez Conn.SetAutoCommit (false) pour démarrer la transaction; 2. Exécuter plusieurs opérations SQL, telles que l'insertion et la mise à jour; 3. Appelez Conn.Commit () Si toutes les opérations sont réussies, et appelez Conn.Rollback () Si une exception se produit pour garantir la cohérence des données; Dans le même temps, les ressources TRY-With doivent être utilisées pour gérer les ressources, gérer correctement les exceptions et cl?turer les connexions pour éviter la fuite de connexion; De plus, il est recommandé d'utiliser des pools de connexion et de définir des points de sauvegarde pour réaliser un retour en arrière partiel, et de maintenir les transactions aussi courtes que possible pour améliorer les performances.

Pré-formancetartuptimemoryusage, quarkusandmicronautleadduetocompile-timeprocessingandgraalvsupport, withquarkusofperforming lightbetterine scénarios.

HTTP Log Middleware dans GO peut enregistrer les méthodes de demande, les chemins de requête, la propriété intellectuelle du client et le temps qui prend du temps. 1. Utilisez http.handlerfunc pour envelopper le processeur, 2. Enregistrez l'heure de début et l'heure de fin avant et après l'appel Suivant.Servehttp, 3. Obtenez le vrai client IP via R.RemoteAddr et X-Forwared-For Headers, 4. Utilisez le log.printf aux journaux de demande de sortie, 5. L'exemple de code complet a été vérifié pour s'exécuter et convient au démarrage d'un projet petit et moyen. Les suggestions d'extension incluent la capture des codes d'état, la prise en charge des journaux JSON et le suivi des ID de demande.

La collecte des ordures de Java (GC) est un mécanisme qui gère automatiquement la mémoire, ce qui réduit le risque de fuite de mémoire en récupérant des objets inaccessibles. 1. GC juge l'accessibilité de l'objet de l'objet racine (tel que les variables de pile, les threads actifs, les champs statiques, etc.), et les objets inaccessibles sont marqués comme des ordures. 2. Sur la base de l'algorithme de compensation de marque, marquez tous les objets accessibles et effacez des objets non marqués. 3. Adopter une stratégie de collecte générationnelle: la nouvelle génération (Eden, S0, S1) exécute fréquemment MinorGC; Les personnes agées fonctionnent moins, mais prend plus de temps pour effectuer MajorGC; Metaspace Stores Metadata de classe. 4. JVM fournit une variété de périphériques GC: SerialGC convient aux petites applications; Le parallelGC améliore le débit; CMS réduit

Le choix du bon type HTMLinput peut améliorer la précision des données, améliorer l'expérience utilisateur et améliorer la convivialité. 1. Sélectionnez les types d'entrée correspondants en fonction du type de données, tels que le texte, le courrier électronique, le tel, le numéro et la date, qui peuvent vérifier automatiquement la somme de la somme et l'adaptation au clavier; 2. Utilisez HTML5 pour ajouter de nouveaux types tels que l'URL, la couleur, la plage et la recherche, qui peuvent fournir une méthode d'interaction plus intuitive; 3. Utilisez l'espace réservé et les attributs requis pour améliorer l'efficacité et la précision du remplissage des formulaires, mais il convient de noter que l'espace réservé ne peut pas remplacer l'étiquette.

GradleisthebetterChoiceFormostNewProjectsDuetOtsSuperiorflexibility, Performance et ModerNtoolingSupport.1.gradle’sgroovy / kotlindslismoreConcis

Le report est utilisé pour effectuer des opérations spécifiées avant le retour de la fonction, telles que les ressources de nettoyage; Les paramètres sont évalués immédiatement lorsqu'ils sont reportés et les fonctions sont exécutées dans l'ordre de la dernière entrée (LIFO); 1. Plusieurs éleveurs sont exécutés dans l'ordre inverse des déclarations; 2. Communément utilisé pour le nettoyage sécurisé tel que la fermeture des fichiers; 3. La valeur de retour nommée peut être modifiée; 4. Il sera exécuté même si la panique se produit, adaptée à la récupération; 5. éviter l'abus de report dans les boucles pour éviter la fuite des ressources; Une utilisation correcte peut améliorer la sécurité et la lisibilité du code.

La réponse claire à cette question est la recommandation d'implémenter le modèle d'observateur à l'aide d'une interface d'observateur personnalisée. 1. Bien que Java offre observable et observateur, le premier est une classe et a été obsolète et manque de flexibilité; 2. La pratique recommandée moderne consiste à définir une interface d'observateur fonctionnel, et le sujet maintient la liste des observateurs et informe tous les observateurs lorsque l'état change; 3. Il peut être utilisé en combinaison avec les expressions de lambda pour améliorer la simplicité et la maintenabilité du code; 4. Pour les scénarios GUI ou Javabean, PropertyChangeListener peut être utilisé. Par conséquent, les nouveaux projets devraient adopter un schéma d'interface d'observateur personnalisé, qui est sécurisé, facile à tester et se spécialise dans le Java moderne
