Java Language
C ++ - Vergleich
Suche…
Einführung
Java und C ++ sind ähnliche Sprachen. Dieses Thema dient als Kurzanleitung für Java- und C ++ - Engineer.
Bemerkungen
In anderen Konstrukten definierte Klassen #
Innerhalb einer anderen Klasse definiert
C ++
Geschachtelte Klasse [ref] (benötigt eine Referenz zum Einschließen der Klasse)
class Outer {
class Inner {
public:
Inner(Outer* o) :outer(o) {}
private:
Outer* outer;
};
};
Java
[nicht statisch] Geschachtelte Klasse (auch bekannt als Inner Class oder Member Class)
class OuterClass {
...
class InnerClass {
...
}
}
Statisch innerhalb einer anderen Klasse definiert
C ++
Statische verschachtelte Klasse
class Outer {
class Inner {
...
};
};
Java
Statische verschachtelte Klasse (auch bekannt als statische Member-Klasse) [ref]
class OuterClass {
...
static class StaticNestedClass {
...
}
}
Innerhalb einer Methode definiert
(zB Eventhandling)
C ++
Lokale Klasse [ref]
void fun() {
class Test {
/* members of Test class */
};
}
Siehe auch Lambda-Ausdrücke
Java
Lokale Klasse [ref]
class Test {
void f() {
new Thread(new Runnable() {
public void run() {
doSomethingBackgroundish();
}
}).start();
}
}
Überschreiben vs Überladen
Die folgenden Overriding- und Overloading-Punkte gelten sowohl für C ++ als auch für Java:
- Eine überschriebene Methode hat denselben Namen und dieselben Argumente wie ihre Basismethode.
- Eine überladene Methode hat denselben Namen, jedoch unterschiedliche Argumente und ist nicht auf die Vererbung angewiesen.
- Zwei Methoden mit demselben Namen und Argumenten, aber unterschiedlichen Rückgabetypen sind ungültig. Siehe verwandte Stackoverflow-Fragen zum Thema "Überladen mit anderem Rückgabetyp in Java" - Frage 1 ; Frage 2
Polymorphismus
Polymorphismus ist die Fähigkeit von Objekten verschiedener Klassen, die durch Vererbung miteinander in Beziehung stehen, auf denselben Methodenaufruf unterschiedlich zu reagieren. Hier ist ein Beispiel:
- Basisklasse Form mit Fläche als abstrakte Methode
- Zwei abgeleitete Klassen, Square und Circle, implementieren Flächenmethoden
- Formbezugspunkte auf Quadrat und Fläche werden aufgerufen
In C ++ wird Polymorphismus durch virtuelle Methoden aktiviert. In Java sind die Methoden standardmäßig virtuell.
Reihenfolge der Konstruktion / Zerstörung
Objektbereinigung
In C ++ empfiehlt es sich, einen Destruktor als virtuell zu deklarieren, um sicherzustellen, dass der Destruktor der Unterklasse aufgerufen wird, wenn der Basisklassenzeiger gelöscht wird.
In Java ist eine Finalize-Methode ein Destruktor in C ++. Finalizer sind jedoch unvorhersehbar (sie sind auf GC angewiesen). Bewährte Methode: Verwenden Sie eine "close" -Methode, um explizit zu bereinigen.
protected void close() {
try {
// do subclass cleanup
}
finally {
isClosed = true;
super.close();
}
}
protected void finalize() {
try {
if(!isClosed) close();
}
finally {
super.finalize();
}
}
Abstrakte Methoden und Klassen
Konzept | C ++ | Java |
---|---|---|
Abstrakte Methode ohne Implementierung deklariert | reine virtuelle Methode virtual void eat(void) = 0; | abstrakte Methode abstract void draw(); |
Abstrakte Klasse kann nicht instanziiert werden | kann nicht instanziiert werden; hat mindestens 1 reine virtuelle Methode class AB {public: virtual void f() = 0;}; | kann nicht instanziiert werden; kann nicht abstrakte Methoden haben abstract class GraphicObject {} |
Schnittstelle keine Instanzfelder | Kein "interface" - Schlüsselwort, kann jedoch eine Java-Schnittstelle mit Einrichtungen einer abstrakten Klasse nachahmen | sehr ähnlich der abstrakten Klasse, aber 1) unterstützt Mehrfachvererbung; 2) keine Instanzfelder interface TestInterface {} |
Eingabehilfen-Modifikatoren
Modifikator | C ++ | Java |
---|---|---|
Öffentlich - für alle zugänglich | keine besonderen Hinweise | keine besonderen Hinweise |
Geschützt - durch Unterklassen zugänglich | auch für Freunde zugänglich | auch innerhalb desselben Pakets zugänglich |
Privat - für Mitglieder zugänglich | auch für Freunde zugänglich | keine besonderen Hinweise |
Standard | Klassenstandard ist privat; struct default ist public | zugänglich für alle Klassen innerhalb desselben Pakets |
andere | Freund - eine Möglichkeit, privaten und geschützten Mitgliedern Zugriff ohne Erbschaft zu gewähren (siehe unten) |
C ++ Freund Beispiel
class Node {
private:
int key; Node *next;
// LinkedList::search() can access "key" & "next"
friend int LinkedList::search();
};
Das gefürchtete Diamantproblem
Das Raute-Problem ist eine Mehrdeutigkeit, die entsteht, wenn zwei Klassen B und C von A erben und Klasse D sowohl von B als auch C erbt. Wenn es eine Methode in A gibt, die B und C überschrieben haben, überschreibt D sie nicht Welche Version der Methode erbt D: die von B oder die von C? (aus Wikipedia )
Während C ++ für Diamantenprobleme immer anfällig war, war Java bis Java 8 anfällig. Ursprünglich unterstützte Java keine Mehrfachvererbung, aber mit dem Aufkommen von Standardschnittstellenmethoden können Java-Klassen die "Implementierung" nicht von mehreren Klassen erben .
java.lang.Object-Klasse
In Java erben alle Klassen implizit oder explizit von der Object-Klasse. Jede Java-Referenz kann in den Objekttyp umgewandelt werden.
C ++ hat keine vergleichbare "Object" -Klasse.
Java-Sammlungen und C ++ - Container
Java Collections sind mit C ++ Containern identisch.
Flussdiagramm für Java-Sammlungen
C ++ Container-Flussdiagramm
Integer-Typen
Bits | Mindest | Max | C ++ - Typ (auf LLP64 oder LP64) | Java-Typ |
---|---|---|---|---|
8 | -2 (8-1) = -128 | 2 (8-1) -1 = 127 | verkohlen | Byte |
8 | 0 | 2 (8) -1 = 255 | unsigniertes Zeichen | - |
16 | -2 (16-1) = -32,768 | 2 (16-1) -1 = 32.767 | kurz | kurz |
16 | 0 (\ u0000) | 2 (16) -1 = 65.535 (\ uFFFF) | unsigniert kurz | char (unsigniert) |
32 | -2 (32-1) = -2,147 Milliarden | 2 (32-1) -1 = 2,147 Milliarden | int | int |
32 | 0 | 2 (32) -1 = 4,295 Milliarden | unsigned int | - |
64 | -2 (64-1) | 2 (16-1) -1 | lange* | lang Lang |
64 | 0 | 2 (16) -1 | unsigniert lang unsigniert lange | - |
*
Win64-API ist nur 32 Bit
Statische Klassenmitglieder
Statische Member haben Klassenbereich im Gegensatz zum Objektbereich
C ++ - Beispiel
// define in header
class Singleton {
public:
static Singleton *getInstance();
private:
Singleton() {}
static Singleton *instance;
};
// initialize in .cpp
Singleton* Singleton::instance = 0;
Java- Beispiel
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
In anderen Konstrukten definierte Klassen
Innerhalb einer anderen Klasse definiert
C ++
Geschachtelte Klasse [ref] (benötigt eine Referenz zum Einschließen der Klasse)
class Outer {
class Inner {
public:
Inner(Outer* o) :outer(o) {}
private:
Outer* outer;
};
};
Java
[nicht statisch] Geschachtelte Klasse (auch bekannt als Inner Class oder Member Class)
class OuterClass {
...
class InnerClass {
...
}
}
Statisch innerhalb einer anderen Klasse definiert
C ++
Statische verschachtelte Klasse
class Outer {
class Inner {
...
};
};
Java
Statische verschachtelte Klasse (auch bekannt als statische Member-Klasse) [ref]
class OuterClass {
...
static class StaticNestedClass {
...
}
}
Innerhalb einer Methode definiert
(zB Eventhandling)
C ++
Lokale Klasse [ref]
void fun() {
class Test {
/* members of Test class */
};
}
Java
Lokale Klasse [ref]
class Test {
void f() {
new Thread(new Runnable() {
public void run() {
doSomethingBackgroundish();
}
}).start();
}
}
Pass-by-Value & Pass-by-Referenz
Viele behaupten, dass Java NUR ein Wert für Vorübergehen ist, aber es ist nuancierter als das. Vergleichen Sie die folgenden C ++ - und Java-Beispiele, um die vielen Varianten von Pass-by-Value (aka copy) und Pass-by-Reference (Alias) zu sehen.
C ++ - Beispiel (vollständiger Code)
// passes a COPY of the object
static void passByCopy(PassIt obj) {
obj.i = 22; // only a "local" change
}
// passes a pointer
static void passByPointer(PassIt* ptr) {
ptr->i = 33;
ptr = 0; // better to use nullptr instead if '0'
}
// passes an alias (aka reference)
static void passByAlias(PassIt& ref) {
ref.i = 44;
}
// This is an old-school way of doing it.
// Check out std::swap for the best way to do this
static void swap(PassIt** pptr1, PassIt** pptr2) {
PassIt* tmp = *pptr1;
*pptr1 = *pptr2;
*pptr2 = tmp;
}
Java-Beispiel (vollständiger Code)
// passes a copy of the variable
// NOTE: in java only primitives are pass-by-copy
public static void passByCopy(int copy) {
copy = 33; // only a "local" change
}
// No such thing as pointers in Java
/*
public static void passByPointer(PassIt *ptr) {
ptr->i = 33;
ptr = 0; // better to use nullptr instead if '0'
}
*/
// passes an alias (aka reference)
public static void passByAlias(PassIt ref) {
ref.i = 44;
}
// passes aliases (aka references),
// but need to do "manual", potentially expensive copies
public static void swap(PassIt ref1, PassIt ref2) {
PassIt tmp = new PassIt(ref1);
ref1.copy(ref2);
ref2.copy(tmp);
}
Vererbung vs. Zusammensetzung
C ++ und Java sind beide objektorientierte Sprachen, daher gilt das folgende Diagramm für beide.
Ausgestoßener Downcasting
Vorsicht bei der Verwendung von "Downcasting" - Downcasting führt die Vererbungshierarchie von einer Basisklasse in eine Unterklasse (dh entgegengesetzt zum Polymorphismus). Verwenden Sie im Allgemeinen Polymorphie und Überschreiben anstelle von Instanzierung und Downcasting.
C ++ - Beispiel
// explicit type case required
Child *pChild = (Child *) &parent;
Java-Beispiel
if(mySubClass instanceof SubClass) {
SubClass mySubClass = (SubClass)someBaseClass;
mySubClass.nonInheritedMethod();
}
Abstrakte Methoden und Klassen
Abstrakte Methode
ohne Implementierung deklariert
C ++
reine virtuelle Methode
virtual void eat(void) = 0;
Java
abstrakte Methode
abstract void draw();
Abstrakte Klasse
kann nicht instanziiert werden
C ++
kann nicht instanziiert werden; hat mindestens 1 reine virtuelle Methode
class AB {public: virtual void f() = 0;};
Java
kann nicht instanziiert werden; kann nicht abstrakte Methoden haben
abstract class GraphicObject {}
Schnittstelle
keine Instanzfelder
C ++
nichts vergleichbar mit Java
Java
sehr ähnlich der abstrakten Klasse, aber 1) unterstützt Mehrfachvererbung; 2) keine Instanzfelder
interface TestInterface {}