Mit Qiita ist es schwierig, nur den Textteil zu drucken. Daher wird derselbe Inhalt auf der folgenden Seite veröffentlicht. Wenn Sie ausdrucken oder in PDF konvertieren möchten, verwenden Sie bitte diese Seite:

http://gurakura.sakura.ne.jp/hellomondrian/variable/

Klicken Sie hier für eine Liste: http://gurakura.sakura.ne.jp/series/美大生のためのプログラミング入門/

Qiita Version umfassendes Inhaltsverzeichnis: https://qiita.com/iigura/items/37180d127da93d0b8abb

Vertical Composition with Blue and White by Piet Mondrian, 1936. https://www.wikiart.org/en/piet-mondrian/vertical-composition-with-blue-and-white-1936

Einführung

In diesem Kapitel lernen Sie Variablen kennen. Ich frage mich, ob Variablen die erste Barriere (und Herausforderung) bei der Programmierung sind. Es ist eine schwierige "Variable" für diejenigen, die gerade erst anfangen, Programmieren zu lernen, aber es ist nicht dazu gedacht, Sie gemein zu machen.

Wenn Sie das Konzept der "Variablen" nicht verwenden, gibt es Dinge, die nicht realisiert werden können, oder es ist möglicherweise bequemer oder einfacher, Variablen zu verwenden, sodass das Konzept und die Funktion von Variablen vorhanden sind.

Das heißt, es ist ein etwas esoterisches Konzept, deshalb werde ich es in diesem Kapitel erklären und mich auf seine Notwendigkeit und Zweckmäßigkeit konzentrieren.

Erleben Sie eine schwierige Situation

Um die Notwendigkeit und "Dankbarkeit" von Variablen zu erkennen, halte ich es für besser, schwierige Situationen ohne Verwendung von Variablen zu erleben. Hier wagen wir es, die "problematische Situation" zu erleben, indem wir ein Bild wie das unten gezeigte von einem Programm zeichnen.

Das Programm zum Zeichnen dieser Figur lautet wie folgt:

// vertical comp-position ver.0
background(250,245,230);
size(500,500);

noStroke();
fill(0,80,255); // blue
rect(450,0,50,100);

strokeWeight(10);
stroke(0,0,0);
line(450,0,450,500);   // vertical
line(450,100,500,100); // horizontal

In der Arbeit des obigen Programms habe ich das Gefühl, dass die Position des blauen Quadrats etwas zu richtig ist (nur mein Gefühl). Verschieben wir die Position des Quadrats etwas weiter nach links. Natürlich müssen wir die Breite vergrößern, nicht nur verschieben. Ich werde versuchen, es auch zu erhöhen.

Lassen Sie uns zum Beispiel sehen, wie die Funktion rect das erste Argument von 450 auf 300 reduziert und das dritte Argument von 50 auf 120 erhöht. Das Programm sieht folgendermaßen aus:

// vertical comp-position ver.1
background(250,245,230);
size(500,500);

noStroke();
fill(0,80,255);        // blue
rect(350,0,120,100);   // <-- change

strokeWeight(10);
stroke(0,0,0);
line(450,0,450,500);   // vertical
line(450,100,500,100); // horizontal

Wenn Sie dieses Programm ausführen, erhalten Sie die folgende Arbeit:

... Leider ist das Bild kaputt. Wenn Sie sorgfältig darüber nachdenken, wird die Größe der Leinwand durch die Größenfunktion als 500 Pixel breit angegeben. Wenn Sie das Viereck ganz nach rechts platzieren möchten, sollte die Breite des Vierecks mit dem x-Wert der oberen linken Koordinate des Vierecks in Beziehung gesetzt werden. Wenn der x-Wert der oberen linken Koordinate 350 beträgt, muss die Breite des Vierecks 150 (= 500 - 350) betragen.

Auch das Argument der Linie (450,0,450,500), das eine vertikale Linie zeichnet, muss geändert werden. Dieses Mal müssen Sie die Werte des ersten und dritten Arguments dieser Linienbeziehung von 450 auf 350 ändern, um sie so zu zeichnen, dass sie die oberen linken Koordinaten des korrigierten blauen Quadrats überlappen.

Ebenso müssen die Koordinaten am linken Ende des Horizonts geändert werden. Insbesondere muss das, was als Zeile (450.100.500.100) geschrieben wurde, als Zeile (350.100.500.100) umgeschrieben werden, indem das erste Argument von 450 auf 350 geändert wird.

Hier ist eine Liste der geänderten Programme und ihrer Ausführungsergebnisse:

