Ich habe nur statische Sprachen gemacht, aber ich wollte maschinelles Lernen machen, also habe ich beschlossen, Python zu lernen. Ich bin schockiert von der Kultur, weil es viele Unterschiede zu Go, Java und TypeScript gibt, die ich bisher gemacht habe ... Trotzdem ist es aufregend, eine neue Sprache zu lernen.
Zur Zeit habe ich dieselbe Klasse und ihre untergeordneten Klassen in beiden Sprachen geschrieben, damit ich Java- und Python-Klassen vergleichen kann, damit ich die Python-Klassensyntax nicht vergesse.
Beide erstellen eine Telefonklasse. Erstellen Sie als Nächstes die untergeordnete Klasse, die SmartPhone-Klasse. Instanzulieren Sie beide und rufen Sie jede Methode auf. (Die Calss-Methode ist natürlich, aber nicht instanziiert.)
Übrigens habe ich das Telefon und das Smartphone als Thema verwendet, weil ich beim Schreiben des Artikels ein iPhone zur Hand hatte (lacht).
Ich habe die detaillierte Verarbeitung im Code notiert.
Phone.java
package com.company;
/**
*Telefonklasse
*/
public class Phone {
/**
*Telefonnummer
*/
private String number;
/**
*Konstrukteur
* @param number
*/
public Phone(String number) {
this.number = number;
}
/**
*Zeigen Sie Ihre Telefonnummer
*/
public void showMyNumber(){
System.out.println("This phone's number is " + this.number);
}
/**
*Rufen Sie die angegebene Person an
* @param phonePartner
*/
public void call(String phonePartner) {
System.out.println("Call to " + phonePartner);
}
}
Kinderklasse der Telefonklasse
SmartPhone.java
package com.company;
/**
*Smartphone
*Kinderklasse der Telefonklasse
*/
public class SmartPhone extends Phone {
/**
* os
*/
private String os;
/**
*Konstrukteur
*
* @Param Nummer Telefonnummer
* @param os os
*/
public SmartPhone(String number, String os) {
super(number);
this.os = os;
}
/**
*Tätigen Sie einen Videoanruf an die angegebene Person
*Überschrieben
*
* @param phonePartner
*/
@Override
public void call(String phonePartner) {
System.out.println("Video call to" + phonePartner);
}
/**
*Betriebssystem anzeigen
*/
public void showMyOS() {
System.out.println("his phone's os is" + this.os);
}
/**
*Klassenmethode
*Mach ein Foto
*
* @param Fach Thema
*/
public static void takeAPitcure(String subject) {
System.out.println("Take a picture of " + subject);
}
}
Hier wird jede Klasse instanziiert.
Main.java
package com.company;
/**
*Maine
*/
public class Main {
public static void main (String[] args) {
System.out.println("===Normal Phone===");
//Instanziierung
Phone normalPhone = new Phone("xxx-xxx-xxx");
normalPhone.showMyNumber();
normalPhone.call("sekky0905");
System.out.println("===Smart Phone===");
//Instanziierung
SmartPhone iPhone = new SmartPhone("○○○-○○○-○○○", "ios");
iPhone.showMyNumber();
iPhone.call("sekky0905");
iPhone.showMyOS();
SmartPhone.takeAPitcure("flower");
System.out.println("===Smart Phone2===");
//Instanziierung
Phone zenPhone = new SmartPhone("△△△-△△△-△△△", "android");
zenPhone.showMyNumber();
zenPhone.call("sekky0905");
//Übrigens kann man natürlich nichts machen
// 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
#Klasse
class Phone:
#Konstrukteur
def __init__(self, number):
self.__number = number
#Es scheint, dass Python-Methoden immer ein Argument haben
#Es scheint üblich, das erste Argument immer auf sich selbst zu setzen
def show_my_number(self):
print('This phone\'s number is{0}.'.format(self.__number))
#Es scheint, dass Python-Methoden immer ein Argument haben
#Es scheint üblich, das erste Argument immer auf sich selbst zu setzen
def call(self, phone_partner):
print('Call to {0}.'.format(phone_partner))
#Telefon Kinderklasse
class SmartPhone(Phone):
def __init__(self, number, os):
super().__init__(number)
self.os = os
#Überschreiben
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))
#Klassenmethode
@classmethod
def take_a_picture(cls, subject):
print('Take a picture of {0}.'.format(subject))
print("===Normal Phone===")
#Instanziierung
normalPhone = Phone("xxx-xxx-xxx")
normalPhone.show_my_number()
normalPhone.call("sekky0905")
print("===Smart Phone===")
#Instanziierung
iPhone = SmartPhone("○○○-○○○-○○○", "ios")
iPhone.show_my_number()
#Kann verwendet werden, weil es Telefon erbt
iPhone.call("sekky0905")
iPhone.show_my_os()
#Klassenmethode
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.
Anfangs wollte ich Python nicht verwenden, aber als ich mich daran gewöhnt hatte, dachte ich, es könnte einfacher sein, zu schreiben. Das Schreiben einer statischen Sprache nach dem Berühren von Python gibt mir jedoch ein Gefühl der Sicherheit, wenn ich in meine Heimatstadt zurückkehre.
Eine neue Sprache zu lernen macht Spaß ~!
9. Klassen - Python 3.6.1-Dokumentation
Python-Grundkurs (13 Klassen) - Qiita
Recommended Posts