Es ist ein Jahr her, seit ich angefangen habe zu programmieren. Es ist nicht so, dass ich es überhaupt nicht angefasst habe, weil ich eine Android-App erstellt habe, aber ich denke immer wieder, dass es objektorientiert ist. Wenn Sie es nicht verstehen, wird es in Zukunft schwierig sein, machen Sie sich also eine Notiz. Geschrieben in Java und Ruby
Ich wäre Ihnen dankbar, wenn Sie auf Fehler hinweisen könnten.
Ich habe viele Methoden in der Hauptklasse gemacht! !! Ich weiß das nicht mehr!
Main.java
class Main{
public static void main(String[] args){
hello();
sorry();
goodbye();
fine();
.
.
.
}
public static void hello(){
//Prozessanweisung
}
public static void sorry(){
//Prozessanweisung
}
.
.
.
}
↓ Erstellen Sie andere Klassen und schreiben Sie viele Methoden!
Main.java
class Main{
public static void main(String[] args){
Person.hello();
}
}
Person.java
class Person{
public static void hello(){
System.out.println("Hello World");
}
}
(In Ruby)
index.rb
class Person
#Inhalt
end
groß! Sauber!
Repräsentiert "Dinge" in der realen Welt (oft an verschiedenen Orten geschrieben) Zum Beispiel, wenn es ein Objekt namens Otaku gibt
Technische Daten (Informationen) --28 Jahre alt --Single
Was Sie tun können (Verhalten)
Kann mit dem Gefühl (Voreingenommenheit) erklärt werden
Sie benötigen eine Klasse, um eine Instanz zu erstellen. Mit anderen Worten, die Klasse ist eine Instanzentwurfszeichnung. (Es wird oft an verschiedenen Stellen geschrieben)
Nun definieren wir Otaku. Es ist einfach. Schreiben Sie einfach die "Spezifikationen" und "Was Sie tun können" der Instanz in die Otaku-Klasse (Konstruktionszeichnung).
Main.java
class Main{
public static void main(String[] args){
Otaku otaku1 = new Otaku(); //➀ Erstellen Sie eine Instanz der Otaku-Klasse! Weisen Sie die Instanz einer Variablen zu und verwenden Sie sie!
//Klassentyp Variablenname(Instanzname) =neuer Klassenname();
Otaku otaku2 = new Otaku();
Otaku otaku3 = new Otaku(); //➁ Sie können viele Instanzen aus demselben Klassentyp erstellen! Es gibt viele Otaku!
//➃ Instanzname.Methodenname()Sie können verwenden, was Otaku kann!
otaku1.usePC();
otaku1.specBody(); //➄ In der specBody-Methode "Ich bin fett!Ich möchte sagen! Wert des Instanzfeldkörpers("Fett")Möchte benutzen!
}
}
Otaku.java
class Otaku{
//➂ Hier sind die Spezifikationen von Otaku(Information)Ich werde definieren! Es scheint, dass das schwierige Wort Instanzfeld ist? Aber es ist eine Variablendeklaration!(vielleicht!)
public String age;
public String body;
//➂ Weisen Sie im Konstruktor einen Wert zu!
Otaku(){
otaku1.age = "28 Jahre alt";
otaku1.body = "Fett";
}
//➃ Was Otaku von hier aus tun kann(Verhalten)Wird durch eine Methode ausgedrückt! Wird auch als Instanzmethode bezeichnet!
public void usePC(){
System.out.println("Ich bin ein großer Lehrer für PCs!");
}
public void specBody(){
System.out.println("ich" * this.body + "ist!"); //➄ MainクラスでspecBodyメソッドが呼ばれた時に、thisをインスタンス名に置き換えるよ！ これで「ichデブist!Sie können sagen!
}
}
(Verwendung der Instanzmethode in Ruby)
otaku.rb
class Otaku
def usePC #Definition der Instanzmethode
puts "Ich bin ein großer Lehrer für PCs!"
end
end
otaku = Otaku.new #Instanzgenerierung
otaku.usePC
public ・ ・ ・ Kann von außerhalb der Klasse aufgerufen werden static ・ ・ ・ Kann aufgerufen werden, ohne eine Instanz zu erstellen
Ein Konstruktor ist eine spezielle Methode, die automatisch aufgerufen wird, nachdem eine Instanz mit new erstellt wurde. Synonym für "Methode initialisieren" in Ruby
Wenn Sie den Konstruktor beim Festlegen des Werts des Instanzfelds verwenden und nicht verwenden, ändert sich der Code erheblich! Erinnern wir uns richtig!
Kein Konstruktor ver
Main.java
class Main{
public static void main(String[] args){
Otaku otaku1 = new Otaku(); //➀ Erstellen Sie eine Instanz der Otaku-Klasse! Weisen Sie die Instanz einer Variablen zu und verwenden Sie sie!
//Klassentyp Variablenname(Instanzname) =neuer Klassenname();
Otaku otaku2 = new Otaku();
Otaku otaku3 = new Otaku(); //➁ Sie können viele Instanzen aus demselben Klassentyp erstellen! Es gibt viele Otaku!
otaku1.age = "28 Jahre alt"; //➂ Ich werde in jedem Fall detaillierte Informationen über Otaku geben! Das ist kein guter Mensch!
otaku1.body = "Fett";
otaku1.usePC(); //➃ Instanzname.Methodenname()Sie können verwenden, was Otaku kann!
otaku1.specBody(); //➄ In der specBody-Methode "Ich bin fett!Ich möchte sagen! Wert des Instanzfeldkörpers("Fett")Möchte benutzen!
}
}
Von diesem Code otaku1.age = "28 Jahre alt"; otaku1.body = "Fett"; Ich setze den Wert auf. Damit wäre es schwierig, die Anzahl der Instanzfelder zu erhöhen! Ich weiß es nicht, weil es so viele gibt!
Mit Konstruktor ver
Main.java
class Main{
public static void main(String[] args){
Otaku otaku1 = new Otaku(); //➀ Erstellen Sie eine Instanz der Otaku-Klasse! Weisen Sie die Instanz einer Variablen zu und verwenden Sie sie!
//Klassentyp Variablenname(Instanzname) =neuer Klassenname();
Otaku otaku2 = new Otaku();
Otaku otaku3 = new Otaku(); //➁ Sie können viele Instanzen aus demselben Klassentyp erstellen! Es gibt viele Otaku!
//Nein!
otaku1.usePC(); //➃ Instanzname.Methodenname()Sie können verwenden, was Otaku kann!
otaku1.specBody(); //➄ In der specBody-Methode "Ich bin fett!Ich möchte sagen! Wert des Instanzfeldkörpers("Fett")Möchte benutzen!
}
}
Otaku.java
class Otaku{
//➂ Hier sind die Spezifikationen von Otaku(Information)Ich werde definieren! Es scheint, dass das schwierige Wort Instanzfeld ist? Aber es ist eine Variablendeklaration!(vielleicht!)
public String age;
public String body;
//Ich werde den Konstruktor hier verwenden! neuer Otaku();Diese Methode wird immer verwendet, wenn sie aufgerufen wird!
Otaku(){
otaku1.age = "28 Jahre alt"; //➂ Ich werde in jedem Fall detaillierte Informationen über Otaku geben! Das ist kein guter Mensch!
otaku1.body = "Fett";
}
//➃ Was Otaku von hier aus tun kann(Verhalten)Wird durch eine Methode ausgedrückt! Wird auch als Instanzmethode bezeichnet!
public void usePC(){
System.out.println("Ich bin ein großer Lehrer für PCs!");
}
public void specBody(){
System.out.println("ich" * this.body + "ist!"); //➄ MainクラスでspecBodyメソッドが呼ばれた時に、thisをインスタンス名に置き換えるよ！ これで「ichデブist!Sie können sagen!
}
}
Sie können beim Erstellen einer Instanz auch einen Wert als Argument festlegen und an den Konstruktor übergeben!
Main.java
Otaku otaku = new Otaku("Fett");
Otaku.java
class Otaku{
public String body;
Otaku(String body){ //"Fett"Eingeben
this.body = body; //otaku.body = "Fett";Gleich wie!
}
}
Dies ist bei Ruby der Fall
index.rb
class Otaku
def initialize(name) //Was Sie beim Erstellen einer Instanz tun möchten
@name = name #Instanzvariable(Informationen, die die Instanz hat(Daten))
end
def info
puts "ich#{@name}ist" #Instanzvariablen nur innerhalb der Klasse verfügbar
end
end
otaku = Otaku.new("Fett")
otaku.info
Es ist an der Zeit, dass mein Kopf nicht aufholt. Bedeutet das, dass die Klasse auch Informationen haben kann?
Klassen können auch Methoden haben. An erster Stelle public static void main(String[] args){ } Dies ist auch eine Klassenmethode, nicht wahr?
Otaku.java
class Otaku{
static int count = 0; //Klassenvariable(Variablen, die in allen Fällen verwendet werden können)
//Instanzfeld
public String age;
public String body;
//Konstrukteur
Otaku(){
Otaku.count++; //Zugriff auf Klassenfelder
}
}
So schreiben Sie Klassenmethoden in Ruby
index.rb
class Otaku
@@count = 0 #Definition von Klassenvariablen
def initialize(name)
@name = name
@@count += 1
end
def Otaku.data #Klassenmethodendefinition selbst.Kann auch eine Klassenmethode sein
puts "ist Name"
end
end
Otaku.data #Aufrufen einer Klassenmethode
#Name des Ausgabeergebnisses
Nein, es ist eng Einfach ausgedrückt, legen Sie die sicheren Teile der von Ihnen erstellten Funktionen offen und begrenzen (kapseln) Sie die Teile, die Sie nicht verwenden möchten. Dies kann durch Einschränken des Zugriffs auf Felder und Methoden erfolgen.
Wai "Ich habe eine Klasse gemacht! Schau dir das an! Es ist erstaunlich! Ich habe es auch in anderen Klassen benutzt!" Fügen Sie "public" hinzu!
Main.java
class Main(){
public static void main(String[] args){
Otaku otaku = new Otaku("wai"); //Instanzgenerierung
System.out.println(otaku.name); //Es ist für die Öffentlichkeit zugänglich, so dass Sie es verwenden können!
}
}
Otaku.java
class Otaku{
//Instanzfeld
public String name; //Fügen Sie "public" hinzu, damit von außerhalb der Klasse darauf zugegriffen werden kann!
//Konstrukteur
Otaku(String name){
this.name = name;
}
}
Wai "Ich habe eine Klasse gemacht! Schau dir das an! Aber wenn ich es in einer anderen Klasse benutze, scheint es einen Fehler zu verursachen, also kann ich es nicht benutzen ..." Fügen Sie "privat" hinzu!
Main.java
class Main(){
public static void main(String[] args){
Otaku otaku = new Otaku(28); //Instanzgenerierung
System.out.println(otaku.age); //Error! !! !! Kann ich nicht benutzen!
}
Otaku.java
class Otaku{
//Instanzfeld
private int age; //Fügen Sie "privat" hinzu, um den Zugriff von außen zu verhindern!
//Konstrukteur
Otaku(int age){
this.age = age; //Sie können es in der gleichen Klasse verwenden!
}
}
Ruby-Methoden sind öffentliche Methoden, sofern Sie nichts angeben. Die nach private geschriebene Methode wird zu einer privaten Methode und kann nur innerhalb der Klasse aufgerufen werden.
Jedoch, Für Kunden, die einen sicheren Wert erhalten möchten, auch wenn das Instanzfeld privat ist, bieten wir eine Methode namens "getter" an, die nur den Rückgabewert des Felds verwenden kann!
Main.java
class Main{
public static void main(String[] args){
Otaku otaku = new Otaku("~","~","~");
System.out.println(otaku.getName());
}
}
Otaku.java
class Otaku{
//Instanzfeld
~
private String name; //Das ist "privat", aber ...
~
//Instanzmethode
public String getName(){ //Da dies "öffentlich" ist, kann von außerhalb der Klasse darauf zugegriffen werden
return this.name; //Gibt den Wert des Feldes zurück
}
}
Selbst in Ruby kann der Wert einer Instanzvariablen nur innerhalb der Klasse abgerufen werden, sodass er mit einem Getter von außerhalb der Klasse abgerufen werden kann.
index.rb
class Otaku
attr_reader:name #Getter Definition
def initialize(name)
@name = name
end
end
otaku = Otaku.new("Beschäftigt")
puts otaku.name
Attr_reader definiert Getter, indem es dasselbe wie ↓ tut
def name
@name #Rückgabewert(Rückgabe weggelassen)
end
Im Gegenteil, es gibt auch eine Methode "Setter", die den Wert des Feldes von außen ändert.
Main.java
class Main{
public static void main(String[] args){
Otaku otaku = new Otaku("~","~","~");
otaku.setName("washi"); //In der setName-Methode festgelegtes Argument
System.out.println(otaku.getName());
//Ausgabeergebnis: washi
}
}
Otaku.java
class Otaku{
~
private String name;
~
public void setName(String name){
this.name = name; //Wert im Feld einstellen
}
}
Setter Definition in Ruby
index.rb
class Otaku
attr_writer:name #Definition des Setzers
def initialize(name)
@name = name
end
end
otaku = Otaku.new("Beschäftigt")
otaku.name = "süß" #Setter anrufen
puts otaku.name #Das Ausgabeergebnis ist niedlich
Attr_writer definiert einen Setter, indem er dasselbe wie ↓ tut
def name=(value)
@name = value
end
Wenn Sie in Ruby Getter und Setter gleichzeitig definieren, können Sie beide gleichzeitig definieren, indem Sie "attr_accessor" verwenden.
--Feld ist privat
Durch Setzen auf wird die Variable privat geschützt und die Methode kann in anderen Klassen öffentlich verwendet werden, was praktisch ist.
Was für eine coole Sache.
Sie möchten Code mit ähnlichem Inhalt zusammenstellen. Gleiches gilt für den Inhalt der Klasse. Vererbung des Inhalts einer Klasse durch eine andere Klasse.
Senior "Meine Spezialfähigkeit ist vielseitig! Super verwendbar!" (Geerbte Spezialfähigkeit (Klasse): Superklasse)
Super.java
class Super{
public void setName(String name){
System.out.println(name);
}
}
Junior "Senior! Lass es mich benutzen!" (Spezialfähigkeit (Klasse), die vererbt werden kann: Unterklasse)
Sub.java
class Sub extends Super{ //Erbt die Instanzmethode der Super-Klasse
}
Main.java
class Main{
public static void main(String[] args){
Sub sub = new Sub();
sub.setName("Hyperkinetischer Positionsumkehrer!!!"); //Rufen Sie eine Instanzmethode einer Oberklasse auf
}
}
In Ruby sieht es so aus
index.rb
class Super
def initialize(name)
@name = name
end
def info
puts @name
end
end
class Sub < Super
end
sub = Sub.new("Hyperkinetischer Positionsumkehrer!!!") #Wenn new ausgeführt wird, wird die Initialisierungsmethode der übergeordneten Klasse ausgeführt.
sub.info #Da es von der übergeordneten Klasse erbt, kann die info-Methode verwendet werden
Durch Definieren einer Methode mit demselben Namen wie die von der Oberklasse in der Unterklasse geerbte Methode kann der Inhalt der Oberklasse überschrieben werden. Dies wird als "Überschreiben" bezeichnet.
Außerdem kann nur innerhalb dieser Klasse auf "privat" zugegriffen werden, während auf "geschützt" nur innerhalb dieser Klasse und ihrer Unterklassen zugegriffen werden kann.
--Methoden werden in der Klasse definiert --dies wird verwendet, um auf eine Methode oder Instanz in einer Klasse zu verweisen
Recommended Posts