// vertical comp-position ver.2
background(250,245,230);
size(500,500);

noStroke();
fill(0,80,255); // blue
rect(350,0,500-350,100);

strokeWeight(10);
stroke(0,0,0);
line(350,0,350,500);   // vertical
line(350,100,500,100); // horizontal

Es fühlt sich ziemlich gut an. Durch Korrigieren aller Zahlen an diesen verwandten Stellen wurde das kaputte Bild irgendwie behoben. Wenn ich das erzeugte Bild mit einem Gefühl der Sicherheit betrachtete, wollte ich die Position der vertikalen Linie etwas weiter nach rechts verschieben.

Sie müssen das Programm auch wie zuvor ändern. Darüber hinaus müssen Sie alles reparieren, was repariert werden muss, und nicht vergessen, es zu reparieren. Die Arbeit, das Programm zu ändern und viele Male zu überprüfen, wird endlos wiederholt. Das ist sehr nervig.

Ist das etwas, was nicht geht? (Wenn Sie Lust haben ..., hat dieser Abschnitt gut funktioniert).

Programmstruktur

Um die Position der vertikalen Linie oder die Position oben links im blauen Quadrat leicht zu ändern, schauen wir uns die Struktur des oben gezeigten Programms an. Dieses Programm hat die Position der vertikalen Linie und der oberen linken Ecke des Rechtecks auf die Position x = 350 geändert. Wenn Sie sich die Programmliste noch einmal ansehen und sich auf diese Zahl von 350 konzentrieren, sehen Sie Folgendes.

Die erste Zahl 350 ist das Argument für die Funktion rect in Zeile 7:

rect( 350 ,0,500- 350 ,0);
//    ^^^         ^^^

Der Klarheit halber habe ich es mit einem Kommentar unter dem x-Koordinatenwert 350 markiert.

In ähnlicher Weise ist der Teil, der sich auf den x-Koordinatenwert 350 bezieht, unten gezeigt:

line( 350 ,0, 350 ,500); //11. Zeile
//    ^^^     ^^^

line( 350 ,100,500,100); //12. Zeile
//    ^^^

Wenn Sie sich alle Positionen für den x-Koordinatenwert 350 ansehen, gibt es insgesamt 5 Positionen. Mit anderen Worten, wenn Sie die Position der vertikalen Linie von 350 auf 335 ändern, wenn Sie beispielsweise die Werte nicht an allen fünf Stellen ändern, wird das Bild unterbrochen.

Mit anderen Worten, selbst ein Programm, das ein so einfaches Bild erzeugt, würde fünf Änderungen erfordern, um die Zeichenposition geringfügig zu ändern. Natürlich haben Programme, die komplexere Bilder erzeugen, mit größerer Wahrscheinlichkeit mehr Stellen zum Ändern.

Ist es nicht möglich, diese Änderungen automatisch zu aktualisieren, da wir nur die Zeichnungsposition ändern? Es ist mühsam, die zugehörigen Stellen einzeln manuell zu korrigieren. Wenn Sie jedes Mal manuell Korrekturen vornehmen, vergessen Sie möglicherweise, Korrekturen vorzunehmen, was ein Problem darstellt.

... Nun, wenn Sie sich so fühlen, haben Sie das Potenzial, (vielleicht) ein gutes Programm zu schreiben. Ich denke, die Idee, mehr Ärger zu vermeiden, indem man ein wenig Ärger akzeptiert, ist bei der Programmentwicklung sehr wichtig.

Die Geschichte war ein wenig anders. Kommen wir zurück zur Geschichte. Warum muss ich zuerst jedes Mal, wenn ich die Position der vertikalen Linie ändere, 5 Stellen im Programm ändern? Das liegt daran, dass die Programmliste, die ich bisher gezeigt habe, "zu spezifisch" ist.

Das Gegenteil von konkret ist abstrakt, und um konkrete Informationen abstrakt zu machen, muss die Informationsmenge reduziert werden.

Was bedeutet es, die Informationsmenge zu reduzieren? Lassen Sie uns hier zuerst über das Erhöhen von Informationen und das Verringern von Informationen im Gegenteil nachdenken.

Je mehr Informationen Sie haben, desto spezifischer werden sie im Allgemeinen. Wenn Sie beispielsweise die Informationen "Akita-Hund" oder "Shiba-Hund" zu den Informationen "Hund" hinzufügen, beschreiben Sie eine spezifischere Hunderasse. Wenn wir andererseits die spezifischen Informationen über Hunde aus dem Begriff "Hunde" reduzieren, erhalten wir abstraktere Konzepte wie "Säugetier", "Wirbeltier", "Tier" und "lebender Organismus".

