Die Datentypen in Java können in zwei Kategorien unterteilt werden :
Grundlegende Datentypen, auch primitive Datentypen genannt
Um Byte, Short, Char, Int, Long, Float, Double und Boolean zu vergleichen, verwenden Sie das doppelte Gleichheitszeichen (==) und vergleichen Sie ihre Werte.
Referenztyp (Klasse, Schnittstelle, Array)
Wenn sie mit (==) vergleichen, vergleichen sie ihre Speicheradressen im Speicher. Daher ist das Ergebnis ihres Vergleichs wahr, es sei denn, es handelt sich um dasselbe neue Objekt, andernfalls ist das Ergebnis des Vergleichs falsch. Objekte werden auf dem Heap platziert und die Referenz (Adresse) des Objekts wird auf dem Stapel gespeichert. Schauen Sie sich zunächst die Speicherzuordnung und den Code der virtuellen Maschine an:
public class testDay {
public static void main(String[] args) {
String s1 = new String("11");
String s2 = new String("11");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}
Nach dem Login kopieren
Das Ergebnis ist:
false true
Sowohl s1 als auch s2 speichern jeweils die Adressen der entsprechenden Objekte. Wenn also s1 == s2 verwendet wird, werden die Adresswerte der beiden Objekte verglichen (dh ob die Referenzen gleich sind), was falsch ist. Beim Aufruf der Gleichheitsrichtung wird der Wert in der entsprechenden Adresse verglichen, sodass der Wert wahr ist. Hier müssen wir equal() im Detail beschreiben.
2. Detaillierte Erläuterung der Methode equal()
equals() wird verwendet, um zu bestimmen, ob andere Objekte diesem Objekt gleich sind. Es ist in Object definiert, sodass jedes Objekt über die Methode equal() verfügt. Der Unterschied besteht darin, ob die Methode überschrieben wird oder nicht.
Werfen wir zunächst einen Blick auf den Quellcode:
public boolean equals(Object obj) { return (this == obj);
}
Nach dem Login kopieren
Offensichtlich definiert Object einen Vergleich der Adresswerte zweier Objekte (also den Vergleich, ob die Referenzen gleich sind). Aber warum vergleicht der Aufruf von equal() in String nicht die Adresse, sondern den Wert in der Heap-Speicheradresse? Hier ist der entscheidende Punkt. Wenn Kapselungsklassen wie String, Math, Integer, Double usw. die Methode equal() verwenden, haben sie bereits die Methode equal() der Objektklasse behandelt. Schauen Sie sich das umgeschriebene equal() in String an:
public boolean equals(Object anObject) { if (this == anObject) { return true;
} if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length; if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false;
i++;
} return true;
}
} return false;
}
Nach dem Login kopieren
Nach dem Umschreiben ist dies der Inhaltsvergleich und nicht mehr der vorherige Adressvergleich. Analog dazu überschreiben Math, Integer, Double und andere Klassen alle die Methode equal(), um Inhalte zu vergleichen. Natürlich führen Basistypen Wertevergleiche durch.
Es ist zu beachten, dass beim Überschreiben der Methode equal() auch hashCode() überschrieben wird. Gemäß der Implementierung der allgemeinen Methode hashCode() müssen gleiche Objekte gleiche Hashcodes haben. Warum ist das so? Hier müssen wir den Hashcode noch einmal kurz erwähnen.
3. Eine kurze Diskussion zu hashcode()
Es geht offensichtlich um den Unterschied zwischen ==, equal und hashCode in Java, aber warum hängt es plötzlich mit hashcode() zusammen? Sie müssen sehr deprimiert sein, okay, lassen Sie mich ein einfaches Beispiel geben und Sie werden wissen, warum HashCode beteiligt ist, wenn == oder gleich ist.
Lassen Sie uns ein Beispiel geben: Wenn Sie herausfinden möchten, ob eine Sammlung ein Objekt enthält, wie sollten Sie das Programm schreiben? Wenn Sie die indexOf-Methode nicht verwenden, durchlaufen Sie einfach die Sammlung und vergleichen Sie, ob Sie daran denken. Was wäre, wenn es 10.000 Elemente in der Sammlung gäbe, wäre das doch ermüdend, oder? Um die Effizienz zu verbessern, wurde der Hash-Algorithmus geboren. Die Kernidee besteht darin, die Sammlung in mehrere Speicherbereiche zu unterteilen (kann als Buckets betrachtet werden) und kann entsprechend dem Hash-Code gruppiert werden. Ein Objekt kann nach dem Hash-Code gruppiert werden. Sein Hash-Code kann in verschiedene Speicherbereiche (unterschiedliche Bereiche) unterteilt werden.
Beim Vergleichen von Elementen wird also tatsächlich zuerst der Hashcode verglichen, und wenn sie gleich sind, wird die Gleichheitsmethode verglichen.
Sehen Sie sich das Hashcode-Diagramm an:
Ein Objekt hat im Allgemeinen einen Schlüssel und einen Wert. Sein HashCode-Wert kann basierend auf dem Schlüssel berechnet und dann basierend auf seinem HashCode-Wert in verschiedenen Speicherbereichen gespeichert werden in der Abbildung oben dargestellt. Verschiedene Bereiche können mehrere Werte speichern, da es zu Hash-Konflikten kommt. Ganz einfach: Wenn der HashCode zweier verschiedener Objekte gleich ist, spricht man von einem Hash-Konflikt. Einfach ausgedrückt bedeutet dies, dass der Hashcode derselbe ist, Equals jedoch ein anderer Wert ist. Für den Vergleich von 10.000 Elementen ist es nicht erforderlich, die gesamte Sammlung zu durchlaufen. Sie müssen lediglich den HashCode des Schlüssels des gesuchten Objekts berechnen und dann den dem HashCode entsprechenden Speicherbereich finden.
Fu f1=new Zi();
Fu f2=new Son();if(f1 instanceof Zi){
System.out.println("f1是Zi的类型");
}else{
System.out.println("f1是Son的类型");
}
Nach dem Login kopieren
4.多态的转型
多态的转型分为向上转型和向下转型两种
向上转型：多态本身就是向上转型过的过程
使用格式：父类类型 变量名=new 子类类型();
适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。
向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型
使用格式：子类类型 变量名=（子类类型）父类类型的变量；
适用场景：当要使用子类特有功能时。
5.多态案例：
例1：
package day0524;
public class demo04 {
public static void main(String[] args) {
People p=new Stu();
p.eat();
//调用特有的方法
Stu s=(Stu)p;
s.study();
//((Stu) p).study();
}
}
class People{
public void eat(){
System.out.println("吃饭");
}
}
class Stu extends People{
@Override
public void eat(){
System.out.println("吃水煮肉片");
}
public void study(){
System.out.println("好好学习");
}
}
class Teachers extends People{
@Override
public void eat(){
System.out.println("吃樱桃");
}
public void teach(){
System.out.println("认真授课");
}
}
Nach dem Login kopieren
答案：吃水煮肉片
好好学习
例2：
请问题目运行结果是什么？
package day0524;
public class demo1 {
public static void main(String[] args) {
A a=new A();
a.show();
B b=new B();
b.show();
}
}
class A{
public void show(){
show2();
}
public void show2(){
System.out.println("A");
}
}
class B extends A{
public void show2(){
System.out.println("B");
}
}
class C extends B{
public void show(){
super.show();
}
public void show2(){
System.out.println("C");
}
}
Nach dem Login kopieren
答案：A B
5. String、StringBuffer和StringBuilder区别
1、长度是否可变
String 是被 final 修饰的，他的长度是不可变的，就算调用 String 的concat 方法，那也是把字符串拼接起来并重新创建一个对象，把拼接后的 String 的值赋给新创建的对象
7. Der Unterschied zwischen abstrakten Klassen und Schnittstellen
Abstrakte Klassen müssen von Unterklassen geerbt werden und Schnittstellen müssen von Klassen implementiert werden.
Schnittstellen können nur Methodendeklarationen vornehmen, während abstrakte Klassen Methodendeklarationen und Methodenimplementierungen vornehmen können.
In der Schnittstelle definierte Variablen können nur öffentliche statische Konstanten sein, und Variablen in abstrakten Klassen sind gewöhnliche Variablen.
Schnittstelle ist das Ergebnis von Design und abstrakte Klasse ist das Ergebnis von Refactoring.
Abstrakte Klassen und Schnittstellen werden zum Abstrahieren bestimmter Objekte verwendet, Schnittstellen weisen jedoch die höchste Abstraktionsebene auf.
Abstrakte Klassen können bestimmte Methoden und Eigenschaften haben, während Schnittstellen nur abstrakte Methoden und unveränderliche Konstanten haben können.
Abstrakte Klassen werden hauptsächlich zum Abstrahieren von Kategorien verwendet, und Schnittstellen werden hauptsächlich zum Abstrahieren von Funktionen verwendet.
8. Die Bedeutung der abstrakten Klasse
Abstrakte Klasse:
Wenn eine Klasse abstrakte Methoden enthält, sollte die Klasse mit dem Schlüsselwort abstract als abstrakte Klasse deklariert werden.
Bedeutung:
Stellen Sie einen gemeinsamen Typ für Unterklassen bereit.
Kapseln Sie wiederholte Inhalte (Mitgliedsvariablen und Methoden).
9. Anwendungsszenarien von abstrakten Klassen und Schnittstellen
1. Anwendungsszenarien von Schnittstellen:
Spezifische Schnittstellen werden für die Koordination zwischen Klassen benötigt, unabhängig davon, wie sie implementiert sind.
Existiert als Bezeichner, der bestimmte Funktionen implementieren kann, oder es kann ein reiner Bezeichner ohne Schnittstellenmethoden sein.
Eine Klassengruppe muss als einzelne Klasse behandelt werden, und der Anrufer kontaktiert diese Klassengruppe nur über die Schnittstelle.
Bestimmte Mehrfachfunktionen müssen implementiert werden, und diese Funktionen haben möglicherweise überhaupt keine Verbindung.
2. Anwendungsfälle der abstrakten Klasse (abstract.class):
Kurz gesagt, Sie können sie verwenden, wenn Sie sowohl eine einheitliche Schnittstelle als auch Instanzvariablen oder Standardmethoden benötigen. Die häufigsten sind:
definiert eine Reihe von Schnittstellen, möchte aber nicht jede Implementierungsklasse zwingen, alle Schnittstellen zu implementieren. Sie können abstract.class verwenden, um eine Reihe von Methodenkörpern oder sogar leere Methodenkörper zu definieren, und dann kann die Unterklasse die Methoden auswählen, die sie abdecken möchte.
In einigen Fällen können reine Schnittstellen allein die Koordination zwischen Klassen nicht erfüllen. Zur Unterscheidung verschiedener Beziehungen werden auch Variablen benötigt, die Zustände in der Klasse darstellen. Die Vermittlerrolle des Abstrakten kann dies sehr gut erfüllen.
Standardisiert eine Reihe gegenseitig koordinierter Methoden, von denen einige gemeinsam und zustandsunabhängig sind und gemeinsam genutzt werden können, ohne dass Unterklassen sie separat implementieren müssen, während andere Methoden erfordern, dass jede Unterklasse spezifische Methoden basierend auf ihren eigenen spezifischen Zuständen implementiert . Funktion
10. Kann eine abstrakte Klasse keine Methoden und Attribute haben?
Die Antwort lautet: Ja
Abstrakte Klassen benötigen keine abstrakten Methoden, aber diejenigen mit abstrakten Methoden müssen abstrakte Klassen sein. Daher kann es in Java keine abstrakten Methoden in abstrakten Klassen geben. Beachten Sie, dass selbst abstrakte Klassen ohne abstrakte Methoden und Eigenschaften nicht instanziiert werden können.
11. 接口的意义
定义接口的重要性：在Java编程，abstract class 和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在，才使得Java成为面向对象的编程语言。
public class Food {}
public class Fruit extends Food {}
public class Apple extends Fruit {}
public class Banana extends Fruit{}
public class GenericTest {
public void testExtends(List extends Fruit> list){
//报错,extends为上界通配符,只能取值,不能放.
//因为Fruit的子类不只有Apple还有Banana,这里不能确定具体的泛型到底是Apple还是Banana，所以放入任何一种类型都会报错
//list.add(new Apple());
//可以正常获取
Fruit fruit = list.get(1);
}
public void testSuper(List super Fruit> list){
//super为下界通配符，可以存放元素，但是也只能存放当前类或者子类的实例，以当前的例子来讲，
//无法确定Fruit的父类是否只有Food一个(Object是超级父类)
//因此放入Food的实例编译不通过
list.add(new Apple());
// list.add(new Food());
Object object = list.get(1);
}
}
class Fruit{
static String color = "五颜六色";
static public void call() {
System.out.println("这是一个水果");
}
}
public class Banana extends Fruit{
static String color = "黄色";
static public void call() {
System.out.println("这是一个香蕉");
}
public static void main(String[] args) {
Fruit fruit = new Banana();
System.out.println(fruit.color); //五颜六色
fruit.call(); //这是一个水果
}
}
14. Der Unterschied zwischen Threads und Prozessen
Definition: Ein Prozess ist eine laufende Aktivität eines Programms für eine bestimmte Datensammlung; ein Thread ist ein Ausführungspfad in einem Prozess. (Ein Prozess kann mehrere Threads erstellen)
Rollenaspekt: In einem System, das den Thread-Mechanismus unterstützt, ist der Prozess die Einheit der Systemressourcenzuweisung und der Thread die Einheit der CPU-Planung.
Ressourcenfreigabe: Ressourcen können nicht zwischen Prozessen gemeinsam genutzt werden, aber Threads teilen sich den Adressraum und andere Ressourcen des Prozesses, in dem sie sich befinden. Gleichzeitig verfügt der Thread auch über einen eigenen Stapel, Stapelzeiger, Programmzähler und andere Register.
In Bezug auf die Unabhängigkeit: Der Prozess verfügt über einen eigenen unabhängigen Adressraum, der Thread jedoch nicht. Der Thread muss vom Prozess abhängig sein, um zu existieren.
In Bezug auf die Ausgaben. Prozesswechsel sind teuer. Die Fäden sind relativ klein. (Wie bereits erwähnt, ist die Einführung von Threads auch auf Kostenüberlegungen zurückzuführen.)
Sie können diesen Artikel lesen: juejin.im/post/684490…
15. Der Unterschied zwischen final, final und finalize
final wird zum Deklarieren von Eigenschaften, Methoden und Klassen verwendet, was bedeutet, dass Eigenschaften unveränderlich sind, Methoden nicht überschrieben werden können und Klassen nicht vererbt werden können.
finally ist Teil der Anweisungsstruktur zur Ausnahmebehandlung und gibt an, dass sie immer ausgeführt wird.
finalize ist eine Methode der Object-Klasse. Diese Methode des recycelten Objekts wird aufgerufen, wenn der Garbage Collector ausgeführt wird. Diese Methode kann überschrieben werden, um während der Garbage Collection andere Ressourcen wie das Schließen von Dateien usw. bereitzustellen
16. Der Unterschied zwischen Serializable und Parcelable
in Android Wenn Intent ein Klassenobjekt übergeben möchte, kann dies auf zwei Arten erreicht werden.
Methode 1: Serialisierbar, die zu übergebende Klasse implementiert die Serializable-Schnittstelle, um das Objekt zu übergeben.
Methode 2: Parcelable, die zu übertragende Klasse implementiert die Parcelable-Schnittstelle, um das Objekt zu übertragen.
Serialisierbar (wird mit Java geliefert):
Serialisierbar bedeutet Serialisierung, was bedeutet, dass ein Objekt in einen speicherbaren oder übertragbaren Zustand umgewandelt wird. Serialisierte Objekte können über das Netzwerk übertragen oder lokal gespeichert werden. Serializable ist eine getaggte Schnittstelle, was bedeutet, dass Java dieses Objekt effizient serialisieren kann, ohne Methoden zu implementieren.
Parcelable (nur Android):
Parcelable von Android wurde ursprünglich entwickelt, weil Serializable zu langsam ist (unter Verwendung von Reflektion) und darauf ausgelegt ist, Daten effizient zwischen verschiedenen Komponenten innerhalb des Programms und zwischen verschiedenen Android-Programmen zu übertragen (AIDL). in Erinnerung. Das Implementierungsprinzip der Parcelable-Methode besteht darin, ein vollständiges Objekt zu zerlegen. Jeder Teil nach der Zerlegung ist ein von Intent unterstützter Datentyp, wodurch die Funktion der Übergabe des Objekts realisiert wird. Effizienz und Auswahl:
Parcelable hat eine bessere Leistung als Serializable, da letzteres während des Reflexionsprozesses häufig GCs durchführt. Daher wird empfohlen, Parcelable beim Übertragen von Daten zwischen Speichern, z. B. beim Übertragen von Daten zwischen Aktivitäten, zu verwenden. Serialisierbar kann Daten zur einfachen Speicherung beibehalten. Wählen Sie daher Serialisierbar, wenn Sie Daten über das Netzwerk speichern oder übertragen müssen. Da Parcelable in verschiedenen Android-Versionen unterschiedlich sein kann, wird die Verwendung von Parcelable für die Datenpersistenz nicht empfohlen. Parcelable kann nicht verwendet werden, wenn Daten auf der Festplatte gespeichert werden sollen, da Parcelable die Persistenz von Daten bei Änderungen in der Außenwelt nicht garantieren kann. Obwohl Serializable weniger effizient ist, wird dennoch empfohlen, zu diesem Zeitpunkt Serializable zu verwenden.
Bei der absichtlichen Übergabe komplexer Datentypen müssen Sie zunächst eine der beiden Schnittstellen implementieren. Die entsprechenden Methoden sind getSerializableExtra() und getParcelableExtra().
17. Können statische Eigenschaften und statische Methoden vererbt werden? Kann es umgeschrieben werden? Und warum?
Statische Eigenschaften und Methoden der übergeordneten Klasse können von Unterklassen geerbt werden
können nicht von Unterklassen überschrieben werden
: Wenn der Verweis der übergeordneten Klasse auf die Unterklasse zeigt, wird das Objekt zum Aufrufen statischer Methoden oder statischer Variablen verwendet die aufrufenden Methoden oder Variablen der übergeordneten Klasse in . Es wird nicht von Unterklassen überschrieben.
Grund:
Weil die statische Methode seit dem Start des Programms Speicher zugewiesen hat, was bedeutet, dass sie fest codiert wurde. Alle Objekte, die auf diese Methode verweisen (entweder Objekte der übergeordneten Klasse oder Objekte der Unterklasse), verweisen auf dasselbe Datenelement im Speicher, nämlich die statische Methode.
Wenn eine statische Methode mit demselben Namen in einer Unterklasse definiert ist, wird sie nicht überschrieben. Stattdessen sollte eine andere statische Methode in der Unterklasse im Speicher zugewiesen werden, und es gibt kein Überschreiben.
18. Die Designabsicht statischer innerer Klassen in Java
Innere Klassen
Innere Klassen sind innerhalb einer Klasse definierte Klassen. Warum gibt es innere Klassen?
Wir wissen, dass es sich bei Klassen in Java um Einzelvererbungen handelt und eine Klasse nur eine andere konkrete Klasse oder abstrakte Klasse erben kann (die mehrere Schnittstellen implementieren kann). Der Zweck dieses Entwurfs besteht darin, dass bei der Mehrfachvererbung, wenn in mehreren übergeordneten Klassen doppelte Attribute oder Methoden vorhanden sind, das Aufrufergebnis der Unterklasse mehrdeutig ist, sodass eine Einzelvererbung verwendet wird.
Der Grund für die Verwendung innerer Klassen besteht darin, dass jede innere Klasse unabhängig eine Implementierung (der Schnittstelle) erben kann. Unabhängig davon, ob die äußere Klasse eine Implementierung (der Schnittstelle) geerbt hat, hat dies keine Auswirkungen auf die innere Klasse.
In unserer Programmierung gibt es manchmal einige Probleme, die mithilfe von Schnittstellen schwer zu lösen sind. Zu diesem Zeitpunkt können wir die von internen Klassen bereitgestellte Fähigkeit nutzen, mehrere konkrete oder abstrakte Klassen zu erben, um diese Programmierprobleme zu lösen. Man kann sagen, dass Schnittstellen nur einen Teil des Problems lösen und innere Klassen die Lösung der Mehrfachvererbung vollständiger machen.
Statische innere Klassen
Bevor wir über statische innere Klassen sprechen, wollen wir zunächst die inneren Klassen der Mitglieder (nicht statische innere Klassen) verstehen.
Innere Klasse des Mitglieds
Die innere Klasse des Mitglieds ist auch die häufigste innere Klasse, sodass sie uneingeschränkten Zugriff auf alle Mitgliedseigenschaften und -methoden der äußeren Klasse hat , die äußere Klasse Wenn eine Klasse auf die Mitgliedseigenschaften und -methoden einer inneren Klasse zugreifen möchte, muss sie über eine Instanz der inneren Klasse darauf zugreifen.
Zwei Punkte, die Sie bei inneren Mitgliedsklassen beachten sollten:
In inneren Mitgliedsklassen können keine statischen Variablen und Methoden vorhanden sein.
Innere Mitgliedsklassen sind an die äußere Klasse angehängt, sodass Sie zuerst nur die äußere Klasse erstellen können Nur dann können innere Klassen erstellt werden.
Statische innere Klassen
Es gibt einen größten Unterschied zwischen statischen inneren Klassen und nicht statischen inneren Klassen: Nicht statische innere Klassen speichern nach der Kompilierung implizit eine Referenz, die auf den Punkt verweist, an dem sie erstellt wurde. s äußere Klasse, die statische innere Klasse jedoch nicht.
Das Fehlen dieser Referenz bedeutet:
Seine Erstellung muss nicht von der Peripherieklasse abhängen.
Es können keine nicht statischen Mitgliedsvariablen und Methoden einer äußeren Klasse verwendet werden.
Die anderen beiden internen Klassen: lokale interne Klassen und anonyme interne Klassen
Lokale interne Klassen
Lokale interne Klassen sind in Methoden und Bereichen verschachtelt. Die Verwendung dieser Klasse dient hauptsächlich dem Anwendungs- und Lösungsvergleich für komplexe Probleme Wir möchten eine Klasse erstellen, um unsere Lösung zu unterstützen. Zu diesem Zeitpunkt möchten wir jedoch nicht, dass diese Klasse öffentlich verfügbar ist. Daher wird eine lokale innere Klasse generiert. Die lokale innere Klasse wird wie die innere Mitgliedsklasse kompiliert, ist jedoch die Wenn sich der Gültigkeitsbereich geändert hat, kann er nur innerhalb der Methode und des Attributs verwendet werden und wird außerhalb der Methode und des Attributs ungültig.
Anonyme innere Klassen
Anonyme innere Klassen haben keine Zugriffsmodifikatoren.
Neue anonyme innere Klasse, diese Klasse muss zuerst existieren.
Wenn der formale Parameter der Methode von der anonymen inneren Klasse verwendet werden muss, muss der formale Parameter endgültig sein.
Anonyme innere Klassen haben keinen expliziten Konstruktor und der Compiler generiert automatisch einen Konstruktor, der auf die äußere Klasse verweist.
Das obige ist der detaillierte Inhalt vonZusammenfassung der neuen Java-Grundlageninterviewfragen für 2020. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
