Cette page traite principalement de la notation Java / Swift de «l'implémentation de classe», «l'héritage de classe» et «conception de classe». Cet article est basé sur 1.7 pour Java et Swift3 pour Swift, mais je suis désolé s'il y a une erreur de notation.
La notation de classe suivante est décrite.
** Conception de classe **
--Classe d'employé --Dispose des propriétés suivantes --Name: type de chaîne de caractères --Gender: constantes énumérées --Age: valeur numérique
Java
python
/**
*Classe d'employé
*/
public class Employee {
/**
*Nom
*/
protected String name;
/**
*sexe
*/
protected Sex sex;
/**
*âge
*/
protected int age;
/**
*constructeur
*
* @nom du paramètre nom
* @param sexe sexe
* @âge param
*/
public Employee(String name, Sex sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
/**
*constructeur
*/
public Employee() {
this.name = "";
this.sex = Sex.Unknown;
this.age = 0;
}
/**
*Auto-introduction
*
* @retour Texte d'auto-introduction
*/
public String selfIntroduction() {
String value = "";
value += "name:=" + this.name + ", ";
value += "age:=" + this.age + ", ";
value += "sex:=" + this.sex + ", ";
return value;
}
/**
*Énumération de genre
*/
public enum Sex {
Man("Homme"),
Woman("femme"),
Unknown("inconnue");
private String value;
Sex(String value) {
this.value = value;
}
}
}
python
Employee employee = new Employee(); //Génération d'instance
String value = employee.selfIntroduction(); //Invocation de la méthode d'instance
System.out.print(value);
Swift
python
class Employee {
///Énumération de genre
enum Sex:String {
case Man = "Homme"
case Woman = "femme"
case Unknown = "inconnue"
}
///Nom
var name:String
///sexe
var sex:Sex
//âge
var age:Int
///Initialiseur
init(name:String = "", age:Int = 0, sex:Sex = Sex.Unknown) {
self.name = name
self.sex = sex
self.age = age
}
//Auto-introduction
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() //Génération d'instance
let value = employee.selfIntroduction() //Invocation de la méthode d'instance
print(value)
La notation de classe suivante est décrite.
** Conception de classe **
Java
/**
*Classe de programmeur
*/
public class Programmer extends Employee {
/**
*Position
*/
private JobTitle jobTitle;
/**
*constructeur
*
* @param jobTitle Position
* @nom du paramètre nom
* @param sexe sexe
* @âge param
*/
public Programmer(JobTitle jobTitle, String name, Sex sex, int age) {
super(name, sex, age);
this.jobTitle = jobTitle;
}
/**
*Auto-introduction
*
* @retour Texte d'auto-introduction
*/
@Override
public String selfIntroduction() {
String value = super.selfIntroduction();
value += "jobTitle:=" + this.jobTitle + ", ";
return value;
}
/**
*Paie
* @salaire de retour
*/
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;
//Puisqu'il n'est pas possible de décrire une expression dans le résultat d'évaluation de switch en Java, elle est calculée par l'instruction if.
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;
}
/**
*Énumération des positions
*/
public enum JobTitle {
A1,
A2,
B1,
B2,
C1,
C2,
D1,
D2;
}
}
python
Programmer programmer = new Programmer(Programmer.JobTitle.A1, "Marie", Employee.Sex.Woman, 30); //Génération d'instance
String value = programmer.selfIntroduction(); //Invocation de la méthode d'instance
int salary = programmer.salary(); //Appelez la méthode de paie
System.out.print(value);
Swift
--Swift, comme Java, n'autorise pas l'héritage multiple et n'a qu'une seule classe de base.
python
///Programmeur
class Programmer:Employee {
///Énumération des positions
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;
///Nom
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
}
}
///Initialiseur
init(jobTitle:JobTitle = JobTitle.Unknown) {
self.jobTitle = jobTitle
super.init()
}
//Auto-introduction
override func selfIntroduction() -> String {
var value = super.selfIntroduction()
value += "jobTitle:=" + self.jobTitle.rawValue.description + ", "
return value
}
}
let programmer = Programmer(jobTitle: Programmer.JobTitle.Unknown) //Génération d'instance
let value = programmer.selfIntroduction() //Invocation de la méthode d'instance
let salary = programmer.salary //Appel de la propriété Computed
print(value)
print(salary)
Ce qui suit est une brève explication des spécifications uniques de Java et de Swift et comment les utiliser lors de la conception de classes.
Java
Java a l'idée de définir efficacement les trois principaux éléments orientés objet (encapsulation, héritage et polymorphisme) appelés classes abstraites. Contrairement aux classes dites ordinaires, les classes abstraites, comme leur nom l'indique, sont abstraites et ne peuvent pas être instanciées. Les super-héros sont réels, mais des classes qui représentent tout aussi abstraite que l'incapacité de la justice.
Pour déclarer une classe abstraite, préfixez le nom de la classe avec le modificateur "abstract", tel que "abstract class abstract class name {...}". Le contour du processus et les propriétés communes sont définis dans la classe abstraite et le processus spécifique est décrit dans la sous-classe qui hérite de la classe abstraite.
/**
*Classe abstraite de justice
*/
public abstract class AbstractJustice {
/**
*Capacité de base
*/
protected int mBasicAbility;
/**
*Potentiel
*/
protected int mPotentialCapacity;
/**
*Traitement pour enregistrer
*/
public abstract void save();
/**
*Acquisition des capacités de base
*
* @retourne la capacité de base
*/
public int getBasicAbility() {
return mBasicAbility;
}
/**
*Acquisition potentielle
*
* @potentiel de retour
*/
public int getPotentialCapacity() {
return mPotentialCapacity;
}
/**
*combat
*
* @param ennemiAbility Capacité ennemie
* @retourne le résultat du combat true...Victoire, faux...défaite
*/
public boolean fight(int enemyAbility) {
int basicAbility = getBasicAbility();
if (basicAbility > enemyAbility) {
//Gagnez si votre capacité de base est dépassée
return true;
}
//Capacité de base+Potentiel*Gagnez si le coefficient aléatoire est supérieur, battez s'il est inférieur
int potentialCapacity = getPotentialCapacity();
float coefficient = new java.util.Random().nextFloat();
return basicAbility + potentialCapacity * coefficient > enemyAbility;
}
}
/**
*Classe Anpanman
*/
public class Anpanman extends AbstractJustice {
/**
*Capacité de base initiale
*/
private int INIT_BASIC_ABILITY = 10;
/**
*Potentiel initial
*/
private int INIT_POTENTIAL_CAPACITY = 3;
/**
*constructeur
*/
public Anpanman() {
mBasicAbility = INIT_BASIC_ABILITY;
mBasicAbility = INIT_POTENTIAL_CAPACITY;
}
@Override
public void save() {
System.out.println("Manger le visage");
//Nourrir le visage réduit les capacités de base mais augmente le potentiel
mBasicAbility--;
mPotentialCapacity++;
//Lorsque la capacité de base devient 3 ou moins, Batako changera de visage, donc il reviendra à l'original.
if (mBasicAbility <= 3) {
//\ Anpanman! Nouveau visage! !! /
mBasicAbility = INIT_BASIC_ABILITY; //<100 fois plus énergique Anpanman! !!
}
}
@Override
public boolean fight(int enemyAbility) {
//Anpanman a une correction de victoire, il devient donc une capacité ennemie-dix
enemyAbility -= 10;
return super.fight(enemyAbility);
}
}
Avant Java 8, les méthodes ne pouvaient être définies que comme des méthodes d'instance dans une interface, mais depuis Java 8, il est désormais possible d'implémenter des méthodes statiques dans une interface. De plus, l'idée d'une méthode par défaut a été ajoutée et le corps de traitement de la méthode peut être implémenté dans l'interface.
L'interface en Java décrit les grandes lignes du processus et vous pouvez la considérer comme une fonction dans laquelle seules les méthodes abstraites de la classe abstraite sont agrégées. Bien qu'il existe des différences dues à des différences dans le protocole et les spécifications linguistiques de Swift, elles peuvent être considérées comme similaires. Cependant, comme l'indique le nom de l'interface en tant que fonction, il s'agit d'un résumé du traitement et des conventions, il ne peut donc pas être instancié et ne peut pas avoir de variables membres comme propriétés. "Gundam operation" lui-même n'a pas de couleur ou de forme, et il a la même signification que Gundam lui-même a une couleur ou une forme. (Je suis désolé si quelqu'un aime Gundam ...)
De plus, contrairement à l'héritage de classe, une classe peut implémenter plusieurs interfaces. Pour déclarer une interface, écrivez "nom de l'interface de l'interface {...}". Dans l'interface, vous pouvez écrire des méthodes qui ne décrivent pas les blocs de traitement qui décrivent uniquement le traitement et les constantes statiques uniquement.
Le contour du processus et le résultat attendu sont définis, mais le contenu du processus est géré par la classe qui implémente l'interface, et lors de l'implémentation de l'interface spécifiée, il est nécessaire d'implémenter toutes les fonctions de cette interface.
python
/**
*Opération Gundam
*/
public interface GundamOperation {
/**
*Accélérer
*/
void speedUp();
/**
*Ralentissez
*/
void speedDown();
/**
*Équipement d'économie de faisceau
*/
void equipmentSaber();
/**
*Libération de l'économiseur de faisceau
*/
void removeSaber();
/**
*Tournage
*/
void shooting();
}
/**
*∀ Classe Gundam
*/
public class GundamTurnA implements GundamOperation {
@Override
public void speedUp() {
System.out.println("Accélérer");
}
@Override
public void speedDown() {
System.out.println("Ralentissez");
}
@Override
public void equipmentSaber() {
System.out.println("Équipement d'économie de faisceau");
}
@Override
public void removeSaber() {
System.out.println("Libération de l'économiseur de faisceau");
}
@Override
public void shooting() {
System.out.print("Tournage");
}
}
/**
*Classe Zaku
*/
public class Zaku implements GundamOperation {
@Override
public void speedUp() {
System.out.println("Accélérer");
}
@Override
public void speedDown() {
System.out.println("Ralentissez");
}
@Override
public void equipmentSaber() {
System.out.println("Équipement d'économie de faisceau");
}
@Override
public void removeSaber() {
System.out.println("Libération de l'économiseur de faisceau");
}
@Override
public void shooting() {
System.out.print("Tournage");
}
}
À ce stade, le mérite d'utiliser l'interface est que l'interface cible est implémentée = l'opération fournie comme interface est garantie. Quelle que soit la classe, fournir une interface permet une implémentation flexible.
GundamTurnA gundamTurnA = new GundamTurnA();
Zaku zaku = new Zaku();
shooting(gundamTurnA);
shooting(zaku);
private void shooting(GundamOperation gundamOperation) {
gundamOperation.shooting(); //Peut être utilisé comme interface
}
Swift
Les extensions peuvent être utilisées pour étendre les classes existantes que Swift n'a pas en Java. La classe fournie par la bibliothèque est également possible (!)
print(10.hex)
extension Int {
///Hexadécimal
var hex: String {
return String(self, radix: 16)
}
///8 base
var oct: String {
return String(self, radix: 8)
}
///Nombre binaire
var bin: String {
return String(self, radix: 2)
}
///Taux d'imposition JP
static func jpTaxRate() -> Double {
return 0.8
}
///Montant JP TTC
func amount() -> Double {
return Int.jpTaxRate() * Double(self)
}
}
Cependant, vous ne pouvez pas effectuer les opérations suivantes.
--Définir les propriétés autres que les propriétés calculées
Le protocole dans Swift décrit les grandes lignes du processus, et on peut considérer qu'ils sont similaires, bien qu'il existe des différences dues à la différence dans l'interface et les spécifications du langage en Java. Cependant, comme le nom du protocole en tant que fonction l'indique, il s'agit d'un résumé du traitement et des conventions, il ne peut donc pas être instancié et ne peut pas avoir de variables membres comme propriétés.
De plus, l'interface Java peut avoir des constantes statiques (par exemple "static final String HOGE =" hoge ""), mais le protocole ne la prend pas en charge et ne peut fournir que des fonctions et des propriétés calculées. Pour déclarer un protocole, écrivez "nom du protocole de protocole {...}". Seule la propriété Computed de la méthode getter / méthode setter qui ne décrit pas le bloc de traitement et la méthode qui ne décrit pas le bloc de traitement peut être décrite dans le protocole. Les grandes lignes du processus et le résultat attendu sont définis, mais la classe qui implémente le protocole est responsable du processus.
///Lire le protocole des délégués
protocol ReadDelegate {
///Processus de lecture
func read() -> Int
}
///Protocole de progression
protocol Progressing {
///Montant total
var total: Int { get }
///Montant d'achèvement
var completed: Int { get set }
func read()
}
///Protocole de conversion de chaîne
protocol StringTranslatable {
///Conversion de chaîne
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!
}
}
}
///Cette classe d'implémentation de protocole de délégué de lecture
class BookReadDelegate:ReadDelegate {
func read() -> Int {
return 5
}
}
À ce stade, le mérite d'utiliser le protocole est que le protocole cible est implémenté = l'opération fournie car le protocole est garanti.
Comme déjà décrit dans la classe "Book" ci-dessus, le traitement de la fonction "read ()" est délégué à "BookReadDelegate", et quelle que soit la classe, le protocole est fourni. Une mise en œuvre flexible est possible.
De plus, dans l'argument d'une fonction, etc., spécifiez "Nom de la variable: protocole
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() //Définir une classe qui implémente ReadDelegate pour déléguer le traitement
readBook(comic)
func readBook(target:protocol<Progressing, StringTranslatable>) { //Implémenté par Progressing, StringTranslatable
print(target.asString)
target.read()
print(target.completed)
}
Parmi les fonctionnalités que Swift n'a pas en Java, les classes existantes peuvent être étendues pour se conformer au protocole. Pour étendre une classe existante avec un protocole, écrivez "nom de classe existant d'extension: nom de protocole cible d'extension {...}". Dans l'exemple ci-dessous, la classe "Int" est étendue avec le "StringTranslatable" créé ci-dessus, et les détails de traitement de la propriété "asString" Computed, qui est l'exigence d'implémentation de "StringTranslatable", sont implémentés.
///Étendre Int avec StringTranslatable
extension Int: StringTranslatable {
var asString: String {
get {
return "Ce nombre est[" + description + "]est."
}
}
}
Un indice est une expression d'indice utilisée lors de l'accès aux éléments d'un tableau ou d'un dictionnaire. Swift vous permet d'implémenter des indices dans des structures, des énumérations et des classes.
var test = Test()
print(test["A"]) // "1"Et sortie
class Test {
let values = ["A":"1", "B":"2", "C":"3", "D":"4"]
subscript(param:String) -> String {
get {
return self.values[param]!
}
}
}
Swift vous permet de surcharger les opérateurs existants. Les surcharges d'opérateurs peuvent être définies comme des fonctions globales pour leur donner un comportement unique.
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)
Recommended Posts