Zurück zum Programm: Was wäre, wenn Sie die fünf oben aufgeführten Teile schreiben könnten, zum Beispiel:

rect(Vertikale Linie x Koordinatenwert,0,   500-Vertikale Linie x Koordinatenwert,0  ); //7. Zeile
line(Vertikale Linie x Koordinatenwert,0,  Vertikale Linie x Koordinatenwert,    500); //11. Zeile
line(Vertikale Linie x Koordinatenwert,100, 500,                 100); //12. Zeile

Wenn Sie es so schreiben, müssen Sie es nicht ändern, auch wenn Sie irgendwo eine vertikale Linie zeichnen. Mit anderen Worten, wenn das folgende Programm zulässig ist, kann es anscheinend überall dort eingesetzt werden, wo vertikale Linien gezeichnet werden:

// pseudo vertical comp-position ver.3
background(250,245,230);
size(500,500);
noStroke();
fill(0,80,255); // blue
rect(Vertikale Linie x Koordinatenwert,0, 500-Vertikale Linie x Koordinatenwert,0);
strokeWeight(10); stroke(0,0,0);
// draw a vertical line
line(Vertikale Linie x Koordinatenwert,0,Vertikale Linie x Koordinatenwert,500);
// draw a horizontal line
line(Vertikale Linie x Koordinatenwert,100, 500,100);

Tatsächlich funktioniert das obige Programm nicht so wie es ist. Warum funktioniert es nicht? Sie können dies sehen, indem Sie auf der Seite des Computers stehen und über die tatsächliche Verarbeitung nachdenken. Zum Beispiel gibt es in Zeile 7 ein Programmstück namens "rect (vertikale Linie x Koordinatenwert, 0, 500-vertikale Linie x Koordinatenwert, 100);". Rect war eine Funktion zum Zeichnen eines Vierecks, aber wo auf der Leinwand sollte ich ein Viereck zeichnen? Es heißt "Wert der x-Koordinate der vertikalen Linie", aber wo soll ich sie "spezifisch" zeichnen?

Nicht nur für die Verarbeitung, sondern auch für die Programmausführung sind bestimmte Werte erforderlich. In der Rect-Funktion im obigen Programm können wir schließen, dass dieses Programm nicht funktioniert, da wir den "konkreten Wert" des Teils nicht kennen, der als "Wert der x-Koordinate der vertikalen Linie" bezeichnet wird.

Ich kann das Gefühl voll verstehen, dass "deshalb ich den Wert 350 geschrieben habe". Aber das sind zu spezifische Informationen als Argument für die Funktionen rect und line. Was ist, wenn zum Beispiel die Beschreibung "Der Wert der x-Koordinate der vertikalen Linie ist 350" im Programm gemacht wird, anstatt einen konkreten Wert in das Argument der Funktion zu schreiben? Mit dieser Methode, rect oder Es wird auch klar, wo eine gerade Linie oder ein Rechteck auf dem Bildschirm gezeichnet werden soll, ohne einen bestimmten Wert als Argument für die Linienfunktion zu verwenden.

Wenn Sie es programmgesteuert schreiben, sieht es folgendermaßen aus:

// pseudo vertical comp-position ver.3
background(250,245,230);
size(500,500);

noStroke();
fill(0,80,255); //blaue vertikale Linie

Der x-Koordinatenwert beträgt 350// <---Spezifische Wertinformationen! 
rechte vertikale Linie(x Koordinatenwert,0,Vertikale Linie 500-x Koordinatenwert,100); 
strokeWeight(10);
stroke(0,0,0);

// draw a vertical line
Linie vertikale Linie(x Koordinatenwert,0,Vertikale Linie x Koordinatenwert,500);

// draw a horizontal line
Linie vertikale Linie(x Koordinatenwert,100, 500,100);

Das Programm erhält in Zeile 8 einen bestimmten x-Koordinatenwert. Theoretisch funktioniert es also. Tatsächlich haben wir genügend Informationen über den Programmfluss und die für das Programm benötigten Informationen, aber die Verarbeitung versteht die Sprache, die wir jeden Tag verwenden (natürliche Sprache), nicht. "Der x-Koordinatenwert der vertikalen Linie beträgt 350. Selbst wenn "Ja" angezeigt wird, kann es nicht verarbeitet werden.

