Je n'ai fait que des langages statiques, mais je voulais faire du machine learning, j'ai donc décidé de commencer à étudier Python. Je suis choqué par la culture car il existe de nombreuses différences entre Go, Java et TypeScript que j'ai faites jusqu'à présent ... Cela dit, apprendre une nouvelle langue est passionnant.
Pour le moment, j'ai écrit la même classe et ses classes enfants dans les deux langages afin de pouvoir comparer les classes Java et Python afin de ne pas oublier la syntaxe de la classe Python.
Les deux créent une classe Phone. Ensuite, créez sa classe enfant, la classe SmartPhone. Instanciez les deux et appelez chaque méthode. (La méthode calss est naturelle mais non instanciée)
Au fait, j'ai utilisé le téléphone et le smartphone comme thème car j'avais un iPhone à portée de main lors de la rédaction de l'article (rires).
J'ai noté le traitement détaillé dans le code.
Phone.java
package com.company;
/**
*Classe de téléphone
*/
public class Phone {
/**
*numéro de téléphone
*/
private String number;
/**
*constructeur
* @param number
*/
public Phone(String number) {
this.number = number;
}
/**
*Montrez votre numéro de téléphone
*/
public void showMyNumber(){
System.out.println("This phone's number is " + this.number);
}
/**
*Appeler la personne spécifiée
* @téléphone param
*/
public void call(String phonePartner) {
System.out.println("Call to " + phonePartner);
}
}
Classe enfant de classe Phone
SmartPhone.java
package com.company;
/**
*téléphone intelligent
*Classe enfant de classe Phone
*/
public class SmartPhone extends Phone {
/**
* os
*/
private String os;
/**
*constructeur
*
* @numéro de téléphone numéro de paramètre
* @param os os
*/
public SmartPhone(String number, String os) {
super(number);
this.os = os;
}
/**
*Passer un appel vidéo à la personne spécifiée
*Remplacé
*
* @téléphone param
*/
@Override
public void call(String phonePartner) {
System.out.println("Video call to" + phonePartner);
}
/**
*Afficher le système d'exploitation
*/
public void showMyOS() {
System.out.println("his phone's os is" + this.os);
}
/**
*Méthode de classe
*Prendre une photo
*
* @sujet sujet param
*/
public static void takeAPitcure(String subject) {
System.out.println("Take a picture of " + subject);
}
}
Ici, chaque classe est instanciée.
Main.java
package com.company;
/**
*Principale
*/
public class Main {
public static void main (String[] args) {
System.out.println("===Normal Phone===");
//Instanciation
Phone normalPhone = new Phone("xxx-xxx-xxx");
normalPhone.showMyNumber();
normalPhone.call("sekky0905");
System.out.println("===Smart Phone===");
//Instanciation
SmartPhone iPhone = new SmartPhone("○○○-○○○-○○○", "ios");
iPhone.showMyNumber();
iPhone.call("sekky0905");
iPhone.showMyOS();
SmartPhone.takeAPitcure("flower");
System.out.println("===Smart Phone2===");
//Instanciation
Phone zenPhone = new SmartPhone("△△△-△△△-△△△", "android");
zenPhone.showMyNumber();
zenPhone.call("sekky0905");
//Au fait, bien sûr, vous ne pouvez rien faire
// zenPhone.showMyOS();
}
}
===Normal Phone===
This phone's number is xxx-xxx-xxx
Call to sekky0905
===Smart Phone===
This phone's number is ○○○-○○○-○○○
Video call tosekky0905
his phone's os isios
Take a picture of flower
===Smart Phone2===
This phone's number is △△△-△△△-△△△
Video call tosekky0905
main.py
#classe
class Phone:
#constructeur
def __init__(self, number):
self.__number = number
#Il semble que les méthodes Python aient toujours un argument
#Il semble habituel de toujours placer le premier argument sur soi
def show_my_number(self):
print('This phone\'s number is{0}.'.format(self.__number))
#Il semble que les méthodes Python aient toujours un argument
#Il semble habituel de toujours placer le premier argument sur soi
def call(self, phone_partner):
print('Call to {0}.'.format(phone_partner))
#Classe enfant par téléphone
class SmartPhone(Phone):
def __init__(self, number, os):
super().__init__(number)
self.os = os
#Passer outre
def call(self, phone_partner):
print('Video call to {0}.'.format(phone_partner))
def show_my_os(self):
print('This phone\'s os is {0}.'.format(self.os))
#Méthode de classe
@classmethod
def take_a_picture(cls, subject):
print('Take a picture of {0}.'.format(subject))
print("===Normal Phone===")
#Instanciation
normalPhone = Phone("xxx-xxx-xxx")
normalPhone.show_my_number()
normalPhone.call("sekky0905")
print("===Smart Phone===")
#Instanciation
iPhone = SmartPhone("○○○-○○○-○○○", "ios")
iPhone.show_my_number()
#Peut être utilisé car il hérite du téléphone
iPhone.call("sekky0905")
iPhone.show_my_os()
#Méthode de classe
SmartPhone.take_a_picture("flower")
===Normal Phone===
This phone's number isxxx-xxx-xxx.
Call to sekky0905.
===Smart Phone===
This phone's number is○○○-○○○-○○○.
Video call to sekky0905.
This phone's os is ios.
Take a picture of flower.
J'étais réticent à utiliser Python au début, mais comme je m'y suis habitué, j'ai pensé que cela pourrait être plus facile à écrire. Mais écrire un langage statique après avoir touché Python me donne un sentiment de sécurité lorsque je reviens dans ma ville natale.
Apprendre une nouvelle langue est amusant ~!
9. Classes - Documentation Python 3.6.1
Cours de base Python (13 classes) --Qiita