Diese Seite befasst sich hauptsächlich mit der Java / Swift-Notation "Klassenimplementierung", "Klassenvererbung" und "Klassendesign". Dieser Artikel basiert auf 1.7 für Java und Swift3 für Swift, wir entschuldigen uns jedoch für etwaige Notationsfehler.
Die folgende Klassennotation wird beschrieben.
** Klassendesign **
Java
python
/**
*Mitarbeiterklasse
*/
public class Employee {
/**
*Name
*/
protected String name;
/**
*Sex
*/
protected Sex sex;
/**
*Alter
*/
protected int age;
/**
*Konstrukteur
*
* @Param Name Name
* @param Geschlecht Geschlecht
* @param Alter Alter
*/
public Employee(String name, Sex sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
/**
*Konstrukteur
*/
public Employee() {
this.name = "";
this.sex = Sex.Unknown;
this.age = 0;
}
/**
*Vorstellen
*
* @Selbsteinführungstext zurückgeben
*/
public String selfIntroduction() {
String value = "";
value += "name:=" + this.name + ", ";
value += "age:=" + this.age + ", ";
value += "sex:=" + this.sex + ", ";
return value;
}
/**
*Geschlechtsaufzählung
*/
public enum Sex {
Man("Mann"),
Woman("Frau"),
Unknown("Unbekannt");
private String value;
Sex(String value) {
this.value = value;
}
}
}
python
Employee employee = new Employee(); //Instanzgenerierung
String value = employee.selfIntroduction(); //Aufruf der Instanzmethode
System.out.print(value);
Swift
python
class Employee {
///Geschlechtsaufzählung
enum Sex:String {
case Man = "Mann"
case Woman = "Frau"
case Unknown = "Unbekannt"
}
///Name
var name:String
///Sex
var sex:Sex
//Alter
var age:Int
///Initialisierer
init(name:String = "", age:Int = 0, sex:Sex = Sex.Unknown) {
self.name = name
self.sex = sex
self.age = age
}
//Vorstellen
func selfIntroduction() -> String {
var value:String = ""
value += "name:=" + self.name + ", "
value += "age:=" + self.age.description + ", "
value += "sex:=" + self.sex.rawValue + ", "
return value
}
}
python
let employee = Employee() //Instanzgenerierung
let value = employee.selfIntroduction() //Aufruf der Instanzmethode
print(value)
Die folgende Klassennotation wird beschrieben.
** Klassendesign **
--Programmer-Klasse, die die Employee-Klasse erbt
Java
/**
*Programmiererklasse
*/
public class Programmer extends Employee {
/**
*Position
*/
private JobTitle jobTitle;
/**
*Konstrukteur
*
* @param jobTitle Position
* @Param Name Name
* @param Geschlecht Geschlecht
* @param Alter Alter
*/
public Programmer(JobTitle jobTitle, String name, Sex sex, int age) {
super(name, sex, age);
this.jobTitle = jobTitle;
}
/**
*Vorstellen
*
* @Selbsteinführungstext zurückgeben
*/
@Override
public String selfIntroduction() {
String value = super.selfIntroduction();
value += "jobTitle:=" + this.jobTitle + ", ";
return value;
}
/**
*Lohn-und Gehaltsabrechnung
* @Gehalt zurückgeben
*/
public int salary() {
int jobSalary;
switch (this.jobTitle) {
case A1:
jobSalary = 340000;
break;
case A2:
jobSalary = 300000;
break;
case B1:
case B2:
jobSalary = 260000;
break;
case C1:
case C2:
jobSalary = 220000;
break;
case D1:
case D2:
jobSalary = 180000;
break;
default:
jobSalary = 0;
}
int ageSalary;
//Da es nicht möglich ist, einen Ausdruck im Bewertungsergebnis von switch in Java zu beschreiben, wird er durch die if-Anweisung berechnet.
if (super.age >= 0 && super.age < 22) {
ageSalary = 0;
} else if (super.age >= 22 && super.age < 28) {
ageSalary = 20000;
} else if (super.age >= 28 && super.age < 34) {
ageSalary = 40000;
} else if (super.age >= 34 && super.age < 40) {
ageSalary = 40000;
} else if (super.age >= 40 && super.age < 100) {
ageSalary = 20000;
} else {
ageSalary = 0;
}
return jobSalary + ageSalary;
}
/**
*Position enum
*/
public enum JobTitle {
A1,
A2,
B1,
B2,
C1,
C2,
D1,
D2;
}
}
python
Programmer programmer = new Programmer(Programmer.JobTitle.A1, "Marie", Employee.Sex.Woman, 30); //Instanzgenerierung
String value = programmer.selfIntroduction(); //Aufruf der Instanzmethode
int salary = programmer.salary(); //Rufen Sie die Abrechnungsmethode auf
System.out.print(value);
Swift
--Swift erlaubt wie Java keine Mehrfachvererbung und hat nur eine Basisklasse.
python
///Programmierer
class Programmer:Employee {
///Position enum
enum JobTitle:Int {
case A1 = 1
case A2 = 2
case B1 = 3
case B2 = 4
case C1 = 5
case C2 = 6
case D1 = 7
case D2 = 8
case Unknown = 0
}
///Position
var jobTitle:JobTitle;
///Name
var salary:Int {
get {
var jobSalary = 0
switch self.jobTitle {
case JobTitle.A1:
jobSalary = 34-0000
case JobTitle.A2:
jobSalary = 30-0000
case JobTitle.B1, JobTitle.B2:
jobSalary = 26-0000
case JobTitle.C1, JobTitle.C2:
jobSalary = 22-0000
case JobTitle.D1, JobTitle.D2:
jobSalary = 18-0000
default:
jobSalary = 0
}
var ageSalary = 0
switch self.age {
case 0...22:
ageSalary = 0-0000
case 22...28:
ageSalary = 2-0000
case 28...34:
ageSalary = 4-0000
case 34...40:
ageSalary = 4-0000
case 40...100:
ageSalary = 2-0000
default:
ageSalary = 0
}
return jobSalary + ageSalary
}
}
///Initialisierer
init(jobTitle:JobTitle = JobTitle.Unknown) {
self.jobTitle = jobTitle
super.init()
}
//Vorstellen
override func selfIntroduction() -> String {
var value = super.selfIntroduction()
value += "jobTitle:=" + self.jobTitle.rawValue.description + ", "
return value
}
}
let programmer = Programmer(jobTitle: Programmer.JobTitle.Unknown) //Instanzgenerierung
let value = programmer.selfIntroduction() //Aufruf der Instanzmethode
let salary = programmer.salary //Aufruf der Computed-Eigenschaft
print(value)
print(salary)
Im Folgenden werden die einzigartigen Spezifikationen von Java und Swift sowie deren Verwendung beim Entwerfen von Klassen kurz erläutert.
Java
Java hat die Idee, die drei wichtigsten objektorientierten Elemente (Kapselung, Vererbung und Polymorphismus), die als abstrakte Klassen bezeichnet werden, effektiv zu definieren. Im Gegensatz zu sogenannten gewöhnlichen Klassen sind abstrakte Klassen, wie der Name schon sagt, abstrakt und können nicht instanziiert werden. Superhelden sind real, aber Klassen, die genauso abstrakt sind wie die Unfähigkeit der Gerechtigkeit.
Um eine abstrakte Klasse zu deklarieren, stellen Sie dem Klassennamen den Modifikator "abstract" voran, z. B. "abstrakter Klassenname der abstrakten Klasse {...}". Der Umriss des Prozesses und die allgemeinen Eigenschaften werden in der abstrakten Klasse definiert, und der spezifische Prozess wird in der Unterklasse beschrieben, die die abstrakte Klasse erbt.
/**
*Abstrakte Klasse der Gerechtigkeit
*/
public abstract class AbstractJustice {
/**
*Grundlegende Fähigkeit
*/
protected int mBasicAbility;
/**
*Potenzial
*/
protected int mPotentialCapacity;
/**
*Verarbeitung zum Speichern
*/
public abstract void save();
/**
*Grundlegende Fähigkeitserwerb
*
* @Grundfähigkeit zurückgeben
*/
public int getBasicAbility() {
return mBasicAbility;
}
/**
*Mögliche Akquisition
*
* @Rückgabepotential
*/
public int getPotentialCapacity() {
return mPotentialCapacity;
}
/**
*Kampf
*
* @param feindAbility Feindliche Fähigkeit
* @return Combat result true...Sieg, falsch...Niederlage
*/
public boolean fight(int enemyAbility) {
int basicAbility = getBasicAbility();
if (basicAbility > enemyAbility) {
//Gewinnen Sie, wenn Ihre Grundfähigkeit überschritten wird
return true;
}
//Grundlegende Fähigkeit+Potenzial*Gewinnen Sie, wenn der Zufallskoeffizient oben liegt, und besiegen Sie, wenn er unten liegt
int potentialCapacity = getPotentialCapacity();
float coefficient = new java.util.Random().nextFloat();
return basicAbility + potentialCapacity * coefficient > enemyAbility;
}
}
/**
*Anpanman Klasse
*/
public class Anpanman extends AbstractJustice {
/**
*Anfängliche Grundfähigkeit
*/
private int INIT_BASIC_ABILITY = 10;
/**
*Anfangspotential
*/
private int INIT_POTENTIAL_CAPACITY = 3;
/**
*Konstrukteur
*/
public Anpanman() {
mBasicAbility = INIT_BASIC_ABILITY;
mBasicAbility = INIT_POTENTIAL_CAPACITY;
}
@Override
public void save() {
System.out.println("Iss Gesicht");
//Das Füttern des Gesichts senkt die Grundfähigkeiten, erhöht aber das Potenzial
mBasicAbility--;
mPotentialCapacity++;
//Wenn die Grundfähigkeit 3 oder weniger wird, ändert Batako ihr Gesicht, sodass es zum Original zurückkehrt
if (mBasicAbility <= 3) {
//\ Anpanman! Neues Gesicht! !! /.
mBasicAbility = INIT_BASIC_ABILITY; //<100 mal energischer Anpanman! !!
}
}
@Override
public boolean fight(int enemyAbility) {
//Anpanman hat eine Siegeskorrektur, so dass es zu einer feindlichen Fähigkeit wird-10
enemyAbility -= 10;
return super.fight(enemyAbility);
}
}
Vor Java 8 konnten Methoden nur als Instanzmethoden in einer Schnittstelle definiert werden. Seit Java 8 ist es nun möglich, statische Methoden auch in einer Schnittstelle zu implementieren. Darüber hinaus wurde die Idee einer Standardmethode hinzugefügt, und der Verarbeitungskörper der Methode kann in der Schnittstelle implementiert werden.
Die Schnittstelle in Java beschreibt den Umriss des Prozesses, und Sie können sich das als eine Funktion vorstellen, in der nur die abstrakten Methoden der abstrakten Klasse aggregiert werden. Obwohl es aufgrund von Unterschieden in den Protokoll- und Sprachspezifikationen in Swift Unterschiede gibt, kann davon ausgegangen werden, dass sie ähnlich sind. Wie der Name der Schnittstelle als Funktion angibt, handelt es sich jedoch um eine Zusammenfassung der Verarbeitung und Konventionen, sodass sie nicht instanziiert werden kann und keine Mitgliedsvariablen als Eigenschaften haben kann. "Gundam-Betrieb" selbst hat keine Farbe oder Form und hat dieselbe Bedeutung wie der Gundam selbst Farbe oder Form. (Es tut mir leid, wenn jemand Gundam mag ...)
Im Gegensatz zur Klassenvererbung kann eine Klasse auch mehrere Schnittstellen implementieren. Um eine Schnittstelle zu deklarieren, schreiben Sie "Schnittstellenschnittstellenname {...}". In der Schnittstelle können Sie Methoden schreiben, die keine Verarbeitungsblöcke beschreiben, die nur die Verarbeitung umreißen, und nur statische Konstanten.
Die Gliederung des Prozesses und das erwartete Ergebnis werden definiert, aber der Prozessinhalt wird von der Klasse verarbeitet, die die Schnittstelle implementiert, und bei der Implementierung der angegebenen Schnittstelle müssen alle Funktionen dieser Schnittstelle implementiert werden.
python
/**
*Gundam-Betrieb
*/
public interface GundamOperation {
/**
*Beschleunigen Sie
*/
void speedUp();
/**
*Beschleunigen Sie
*/
void speedDown();
/**
*Strahlsparausrüstung
*/
void equipmentSaber();
/**
*Beam Saver Release
*/
void removeSaber();
/**
*Schießen
*/
void shooting();
}
/**
*∀ Gundam-Klasse
*/
public class GundamTurnA implements GundamOperation {
@Override
public void speedUp() {
System.out.println("Beschleunigen Sie");
}
@Override
public void speedDown() {
System.out.println("Beschleunigen Sie");
}
@Override
public void equipmentSaber() {
System.out.println("Strahlsparausrüstung");
}
@Override
public void removeSaber() {
System.out.println("Beam Saver Release");
}
@Override
public void shooting() {
System.out.print("Schießen");
}
}
/**
*Zaku Klasse
*/
public class Zaku implements GundamOperation {
@Override
public void speedUp() {
System.out.println("Beschleunigen Sie");
}
@Override
public void speedDown() {
System.out.println("Beschleunigen Sie");
}
@Override
public void equipmentSaber() {
System.out.println("Strahlsparausrüstung");
}
@Override
public void removeSaber() {
System.out.println("Beam Saver Release");
}
@Override
public void shooting() {
System.out.print("Schießen");
}
}
Zu diesem Zeitpunkt besteht der Vorteil der Verwendung der Schnittstelle darin, dass die Zielschnittstelle implementiert ist = die als Schnittstelle bereitgestellte Operation ist garantiert. Unabhängig von der Klasse ermöglicht die Bereitstellung einer Schnittstelle eine flexible Implementierung.
GundamTurnA gundamTurnA = new GundamTurnA();
Zaku zaku = new Zaku();
shooting(gundamTurnA);
shooting(zaku);
private void shooting(GundamOperation gundamOperation) {
gundamOperation.shooting(); //Kann als Schnittstelle betrieben werden
}
Swift
Erweiterungen können verwendet werden, um vorhandene Klassen zu erweitern, die Swift in Java nicht hat. Die von der Bibliothek bereitgestellte Klasse ist ebenfalls möglich (!)
print(10.hex)
extension Int {
///Hexadezimal
var hex: String {
return String(self, radix: 16)
}
///8 Basis
var oct: String {
return String(self, radix: 8)
}
///Binärzahl
var bin: String {
return String(self, radix: 2)
}
///JP Steuersatz
static func jpTaxRate() -> Double {
return 0.8
}
///JP Steuerbetrag enthalten
func amount() -> Double {
return Int.jpTaxRate() * Double(self)
}
}
Sie können jedoch Folgendes nicht tun.
Das Protokoll in Swift beschreibt den Umriss des Prozesses, und es kann davon ausgegangen werden, dass sie ähnlich sind, obwohl es Unterschiede aufgrund der unterschiedlichen Schnittstellen- und Sprachspezifikationen in Java gibt. Wie der Name des Protokolls als Funktion angibt, handelt es sich jedoch um eine Zusammenfassung der Verarbeitung und Konventionen, sodass es nicht instanziiert werden kann und keine Mitgliedsvariablen als Eigenschaften haben kann.
Die Java-Schnittstelle kann auch statische Konstanten haben (z. B. "static final String HOGE =" hoge ""), das Protokoll unterstützt dies jedoch nicht und kann nur Funktionen und berechnete Eigenschaften bereitstellen. Um ein Protokoll zu deklarieren, schreiben Sie "Protokollprotokollname {...}". Im Protokoll kann nur die Computed-Eigenschaft der Getter-Methode / Setter-Methode beschrieben werden, die den Verarbeitungsblock nicht beschreibt, und die Methode, die den Verarbeitungsblock nicht beschreibt. Die Gliederung des Prozesses und das erwartete Ergebnis sind definiert, aber die Klasse, die das Protokoll implementiert, ist für den Prozess verantwortlich.
///Delegatenprotokoll lesen
protocol ReadDelegate {
///Lesevorgang
func read() -> Int
}
///Fortschrittsprotokoll
protocol Progressing {
///Gesamtsumme
var total: Int { get }
///Abschlussbetrag
var completed: Int { get set }
func read()
}
///String-Konvertierungsprotokoll
protocol StringTranslatable {
///String-Konvertierung
var asString: String{ get }
}
class Comic : StringTranslatable, Progressing {
var author:String = ""
var title:String = ""
var text:String = ""
var readDelegate:ReadDelegate?
let rawTotal:Int = 300
var rawCompleted:Int = 0
var asString: String {
get {
return "author:=" + author + "\n"
+ "title:=" + title + "\n"
+ "text:=" + text + "\n"
}
}
var total: Int {
get {
return rawTotal
}
}
var completed: Int {
get {
return rawCompleted
}
set {
rawCompleted = newValue
}
}
func read() {
if (readDelegate != nil) {
let readPage = readDelegate?.read()
completed += readPage!
}
}
}
///Diese Implementierungsklasse für das Lesen des Delegatenprotokolls
class BookReadDelegate:ReadDelegate {
func read() -> Int {
return 5
}
}
Zu diesem Zeitpunkt besteht der Vorteil der Verwendung des Protokolls darin, dass das Zielprotokoll implementiert ist = die Operation, die bereitgestellt wird, da das Protokoll garantiert ist.
Wie bereits oben in der Klasse "Book" beschrieben, wird die Verarbeitung der Funktion "read ()" an "BookReadDelegate" delegiert, und unabhängig von der Klasse wird das Protokoll bereitgestellt. Eine flexible Implementierung ist möglich.
Geben Sie im Argument einer Funktion usw. "Variablenname: Protokoll
let comic = Comic()
comic.title = "El extranjero"
comic.author = "Albert Camus"
comic.text = "L'Etranger has the force and fascination of myth......"
comic.readDelegate = BookReadDelegate() //Legen Sie eine Klasse fest, die ReadDelegate implementiert, um die Verarbeitung zu delegieren
readBook(comic)
func readBook(target:protocol<Progressing, StringTranslatable>) { //Implementiert von Progressing, StringTranslatable
print(target.asString)
target.read()
print(target.completed)
}
Unter den Funktionen, die Swift in Java nicht bietet, können vorhandene Klassen erweitert werden, um dem Protokoll zu entsprechen. Um eine vorhandene Klasse um ein Protokoll zu erweitern, schreiben Sie "Name der erweiterten vorhandenen Klasse: Name des Erweiterungszielprotokolls {...}". Im folgenden Beispiel wird die Klasse "Int" um die oben erstellte Klasse "StringTranslatable" erweitert, und die Verarbeitungsdetails der berechneten Eigenschaft "asString", die die Implementierungsanforderung der "StringTranslatable" darstellt, werden implementiert.
///Erweitern Sie Int mit StringTranslatable
extension Int: StringTranslatable {
var asString: String {
get {
return "Diese Nummer ist[" + description + "]ist."
}
}
}
Ein Index ist ein Indexausdruck, der beim Zugriff auf Elemente eines Arrays oder Wörterbuchs verwendet wird. Mit Swift können Sie Indizes in Strukturen, Aufzählungen und Klassen implementieren.
var test = Test()
print(test["A"]) // "1"Und Ausgabe
class Test {
let values = ["A":"1", "B":"2", "C":"3", "D":"4"]
subscript(param:String) -> String {
get {
return self.values[param]!
}
}
}
Mit Swift können Sie vorhandene Operatoren überlasten. Operatorüberladungen können als globale Funktionen definiert werden, um ihnen ein eindeutiges Verhalten zu verleihen.
struct Test {
var count:Int = 0
}
struct SumTest {
var count:Int = 0
}
func + (left: Test, right: Test) -> SumTest {
let sum = left.count + right.count
return SumTest(count: sum)
}
let hoge1 = Test(count: 1)
let hoge2 = Test(count: 1)
let add = hoge1 + hoge2
print(add) // SumTest(count: 2)