Im nächsten Abschnitt wird beschrieben, wie dies auf eine Weise beschrieben wird, die die Verarbeitung verstehen kann.

Programm, das das Ändern der Position vertikaler Linien unterstützt

Das Problem mit der obigen Programmliste war der auf Japanisch geschriebene Teil "Der x-Koordinatenwert der vertikalen Linie beträgt 350". Selbst wenn Sie im Verarbeitungseditor (dem Teil, in dem Sie das Programm eingeben) Japanisch eingeben, werden die Zeichen zunächst verstümmelt, sodass Sie diese Informationen ohne Verwendung von Japanisch schreiben müssen.

Wenn beispielsweise "der Wert der x-Koordinate der vertikalen Linie" px ist, kann der Satz "der Wert der x-Koordinate der vertikalen Linie ist 350" als "px ist 350" umgeschrieben werden. Warum px? Sie können Zweifel haben. Das Fazit ist, dass ich die richtige Entscheidung getroffen habe. Jede Zeichenfolge, die mit einem Alphabet oder einem Symbol beginnt, das als Unterstrich bezeichnet wird, ist in Ordnung, aber ich habe sie als Bedeutung von Position x px genannt.

Der Prozess "px ist 350" wird als px = 350 geschrieben. In der Mathematik bedeutet die Beschreibung px = 350 auch, dass px "gleich" zu 350 ist, aber in der Verarbeitung bedeutet das Gleichheitszeichen ('=' gleich) "Zuweisung".

Wenn a = 1 ist, wird a auf 1 gesetzt (Ersatz), und wenn a danach geschrieben wird, ist es dasselbe wie 1.

Damit

px=350;
rect(px,0, 500-px,100);

Das Programm ist

rect(350,0, 500-350,100);

Es wird die gleiche Operation sein wie.

Wenn Sie dann px = 350 schreiben möchten, müssen Sie im Programm etwas mehr schreiben. Selbst wenn Sie einfach px = 350 schreiben, befindet es sich im Status "Was ist px überhaupt?".

Nun, es gibt einige Sprachen, die dies nicht tun, aber in der Java-Sprache, mit der wir uns in dieser Serie beschäftigen, stellen sich am Ende die Fragen: "Was ist px überhaupt?"

px sollte angeben, dass es sich um ein Symbol handelt, das den Wert darstellt - hier eine Ganzzahl -. Schreiben Sie dazu int px; Das Wort int kommt von der Ganzzahl, was Ganzzahl bedeutet.

Sie können Ihrem Computer mitteilen, dass die Notation px eine Ganzzahl darstellt, indem Sie int px; Also wer ist px? Das Weitergeben der Informationen an den Computer wird als "Deklaration" bezeichnet. Sobald Sie dem Computer mitteilen (deklarieren), können Sie px einen Wert zuweisen, sodass Sie px = 350 schreiben können, und so weiter.

Im eigentlichen Code

int px;
px=350;

Es ist wie es ist.

Natürlich ist der Wert nicht auf 350 beschränkt, sondern kann 349 betragen.

int px;
px=349;

Es ist auch möglich, zum Zeitpunkt der Deklaration einen Wert zuzuweisen (zuzuweisen). In diesem Fall,

int px=350;

Und so weiter.

Mit dem bisherigen Wissen ist es nun möglich, ein abstraktes Zeichenprogramm mit dem Ausdruck px zu schreiben. Wenn Sie px verwenden und das Programm wie folgt ändern, handelt es sich um ein Arbeitsprogramm:

// vertical comp-position ver.4
background(250,245,230);
size(500,500);

noStroke();
fill(0,80,255); // blue

int px=350; // <---Spezifische Wertinformationen!

rect(px,0, 500-px,100);

strokeWeight(10);
stroke(0,0,0);
line(px,  0, px, 500); // draw a vertical line
line(px,100, 500,100); // draw a horizontal line

Dieses Programm unterstützt das Ändern der Zeichenposition vertikaler Linien. Ändern wir also den Wert von px in Zeile 8 - zum Beispiel extremer - auf 100:

// vertical comp-position ver.5
background(250,245,230);
size(500,500);

noStroke();
fill(0,80,255); // blue

int px=100; // <---Geändert von 350 auf 100

rect(px,0, 500-px,100); 11

strokeWeight(10);
stroke(0,0,0);
line(px,  0, px, 500); // draw a vertical line
line(px,100, 500,100); // draw a horizontal line

Was ist eine Variable?

Mit der obigen Programmliste können Sie die generierte Arbeit jetzt (bis zu einem gewissen Grad) ohne großen Aufwand frei ändern, dh indem Sie einfach den Wert ändern, der px zugewiesen ist. Selbst wenn Sie den px zugewiesenen Wert ändern, müssen Sie ihn nach der 10. Zeile des Programms nicht mehr ändern.

Was genau bedeutet das? Die Programme ab der 10. Zeile haben einen gewissen Abstraktionsgrad. Beispielsweise ist die vertikale Linie eine abstrakte Linie (px, 0, px, 500), sodass eine vertikale Linie gezeichnet wird, deren Koordinatenwert von x px ist. Es ist programmiert.

Es wird als abstrakter Prozess geschrieben. Selbst wenn px ein ganzzahliger Wert wie 350 oder 100 zugewiesen wird, wird der Prozess ohne Fehler ausgeführt.

Was genau ist px für ein abstrakt geschriebenes Programm? Manchmal ist es ein Wert von 350 (ein ganzzahliger Wert), und manchmal ist es ein Wert von 100.

Für Programme in Zeile 10 und darüber hinaus ist px nichts anderes als eine sich ändernde Nummer, eine sich ändernde Nummer. Diese sich ändernde Zahl px wird als "Variable" bezeichnet.

Deklarationen wie int px; werden manchmal als "deklarieren Sie die Variable px" bezeichnet (dasselbe gilt für das Programmstück int px = 300;).

Es können mehrere Variablen vorhanden sein

Bisher haben wir die Variable px beschrieben. Wenn mehrere Größen / Werte abstrakt behandelt werden müssen, werden mehrere Variablen verwendet.

In gängigen Programmiersprachen stehen mehrere Variablen zur Verfügung. Natürlich auch die Verarbeitung.

Im Folgenden beenden wir dieses Kapitel, indem wir eine Variable hinzufügen, die die Position der Breite darstellt, und ein Programm anzeigen, mit dem Sie Bilder freier erstellen können.

Für die y-Koordinate der horizontalen Linie verwenden wir eine Variable namens py. Dies liegt daran, dass die Variable für die x-Koordinate der vertikalen Linie px war, daher habe ich sie nur py genannt, da es sich um einen ähnlichen Namen handelt. Die y-Koordinate der horizontalen Linie ist auch die Höhe des Vierecks, sodass der Variablenname h akzeptabel sein kann.

Natürlich funktionieren auch andere Variablennamen wie zzz. Die Variablennamen gelten jedoch nicht für den Computer, sondern für uns Menschen, die die Programmliste lesen. Daher sollte es so greifbar wie möglich sein (die Programmliste ist leichter zu lesen).

Unten finden Sie eine Liste von Programmen, die die Positionen der vertikalen und horizontalen Linien mithilfe der Variablen px und px tatsächlich abstrahieren:

// a study for vertical comp-position blue and white
background(250,245,230);
size(500,500);

noStroke();
fill(0,80,255); // blue

// position cofiguration
int px=380;
int py=300;

rect(px,0, 500-px,py); // draw a rectangle.

strokeWeight(10);
stroke(0,0,0);
line(px, 0, px, 500); // draw a vertical line.
line(px,py, 500, py); // draw a horizontal line.

Und das von diesem Programm erzeugte Bild ist Es wird wie folgt sein:

Spalte: Variablennamen sind wichtig (für Menschen)

Es ist sehr schwierig, das Programm einer anderen Person zu lesen (zu entschlüsseln / zu verstehen). Versuchen Sie daher, das Programm für andere benutzerfreundlich zu gestalten, z. B. so aussagekräftige Variablennamen wie möglich. Ihre Freundlichkeit wird Sie sicherlich retten.

In der Programmier-Community gibt es den Satz "Ich war vor drei Monaten eine andere Person". Beim Erstellen eines Programms können Sie selbst erstellten Code verwenden oder auf diesen verweisen. Selbst wenn es sich um ein selbst erstelltes Programm handelt, verblasst nach 3 Monaten die Erinnerung, als ich es erstellt habe, und es fühlt sich an wie ein Programm, das von einer anderen Person erstellt wurde, auch wenn es sich um einen selbst erstellten Code handelt, um es zu lesen Ist ein Wort, das bedeutet, dass es genauso viel kostet wie der Code eines anderen.

Versuchen Sie daher, einen beschreibenden Variablennamen anzugeben, der die Funktion und den Inhalt der Variablen so gut wie möglich darstellt. "Mitleid ist nicht gut für Menschen" gibt es auch in der Programmierwelt.

[JAVA] Einführung in die Programmierung für Studenten: Variablen