Transkripte
1. Einführung: Hallo Leute und willkommen. Ich heiße Michael.
Ich bin Fotograf, Kameramann
und Physiker. Und in diesem Kurs werde
ich mit
euch einige Tipps und
Tricks untersuchen , mit denen ihr
definitiv
euer Programmieren oder
Programmieren verbessern könnt definitiv
euer Programmieren . Stufe. Rise wird
sich hauptsächlich mit Java befassen. Und dieser Kurs richtet sich an fortgeschrittene Personengruppen. Das bedeutet, dass Sie
ein grundlegendes Verständnis
davon haben , was Java ist. Aber wir entwickeln immer noch
einige Grundlagen damit. Habe gerade eine Zwischenstufe gemacht. Es gibt also ein bisschen Hintergrundwissen, das
Sie haben müssen. Und ich hoffe, wir sehen uns
in der nächsten Lektion.
2. Bedingte Aussagen: Okay Leute, ich freue mich,
dass du hier bist. Und nur zur Erinnerung, dass in
diesem Kurs davon ausgegangen wird, dass Sie bereits einige Grundlagen
des Programmierens in Java haben, oder? Und was wir tun werden, ist, dass
wir
hier mit bedingten
Anweisungen beginnen , genau hier, genau
hier oben, bedingte Anweisung. Und denk daran, dass das genau dort ein
Kommentar ist. Und wir
beginnen besonders mit der if-else-Anweisung. Wenn Dadadadada bedeutet, dass wir dort drüben eine
Bedingung stellen, und dann sagen wir
etwas anderes dort drüben. Und dann setzen wir auch eine Bedingung dafür was passieren sollte, oder? Und inhärent
ist Java durchaus in der
Lage, eine ganze Reihe logischer Bedingungen
aus der Mathematik zu
unterstützen , oder? Ob es logische
Bedingungen sind wie vielleicht etwas wie weniger als, sagen
wir weniger als. Und denken Sie daran, dass
wir , wir zeigen, mathematisch
gesehen, weniger durch etwas
des folgenden Szenarios getan werden. Wir sagen zum Beispiel, a ist kleiner als
b, oder? Und dann könnten wir ein anderes Szenario
haben , in dem wir weniger
als oder gleich haben , oder? Und das müsste natürlich wie folgt sein,
wobei wir sagen müssten, dass
a vielleicht kleiner oder gleich b ist. Dann könnten wir auch
ein Szenario haben, über das wir sprechen
größer als, größer als, was dann als a
größer als b bezeichnet
werden würde . Und Sie können definitiv in der
Lage sein, oben zu verfolgen, was ich sagen
werde ein x
größer oder gleich, was dann wäre
auf die folgende
Weise bezeichnet oder gezeigt werden, wobei wir sagen, dass dasselbe Muster
größer oder gleich b ist. Dann könnten wir auch ein Szenario
haben, in dem Sie davon sprechen, dass es gleich etwas ist und wie wir das
bezeichnen, wie wir sagen, a ist gleichbedeutend mit der Tatsache, lassen Sie mich das einfach tun. Nun, ich sage, a ist
gleich a ist gleich b,
nicht, und ich wiederhole nicht. A ist gleich b. Die Kodierung
a ist gleich b bedeutet , dass Sie sagen, dass a durch b ersetzt werden
soll. Es bedeutet gleich, bedeutet
wörtlich Einfügen. Sie sehen, aber wenn Sie gleich, gleich
sagen, bedeutet das, dass Sie sich
tatsächlich auf
die mathematische Notation beziehen oder gleich, oder? Was
möchten Sie
vielleicht in das Szenario
der Bedingungen setzen . Dann könnten Sie andernfalls
zeigen, dass etwas
nicht gleich etwas ist ,
indem Sie nicht gleich sagen. Und dann nehmen wir das
und sagen, a ist gleich b. Es gibt
also auf jeden Fall eine
ganze Reihe von Bedingungen
, die Sie auf jeden Fall nutzen können. Und basierend auf dem, was
Sie möchten, können
Sie mit
verschiedenen Aufführungen oder
Aktionen herauskommen , um dies zu erreichen, in Ordnung? Und eine andere Sache, die Sie
vielleicht beachten
sollten, ist, dass Java selbst die folgenden
bedingten Anweisungen hat. Also hier sind sie
bedingte Anweisungen. Aus Java selbst. Wir haben eine if-Bedingung. Wir haben die
if-Bedingung, Bedingung. Und was soll das tun? Dies dient dazu, einen
Code anzugeben, der ausgeführt werden soll. So einfach ist das wirklich. Wenn eine angegebene
Bedingung wahr ist, wenn die Bedingung wahr ist, oder? Also würde man im Wesentlichen in der Lage sein, diese Wenn-Bedingung zu haben, oder? Und lassen Sie mich erlauben, es
hier einfach in diese beiden Klammern zu
setzen , damit
es selbst
als Bedingung hervorsticht . Man kann es nicht so
verwechseln, als wäre es nur ein
fortlaufender Satz. Nein. Wir nutzen if, um das zu können. Ich könnte das sogar hier verwenden. Wir verwenden f, um dies zu tun, und dann könnten
wir auch else verwenden, um einen Code
anzugeben, der ebenfalls ausgeführt werden soll. Okay, lass mich das einfach machen. Aber wenn eine Bedingung
falsch ist, siehst du das? Also hier ist das perfekt. Wenn die Bedingung wahr ist, bedeutet
nichts anderes, dass
die Bedingung falsch ist. So benutzt man es also. Und dann könnten wir auch über else if
sprechen, was auch eine Bedingung ist. Deshalb sollte
ich eine Klammer anbringen. Sonst, wenn wir else if verwenden. Und der Zustand
ist Zustand. Und dann wollen wir eine zu testende Bedingung
angeben. Muss getestet werden. Das ist, wenn die Bedingung falsch
ist, oder? Was also
normalerweise passiert, ist, dass wahrscheinlich zuerst so etwas
wie diese Bedingung auftreten
würde, was die if-Bedingung ist. Und dann
hätte als nächstes anders-wenn. Und dann
hätten wir endlich diesen anderen. Das heißt, wenn alle Bedingungen
eintreten, dann gehen wir endlich zu den anderen. Das ist normalerweise die Reihenfolge
, in der man sich Sorgen machen würde. Wir werden uns auf jeden
Fall kurz danach damit befassen. Dies ist nur eine Präsentation
dieser Methoden. Und dann haben wir auch eine
Switch-Bedingung, die
verwendet wird, um zu spezifizieren, dass es dort eine
Bedingung gibt, oder? Tippfehler, der
definitiv verwendet wird, um anzugeben, wie
viele, viele alternative
Codeblöcke ausgeführt werden sollen. Dies ist sehr praktisch, insbesondere in Bezug auf
maschinelles Lernen oder Data Science oder
irgendetwas davon. Sie werden feststellen, dass Sie
dies wirklich oft verwenden,
nur um tiefer in
die gesamte Idee
der if-Anweisung einzutauchen nur um tiefer in . Lassen Sie mich Ihnen ein bisschen etwas
Interessantes geben, Garrett. Schauen wir uns das Folgende
an. Sagen wir einfach, wir schauen uns
an, ob jetzt der Zustand ist. Und mit dieser Wenn-Bedingung schreiben
wir das.
3. Wenn bedingte Aussagen: Was wir tun werden ist, dass
wir
hier einfach eine Bedingung
stellen und sagen ob. Und dann stellen wir unsere
Bedingung ein, wenn zum Beispiel drei größer als eins sind. Das ist ein Beispiel. Die Frage ist nun, wenn das
der Fall ist, was sollte passieren? Was sollte passieren,
wenn das der Fall ist? So könnte man es
zum Beispiel gemischt sagen, System. Denken Sie daran, es
richtig zu setzen. Punkt, Punkt, Druck, LN, drucken. Drucken wir eine Zeichenfolge, die besagt, dass die erste Zahl größer als die
zweite Zahl ist. Richtig? Also im Wesentlichen
sage ich meinem, meinem, meinem,
meinem, meinem Java hier,
wenn die erste Zahl, die drei ist, größer ist
als die zweite Zahl, wenn diese Bedingung wahr ist, dann sollte diese ausgedruckt werden. Das sollte ich sehen. Und wenn es falsch ist, ist
die Frage, ob es falsch ist, was sollte
dann passieren? Nun, nichts, weil
ich nicht gesagt , was
passieren soll, wenn nichts, wenn dieser Zustand falsch ist. Versuchen wir also einfach, das
auszuführen und sehen, dass Java in der Lage sein wird, das auszudrucken was wir erwarten, dass es ausdrucken wird. Die erste Zahl ist größer
als die zweite Zahl. Lassen Sie sich jetzt nicht
von dieser HelloWorld bewegen. Das liegt daran, genau hier. Ich könnte das einfach ganz
einfach löschen. Wir brauchen es nicht wirklich. Ehrlich gesagt. Ich könnte es noch einmal ausführen,
nur damit wir
davon überzeugt sind , dass wir
nur diese als
erste Zahl größer als die
zweite Zahl haben . Wirklich gut. Betrachten Sie also das
folgende Szenario. Ich, ich habe meinen hier
hingelegt und meine 3M. Lassen Sie uns nun vorhersagen
, was passieren sollte. Inhärent wissen wir, dass eins nicht größer als drei
ist. Und deshalb bedeutet das, dass diese
erste Bedingung nicht zutrifft. Und denken Sie daran, dass Code ausgeführt wird, wenn die
Bedingung verwendet wird, um einen Code
anzugeben , der wahr ist,
wenn diese Bedingung , der wahr ist,
wenn diese Bedingung wahr ist. Aber in unserem
Szenario hier ist
diese Bedingung
nicht wahr, oder? Also lass uns nichts sehen. Warum nichts? Das liegt daran, die Bedingung falsch ist.
Definitiv falsch. Aber dann fragt sich Java, wenn es falsch ist,
was soll ich als nächstes tun? Da wir nicht angegeben haben, was es als nächstes tun
soll, habe ich einfach nichts
zusammengefasst. Was wir tun sollten, ist
etwas anderes zu sagen. Wir könnten anders sagen, wenn,
oder wir könnten anders sagen. Aber ich fange mit „else“ an. Das heißt, wenn die erste
Bedingung nicht wahr ist, wenn sie falsch ist,
was sollte dann passieren? Da kommt sonst noch ins Spiel. Und dann sage ich system, out, dot, dot, out, dot, print LN. Und wir haben die erste Zahl, kleiner als die zweite Zahl. Also lass uns sehen, lass es uns jetzt ausführen. Im Wesentlichen
sagen wir, wenn dies falsch ist, sollte dies aufrechterhalten werden. Wenn diese Bedingung
nicht
zutrifft, bedeutet das offensichtlich, dass sie falsch ist. Und wenn es falsch ist, sollte
das hier getestet
werden, oder? Das heißt, wenn wir den ersten nicht
machen, werden
wir
sonst Folgendes tun. Also lass es uns ausführen und
sehen, was wir bekommen. Walla, erste Zahl,
kleiner als die zweite Zahl. Das stimmt definitiv,
laut dem, was wir hier sehen, ist
die erste Zahl kleiner
als die zweite Zahl. Und wir könnten mit
so vielen Werten herumspielen, wenn wir wollen. Wir könnten sogar mit 100
herumspielen. Und mal sehen 103,
welches ist größer? Es sind definitiv Hunderte, also bedeutet das, dass die
erste Zahl größer
sein sollte als
die zweite Zahl. Mal sehen. Voila, da ist es. Die erste Zahl ist größer als
die zweite Zahl, oder? Also das ist definitiv die
if-Anweisung da drüben, richtig.
4. Fehler, die mit bedingten Aussagen verbunden sind: Dann nimm einfach zur Kenntnis,
dass es einige Fehler gibt
, die die Leute machen werden. Nehmen Sie manchmal den Modus,
dass wenn Sie
Großbuchstaben verwenden , wenn
das so ist, das etwas
anderes bedeutet, dann geben wir Ihnen einen Fehler. Es ist sehr wichtig
, das zu beachten, oder? Sie können sich das also vorstellen, oder besser gesagt sogar Teslas, das
wir gerade hier gemacht haben. Nicht nur für Zahlen, man könnte sogar
auf Variablen testen. Was ist,
wenn Sie zum Beispiel Variablen hinzufügen, sagen
wir, dass int x gleich 25
ist. Und ich sage int y ist gleich 79. Dann anders als richtig,
Semikolon da drüben. Und dann habe ich
die Bedingung gestellt. Jetzt öffne ich einfach die
Klammer und sage zum Beispiel, dass x kleiner als y
ist. In Ordnung? Wenn das der Fall ist, was sollte
dann passieren?
Das sollte passieren. System. Dann sage ich
dot out dot print LN. Und deshalb
sagen wir einfach, dass x größer ist. Nehmen wir an, x ist kleiner als, x ist kleiner als
y. Wenn das zum Beispiel stimmt, wenn das stimmt, wenn das
stimmt, dann ist das der Fall. Was
sagen wir nun voraus? Nun, inhärent können wir
sehen, dass x definitiv kleiner als y ist, weil
x 25 und y 79 ist. Und deshalb erwarten wir
, dass wir dort drüben sehen , das sollte
wahr sein.
Das stimmt. Wenn diese Bedingung
zutrifft, wird diese gedruckt und sie ist wahr. Deshalb erwarten wir
,
dass x kleiner ist als y. Das erwarten
wir. Denken Sie daran,
dass
wir dies in
Kommentare aufnehmen möchten, um sicherzustellen , dass wir keine
Antworten von der vorherigen
Sache erhalten . Wir wollen nur diesen
Teil und das X von Viola Data ist kleiner als y, oder? Fantastisch. Ich hoffe, dass es für euch
Sinn ergibt. Es steht das
Wichtigste geschrieben.
5. Sonstige Erklärung: Und dann werden
wir einfach schnell
weitermachen und sehen, ob wir einfach
die L-Anweisung einschalten können . Okay, wir verstehen
die else Aussage
nur noch weiter. Der Fokus lag hauptsächlich
auf dem F. Jetzt
konzentrieren wir uns hauptsächlich auf
die else Aussage. Wie ich bereits erwähnt habe,
wird
die else-Anweisung nur verwendet, um einen Codeblock anzugeben ,
der ausgeführt werden soll, wenn die
Bedingung falsch ist, oder? Sie können sich das also vorstellen, sagen wir zum Beispiel, wir würden Ende sagen
und dann sprechen wir über Zeit. Das entspricht vielleicht
40 Minuten, oder? Und wir sagen dann, wenn die Zeit weniger als 60
Minuten beträgt, eine Stunde, oder? , wenn die Zeit weniger als Was sollte passieren, wenn die Zeit weniger als
60 Minuten beträgt? Nun, wenn das der
Fall ist, bin ich früh dran. Der Student ist LE vielleicht, wenn dies ein
Fall war, in dem ein Student zu
spät zu einer Prüfung kommt, sei es 40 Minuten zu früh, oder eher 40 Minuten zu
spät oder 60 Minuten. 60 Minuten über die Zeit hinaus. Offensichtlich
wird der Student weggehoben, aber es ist nur eine Frage, welcher zwischen den beiden besser ist. Also würden wir wahrscheinlich
etwas drucken wie, hey, wenn die Zeit weniger
als 60 Minuten ist, dann kommt der Student
nicht so spät. Wisse, ob das ratsam ist, aber hoffentlich kommt der Student
überhaupt nicht zu spät. Der Student kommt nicht so spät. Das heißt, wenn es weniger
als 60 Minuten sind. Und mal sehen. Denken Sie daran,
das liegt daran, dass der erste hier erscheint,
weil wir keine Kommentare hinzugefügt haben. Lassen Sie mich einfach Kommentare
abgeben und dann können wir uns
ohne Ablenkung
auf den zweiten konzentrieren . Da ist es also versteckt und der Student ist nicht so
hier, wie wir es sehen können. liegt daran, dass
die Variable hier, was Java tut, ist
, dass es versteht. Erinnern Sie sich, wir haben darüber gesprochen,
wie das Gleichheitszeichen und im Wesentlichen nur bedeutet,
fügen Sie alles ein, was
ich sehe im Wesentlichen nur bedeutet,
fügen Sie alles ein, was
ich sehe,
Zeit, ich habe 40 in die Zeit eingefügt , wenn Java Zeit
erwähnt wird, Java versteht schnell,
dass Dies ist nicht wirklich Zeit. Dies ist nicht wirklich die
Zeit,
über die wir sprechen , 40 ist, wenn die ganze Zahl, alle ganzen Zahlen für t ,
und daher ist der Student gemäß einer Bedingung,
die wir hier haben einer Bedingung,
die wir hier haben, nicht tot gelegt. Und dann optimieren wir es. Wir optimieren es. Wie optimieren wir es? Wir sagen jetzt anders, wir sagen jetzt anders. Sonst. Dies bedeutet, dass der Student zu spät kommt, wenn diese Bedingung nicht eingehalten wird. Freundin Ellen, die Studentin ist spät dran. Dies würde im
folgenden Szenario gelten. Stellen Sie sich vor, ich würde sagen, welche Alia wird Minuten zu spät
oder 40 Minuten zu spät
gedruckt? Welches ist relativ wie Ellie, offensichtlich 20 Minuten, oder? Daher ist der Student jetzt der Hauptdarsteller, wenn er
40 Minuten zu spät kommt. Zum Beispiel bedeutet in unserem
Szenario hier, dass in also für t weniger als 20 ist, nein, das sagen
wir hier. Die Bedingung ist, wenn für
t kleiner als 2040 ist, dargestellt durch die Zeit,
die Variable der Zeit. Wenn das der Fall ist, wird das gedruckt. Aber das stimmt nicht. Was jetzt wahr ist, ist, dass
für t größer als 20 ist, und daher fällt das in die else Anweisung,
weil es hier falsch ist, und daher wird alles, was
hier falsch ist , hier unten ausgeführt. Lassen Sie es uns ausführen und sehen, dass wir vorhersagen, dass der Schüler zu spät kommt, voila. Da ist es. Da haben wir es. Der Student ist spät dran. Wunderschönen. Ich hoffe, es ergibt einfach noch
mehr Sinn für euch.
6. Else..if Conditional: Geh schnell ins Andere. Lassen Sie mich
das einfach als üblich bezeichnen. Die sonst, wenn das die
ELF ist, die Else-wenn-Bedingung. Und mit der Else-if-Bedingung ist das, was hier
wirklich
passiert , das, was hier tatsächlich
passiert ,
dass wir das
folgende Szenario haben, oder? Da. Wir haben es zum Beispiel, wir werden genau das anwenden,
was wir gerade hier getan haben. Nehmen Sie es einfach mit
, um viel besser zu verstehen. Lassen Sie mich diesen einfach in Kommentare schreiben, weil wir ihn
nicht mehr brauchen. Ich könnte das immer
buchstäblich nur trösten und
ja, es ist okay. Wir haben also kein Szenario
verfolgt. Denk jetzt darüber nach. Was
ist, wenn die Zeit weniger als zehn ist, dann wird dies
LE oder vielleicht Guten Morgen drucken .
Lass uns das ein bisschen ändern. Nur um zu verstehen. Besser. Zum Beispiel Nachmittag. Oder anders hier ist es Abend. Abend. Es bedeutet, dass unabhängig von der
Zeit, die ich hier habe, es eine ziemlich binäre Situation ist. Wenn es weniger als zehn ist, ist
die Zeit weniger als
zehn, es ist Morgen Zeit. Wenn es größer als zehn ist, auch im Feuer automatisch. Richtig? Aber dann kommt das andere
wenn und sagt:
Hey, was ist, wenn ich etwas anderes sagen will? Wenn? Sagen wir anders-wenn. Und dann setzen wir unseren
Zustand ein und wir Zellen wenn die Zeit kürzer ist als, was ist, wenn es nur
weniger als 30 Minuten sind? Nun, in diesem Fall lässt
du mich einfach diese Zeile
hier kopieren , damit wir sie nicht jedes
Mal schreiben
müssen , wenn wir sie sehen. Dann wäre hier
nur der Nachmittag. Nachmittag. Was hier also buchstäblich
passiert , ist, dass wir sagen, wenn die Zeit weniger als
zehn ist, ist es Morgen. Wenn es weniger als 30 Uhr
nachmittags ist. Und wenn es größer ist als was? Als T, was bedeutet, dass es nicht weniger als zehn und
nicht weniger als 30 ist, dann bedeutet es definitiv, dass es
größer als Theta ist, oder? Und Sie fragen sich wahrscheinlich,
warum wir den LCF brauchen würden? Nun, du siehst, wenn du es
schaffst, wenn dann sonst, es ist eine sehr willkürliche oder eher
eine sehr binäre Situation, schränkt dich so sehr ein,
weil es wirklich eine Option ist, eine, die ich sein werde. Aber das Schöne
an else-if ist, dass Sie damit weitere Bedingungen hinzufügen
können. Daher können Sie beliebig viele Optionen a, B,
C, D, E
hinzufügen . Sie können so viele
Wenns hinzufügen, wenn Sie möchten. Nun, wenn ich eine Zeit habe, sagen
wir mal, dass ich eine
Zeit hatte, war das was? Buchstäblich fünf. Vielleicht. Wenn ich fünf habe, heißt das, dass
es weniger
als zehn sind, oder? Die erste Bedingung
ist erfüllt. Es bedeutet, was in Java läuft
, könnte man mir sagen, aber dann ist fünf auch
weniger als 30, E13. Drucken Sie diese Nachricht aus. Nun, wenn Java es ausführt, fängt
er
buchstäblich von
hier aus andere Sachen an, schaut hier nach. Stimmt das oder nicht? Und wenn es dann nicht
stimmt, macht er weiter. Aber wenn es dann wahr ist, dann wird Java einfach den Code
ausführen , der da drin
ist, der definitiv hier richtig ist, oder? Aber wenn es größer ist
, wird es hierher kommen. In diesem Szenario haben wir also
vorausgesagt, dass wir uns
im ersten Szenario befinden werden. Daher erwarten wir, dass
es uns morgen über das Geld und die Daten informiert. Das liegt daran, dass es lief
dieses erste ist, beachte, dass hey, fünf ist weniger
als zehn, also Geld. Aber was ist, wenn ich plus zehn hinzufüge? Jetzt 15 draus machen? Jetzt sind es mehr als zehn. Es bedeutet, dass es das
erste Jahr überprüft und überprüft und sagt:
Hey, das ist falsch,
das ist nicht wahr. Und
was macht es, wenn es das tut? Es überspringt und geht hierher und
überprüft, ob Hühner hier sind. Was ist mit dieser Gegend? Sonst, wenn die Zeit weniger als 30
ist, ist es 15 weniger als 30. Und da steht: Ja, das ist es. Und deshalb wird
es am Nachmittag gedruckt. Also lass es uns ausführen und sehen. Da ist es Nachmittag. Und auf jeden Fall wahr, in der Lage, den Trend zu erkennen, wenn ich ihn erhöhen
würde indem ich hier drucke und ihn jetzt
einfach besser machen würde, bedeutet das, dass Sie zuerst
hier nachschauen und sagen werden :
Ist das eine Fünf weniger als eine Kurve? Es wird sagen
, dass das möglich falsch ist. Und dann mach weiter und überprüfe fünf weniger als 13 auch
nicht wahr sind. Und dann sagst du
jetzt auch einfach falsch. Dann wird es endlich
zu dem anderen hier kommen und sagen, wenn dieser nicht
zufrieden ist und
dieser nicht zufrieden ist, dann wird er
sich hier definitiv festigen. Daher wird das hier wahr
sein und wir sagen
daher voraus, dass unser
Code hier ausgeführt wird, unsere Zeichenfolge hier angezeigt wird,
unser Text, der
hier angezeigt wird, was ist? Abend. Also lass es uns
ausführen und sehen. Und voila, da ist es. Also ich hoffe, das hat
euch geholfen und ich werde jetzt zu einer anderen Sache
übergehen.
7. Der ternäre Operator: Richtig? Die nächste, die
wir
untersuchen werden, ist immer noch eine bedingungslose Aussage, aber ich möchte Ihnen
nur zeigen wie Sie
mit den gesamten, wenn sonst
bedingten Anweisungen umgehen . Und das hier bringt
uns zu dem, was wir nennen, ich werde
den ternären Operator verwenden. Und mach dir keine Sorgen. Wir
werden das in Kürze erklären, aber es heißt Java. Lass es mich einfach
mal abkürzen. Wenn sonst. Okay, das ist der
Java-Schuss und das Böse. Es ist also eher eine Abkürzung die im Wesentlichen ein ternärer
Operator ist. Und Sie
fragen sich wahrscheinlich, was der Bediener selbst hört. So buchstabieren wir es. Es ist ein ternärer Operator. Und ein ternärer Operator ist
wirklich nur ein ternärer
Operator, weil er aus drei Operanden besteht. Operanden sind, du wirst sie in Kürze
sehen wie ich, da ich ihnen eine SMS schreiben werde. Denken Sie also über das
folgende Szenario nach, das wir hatten. Denk so darüber nach. Nehmen wir an, Sie hatten
so etwas wie Ende und Zeit, wie wir es im ersten
Szenario getan haben, und wir haben diesem zum Beispiel einen Wert
von 30
gegeben. Und dann sag, wenn die Zeit kürzer
ist als Twain t, was
dann passieren sollte, was sollte passieren, wir
sollten es ausdrucken, oder? Was soll es ausdrucken? Vielleicht so etwas wie ein guter Tag. Oder was sollte passieren, wenn das nicht der
Fall ist? Also schreiben wir anders
und dann sagen wir, das ist buchstäblich das,
was wir gerade getan haben. Wir könnten
den Druck ausdrucken und jetzt könnten
wir
vielleicht einen guten Abend ausdrucken. Ja, das ist gut, wir haben bereits darüber gesprochen und nichts ist jetzt besonders
gestört zumindest weil wir es
schon einmal gemacht haben. Und ich werde auf jeden Fall ein guter Abend
sein , denn 30 ist größer als 20. Das ist ein langer Weg, auf diese Weise zu
schreiben. Verwenden ternärer Operatoren oder wirklich diese Kurzregel
, die wir verwenden werden. Sie können einfach
all das ersetzen , anstatt es so zu
schreiben Sie könnten es buchstäblich so
schreiben
und einfach sagen, dass Endzeit ein gleichwertiges Werkzeug
ist. Lassen Sie mich sie hier einfach in den
Operator setzen und sagen, dass die
Endzeit gleich drei ist, wie wir im vorherigen Fall gesagt haben. Und dann ändern wir
diese Bettscherdehnung. Und dann sagen wir Ergebnis. Und dann sagen wir, es ist gleichbedeutend
mit Zeit, okay, was weniger als t ist. Dann wir buchstäblich von dort setzen
wir buchstäblich von dort
drüben ein
Fragezeichen. Einfach so. Und wir
setzen das Fragezeichen. Wir haben sogar das hier,
wo wir sagen: Guten Tag. Einfach so, setze sogar einen Punkt. Und wir brauchen nicht
unbedingt unbedingt einen Hund, es ist nur der Mittelwert
, einen Punkt zu setzen. Und dann könnten wir auch
so etwas wie
Guten Abend hier haben . Aber nur als String, denn so definieren
wir das. Es ist eine Zeichenfolge. Abend. In Ordnung? Dann schließen wir
es einfach so. Wie Sie sehen, liegt
kein Fehler vor. Es bedeutet also Darwins Leben. Ich verstehe, was du sagst. Und dann habe ich einfach einen
seltsamen Druck und ein Ergebnis eingegeben. Anstatt
es also so weit zu schreiben, wie Sie sehen können,
dauert es wie viele Zeilen? 12345 hier, drei Zeilen. Wahrscheinlich fragen wir uns, warum wir, was ist der Sinn, wenn es
dasselbe mit dem Punkt macht ? Nun, je mehr Sie wirklich
eingehend mit der gesamten Codierung befassen, werden
Sie feststellen, dass Sie
manchmal sich
wirklich
eingehend mit der gesamten Codierung befassen, werden
Sie feststellen, dass Sie
manchmal Tausende
von Zeilen finden, die Sie sehen. Es ist also
manchmal einfacher, wenn Sie
abgekürzte Formen dieser
Zeilen oder Codes finden können , oder? Also lass uns nochmal sehen,
guten Abend. Siehst du das? Also
das stimmt, es gibt eine Anwendung
der Kurzschriftenregel oder des ternären Operators, oder?
8. Bedingte Anweisungen wechseln: Das bringt uns dann
zum nächsten Punkt. Lassen Sie mich nur ein paar Kommentare abgeben. Unser nächster Punkt
hat mit
der bedingten
Anweisung von switch zu tun . Switch-bedingte Anweisung. Für solche bedingten
Anweisungen verwenden
wir sie also, um einen von
vielen Codeblöcken auszuwählen , die ausgedrückt werden
sollen. Wie es funktioniert ist so. Funktionsweise
ist im Wesentlichen so. Hier ist ein Fehler, weil dieser
Typ hier unten sein sollte. Ja. Ja, gut. Sturmhaus, was
im Wesentlichen funktioniert. Es ist so, oder? Den Schaltercode, lass
mich das einfach eintragen. Wir werden hier
einige Kommentare abgeben. Der Suchcode. Vielmehr
wird der Switch-Ausdruck ausgewertet, oder? Was ist der Wert
des Ausdrucks wird
mit den Werten der einzelnen Fälle verglichen. Ordnung, also Vergleich der
Werte für ist der
Vergleich der
Werte für jeden Fall abgeschlossen, oder? Dann haben wir auch,
wenn es eine Übereinstimmung gibt, wenn es
zum Beispiel eine Übereinstimmung gibt, haben
wir die dritte Stufe Wenn es eine Übereinstimmung gibt, wird
der Code ausgeführt. Und es gibt einige Wörter,
Stichwörter wie break. Die Pause, wir verwenden Schlüsselwörter
wie dieses hier, break und default. Das sind einige Schlüsselwörter, die
wir verwenden, das ist optional, oder? Und das hat einige
Schlüsselwörter zu beachten. Und ich werde sie feucht ausarbeiten. Wir machen weiter, oder? Und das Wichtigste, was
hier zu beachten ist, ist, wie wir sehen werden, insbesondere jetzt
mit einem Beispiel, dies
wirklich die Hauptader ist. Nehmen wir an, wir sprechen zum Beispiel über, hey, sie sind zum Beispiel standardmäßig oder eher die fünf und
vorzugsweise fünf über vier. Und dann reden wir über einen
Switch und dann sagen wir, Tag, so
machen wir das übrigens. Und wir öffnen einfach unsere Aussage, dass es
bedingte Aussagen gibt, wir führen sie durch
Fall Nummer eins. Und in Fall Nummer eins schauen
wir uns Fall Nummer eins
an. Wir können runtergehen und
dann sagen wir: Hey, das ist der erste Fall, dann drucken wir Montag, zum
Beispiel die Wochentage. Und wenn dies nicht der Fall ist,
wenn, wenn was, unser
Zustand nicht ist, werden Sie am Montag
nicht drucken. Wir werden Java anweisen, diese Schleife
oder diese Bedingung für
Fall hier
zu verlassen und zu
Fall Nummer zwei zu kommen und eine Zwei zu überprüfen. Es nimmt also mit
diesen Werten hier, es versucht,
diese Werte mit dem abzugleichen , was wir
ursprünglich dort drüben haben. Es wird also hierher kommen und mir erlauben, das
einfach zu kopieren und zu verwenden , damit ich das
viel schneller machen kann und sagen kann, dass
es Dienstag ist, der zweite Tag der Woche. Und für den Fall Nummer, ich meine,
werden wir definitiv eine Pause einlegen. Wenn Sie also keine Pause einlegen, wird der Teufel nicht richtig verstehen, wie
man in diesem Szenario richtig vorgeht oder was
zu tun ist. Siehst du? Es ist also immer ratsam, es auf die folgende Weise zu verwenden. In Ordnung, also haben wir
Punkt hier vergriffen. Wir haben einen Wildness-Tag und
wir haben eine Pause. Und bis Donnerstag haben wir Kaizen schon einmal
gegeben. Mit Pause. Ja. Wie Sie sehen
können, gibt es definitiv mehr Zeilen
hier drüben Das ist Schleim mit Angabe einer ganzen
Reihe von Bedingungen. Lloyd, Fall Nummer fünf, ich glaube, ich werde wahrscheinlich
bei Kids Nummer sieben aufhören. Also ertrage es einfach mit mir hier. Freitag. Da drüben ist Freitag. Und nur
Kaffeepause auch hier und Fall lass mich einfach kopieren
all das sollte viel, viel schneller sein. Fall Nummer sechs und
Fall Nummer sieben. Und hier sind Samstag
und Sonntag. sonntag. Richtig. Was wir also erwarten, da wir den Tag dort
auschecken, was passieren wird,
ist, dass Java durchläuft , überprüft, die Nummer fünf
nimmt und sie mit
allen
durchscannt diese Bedingungen hier,
es ist Zustand 1234. Und wenn es
ein Fünferspiel gibt, bekommt es, wie Sie sehen können, bereits
eine Metro Five. Es gibt fünf hier
und es gibt eine Fünf, ob sie bereits
hervorgehoben ist. Es wird am Freitag gedruckt. Also lass es uns am Freitag laufen lassen. In Ordnung, so wunderschön. So arbeiten
wir uns im Allgemeinen einfach um den gesamten Java-Code herum. Ganzer Java-Code, wenn es
um bedingte Anweisungen geht
, also um bedingte Anweisungen.
9. Java: Okay, das nächste, was wir uns ansehen werden
, ist
das, was wir Java-Schleifen nennen. Dies ist eine Java-Schleife, vor allem
beginnen wir mit den while Schleifen,
was bedeutet, dass eine ganze
Reihe von Schleifen. Aber wir werden uns
auf die while-Schleife konzentrieren. Und schleift sich selbst. Moleküle wie wir
die Schleife auf Englisch definieren
, sind fast, man könnte sagen, Wiederholungsrate. Sie können einen
Codeblock ausführen,
solange die angegebene
Bedingung erreicht ist. Sie sind sehr praktisch,
weil sie Zeit sparen Fehler im
Hauptcode besser lesbar
reduzieren. Und der Java-Code, es sind dieselben Texte, können auf folgende
Weise gesehen werden. Lassen Sie mich einfach
den Kommentar
hier drüben , damit
wir hier einen
Kommentar hinzufügen können . Siehst du gut. In Ordnung. Die Syntax dafür
wäre gegeben durch, lass es mich einfach
hier unten für uns haben, die Syntax wird
durch while Bedingung gegeben. Wie Sie wissen, liebe ich es,
Bedingungen in solche
Klammern zu setzen . Sie sich einfach aus dem Weg räumen und Sie wissen, wie Sie sie
besser einsetzen können. Und natürlich werden
wir da
drüben etwas öffnen und dann haben wir
einen Code, der hier ausgeführt werden muss. Und dann schließen wir es mit diesem Typen hier drüben
ab. Es bedeutet also, dass
dies wahrscheinlich
alles ist , was Sie benötigen, und schließen Sie es
einfach dort drüben. In Ordnung. Ein Beispiel dafür
wäre also so etwas. Lassen Sie mich zum Beispiel einfach sagen, int I ist gleichwertig eins. Und ich sage, ich gebe eine
Bedingung an, solange ich weniger als fünf
oder fünf Jahre alt bin, warum nicht? Das sollte passieren. System. Punkt aus, Punkt, Druck, Druck I. In Ordnung. Also was ist hier los? Was bisher passiert ist, ist, dass
wir unserem Code mitteilen, dass ich
zwar weniger als fünf Jahre alt bin, aber
weiterhin Folgendes mache. Zeige weiter den Wert von I. Und hör nicht einfach damit auf. Erhöhen. Und das bin ich,
um die Erhöhung zu setzen. Ich sage e plus plus. Ich sage so einen Schrank. Geh weiter hoch. Mache jedes Mal ein Inkrement von
plus eins. Also nimmt Java eins, vergleicht es mit
fünf und stellt fest,
dass es weniger als fünf ist. Was Sie
dann tun werden, nehmen
Sie den Wert
11 und drucken ihn als eins aus, und dann kommen Sie runter und fügen einen
hinzu es mit
fünf und stellt fest,
dass es weniger als fünf ist. Was Sie
dann tun werden, nehmen
Sie den Wert
11 und drucken ihn als eins aus,
und dann kommen Sie runter und fügen einen
hinzu selbst wieder und
dann zurück zu sagen, jetzt habe ich eins plus eins. Jetzt sind es zwei. Und so kann man demonstrieren, dass
es eins sein wird, dann eins. Dann hast du eins plus eins. Und dann hast du
eins plus eins plus eins. Und dann hast du eins
plus eins plus eins plus eins. Und dann
wird er endlich genau dort aufhören. Daher sind die Werte, die
Sie im Wesentlichen erhalten eins plus zwei plus
drei plus vier. Siehst du das? Lassen Sie uns das einfach für
uns überprüfen und sehen, was wir bekommen. Da ist es also, 1234. Das sind die
Werte, die wir erhalten. Und denken Sie daran, dass der Grund, warum
wir um vier Uhr
angehalten haben und nicht darüber hinausgehen oder eine Fünf oder
ähnliches mögen. Es liegt
einfach daran , dass wir weniger als fünf
gesagt haben. Wenn wir weniger
oder gleich fünf gesagt hätten, wäre
das
anders gewesen, weil es bedeutet , dass fünf enthalten sind. In diesem Fall sind
fünf jedoch nicht enthalten. Jetzt, wo es wahr ist,
können wir den Unterschied erkennen. Du wirst sehen, dass es fünf wird. Mal sehen, Daten
von eins bis fünf. Jetzt siehst du das. Es ist also nur eine Art, wie
wir das umgehen. Nur ein bisschen
Vorsicht hier drüben, bitte denk daran. Lass es mich einfach für dich tun. Vergessen Sie nicht, die
in der Bedingung verwendete Variable zu erhöhen. Sie nicht davon aus, richtig, gehen Sie
nicht davon aus. Nur das allein reicht aus,
um das Auge
weiter steigen zu lassen. Nein, ist es nicht. ist es wirklich nicht.
Und es wird nicht einmal wissen, wann man aufhören muss, ist entweder
Ihr Risiko, ein Ende zu machen, Never End Loop lässt mich
das wirklich entfernen und
einfach etwas verkleinern. Ja. Wenn ich so renne,
schauen wir mal, was hier passiert. Es geht weiter 111111. Warum macht es das? Es macht
das weiter, weil es
einfach auf einer
unendlichen Ebene davon bleiben wird . Deshalb
kämpft mein Computer
buchstäblich sogar darum, zu sehen,
dass er weiter ausfällt. Ich kann sogar nach unten oder oben scrollen. Ich kann ehrlich gesagt nicht. Das einzige, was ich
in dieser Phase tun muss, ist, dass ich das jetzt
einfach wieder tun kann . Und ich höre auch
gleich hier auf. Habe angehalten und führe es erneut aus. Der Grund, warum das passiert ist,
ist,
dass es den Wert
eins
annimmt und sich dann wiederholt um erneut gegen
den Willen von eins zu überprüfen. Und jedes Mal nimmt es die Villa von eins und
den Knopf fünf, aber eins ist weniger als fünf. Also was soll ich tun? Ich sollte I drucken, was eins ist. Und das gibt mir
immer wieder. Es ist also eine Endlosschleife. Das wird es auch weiterhin
tun. Es wird einfach nicht aufhören. Sie müssen also einige
dieser Bedingungen
darunter haben , um es zu erhalten Wann sollte es aufhören? Woher sollte es wissen
, dass es aufhören sollte? Wartet. Wenn Sie
es also mit diesem Inkrement versehen, sagen Sie, gehen weiter hoch, bis
Sie das Rückgrat erreichen, die Aussage hier,
und das ist wahr. Dann hörst du auf. Sie sehen , dass es einfach sehr
wertvoll und sehr wichtig ist
, das auch zu verstehen, oder? Und nur gepaart mit der
while Bedingung ist das, was wir die Standardbedingung
nennen. Und nur die vier Bedingungen. Lass mich die einfach
weglegen und sie hier hinstellen. Wunderschönen. Die vier Bedingungen sind also ruhig. Eine dieser Bedingungen
, die
häufig verwendet werden und wie sie
wirklich funktionieren, ist so. Lass es mich einfach für dich ablegen. Wir nennen es die Java for-Schleife. Und wir verwenden diesen, wenn
Sie genau wissen, wie
oft Sie einen Codeblock
durchlaufen möchten. Statt einer while Schleife. While-Schleife, wenn du es nicht weißt, wann würde es aufhören, oder? Es ist also, als würdest du eine Einschränkung
setzen. Aber du
weißt definitiv, was der Anfang ist, du weißt was das Ende ist. Und die Syntax, die wir für
diesen verwenden, ist die folgende. Wirklich Syntax ist die folgende. Wir sagen für mich einfach nach
unten scrollen, wir sehen vier. Wir setzen Aussage eins, Aussage zwei. Und dann setzen wir auch
Aussage drei. Denken Sie daran, dass
wir hier
dazwischen Semikolons setzen, anstatt nur solche Kommas. Wir setzen Semikolons. Und dann, wie Sie wissen, öffnen
wir immer nur hier und Sie
möchten auch schließen. Und dann haben wir hier nur noch
einen Code, der ausgeführt werden muss. Hingerichtet. Sie
fragen sich wahrscheinlich zu diesem Zeitpunkt was als Anweisung1 bezeichnet wird. Was bedeutet Aussage zwei, was bedeutet, worum geht
es bei all dem? Nun, worum es wirklich
geht , ist
diese Anweisung, was sie bewirkt, ist, dass es eine Anweisung ist, die
wirklich
einmal ausgeführt wird, bevor die Ausführung
des Blockcodes ausgeführt wird. Ein Mal vor der Ausführung des Codes. Dann Aussage zwei. Auf der anderen Seite definiert
es, was die Bedingung
definiert. Bedingung, definiert die Bedingung
für die Ausführung des Codes. Und dann endlich die
Aussage drei. Aussage drei dreht sich alles um, wirklich ist es nur die
letzte Stufe, die man sagen könnte ausgeführt nach der Kälte bedeutet natürlich,
nachdem der Code
ausgeführt wurde, oder? Ein Beispiel
dafür wäre wahrscheinlich
so etwas. Mal sehen, ob wir es einfach hier
finden und sagen, denn x ist gleich 0. Dann sagen wir Aussage zwei. Wir sagen, ich sei kleiner
oder besser gesagt nicht ich, x ist weniger als sieben. Und dann sagen
wir endlich: Hey. Ich bin das x nimmt auf folgende
Weise weiter zu,
was bedeutet, dass es ein Inkrement hat. Und wir öffnen einfach
Klammern da drüben. Und wir drucken, wir drucken
einfach x. Also, um vorherzusagen , was hier
passieren wird, definieren wir im Wesentlichen
den Wert von x, beginnend bei, von, von 0. Wir definieren x ist 0. Dann geben wir eine Bedingung, um zu sagen, während x kleiner als 0 ist. Und dann
mach weiter wie folgt. Was sollte weiter passieren? Sie einfach weiter eins hinzu,
denn es ist x plus plus, was eine Schrittweite von eins bedeutet. Also geht der Couponing vorbei, wieder um
eins, wieder, wieder. Was Java also tun wird, ist, den ersten Wert zu nehmen, gegen sieben zu
prüfen und zu sehen
, dass wir nur 0 haben, oder? Dann
wird er von dort aus gerade ab 0. Es wird ein Inkrement
von 0 plus eins geben. Dann
mach das nochmal weiter, 0 plus eins plus eins. Und dann wieder 0
plus eins plus eins, plus eins plus eins
und so weiter und so
fort, bis es den
ganzen Weg auf sechs geht den
ganzen Weg , weil es weniger als sieben ist,
sollte es nicht sieben erreichen. Es ist also von
0 bis sechs. Es bedeutet also, wenn wir das ausführen, sollten
wir nur Werte sehen, die das bis zu sechs
tun. Wunderschön, da ist es. Genau das
haben wir erwartet, und genau das hat
es getan, oder? Also das ist einfach unglaublich,
das ist einfach unglaublich. Ein Beispiel, über das Sie
definitiv nachdenken oder einfach nur einen Wert finden
können, ist das hier. Lass mich
das einfach kommentieren und
aber, aber, äh, richtig. Kommentieren Sie dies einfach und betrachten wir das
folgende Szenario. Was wäre, wenn du zum Beispiel
für das Ende hättest, es ist definitiv Zeit. Liebe Französisch von mir. Ganz nett. Ich sage, es ist weniger als oder
gleich zehn. Und dann gebe ich es dem letzten Akt
vor, einfach
um zwei zu steigen,
anstatt um eins zu sprengen. Siehst du das? Jetzt gehe ich um zwei hoch
und dann sage ich System out, print LN und die Manager
sagen: Hey, print i. Und was
hier passieren wird , ist, dass Sie
wahrscheinlich vorhersagen können, ob wir das
haben werden folgend. Wir werden 0 haben, und dann werden wir
ein Inkrement von plus zwei haben. Es wird also 0 plus zwei sein. In Ordnung? Ich hoffe du
siehst schon, wohin
das führt. Wir werden 0 sein. Und dann plus zwei
plus zwei, okay? Das Inkrement ist wahr,
es ist keiner, oder? Es bedeutet also unser Zuwachs. Jeder Schritt wird nur
um zwei sein. Wir haben es jetzt um sechs Uhr. Es ist immer noch nicht größer als zehn. Also wird es endlich auch
hier aufhören, als zwei plus zwei plus zwei. Und finde heraus, dass das acht
ist, oder? Und was es
tatsächlich tun wird, ist
das, was es tatsächlich tun wird. Jetzt sage ich
Ihnen nur im Nachhinein das
schon nicht oft getan haben. Es wird geprüft und 0 gesagt, und dann überprüft und setzt jetzt, um den Wert von
true
aufzuzeichnen. Drucken Sie ihn aus. Es wird ein Wert von 0 ausgegeben, der
Wert von zwei wird ausgegeben. Hier wird der
Wert von zwei plus zwei gedruckt, was vier ist. Hier wird
der Wert von zwei plus zwei
plus zwei gedruckt , was sechs ist. Hier wird der
Wert von zwei plus zwei plus zwei
plus zwei gedruckt ,
was acht ist. Und wenn es dann hier ist, heißt
es, dass es zehn sind. Es wird es durch den
Scan laufen lassen und sagen, warte, zehn ist zehn weniger als
oder gleich zehn. Und dann lautet die Antwort ja. Eigentlich ist es das, denn
es ist gleich zwei. Siehst du das? Es sollte also tatsächlich in der
Lage sein , diesen Wert auch anzunehmen. Ich hatte eigentlich nicht gesehen, dass
ich hier ein Gleichheitszeichen gesetzt habe, aber weil es
ein Gleichheitszeichen
gibt, wird es
definitiv registriert. Das ist zehn, also
wird 0246810 angezeigt. Lassen Sie uns es ausführen und
selbst sehen, dass es 0248610 gibt. Und denken Sie daran, dass,
wenn ich das Gleichheitszeichen entferne, es bei acht aufhören
wird, 0 bis acht sein wird. Var law, das sind Daten. Es ist einfach unglaublich. Wunderschönen. Die nächste, die
auf jeden Fall untersucht werden möchte,
heißt die Java-Each-Schleife. Java jede Schleife, in Ordnung? Und für diesen haben wir
es so als Java jede Schleife, so schreiben wir
jede, wirklich aus dem Englischen.
Für jede Gruppe. Das ist für jeden, für jeden, nicht nur für jeden, für jeden sollte die ganze Zeit für
jeden sein. Ordnung, also für diesen hier ist die Syntax dafür
wirklich die folgende Natur. Wir sagen vier und dann geben wir
den Typ einer Variablen an. Und wir haben den
Variablennamen hier eingegeben. Und gleich da drüben geben
wir einen Array-Namen ein. Und wir öffnen es so. Und dann
haben wir einfach unseren Code. Hier. Dies ist Code, der wie immer
ausgeführt werden muss. Der auszuführende Code
ist gleich da drüben. Und ja, nur um zu
bedenken , dass Sie das schließen
müssen, oder? Denken Sie also daran, dass Sie wahrscheinlich so etwas hier drüben haben
möchten. In Ordnung, sehr wichtig. Und einfach so, versuchen
wir
ein Beispiel dafür zu sehen. Nehmen wir an, wir hatten eine
Zeichenfolge mit Namen
von Kosten, oder? Und lassen Sie mich das einfach tun, weil meine Tastatur dies nicht
von Natur aus hat, also muss ich immer
meine Schlüsselstimmen ändern ,
um das zu tun. Wenn Sie an einem Computer oder Mac arbeiten, der nicht über die vielen Tasten verfügt, können
Sie hier immer einfach die
Tastatur wechseln. Erinnerst du dich? Dann? Wir können hier
immer zu den Autos kommen. Und nur wir haben
zum Beispiel Volvo. Wir könnten zum Beispiel BMW haben. Ja, du hast erwähnt, dass es VW, Volkswagen sein
könnte. Es könnte sein, dass Amerikaner diesen
definitiv lieben würden. Es könnte definitiv
vielleicht Honda sein, Japan. könntest du also auch
haben. Und dann genau hier drin, was machen wir, was machen wir? Nun, wir
öffnen es derzeit nicht wirklich. Wenn wir anfangen, die vier zu
verwenden öffnen wir
die
Dinge vorerst Dies ist nur eine Liste von Ints,
ein Array, das
eine Liste von Daten enthält. Also ist es string, string I. Dann sagen wir cos. Ja. Dann öffnen wir es. Jetzt. Jetzt ist definitiv
die Zeit zum Öffnen. Und dann sagen wir zum
Beispiel System Out Dot Print, oder? Also lass uns einfach, das heißt
also in diesem Szenario, lass es uns einfach laufen lassen und wir
sehen dort das Schöne. Es bedeutet also, dass wir für jedes
der Dinge, die
wir in einer Liste sehen, kontinuierliche Listen wie jedes von ihnen
präsentieren konnten. Es bedeutet also, dass Java in der Lage
war, jeden von ihnen zu
durchlaufen. Wie Java
das interpretiert, ist so. Es ist fast so, als würde dies durch einen Wert von 0
dargestellt. Und dann der Wert
eins, Wert zwei hier. Aber wenn drei vier sind, und indem wir das einfach tun, sagen
wir Ihnen,
dass es sich um eine Zeichenfolge handelt. Drucken Sie den Wert eins aus, und dann wird er verstehen. Also eine ist eigentlich eine
Zeichenfolge und sie repräsentiert, sie repräsentiert eine Zeichenfolge von Volvo. So wird Volvo gedruckt, dargestellt durch den Wert 0, und dann zu eins kommen
und c1 ist BMW und dann kommt zu zwei und c2 als vw, und dann C kommt zu
drei und dann
S3, S4 und dann zu vier. Und C4 ist ein Honda, oder? Ben meins, dass ich mit
0 angefangen habe und so in Java immer bei 0
beginnt und steigt. Das hört hier nicht auf und sieht es unbedingt als eine Eins an,
es sieht es als eine 0. Das ist also nur etwas
anderes, das man im Auge behalten und
seinen Wert erkennen sollte, und wir sind immer noch bei diesem sehr
interessanten Thema. Interessantes Thema.
10. Java Break & Fortfahren, Arrays: Okay Leute, also die nächste
Sache, die wir auf jeden Fall ansprechen wollen wird
mit dem zu tun haben, was wir
Java break and continue nennen . Also Java kaputt und macht weiter, es ist immer noch Teil dessen, was
wir gerade noch machen. Definitiv immer noch ein Teil davon. Und was wir damit machen
werden, und du wirst auch sehen. Aus diesem Grund haben wir bereits die break-Anweisung
gesehen in einer fremden Situation
verwendet wird über die wir
gesprochen haben. Und wir haben es offensichtlich benutzt, um aus einer
switch-Anweisung
herauszuspringen, oder? Wir können die break-Anweisung auch verwenden , um aus einer Schleife zu springen. Springe aus der Schleife. Und das
wird natürlich ein Kommentar sein. In Ordnung? Und der beste Weg, dies zu
demonstrieren, wäre, sagen
wir, Sie haben etwas
von der folgenden Natur. Du solltest Herbst sagen.
Und dann würdest du Ende sagen. I entspricht, sagen
wir mal ist gleichbedeutend mit 0. Und wie Sie sich erinnern, müssen
Sie
immer drei Aussagen haben, wenn Sie vier haben. Lassen Sie mich
hier
noch ein paar Aussagen für mich selbst definieren und sehen, was ich mir
einfallen lassen kann. In Ordnung? In Ordnung und so weiter. Und dann sagen wir, wenn E
gleich vier ist, oder? Vier davon,
was sollte passieren? Dann sollte es einen
Sprung aus dieser Schleife geben. Da haben wir es also. Und was mache ich dann als Nächstes? Ich sage einfach System dot out, dot print LN, und ich
habe mein Auge dort drüben. Okay, lass es uns
einfach
hier rüber laufen lassen und sehen, was
wir davon bekommen. Und voila, da haben wir es. Wir haben die Werte
von 0 bis drei. Und der Grund dafür
ist, dass wir unseren Code hier einfach
gesagt haben, unsere Software Java
dazu bei 0 beginnt. Und solange diese Bedingung
erfüllt ist , hat man
eine Zahl, die kleiner als zehn
ist, mit
Schritten von jeweils eins. Was sollte passieren? Das
Folgende sollte passieren, wenn ich für
den Moment
gleichwertig
bin, in dem ich auf den Wert
von vier komme, dann hör auf. Sie sehen, was Java macht. Es beginnt bei 0, macht
das und merkt, hey, wir sind 0 ist
definitiv weniger als zehn. Und dann
druckt es auch hier den Wert aller Schecks aus. Auf jeden Fall wird es hier nachschauen
und überprüfen und sagen, Hey, ich bin 00 ist nicht gleich vier. Daher müssen Sie nicht
zu dieser Pause kommen. Es wird überspringen und hierher kommen
und den Wert von 0 ausgeben und dann um eins hochgehen und
dann den Wert eins nehmen, es mit dem Tag vergleichen und
prüfen, ob es größer oder kleiner als ist, und sehen, dass es kleiner als ist. Überprüfen Sie
es auch hier mit vier und prüfen Sie, ob eins gleich vier ist. Und es wird offensichtlich herausfinden,
dass es nicht gleich vier ist. Was es also tun wird,
es wird wieder springen, den Wert von eins
ausgeben,
so weiter und so fort, bis es den Ort von erreicht, von, bis es
den Wert vier erreicht. Wenn es
den Wert vier erreicht, ist das
Folgende immer noch
zufrieden, oder? Aber wenn es dann hasserfüllt wird, sieh
zu, dass vier gleich vier ist und dann neutral. Deshalb werde ich brechen. Es wird genau hier aufhören und man kommt, um
diesen Wert hier zu drucken. Siehst du das? Es ist also nicht nötig, diesen
Wert hier zu drucken. Aber wenn ich zum Beispiel
sagen würde, ob ich diesen Druck entfernen würde oder ob ich diesen Druck hier haben
würde und einfach sagen, ob
ich das hier ausdrucken kann. Wenn ich das hier drucken
und auf vier setzen würde, sollte
es den Wert von I ausgeben. Es würde definitiv
den Wert von vier registrieren , der da
war, oder? Aber ja, es
ergibt definitiv Sinn. Ich hoffe es jetzt. Dann
machen wir weiter und reden dann darüber, wo es ist. Da drüben ist unser Kommentar. Das nächste, worüber wir sprechen
wollen, ist definitiv die Fortsetzung von Java. Sie gehen Hand in Hand. Es ist eine Pause und weiter. Die kontinuierliche
Anweisung unterbricht also eine Iteration in der Schleife. Wenn eine angegebene Bedingung
auftritt und
mit der nächsten
Iteration in der Schleife fortfährt . Es ist also fast so, als würden wir den einen Bereich
überspringen, nach dem wir
vielleicht gesucht haben. Zum Beispiel genau in dem
Problem, das wir hier haben, der verschiedenen Situation
, die wir hier haben. Kopieren wir das einfach und
fügen es gleich hier ein. Anstatt dass ich hier
eine Pause einlege, was wäre, wenn ich
vielleicht weiter gemacht hätte? Was ist der Effekt? War der Effekt, dort definitiv ein Continue zu
haben. Und es gibt ein kleines Problem, wie Sie mit
meinem Code hier sehen können. Es ist okay, jetzt führen wir das aus. Und jetzt nicht 0123,
es gibt kein falsch. Wir überspringen bis zu 56789.
Siehst du das? Das liegt daran
, dass wir gesagt haben , dass wenn vier
gleich vier ist, zusammenhängend, was bedeutet, es nicht ausgedruckt werden muss. Überspringen Sie es einfach und kehren Sie auch dazu
zurück. Deshalb überspringt es dort den
Wert von vier. Also im Wesentlichen
So funktioniert continue. Tolle Leute. Dann ist das nächste, was wir uns ansehen
wollen, wahrscheinlich eines der
wichtigsten Dinge, wenn es
um das Programmieren geht , das
alles mit dem zu tun hat, was wir Arrays nennen, Java-Arrays. Also lass mich
das einfach für dich aufschreiben. Java-Array. Das ist das, oder? Und mit Java-Arrays verwenden
wir Arrays für
eine ganze Reihe von Dingen. Ehrlich gesagt. Wir können sie
beispielsweise verwenden, um mehrere Werte
in einer einzigen Variablen zu
speichern und zu speichern. Das ist das Schöne daran. Rendern kann es anhalten. Zum Beispiel kann es
eine Sammlung von Autos, eine
Sammlung verschiedener
Bevölkerungsgrößen,
alle möglichen Statistiken speichern Sammlung verschiedener
Bevölkerungsgrößen, , Sie können
sie
wirklich behalten und
unter einer Kategorie speichern, vielleicht in der Größe von Personen. und
verschiedene Farben, die du siehst. Das Wichtigste ist also, dass Sie, wenn Sie ein Array deklarieren möchten, zuerst
den Variablentyp
mit eckigen Klammern definieren müssen . Und wie macht man das? Nun, im Grunde machst du es
einfach so. Natürlich werde ich ein Beispiel
geben, aber ich möchte Ihnen nur helfen, sich mit der Syntax
vertraut zu machen. Ich habe mein Quadrat hier. Lass mich die Tastatur wechseln
und es ist hier drüben. Lass es mich einfach öffnen. Das kann
ich auf irgendeine Weise kopieren und einfügen, die ich kenne, weil
ich das schon benutzt
habe, glaube ich heute irgendwann. Nein, ich habe es noch nicht benutzt. Kein Problem. Wir
geben es einfach so. Und lass mich auf meiner Tastatur sehen , wo ich einen
Weg finde, das zu schließen. Also, ja,
das ist genau hier. In Ordnung. Wunderschönen. In Ordnung. Also gehen
wir auch so. Hervorragend, ausgezeichnet. Wenn Sie sich also in einer
Situation wie meiner befinden, Sie auf Ihrer Tastatur nicht zu viel zu
erkunden haben. Sie können immer diesen
visuellen Cue Bottom damit verwenden. Und dann hast du Autos, richtig? Und es ist eine Reihe von Autos. Und mit dieser Reihe von Autos können Sie
wirklich
so viele Autos darin verstauen , wie Sie
möchten. Denn wenn wir das getan haben, haben
wir jetzt
eine Variable deklariert, die ein Array von Strings
enthält, um Werte hinzuzufügen. Wir können einfach ein
Array-Literal verwenden und
die Werte in einer kommagetrennten Liste in geschweiften Klammern abspielen. Wie machen wir das? Nun, jetzt
kommt das Beispiel. Also lass mich einfach schreien
und wir sagen Schnur. Lassen Sie mich
dieses Beispiel wörtlich nehmen , sollte es
einfacher sein, es mit dem zu tun, was ich bereits Strain Cars habe und dann
meine Tastatur nicht geändert habe. Fantastisch. Also Screencasts und dann
sagen wir, ist ein gleichwertiges Werkzeug. Und dann stellen wir
unsere Autos da drüben ab. Wir könnten zum Beispiel
Toyota, Ford von meinen
amerikanischen Freunden haben. Aber wie Sie sehen können, ist es rot. Warum ist es rot? Weil es es nicht als Zeichenfolge identifiziert. Also müssen wir diese
Anführungszeichen dort drüben setzen. Fantastisch. Da ist es also. Da ist es. Und dann könnten
wir Toyota haben, wir könnten FADH haben, wir könnten Ferrari haben,
unsere Italiener. Wir könnten Mercedes Benz haben. Wir könnten so viele
Autos haben, wie wir wollen, aber ich denke, das wird für den Moment wirklich
ausreichen. Und voila, so
einfach ist das wirklich. Und das funktioniert natürlich nicht
nur für
String-orientierte Objekte
oder String-Subjekte. Wir könnten das auch
ein bisschen für ganze Zahlen machen, das ist
auch für Werte, oder? Und wie wir das machen, ist,
indem wir das einfach tun, einfach zu string kommen, lass uns das einfach kopieren. Und wir haben int. Jetzt haben wir das und
dann sagen wir meine Nummer. Wir können die
Nino-Variable so deklarieren. Dann öffnen wir uns und
speichern Werte von zehn über 20 bis 30 bis 40. Es liegt an uns, so frei und Entdecker zu sein, wie
wir wollen, oder? Das ist also eine coole Sache. Wir beginnen all diese Werte an einem Ort, meine Zahlen, oder? Dann nehmen wir an,
Sie möchten zum Beispiel auf Elemente
dieses Arrays zugreifen, oder? Lass mich
das einfach für uns aufschreiben. Greifen Sie auf Elemente eines Arrays zu. Wie würden wir das machen? Nun, um das zu tun
,
oder müsste ich zum Beispiel auf Elemente
dieses Arrays zugreifen ,
das ist dieser Bereich. Wie würde ich das machen? Nun, alles was ich tun muss, ist, dass
ich nur
System Out Dot Print LN sagen muss , am
liebsten so, als würde ich sie auf diese Weise
drucken. Und dann wählen Sie
sie als Kosten mit unseren Elementen hier und n hier aus. Zwischen meinen beiden
Quadraten da drüben. Was ich mache ist, dass ich wählen kann,
was ich herausbringen will, oder? Denken Sie daran, wenn Java kennt
er dieses S. Dieses
S entspricht 0, wobei
die Menge S zwei als eins
entspricht, eher dies entspricht, dies entspricht drei, und so weiter und so weiter. Sie sehen, wenn ich
zum Beispiel 0 sagen würde, was Java davon bekommt, muss
ich die erste
Karte drucken, die ich finde, oder? Weil es anfängt,
von mündlich zu zählen , um Ausgaben von 0 zu
zeigen. Also lass uns gehen. Wir sollten uns einen Toyota voila ansehen. Das heißt, wir haben
einen Toyota, oder? Wenn ich
zum Beispiel drei sagen würde, bedeutet drei, wenn das 0 ist, das ist eins, das sind zwei,
das sind 33 sollten Biegungen sein. Lassen Sie uns es also ausführen und sehen, ob wir es
schaffen,
tatsächlich Fälligkeiten. Jep, großartig. Mercedes Benz In der Tat, richtig? Nehmen wir an, dass
du es vielleicht machen willst. Sie möchten sich ändern, sagen
wir, Sie möchten vielleicht ein Array-Element
ändern. Ein Array-Element. Wie würdest du das machen? Nun, um
ein Array-Element zu ändern, müssen
Sie nur das Element
angeben, das
Sie ändern möchten, oder? Nehmen wir zum Beispiel an
, ich wollte Ford
ändern, der für heute
ziemlich viel hat. Also lass uns das
nur für den Kredit ändern. Sagen wir also Autos und wählen
dann gekämpft aus, welches bei 123 oder vier ist. Es gibt eigentlich keine Kraft
10123. Also wählen wir einfach den
ersten aus, der 01 ist,
was für
gekämpft steht, und sagen dann Cars 01 und
ersetzen sie dann durch. Wie wär's mit Aston Martin? Was Martin angeht? Aston Martin, die gutartige, abweichende Vorstellung von
einem Fan von Autos,
wirklich Sportwagen. Das heißt, wir könnten
eine Wiederholung haben , die mit
einem Aston Martin vorwärts geht, oder? In dem Moment,
in dem wir das jetzt haben ,
müssen wir nur noch einmal Krebs
drucken. Also könnten wir einfach sagen,
anstatt
Tonnen Nummer drei zu drucken ,
wie wäre es damit? Wie wäre es, wenn ich diesen Kerl wieder nehme und ihn jetzt hier platziere, nachdem die Änderung stattgefunden hat, und ihn
einfach als kirwan registriere. Das liegt daran, dass es dort früher
gekämpft wurde. Aber es hat sich geändert. Es ist ein steinerner Berg geworden. Also sollten wir jetzt
unsere Stomata haben, Aston Martin DB neun. Das ist also das Schöne daran. Jetzt fragst du dich wahrscheinlich,
warum ich das ändern musste. Nun, nehmen wir an, es
war y t Eigentlich sagen
wir mal eins ist genau hier. Lass es uns ausführen und dann
sehen wir , was da drüben
passieren wird. Es hat wieder gekämpft. Warum ist das so? Das liegt daran, dass es Java ist. Es liest den Code hier. Es beginnt Zeile für Zeile. Das ist von 187188. Soweit 188
oder 1921 gefunden werden,
wenn ich ihm sage, dass er starten soll und mir den
Wert gebe, den man hier hat, es voran,
weil es noch nicht verstanden wurde oder eher keine
Informationen erhalten hat dass
es sich ändern sollte. Diese Änderung
findet nur in Zeile 194 statt. Deshalb musste ich
tun, was ich getan habe, und das einfach hier unten
platzieren,
damit es beim Ausführen verstanden hat, dass es bei 1 eine Änderung
gab. Jetzt meint Cao Huan und Aston
Martin de sei neun, richtig? So machen wir es also, wenn wir
das ROE-Element ändern wollen. Aber was ist, wenn wir bestimmen
wollen, was? Was ist, wenn wir
zum Beispiel aus dem einen oder anderen
Grund eine Array-Länge
bestimmen wollen , ist es möglich, dass Sie herausfinden
möchten wie viele Elemente in einem Array
vorhanden sind. Und dafür
müssen Sie nur die Eigenschaft length
in 3D verwenden. Und wie verwenden wir
die length Eigenschaft? Tun Sie das. Also lass mich einfach
dasselbe verwenden, was wir hier benutzt haben, das System, das dachte. Also komme ich einfach her. Anstatt solche
Autos zu drucken, sage
ich nur Autos
und die Länge, oder? Wenn ich das mache, sollte
es mir sagen wie viele Elemente es gibt. Denken Sie daran. Sie zählt nicht ab 0123. Nein, nein, nein. Es zählt wie viele Werte es überhaupt gibt
. Es zählt 0 und x1, es ist auf eins gegangen, S2, S3 bis S3, und sein
Inhalt drei ist vier. Also sollte es
vier Elemente produzieren, die im Array sind, oder? Weil ich es frage,
wie viele Elemente es
in den Bereichen gibt , in denen
vier Elemente IN Durchfall ,
was wahr ist, also
1234, oder? Das ist also wirklich so, dass ich
hoffe, dass das definitiv hilft.
11. Java Array Loop: Dann wollen
wir uns als Nächstes das ansehen,
was wir Java nennen. Java-Array-Schleife ist definitiv etwas, das wir uns jetzt ansehen
möchten. Und wir können
unsere Array-Elemente mit
einer For-Schleife von Kosten durchlaufen . Und wir können sogar
die length Eigenschaft verwenden , um anzugeben, wie oft
die Schleife ausgeführt werden soll. Richtig? Denken wir also
zum Beispiel über dieselbe,
dieselbe Situation nach, in der wir unsere Saite hier
haben. Nehmen wir zum Beispiel an, wir wollten da drüben einfach eine kleine
Schleife laufen lassen, oder? Versuche einfach,
eine kleine Schleife zu laufen. Was wir also tun könnten, ist das. Wir könnten das hier einfach nehmen und dort platzieren, wo ich leicht darauf zugreifen
kann, besonders dieses, das
erste über die Autos, S1 über die Ursache. Okay, lass es mich versuchen und schreib es
einfach nochmal. Mich selbst. Gleich hier drüben. In Ordnung. Hier der Arm, die Ursache. Also hier ist unser Nochmal, lass mich das noch einmal umschreiben. Ich denke, es hat
sich selbst gelöscht Java-Array-Schleife. Nehmen wir an, ich habe
Folgendes. Nehmen wir an, ich habe eine Zeichenfolge und ich habe auch
die folgende. Neben diesem Training habe ich die folgende
Saite mit Autos und lass mich diese jetzt einfach
in die Klammer setzen , weil ich das nicht mehr wirklich
brauche. Also komme ich einfach von
hier runter und verschiebe das hier. Jetzt. Verschieben Sie dieses eine
bisschen Arbeit hier, sollte
aber in einer Minute erledigt sein. In Ordnung? Was ich jetzt mache, ist, dass ich hier eine kleine Schleife einführe
. Ich sage int I ist gleich 0. Und genau dort
sage ich, dass ich weniger kostet. Und dann sind sie natürlich
lang. Und genau dann sage ich
einfach ich plus plus. Und ich
öffne das für uns. Und wenn ich es öffne, werde
ich einfach
diese Druckmethode
ausdrucken und hier
einsetzen diese Druckmethode
ausdrucken und hier damit ich
herausfinden kann , was hier eigentlich
vor sich geht. Dieses Mal
werde ich
definitiv nicht in Bezug auf die
Fahrzeuglänge drucken und nicht das E verwenden, das bereits dort drüben platziert
wurde. Aber ich werde
es auf jeden Fall
auch in meinen Quadraten platzieren wollen auch in meinen Quadraten weil es ein Array ist, über das
wir hier sprechen. Es ist ein Array, also
wollen wir das nicht aus den Augen verlieren. Das ist also mein Auge
und es ist bereit. Lassen Sie uns das durchgehen und sehen,
was wir uns einfallen lassen. Und sie sind es, wir haben die folgenden Elemente. Wir haben Toyota, wir haben Ford, wir haben, wir haben Bands, richtig? Im Wesentlichen haben wir hier
gesagt, dass wir diese Technik
dieser Längeneigenschaft
verwendet haben dieser Längeneigenschaft um
alles, was sich darin
befindet, ausdrucken zu
können ,
solange es sich selbst
nicht überschreitet solange es nicht aus seiner Array-Liste
herauskommt, sollte das
so weitergehen. Richtig? Auf der anderen Seite könnten
wir auch einfach
darüber sprechen, wie man R benutzt, wie man
durch ein Array mit jeweils vier,
mit einer for each Anweisung, schaut durch ein Array mit jeweils vier,
mit , wenn man das schreiben möchte für jede Schleife, wenn
du willst, richtig. Die Syntax dafür kommt
definitiv auf
folgende Weise vor. Wir machen das einfach. Wir könnten sagen, bei ausgeschalteter
Unterkapitalisierung vier stornieren. Dann schreiben wir den Typ
der Variablen, mit der
wir arbeiten. Und dann ist da drüben eine
Variable. Und dann
bleiben wir einfach der Array-Name, auch der
Array-Name. Genau hier, kein Platz dazwischen. Und wir öffnen alles, womit wir es zu tun haben
wollen. Siehst du das? Natürlich müssen
wir es auch nicht schließen. Ein Beispiel dafür
wäre also gefragt, was zum Beispiel immer noch
genau dasselbe verwendet. Lassen Sie mich sie einfach in Commons aufnehmen. Bringen Sie das gemeinsam. Richtig? Also lass mich
das alles nehmen. Wir werden es auf jeden Fall wieder hier
benutzen. Nehmen wir an, wir haben hier die gleichen
Kosten. Was wir also sagen könnten
ist, dass wir für
diesen Zug I mit
der Syntax der Kosten
sagen könnten diesen Zug I mit , die auch dort verursacht werden. Und auch wenn wir unsere Klammern
öffnen, haben
wir System dot out, dot, print LN, print LN. Dann können wir es einfach
ausdrucken, zum Beispiel. Wir können einfach ausdrucken, dass
mir das gefällt. Dann versuchen wir es auszuführen. Und mal sehen, was wir bekommen. Wir haben uns das
Gleiche ausgedacht, oder? Es ist also wirklich nur eine Methode, man könnte sagen, ich bin eine Frage
der Technik, wenn man will. Sie können
sie auf jeden Fall so frei verwenden , wie Sie sie wirklich verwenden
möchten Es ist nur eine Frage der Technik
und der Präferenz, wie Ihr Code aussehen soll. Dann das nächste, was
wir uns ansehen werden, lass mich das einfach in Commons schreiben. Das nächste, was
wir definitiv
untersuchen , ist das mehrdimensionale,
mehrdimensionale Java-Array ,
mehrdimensionale . Mehrdimensionales
Java-Array, richtig? Und in diesem Fall müssen
Sie nur bedenken, dass um ein
zweidimensionales Array zu erstellen, Sie,
um ein
zweidimensionales Array zu erstellen,
jedes Array innerhalb
seiner eigenen geschweiften Klammern hinzufügen müssen . Die Syntax davon
wäre so etwas wie int. Und dann lass mich einfach auch
diese Zahnspange hier nehmen. Lass mich das einfach machen. Großartig. Ja. Mein num-Bus zum Beispiel. Dann sagen wir, wir setzen
es gleich und setzen
es dann in seine eigenen Klammern. Seien Sie also
vorsichtig, da dies zwei Ereignisse
haben wird , sei 1234. Es sind also vier hier drüben. Wir hören gleich hier um vier auf. Also lass mich diesen Kerl einfach kopieren
und gleich hier einfügen. Und dann sagen wir Koma, weil
wir immer noch weitermachen. Und wir öffnen uns. Und dann sagst du zum Beispiel
567. Und dann schließen wir
es so. Und das nicht nur einmal
, sondern tatsächlich zweimal. Und dann schließen wir es
so ab, richtig. Das ist also ein Beispiel dafür. Wenn ich es
aus deinen Kommentaren herausnehmen würde nur damit du sehen kannst, ob es von Java erkannt wird. Lassen Sie mich das
einfach versuchen
und Sie können es
selbst überprüfen. Also hier ist es, hier ist es genau hier. Und wir haben hier ein Ende. Und unsere Zahnspangen hier, A2, B2. Deshalb haben wir da drüben
einen Pfeil. Da sind sie also. Jeder, man könnte sagen, jeder
repräsentiert sein eigenes Ding und sieht, dass
dieser dieses repräsentiert. Dieser hier steht für diesen
hier. Siehst du das? Das ist also im Wesentlichen die
Syntax. Das ist im Wesentlichen die Syntax.
12. Mehrdimensionale Arrays: Es ist also nur erwähnenswert , dass es jetzt, wo es auf diese
Weise ist, bedeutet, dass diese Minenzahlen bedeutet, dass diese Minenzahlen
hier jetzt ein Array mit zwei Arrays als
Elementen sind, oder? Um auf die Elemente
des Arrays my numbers zuzugreifen, müssen
Sie zwei Indizes angeben, einen für das Array und einen für das Element innerhalb des Arrays. Das Beispiel, das ich dir dafür
geben könnte ,
wäre ungefähr so. Nehmen wir zum Beispiel an, wir verwenden genau dasselbe
, was wir hier verwendet haben. Und dann sollten wir sagen, int
x entspricht zwei meiner Zahlen. Und ich sollte
zum Beispiel einen sagen. Lass mich versuchen,
das einfach zu kopieren , damit ich
viel, viel schneller sein kann. Möchte ich es
in diese Frage stellen? Vielmehr werde ich
das kopieren, was ich will. Das bin ich, weil
ich off angeben muss. Die erste, die ich
spezifiziere, ist das Array. Und dann ist die zweite, die ich
spezifiziere , die
Position im Array. Sie sehen, dass das
Array und dann die Position im
Array selbst ist. Nehmen wir an, ich würde etwas wie 12
angeben. Ja. Also, indem Sie 12 angeben, was ist hier eigentlich los? Was bin ich? Was sage ich
eigentlich hier, oder? also hier eins angeben, ist
dies die, in der
diese erste Klammer hier, oder eher quadratisch hier, Informationen
enthält, die uns
sagen, in welchem Bereich wir
uns befinden, wir uns in Array 0 befinden? Denken Sie daran, dies ist ein
Array ein Array 0. Denken Sie daran, dass dies unsere a 0 ist, oder wir sind in Array eins. Siehst du das? Also das ist unsere a 0,
das ist schon eine. Dies ist soweit
es betrifft. Das zweite Quadrat
hier drüben enthält Informationen ,
wie wir uns
in diesem Array befinden. Auf welche Position
beziehen wir uns genau , um unser
Element aus dem Meer zu gewinnen?
13. FOR-Schleife: Also machen wir einfach so
weiter und sagen system dot
out, dot, print n.
Und wir drucken den Wert von
x aus , weil es nur evaluiert wird, es ist nur ein Wert davon,
nur um zu verifizieren, dass wir es nicht tun
Ich hab noch was anderes da oben. Und wir haben es hier ausgedruckt. Daher sagen wir voraus, dass wenn
ich 12 verkaufe, das heißt 01. Wir sagen voraus,
dass wir hier drin sind. Position zwei pro
Schwerpunkt ist 012. Wir sagen voraus, dass es
uns einen Wert von sieben geben wird. Also lass es uns laufen lassen und sehen, dass es
sieben Tage lang wunderschön ist. Das heißt, es sind also
sieben da drüben. Und wir können auch eine for-Schleife
in einer anderen for-Schleife verwenden , um die Elemente eines
zweidimensionalen Arrays zu erhalten. Und natürlich müssen wir
immer noch eher auf die Indizes der 2x
hinweisen . muss das auf jeden Fall noch tun. Ein Beispiel dafür wäre, sagen
wir mal die Verwendung von for-loop, die
Verwendung von Follow-up, oder? Ein Beispiel dafür
wäre wahrscheinlich, zu spezifizieren und zu erstellen hier
eine Methode zu spezifizieren und zu erstellen und zu
sagen, sie öffentlich zu nennen. Ich möchte nur überprüfen, in
welcher Methode wir uns befinden. Wir sind bereits in der öffentlichen
statischen Leere. Das ist also schon gut. Nur dass
wir wieder den ganzen
Weg hierher kommen
werden. Und wir
müssen die Methode nur nicht angeben , da wir sie
bereits da oben haben. Also wird es einfach zu Ende sein. Und wir schreiben unser Ende hier wieder ab. Und anstatt das alles zu
schreiben, könnte
ich das einfach wirklich kopieren. Lass mich einfach
dort kopieren und einfügen und meine Zahlen sagen. Und anstatt nur meine Zahlen
oder sie hier als eine Eins zu setzen, nur um sie von
dem vorherigen Szenario zu unterscheiden , das wir hatten. Und was ich
auch tun werde, ist einfach zu sagen , dass ich
für int gleich 0 ist, ich bin kleiner als meine
Nummer eins, oder? Weil dies der
besondere ist, ich mich tatsächlich beziehe. Ihre Länge.
Erinnerst du dich an die Es ist einfach so gemeint. Es ist mit der Länge. Und dann machen wir
eine Erhöhung von I. Also da ist es. Wir haben einen Zuwachs von Iowa. Und wir öffnen unsere
for-Loop hier drüben. Dann fügen wir hier eine weitere
for-Schleife hinzu. Und wir sagen für int j ist auch gleich ab 0. Und sage 0 eher ungleich Null. Ich verwende lieber j ungleich Null. Schon wieder meine Zahlen,
Punktlänge. Nicht wirklich fertig. Punkt-Länge. Lass es mich stattdessen einfach
so platzieren. Gehen wir zurück. Und ich nehme das hier minus zwei Quadrate
und platziere sie hier. Also habe ich meine beiden, mein Quadrat, nur einen von ihnen und bitte mein Auge genau da drin. Und das ist die Länge
, nach der ich suche. Das ist die Länge
, nach der ich suche. Und mach einfach weiter mit j
hoch, geh wirklich weiter mit j hoch. Und für jedes dieser Szenarien muss
ich hier Werte
ausdrucken. Und vor allem, wenn ich hier
meine Zahlen
ausdrucke und
sie nur in Bezug auf I und J habe, sollte es
normalerweise so
funktionieren. Also lass es uns einfach laufen lassen und
sehen, was wir
davon bekommen und besser verstehen, was hier
vor sich geht, oder? Es ist also wirklich nur eine Situation , in der wir versuchen, all
diese Werte von hier aus
abzuziehen oder zu ermitteln. Also haben wir ein int und
dann sparen wir für das Ende, wobei es daran liegt, was ich
im Wesentlichen sage? Ich sage, solange ich, was den Bereich bedeutet, erinnere dich an Array 0, Array eins. Solange dies weniger
als seine eigene Länge ist, was bedeutet, hat es eine Länge von
eins von 0 bis eins, oder? Es bedeutet also, dass es
die erste 0 braucht und hierher kommt. Weil 0 hier erlaubt ist, ist
es definitiv weniger als eins. Dann kommt es und druckt aus, was hier
vor sich geht. Drucken Sie aus, was hier vor sich geht. Tatsächlich ist die Länge hier,
urbaner Geist Es ist tatsächlich zwei, weil es die
Länge davon ist, es sind 12. Also braucht es 0, überprüfe es
und sehe, dass 0
definitiv weniger als zwei ist. Und sagen Sie weiter
, was ist mit j? J ist gleich 0. Und dann sag, j ist kleiner als, j ist weniger als drei,
wie du dort sehen kannst. Für j, wie viele Elemente? Sie sind in erster Linie am Tag. Für j sind
es also tatsächlich keine drei Elemente. Es wird 1234567 sein. Es werden also
sieben Elemente drin sein. Also wird es einfach diesen Wert von 0 nehmen
und speichern. Lassen Sie mich hier einfach einen
Kommentar abgeben, damit Sie ihn besser sehen können. Also wird es, wie gesagt, einfach den Wert 0 nehmen. Erstens werden wir eine 0
haben, oder? Dann wird
es gegen diese 0 laufen und eine weitere 0
nehmen, oder? Und dann wird es kommen. Und lass mich das einfach kopieren. Geben Sie den Wert aus, diesem
entspricht, und 0 Komma 0. Offensichtlich
wird uns das einen geben. Dann wird es kommen und es
wird einen Anstieg verursachen. Es wird eine Erhöhung verursachen,
soweit J Zustimmung ist, oder? Es wird also nur
zu einer Erhöhung der
Lohnzustimmungen führen , also wird es 01 sein. Und deshalb ist 01, wie
Sie sehen können, 0, es ist in diesem Array, eins, es bedeutet wahr hier,
also werden es zwei sein. Und dann kommen wir her sagen: Was ist mit drei? Hier? Es werden jetzt zwei sein, was hier drei ergibt, wie wir es hier sehen können, und so weiter und so fort. Ich kann wahrscheinlich davon ausgehen, dass
Sie hier bereits ein kleines Muster gesehen haben, das sich
definitiv abzeichnet. Lassen Sie mich also einfach
diese Werte für uns ändern. Also werden es hier drei sein, hier werden
es vier sein. werden es vier sein, hier werden
es fünf sein. Dann sind es
hier fünf, was zu sechs hier führt. Und dann sind es
hier sechs, was zu sieben hier führt. Warum wird es das irgendwann tun,
und übrigens, wenn es soweit ist, dass ich 0123 hier sehen kann, wird es sich
normalerweise hier ändern. Es wird ziemlich eins sein. Und dann, weil
es jetzt in diesem Set ist, und dann wird es hier nach
der Position suchen und wieder bei 0
beginnen, oder? Also wird es so sein. Und dann
wird es hier einer sein. Und dann
wird es wieder einer sein. Dann wird
es jetzt eins sein, und hier
werden es jetzt zwei sein, richtig? Im Grunde ist es das, was uns
dann irgendwann all diese Werte geben wird. Wenn Sie versuchen, sie selbst zu
finden, benötigen
wir einen Stift oder
einen Stift und Papier. Und versuche 00 zu finden. Sie werden sehen, dass es eine
01 ist, es ist 2023034105116127. Siehst du das?
Im Grunde ist es also so, dass es Sinn
macht, was vor sich geht. Richtig, genau hier,
richtig , genau hier, richtig? Was wir als Nächstes tun werden ist, dass wir einfach zum nächsten Bereich
übergehen, wirklich mit der
nächsten Sache fortfahren.
14. Methoden: In Ordnung, also das nächste, was ich
auf jeden Fall untersuchen
würde, ist, hat mit Java-Methoden zu tun. Wahrscheinlich das
Wichtigste , auf das Sie
stoßen werden, wenn Sie Java machen. Und um
diese richtig zu verstehen , werden wir
definieren, dass die Süßwassermethode eine Methode ist, einfach eine Methode
ist nur ein Kettenblock. Dieser Kettenblock
oder ein Codeblock, der
nur läuft, wenn er kalt ist, oder? Also nennst du es, dann kannst du es
definitiv gebrauchen. So können Sie Daten, die
als Parameter bekannt sind, an eine Methode übergeben. Und Methoden werden verwendet, um
bestimmte Aktionen auszuführen , und sie werden auch als Funktionen
bezeichnet, oder? Richtig. Ja. Und warum sollten wir Methoden verwenden
wollen? Sie fragen sich wahrscheinlich warum. Nun, die Wahrheit ist, es geht wirklich nur
darum, Code wiederzuverwenden. Code wiederverwenden. Definieren Sie
den Code einmal. Und du wirst es so
oft benutzen, wie du willst. So oft du willst. In Ordnung? Das war's also, oder? Und das Wichtigste, was Sie sich
jetzt wahrscheinlich fragen, ist Wie erstellen wir eine Methode? Damit ein Metall
hergestellt werden kann, muss
es zunächst innerhalb einer Klasse
deklariert werden. Und es wird mit
dem Namen der Methode definiert, gefolgt von einer
Klammer, natürlich. Und natürlich wird Java
einige vordefinierte Methoden wie
system.out.print,
line bereitstellen einige vordefinierte Methoden wie , wie Sie wissen. Sie können aber auch
Ihre eigene Methode erstellen , um bestimmte Aktionen
auszuführen. Ein Beispiel dafür wäre, dass Sie eine Methode innerhalb von main
erstellen möchten. Also, was du tust, ist
einfach zu sagen, lass uns sehen, lass uns den ganzen Weg hier hoch gehen
und einfach alles
hier auf die Kommentare setzen ,
weil wir es nicht brauchen. Richtig, genau hier. In unserer öffentlichen Klasse werden
wir sie einfach, anstatt sie
überhaupt öffentlich zu machen, einfach zu
einer statischen Klasse
der folgenden Art machen und sie
dann nennen, sie nennen. Nennen wir es MyMethod. Es ist einfacher, es einfach
so zu nennen myMathLab-Hauptmethode. Und meine Methode,
das ist es. Es ist nur unsere eigene Methode, oder? Und mit dieser, unserer eigenen Methode, brauche
ich das denn lass mich den
Kerl hier reinbringen. Stellen Sie sicher, dass alles unter Kommentaren
steht und dass es keine Fehler gibt, die wir hier
sammeln,
insbesondere hier. Und hier. Davon brauchen wir nichts, oder? Richtig. Hervorragend“. Jetzt, wo wir
es in dieser Form haben, nennen
wir es einfach unsere Methode. Und dann
hätten wir buchstäblich hier ziehen können, um
hingerichtet zu werden, oder? Das müssen wir ausführen. Ein Beispiel dafür wäre also, sagen
wir, Sie wollten etwas
überfließendes Wesen schreiben. Nehmen wir zum Beispiel an,
Sie wollten sagen, hey, System dot out, dot print LN. Und dann solltest du sagen:
Hey, das macht Spaß.
Das ist einer, oder? Also fuhr er fort, das zu sagen. Dann lass mich
diesen Abstand hier verringern. Normalerweise bevorzuge ich sie
so, damit ich weiß, was genau
ich mache, oder? Dann könnte ich alternativ
einfach pub, public, static, void, main und
meine Zeichenkette hier drüben definieren. Meine Saite genau da. Lass mich einfach, ich brauche ein paar
Quadrate oder hol sie von hier. Und bring meine Quadrate her
und steck meine Schnur so. Und ich bin einfach so, ich nenne das einfach ein RGS. Sie können dies immer
vorne oder hinten platzieren. Es ist wirklich keine große Sache. Definiere, was auch immer
ich ausführen möchte. Also sage ich. Meine Methode endet. Hier. Wie Sie sehen können, erkennt Java
tatsächlich dass ich das ausführen kann, und wenn ich es starte, sollte es
nur sagen, dass dies einer ist. Das ist einer. Warum haben die Schweden das gemacht und es ist im Wesentlichen einfach, es hat verstanden, dass
dies eine Methode ist. Wenn ich das anrufe, fordere
ich, dass
das erledigt wird, oder? Also stell dir vor, ich würde das
einfach tun und
das hier platzieren plus das plus das, plus das hier. Und es ist, als würde man buchstäblich immer wieder
und wieder dasselbe benutzen . Also wird es jedes Mal
einfach wieder anrufen. Das ist einer,
dieser, dieser nicht. Also kann ich es so
oft benutzen wie ich will. Und natürlich ist dies
ein sehr Lee-Beispiel, aber es hilft Ihnen nur, Ihnen
zu beweisen, dass eine Methode mehrmals aufgerufen werden
kann ohne Probleme
mehrmals aufgerufen werden
kann, oder? Was sehr praktisch ist. Weiter gehen wir auf den gesamten Aspekt
der
Methoden und alles, was Sie sehen, ein. können also nur Informationen weitergegeben werden. Zwei Methoden als Parameter, und Parameter fungieren wirklich als Variablen
innerhalb der Methode. Und Parameter werden
nach
dem Methodennamen und
in Klammern angegeben. Und Sie können so viele
Parameter hinzufügen, wie Sie möchten. Trenne sie einfach durch ein Komma. Das ist wirklich der Schlüssel. Und dann hat dieses Beispiel, das
ich Ihnen zeigen werde eine Methode, die eine Zeichenfolge
namens I'm F9 als Parameter verwendet. Wenn die
Methode beispielsweise aufgerufen wird, übergeben
wir einen
Vornamen, der innerhalb einer Methode
verwendet wird , um
den vollständigen Namen auszugeben. Also lasst uns gleich darauf eingehen
und es uns selbst ansehen, oder? Nehmen wir also an, wir
haben public static void, und dann haben wir hier eine Zeichenfolge. Wir nennen es fname,
wie ich gerade sagte, F name
bedeutet wörtlich nur Vorname, oder? Dann sagen wir hier einfach fname. Wir rufen es wieder an. Und plus Reference läuft. Wenn ich das mache,
komme ich zu meiner öffentlichen statischen Leere hier drüben. Und jetzt spezifiziere es immer noch, weil ich angeben sollte, was
los ist, was hier passiert ist. Also muss ich
Namen nennen, zum Beispiel
Tom, Tom da drin. Aber denk daran, dass Tom eine Schnur ist. Also sollte ich es haben.
Tom als Zeichenfolge. Und da ist es, es
identifiziert ihn bereits als Zeichenfolge. Und dann auch hier rein, Lindy. Lindy, ja. Dann habe ich Sam hier drin. Und dann habe ich Rob hier drin. Und dann habe ich Lincoln hier drin. Und ja. Also, wenn ich das führe und
sagen wir, das ist ein Mittel,
das alles
buchstäblich für eine Familie zu erwähnen. Lassen Sie mich also sagen, es ist eine Familie von Thompsons Sendung
Thompsons. Ich habe also Tom Thompson, Linda Thompsons,
Sams, Thompsons, Rob Thompsons und
lecke auf Thomson's. Jetzt sagst du wahrscheinlich, hey, was ich
zwischen ihnen schaffen wollte, kein Problem. Sie können das immer einfach
tun,
indem Sie es hier platzieren. Und wenn Sie das tun, sollte
es ein
bisschen Abstand zwischen ihnen haben. Lass es mich so ausdrücken. Und voila hier. Tom Thompson war Linda Thompson. Und manchmal ist
alles eine Familie wenn man eine große Familie will. In Ordnung? Denken Sie also daran, dass ein Parameter, der
an die Methode übergeben
wird, als Argument bezeichnet wird. Aus dem Beispiel, das
ich Ihnen hier gegeben habe, ist
fname ein Parameter, während dieser Name Tom Lindy,
Sam Rob Lincoln oder Argumente ist , sehen
Sie, dass es sich
nur um Argumente handelt. Ich habe das Gleiche
auch in der Mathematik, was auch immer in der Klammer steht,
wir nennen es ein Argument. Und denken Sie daran
, dass Sie
so viele Parameter haben können , wie Sie möchten. Und sagen Sie einfach, dass
ich
für jeden von ihnen auch angeben wollte, dass hey, ich möchte ihr Alter wissen, damit
ich hier sogar das Alter angeben kann. Und wenn ich das einmal mache, muss
ich ein Komma setzen
und sagen, dass Tom 12 ist. Zum Beispiel. Lind ist der älteste. Sie ist 28 Jahre alt. Sam ist 20. Rob ist irgendwo zwischen 25. Und Lincoln ist nur für ja. Also wenn ich das durchführe, wird
es jetzt
auch ihr Alter zeigen. In Ordnung. Es wird jetzt
auch das Alter zeigen. Wie Sie sehen können,
zeigt es noch nicht , dass a warum das
ist? Warum ist das so? Das liegt daran, dass ich das hier nicht
angegeben habe, Hey. Ich will auch die Agenten, oder? Lassen Sie mich einfach dieses Plus,
Plus und H Tage Alter sagen . Also könnte ich sogar sagen, vielleicht füge eine Zeichenfolge hinzu, die so
etwas wie die Daten sagt. Dann sage ich das h, also lass es uns ausführen. Da ist es. Tom
Thompson ist installiert. Dann ist das groß, 828 Sätze sind 20. Rob Thompsons ist 25 und Lincoln Thompsons
ist vier Jahre alt. Das ist also das Schöne daran. Und Sie müssen nur
bedenken , dass, wenn Sie
mit mehreren Parametern arbeiten, die Methode Kohle
die gleiche Anzahl von Argumenten haben muss wie Parameter. Die Argumente müssen in derselben Reihenfolge
übergeben werden. Wir könnten also auch
einige Rückgabewerte haben. Denken Sie also daran, dass wir, wenn wir hier über
Rückgabewerte sprechen, die void-Tastatur verwenden, wir verwenden sie in, wir haben
sie in den obigen Beispielen verwendet. Es zeigt an, dass die Methode keinen Wert zurückgeben
sollte. Wenn Sie möchten, dass die Methode
einen Wert zurückgibt, können
Sie
anstelle von void einen primitiven
Datentyp wie ein Ende oder eine Dusche verwenden
und das Schlüsselwort return
im MathLab verwenden, richtig? Ein Beispiel dafür wäre :
Nehmen wir an, wir haben so
etwas. Lass mich mal sehen. Lassen Sie uns das hier in Kommentare schreiben. Den brauchen wir nicht. Anstelle von static void sage ich
einfach static int. Siehst du das? Wenn ich also static int sage, bedeutet das, dass ich mir sehr sicher bin
, dass ich
mit Ints arbeiten möchte , wenn Sie
wissen, was ich meine. Also kann ich das einfach machen
und einfach int age sagen. Und dabei sage ich
eigentlich, dass ich das sage, Hey, ich möchte auch,
dass du mein Alter
zurückgibst. In Ordnung? Also möchte ich, dass du das Alter zurückgibst. Könnte sogar sagen, dass Alter plus eine Reihe von Beispielen plus sieben
ist. Und das kann es, es kann
definitiv funktionieren. Und dann werde ich das jetzt definitiv
nicht brauchen. Also lass es mich entfernen. Und wenn es
dann um die statische Aufladung geht, beseitige diesen Fehler. Ja, wenn es um
diese Lücke hier drüben
geht, werde ich
sagen System dot out, dot print. Und ich werde meine Altersmethode
ausdrucken. Und ich gebe meinen Alterswert an, ich gebe ihn zum Beispiel als fünf an. Und wenn man ihm fünf gibt, bedeutet das, wenn es
erkennt, dass
alle fünf Jahre alt sind und es fünf plus sieben
sagt und bekommt,
jeder Künstler sollte
normalerweise Zwölfter werden , normalerweise sollte
er 12 bekommen.
Wunderschönen. Da ist es also. Es sind 12 geworden, oder? Dieses Beispiel gibt definitiv die Summe der Methoden zurück,
zwei Parameter. Sie können so kreativ sein,
wie Sie möchten um dies
auf
jeden Fall zu umgehen. Und nur ein
ausführlicheres Beispiel dafür wäre was, wenn ich es
gesagt hätte und warum ist es auch da? Eher nicht nur im Alter
, ich nenne es H1 und H2. Sei praktischer. Alter zwei sollte Sinn ergeben. Jetzt. H1 und H2, H1 ist dann auch eher, lass es mich als H12 sagen. Aber was macht nur
zwei wirklich, das ist wirklich
alles was ich brauche. Und wenn ich das im Wesentlichen tue, sage ich, dass
Rückkehr
zum Beispiel eins plus j2 ist , was fünf plus zwei sein
sollte, was eine Sieben sein sollte. Mal sehen, was wir
bekommen. Wir kriegen eine Sieben. Ich könnte sogar noch einen Wert hinzufügen, sieben plus drei, was jetzt eine Zehn sein
sollte. Also los geht's, es ist jetzt zehn, richtig? So können wir die beiden Parameter
wirklich
nutzen. Ja, Sie können
das Ergebnis auch einfach in einer Variablen speichern, was natürlich empfohlen wird, da es einfacher zu
lesen und zu warten ist, einfacher zu lesen und zu warten ist. Ein ausführlicheres Beispiel dafür ,
von dem ich
spreche, wäre, sagen
wir, Sie
hatten zum Beispiel x hier und y hier und das
kürzeste und das meiste, das wir
am meisten lieben, wenn wir reden über Mathematik ist y hier, und da ist ein x hier drüben. Und was wir tun wollen,
ist, dass wir einfach
angeben können , wann ein z hier ist, wenn wir wollen und z hier
nennen wir es unsere Methode. Und rufen Sie unter 54 an. Dann drucken wir einfach z. Richtig, ist nicht nur, um
all die Dinge auszudrucken , die zuerst
gedruckt werden wo wir
jetzt nur noch z ausdrucken können. Und lassen Sie mich das einfach schließen
richtig auch hier. Und mein Vater. Ja. Also sollte es hier
sofort funktionieren. Also lass uns sehen. Es sollte ohne meine
Methode einfach x0 sagen,
wirklich, das ist alles was wir brauchen. Also lassen wir
es einfach laufen und wir bekommen neun, das sind vier plus fünf, was einfach neun
sein sollte. Das ist also der andere
Wert dafür. Der andere Veranstaltungsort ist
definitiv dazu. Richtig? Richtig. Die nächste, mit der wir uns
definitiv befassen, ist Überlastung der
Java-Methode. In Ordnung? Die
Überladung der Java-Methode funktioniert also so. Beim Überladen können Sie mehrere Methoden
haben , die denselben Namen
mit unterschiedlichen
Parametern haben können , oder? Ein Beispiel dafür wäre vielleicht wenn ich etwas sagen würde wie,
hey, was ist, wenn ich ein Ende habe? Meine Methode? Lass es mich lieber med nennen, man ist gleich, nicht gleich oder
eher nur einem begegnet. Und dann sage ich int x. Und ja, anstatt x zu verwenden, habe ich es
vielleicht zu
oft in T ist besser verwendet. Ich denke Entitäten, aber
auf jeden Fall könnte ich auch einen Float
haben und es einfach auch verrückt
nennen. Und ich bin farbig float und habe auch doppelt. Verrückte Drei mit einer doppelten
Innenseite von Anrufen. Ein a und ein Doppel von B. Ja, auf jeden Fall
sollte das aber sein, wo wir es jetzt auch machen können. Was wir tun können, ist ein Beispiel dafür zu
haben. Ein Beispiel dafür wäre, lassen Sie mich
das einfach loswerden, weil es einige Dinge gibt, die ich anhand eines Beispiels klären und
verbessern möchte. Also lass es uns tun. Sagen wir das. Kehren wir hier zu unserer
statischen Methode zurück. Und wir sagen, ist das das Ende plus. Nennen wir es eine Plus-Methode. Dann haben
wir mit dieser Plus-Methode definitiv
int x und y,
und wir geben x plus y zurück. Und dann sagen wir static, static, double, static double. Wir haben also einen statischen
Doppel-Plus-Math-PFAD mit double hier drüben. Und das ist mit einem int hier. Sehr wichtig. Hier hat es sich verdoppelt, in den Klammern. Ich setze meine zwei
Doubles und nenne es ein doppeltes x, doppeltes y. Und gib einfach x plus y
zurück. Wieder, richtig? Und haben Sie einfach diese
öffentliche Statik. Lassen Sie mich
das alles entfernen. Ich brauche es nicht. Kommen Sie einfach zurück
und sagen Sie Lassen Sie mich einfach sicherstellen, dass
es hier hingehört. Ja. Ja. Also könnten wir hier eine
öffentliche statische Methode haben , die wir immer public
static, void main verwenden. Und nimm diesen Zug. Und oben auf dieser
Saite haben wir auch
unsere Quadrate. Also lass mich sie einfach holen. Wie du weißt, mit meiner Tastatur. Ich muss sie
ganz runterholen. So wie hier. Definitiv hier. Also bekommen wir ihnen String und RGS. Also genau dort öffnen wir
das und öffnen es. Was sagen wir? Wir sagen int num. Zum Beispiel. Meine Nummer eins
entspricht einer Plus-Methode. Und wir freuen uns über Veranstaltungsorte wie
Sieben Komma Neun zum Beispiel. Warum nicht? Dann sagen wir weiter doppelt. Und wir sagen meine Nummer zwei, was
plus Methode double entspricht. Und hier werden wir einfach etwas sagen, das ein bisschen ein Bruch
ist, vielleicht fünf Punkte, mal sehen, vielleicht 5,4 mit 6,9 zum Beispiel. Das. Und dann sagen wir einfach ein
System dot out dot print LN. Und was wir wollen, ist, dass wir unseren Integer-Veranstaltungsort
so mit einer Zeichenfolge drucken wollen, und spielen einfach all unseren r-Wert , den wir hier ausdrucken wollen, was plus num eins
sein wird. Richtig? Dann werden wir genau hier
etwas Ähnliches tun, sagt System dot out, dot print LN. Und genau hier drin werden
wir ein Doppel
im String-Format mit Alarm haben ,
Alarm Nummer zwei da drüben, richtig? Also lass es uns ausführen und
sehen, was wir bekommen. Normalerweise sollte es uns
Summen dieser beiden Werte geben. Hier. Es werden sieben
plus neun sein, was 16 ist. Und ein Doppel hier
wird uns geben, lassen Sie mich das
auch so formulieren, dass es relevant ist. Ein Doppel hier wird uns 5,4 plus sechs mal neun
geben, was nur 12,3 wäre. In Ordnung? Auf diese
Weise können wir also auf jeden Fall das
Überladen nutzen , wenn Sie möchten. In Ordnung.
15. Umfang: Okay Leute,
das nächste, was wir uns auf jeden Fall ansehen wollen,
ist das , was wir den
Java-Bereich nennen, oder? ist es also, Java-Geltungsbereich. Und wenn wir
über den Java-Bereich sprechen, sprechen wir
im Wesentlichen
nur über die Region, die zugänglich
ist, oder? Dort
werden Variablen gefunden, oder? Also lass es mich aufschreiben. Wir sprechen
von etwas der folgenden Natur. In Java wissen wir, dass Variablen selbst
nur zugänglich sind, nur innerhalb,
eher innerhalb einer Region. Sie sind geschaffen. Lassen Sie mich sicherstellen, dass ich das
auf die rechte Seite der Region stelle. Erstellt ist ein doppeltes S über
Matt sagte ursprünglich erstellt. Und das selbst nennen
wir den Geltungsbereich. Das ist unser Spielraum.
Also die Region, die sie verfügbar macht, das ist
im Wesentlichen der Umfang, oder? Variablen können also
direkt in einer Methode deklariert werden
und können daher
überall in der Methode verfügbar sein, die der Codezeile
folgt,
in der die Methode deklariert wurde. Ein Beispiel dafür wäre buchstäblich das, was ich hier
geschrieben habe. Ich schaue mir nur an, was
wir hier mit
unserer vorherigen Methode gemacht haben . Also haben wir eine öffentliche Klasse main, dann haben wir hier eine Methode. Wir nennen es vielleicht, lassen Sie
mich über dieses sprechen, insbesondere über die statische
Doppel-Plus-Methode double und dann haben wir das
und dann
haben wir hier das Interesse an einem. Konzentrieren wir uns genau hier. Konzentrier dich hier. Wir haben öffentliche statische,
void main, richtig? Was haben wir dann da drin? Wir haben alles, was
Sie tun wollen, da reintun. Richtig. Und es ist daher zugänglich. Alles was auch immer wir da draußen
erklärt haben, wenn es hier drin
gefordert werden kann, oder? Und wenn das keinen Sinn ergibt, kann
ich
das immer nur für Sie tun, um
weiter zu klären
, wovon wir sprechen. Ich kann mir das so vorstellen. Lassen Sie mich
das alles klären. Wir brauchen das wirklich nicht
mehr. Den ganzen Weg bis
genau hier und löschen. Und lass uns einfach
direkt gehen und öffentlich sagen. Keine obere Kappe, eine Kappe, eine öffentliche statische Leere. Eigentlich sollte ich einfach die ganze Sache
löschen, lieber diesen oberen
Teil hier entfernen. Das alles. Ja, das brauche ich nicht und das
brauche ich auch nicht. Aber das brauche ich
absolut nur, um meinen Standpunkt zu beweisen,
wovon ich spreche. Und was sagen
wir also hier? Wir sagen, dass wir
so etwas hier enden könnten . Der Code, der hier sein kann,
kann x nicht verwenden, oder? Das ist die Gegend. So haben wir es definiert. Und dann könnten wir dann
angeben, dass die Ganzzahl von x 100 entspricht, oder? Und damit können wir sagen, dass wir etwas erstellen können,
das X verwenden kann. Code hier kann x verwenden. Und wir rufen nach dem
Code, der x verwenden kann, oder wir sagen ein System
dot out dot print LN und rufen dann zurück,
und wir drucken x. In diesem Fall hatten
wir hier nichts, Wir wurden nicht deklariert. Was exit solve bedeutet, sehen Sie, also mussten wir es zuerst
aufrufen und diese Variable von x
deklarieren und daher in der Lage sein, sie dann
aufzurufen und auszudrucken. Wenn wir das jetzt ausführen würden, sollte
es uns einfach
geben können was x im Wesentlichen ist, oder? Und was ich tun werde,
ist nur sicherzustellen , dass alles in Ordnung ist, lass mich das einfach hier ablegen
und genau
hier hinstellen . Wunderschönen. Lassen Sie mich das einfach für Sie erledigen und selbst sehen,
was wir davon haben. Also führen wir es gerade aus. Und eine 100. liegt daran, dass x, wir x als 100
deklariert haben. Und das ist nur ein Methodenbereich , den wir immer noch genau hier
machen, genau dort in etwas, das
auch Block Scope genannt wird. Und ein Blockbereich, das
können Sie sich eher
so vorstellen, oder? Ein Codeblock bezieht sich also auf gesamten Code zwischen
den geschweiften Klammern, diese anderen farbigen Klammern, über die
wir sprechen. Also irgendetwas, was zwischen
diesen beiden farbigen Klammern zu
finden ist, das und das hier ist
nur ein Codeblock, oder? Jetzt werden Variablen
innerhalb eines Codeblocks deklariert, auf den nur der Code
zwischen den geschweiften Klammern
zugreifen kann
, der der Zeile folgt, in
der die Variable deklariert wurde. weiter auszuarbeiten Lassen Sie uns ein Beispiel geben, um es weiter auszuarbeiten. Sagen wir gleich hier mit dem gleichen Beispiel
, das wir hier haben. Nehmen wir an, wir machen so
etwas. Nehmen wir an, wir sollten,
anstatt x hier zu haben, Nehmen wir an, wir sollten so
etwas hier tun, wir wissen, dass ein Code hier x definitiv
nicht verwenden kann. Aber was wäre, wenn ich
etwas der
folgenden Art tun würde, um zu sagen und geschweifte Klammern
darüber zu legen, dann öffne ich die Seite. Sie stellen also fest
, dass alles, was sich zwischen diesen beiden geschweiften Klammern befindet,
hier ein Block ist. Das ist ein Codeblock. Was auch immer ich da reingetan habe, wäre
nur ein Codeblock. Und dieser
Codeblock genau da. X kann auch nicht verwendet werden. Light kann
auch x nicht verwenden. X kann nicht verwendet werden. Wenn
wir zum Beispiel
einfach angeben und sagen, dass
x gleich 100 ist. Nochmals, vielleicht nichts
Besonderes an einer 100, genau wie die Verwendung. Wir können sehen, dass der nächste Code , den wir implementieren
, definitiv
berücksichtigen kann, welcher
Zugangscode hier x verwenden kann. Und so können wir ihn einfach aufrufen und es ist
ein System Dot Out, dot print LN X. Wie wir sehen können, liegt
kein Fehler vor. Dann sehen wir also
, dass dieser
Codeblock genau hier endet. Lass mich das einfach machen. Rolle Also das ist gleich n genau hier. Legen Sie einen Blog und hier. Dann der Code
auch hier ,
der außerhalb der geschweiften Klammern liegt. Code hier, kann x nicht verwenden. also, dass Sie sehen, dass der Effekt, dass er innerhalb dieser geschweiften Klammern liegt, Ihnen den Zugriff auf x
ermöglicht. Aber in dem Moment, in dem es herauskommt, können
Sie nicht mehr auf
x und Daten zugreifen, wir haben unsere 100 da drüben , die wir gerade
spezifiziert haben, oder? Im Wesentlichen
geht es also wirklich um den Blockbereich und denken Sie daran, dass ein Codeblock für sich allein existieren
kann oder zu einer FYI
falscher Aussage gehören kann. Auf jeden Fall aus. Beachten Sie bei Anweisungen, dass in der Anweisung selbst deklarierte Variablen auch innerhalb
des Blockbereichs
verfügbar sind. Es ist einfach etwas
anderes, das du im Hinterkopf
behalten solltest, wenn du
programmierst, oder? Okay, das nächste,
worauf wir uns
konzentrieren sollen, ist das, was
genannt wird und all das. Lass es mich einfach löschen. Wir brauchen es nicht. Das nächste, worüber wir sprechen
wollen, ist das, was wir Java-Rekursionen nennen. Schreiben Sie Java-Rekursion. Also lass es mich einfach hier für uns
ablegen. Lass mich die einfach machen. Ja, Java. Manchmal passiert dies, wenn Sie
die Shift-Taste
eine Weile gedrückt halten . Java-Rekursionen. Fantastisch. Was ist eine Rekursion? Rekursion ist inhärent
nur die Technik, mit der IF-Funktion selbst aufrufen kann. Wenn Sie also eine Funktion haben
, die sich immer wieder selbst aufruft, was Sie dort gerade
getan haben nennen wir eine Rekursion, oder? Also da ist es, nenn dich selbst. Diese Technik
bietet definitiv eine Möglichkeit,
komplizierte Probleme in
einfache Probleme zu zerlegen komplizierte Probleme in
einfache Probleme , die leichter zu lösen
sind. Und natürlich ist das vielleicht ein bisschen schwierig zu verstehen, aber der beste Weg, es
herauszufinden, wie immer, nur zu codieren, muss
man es tun. Du musst dir die Hände schmutzig machen und es einfach selbst machen. Siehst du das? Schauen wir uns einfach
dieses Beispiel hier an. Nehmen wir an, wir möchten Rekursion
verwenden, um alle Zahlen zu addieren. Bis zu zehn. Willst du alle Zahlen hinzufügen? Nun, eine Sache ist das richtige
englische Wort hier. Alle Zahlen. Bis zu zehn, oder? Also, wie würdest du das machen? Nun, wahrscheinlich
möchten Sie zunächst einfach deklarieren, welche Methode
Sie verwenden werden. Also werden wir static, void,
main und call string
verwenden . Hier, ARG ist da. Und genau mit unserer
Saite da drüben. Wir wollen nur die Quadrate hier
benutzen. Also nenne ich sie einfach so. Und komm zurück und ändere meine Tastatur wieder in
den normalen Standardmodus. Und dann int resultiert definitiv innerhalb unseres
Codeblocks, und wir sagen Summe von zehn. Das ist es, was wir uns oft
ansehen. Und in Kürze werden
wir definieren,
worum es bei der Summe von
zehn geht. Was heißt das? Was sollte Java verstehen,
wenn man berücksichtigt, was Summe von zehn bezeichnet
wird, oder? Also drucken wir das Ergebnis hier aus. Was wir dann tun wollen, ist, gleich nachdem
wir das so herausgenommen
haben, hier eine
andere Methode erstellen wollen, die definiert,
was some selbst bedeutet. Also sagen wir int sum. Und dann rufen wir einfach
den ganzzahligen Wert von k auf .
Ja, da ist er also. Jetzt erkennen wir es. Java ist also in der Lage zu interpretieren
und zu sagen, oh, okay, also der Wert einiger,
es gibt eine Methode , die in der Lage ist, die Sonne
aufzurufen. Es muss also noch verstanden werden,
was diese Methode tatsächlich speichert und wie
sie sich verhalten sollte, oder? In Ordnung? Und dann sagen wir einfach, wenn k, wenn k größer als 0 ist, was passieren sollte,
ist das Folgende. Wir sollten k zurückgeben und die Summe addieren weil wir wollen, dass es
rekursiv ist k minus eins. Ja, hier kommt also die
rekursive Fähigkeit ins Spiel. Und ich werde
das so interpretieren, dass du gerade sortiert
bist, du kannst jetzt gründlich verstehen, was genau hier vor
sich geht. Andernfalls sollte das tun. Bedeutung der Bedingung
ist, dass sie nicht erfüllt Geben Sie einfach
den Wert 0 zurück. Und das war's auch schon. Das war's wirklich
schon. Das war's auch schon. Lass mich
das einfach tun, damit ich uns hier
immer verirren kann . Dieser Typ, ich werde
sie nehmen und sie
ziehen und den
ganzen Weg hierher bringen. Nur damit du dich an den
Kerl hier unten, unten, erinnerst. Sims, irgendwo in
diesem Codeblock, mit dem wir uns befasst haben
, ist ein kleiner
Fehler aufgetreten diesem Codeblock, mit dem wir uns befasst haben
, ist ein . Ja, tu das einfach. Der ganze Fehler ist weg. In Ordnung,
was sagen wir also im Wesentlichen hier? Was wir hier
im Wesentlichen sagen, und ich werde
hier nur ein
paar Kommentare abgeben
, damit Sie besser
verstehen können, was vor sich geht. Wir addieren Werte und
lassen Sie es uns übrigens schneller ausführen. Wir können sehen, ob es funktioniert oder nicht, und dann können wir jetzt mit
dem nächsten Schritt fortfahren. Da haben wir
es also. Es ist 55 Jahre. kannst du immer selbst machen. Versuchen Sie einfach und sagen Sie 0
plus eins plus zwei
plus drei plus vier
plus fünf plus sechs
plus sieben plus neun plus zehn, Sie erhalten 55. Wie passiert das
eigentlich? Nun, was passieren wird
, ist das. Ich nehme hier unseren Wert, unseren Ergebniswert. Und normalerweise ist
es offensichtlich eine Klasse. Und dann
wird Java dem
Wert des Ergebnisses suchen,
die Summe und sagen: Oh, die Summe
ist, dass die Räumung tatsächlich
ein Wert von zehn ist. Und dann sag, was macht
diese Methode von manchen?
16. Halting: Wie läuft es eigentlich? Also wird es einfach herkommen und versuchen zu verstehen,
worum es bei Sam geht. Und es wird hier einen
Wert von zehn registrieren, oder? Weil wir
es als zehn gewählt haben und dann sagen, dass zehn größer als 0 ist. Stimmt das? Und dann
sagst du: Ja, das stimmt. Wenn das der Fall ist,
gib k zurück, was in unserem Fall zehn ist. Es wird also
der Wert zehn zurückgegeben. Und dann plus die
Summe von k minus eins. In unserem Fall ist k zehn. Also zehn, im Grunde sind
es 1010 minus eins. Im Grunde
wird das passieren, oder? Und was ist zehn minus eins? Das sind eigentlich neun. Also
sprechen wir im Wesentlichen über die Summe von mir, von einigen von mir. Und es wird den gleichen
Wert von neun annehmen. Nimm es den ganzen Weg zurück. Und wir sind immer noch in dieser Schleife. Wir kommen noch nicht raus. Also wird es hier
hochgehen und sagen, neun ist größer als, ist neun größer als x4 und
sagt, ja, das stimmt. Also tendieren wir zu einem Wert
von neun, siehst du das? Im Grunde wird es dir
nur geben, jetzt ist es dort keine Summe mehr
. Es wird selbst nur den
Wert von neun haben. Plus die Summe von, es wird neun minus eins sein, was die Summe von acht ist. Hast du das gesehen? Mit der Summe von acht wird dasselbe
passieren. Es geht über
die Acht ist größer als 0 und gibt dann
den Wert von acht zurück. Jetzt haben wir also den
Wert von acht selbst. Keine, keine Methode der Acht, aber es ist ein Wert von acht selbst. Und dann
heißt es Summe von sieben. Dann läuft der gleiche Prozess
weiter. Und das
macht rekursiv. Denken Sie daran, dass die Unterdrückung
von Natur eine Funktion
wiederholt, die sich
immer wieder selbst aufruft. Das machen wir hier. Wir machen diese
Funktion von einigen Coupons sich immer
wieder und immer wieder
aufrufen. Also wird es das auch weiterhin tun. Und das bedeutet, dass wir
plus sieben plus sechs plus fünf plus vier plus drei
plus zwei haben. Ich werde sie plus eins
ausräumen, oder? Und wenn es dann zu einem kommt,
was wird es sagen? Es wird im Grunde
nur sagen, dass eins größer als
0 ist. Stimmt das? Gib eins plus Summe von eins
minus eins zurück, es ist 0, oder? Also wird es hier plus
Summe von 0 sagen. Die Summe der Nullen. Dann wird es die Summe von 0 nehmen, sagen wir den Wert von k
, der jetzt als 0 definiert ist. Sie werden also sagen, dass 0 größer als
0
ist und wir haben festgestellt
, dass das nicht stimmt. Das ist falsch. Und Salz, weil
diese Bedingung
nicht mehr erfüllt ist, wird
es jetzt übersprungen. Überspringen Sie diese bedingte
Anweisung und kommen Sie her und sagen Sie, dass wir sonst
0 tendieren, was wahr ist. Also wird es am Ende nur noch eine zusätzliche
0
hinzufügen. Siehst du das? Wie Sie sehen können, addieren sie sich
immer wieder. Also hier heißt es nur
zehn plus 919 plus acht. Siebenunddreißig, vierundfünfzig. Und tatsächlich werden
es 19,
27 für 40, fünfundvierzig,
neunundvierzig, fünfzig bis 5455 sein. Siehst du das?
So fasst es diese
Werte also immer wieder selbst zusammen. Du wirst sie hinzufügen. Es wird sie nicht aufnehmen. Ich nehme sie nur
so auf, um deinetwillen. Aber was es tatsächlich tun wird
, ist , dass es jedes Mal weiter macht und etwas wie zehn plus neun Einrückungen in 19 macht
und dann 19 plus acht sendet. Und dann gib dir, wie
gesagt, 2727 plus sieben. Und dann gibt es dir 34. Und dann werden 34 plus sechs
hinzugefügt, und wir geben 4040 plus fünf. Geben Sie 45, und
dann sagt es 45 plus vier, und dann gibt es 49
und dann 4949 plus drei. Und es wird 5252 plus zwei geben
. Und wir geben 54.
Und es heißt fünf bis vier plus
eins ergibt 55. Hast du das gesehen? So steigt es also und wächst tatsächlich
auf einen Endwert von 55 heran, oder? Denken Sie also daran, dass beim Aufruf
der SUM-Funktion der Parameter
k zur Summe
aller Zahlen kleiner als
k hinzugefügt wird der Parameter
k zur Summe
aller Zahlen kleiner als
k hinzugefügt und das Ergebnis zurückgegeben wird. Wenn K also 0 wird, die Funktion einfach 0 zurück,
wenn die Ausführung im Programm den Schritten
folgt, die
ich Ihnen
gerade oben gezeigt habe gibt
die Funktion einfach 0 zurück,
wenn die Ausführung im Programm den Schritten
folgt, die
ich Ihnen
gerade oben gezeigt habe, oder? Es könnte also natürlich nur ein bisschen kreativer
sein und vielleicht sogar
eine Anhaltebedingung geben, eine Stoppbedingung, wann
es wissen sollte, wann es aufhören muss, unter
welchen Umständen -Szenario sollte nicht aufhören. Darüber reden,
über die Halting-Bedingung sprechen. Anhaltende Bedingung. Wenn Sie darüber sprechen, wissen
wir, dass genau wie Schleifen auf ein Problem
des unendlichen Loops stoßen können, rekursive Funktionen ein Problem
unendlicher Rekursionen beenden können , wenn
die Stoppbedingung dies nicht ist richtig angegebene Rate. Deshalb
müssen wir also etwas über
das Herz lernen und
die Stoppbedingung konditionieren,
wie
ich gerne sage, ich werde diese
Kraft einfach hier auf diese Weise einsetzen
und sie einfach so ausdrücken. Richtig? Fantastisch. Großartig. Okay, es ist jetzt okay,
also haben wir ihn über die Halting-Bedingung und die
unendliche Rekursion oder Sorgen informiert,
oder besser gesagt, es ist, wenn
die Funktion nie aufhört, sich selbst aufzurufen.
Leg einfach die Toten hin. Unbegrenzte Rekursion ist, wenn eine Funktion niemals aufhört, sich selbst aufzurufen. Richtig? Jede rekursive Funktion sollte die Halting -Bedingung
haben. Dies ist
die Bedingung, in der die Funktion aufhört, sich selbst
aufzurufen. Im vorherigen Beispiel. Zum Beispiel ist die
Holton-Bedingung, wenn der Parameter k, wie wir gesehen haben, k 0 wurde , das war, wie
Java wissen musste,
dass wir
genau hier aufgehört haben, oder? Daher ist es hilfreich, sich
verschiedene Beispiele
anzusehen , um das Konzept besser zu
verstehen. In diesem Beispiel fügt
die Funktion einen Zahlenbereich zwischen
einem Anfang und einem Ende hinzu. Die Hot-End-Bedingung für
die Funktion von Lucas ist also Funktion von Lucas ist , wenn n nicht größer
als stat ist, oder? Also werden wir hier
ein Beispiel geben und versuchen
zu sehen, ob wir Regression verwenden
können. Also werden wir die
Rekursion verwenden und sie für uns
ablegen. Wir wollen Gehirnerschütterung hinzufügen, dass alle Zahlen zwischen 510 liegen. Also alle Zahlen zwischen 510. Also werden wir das tun und sehen, wie sich unsere
ganze Sache entwickelt. Also gehen wir zurück, genau
hier, und modifizieren einfach die gleiche
Sache, die wir benutzt haben. Also nur das Endergebnis. Und dann
werden wir es für einige hier ein bisschen
interessant machen ,
anstatt nur zehn zu sagen. Da wir wollen, dass es
bei fünf beginnt , sage ich 510. Ja. Es wird also rot, denn soweit die Methode einiger
bereits definiert war, hatte
sie nur einen
Parameter, also ist es ein bisschen verwirrt darüber was hier tatsächlich
passiert. Also werden wir es ändern,
wenn dies dauerhaft ist. Wir werden eine permanente
Startdauer von
int haben und dann Paramount
of India hier beenden. Jetzt ist es in Ordnung, weil
wir es als
zwei Parameter definiert
haben , die als
fünf als Start erkannt wurden und das Ende
sehnen. Und denken Sie daran,
dass nur die Namen von Variablen bestimmt werden, damit ich weiß, dass diese
die anderen Endungen beginnt. Weil das Studieren und
bestimmte Funktionen haben, die Java erkennen kann , dass das Starten in
ein plötzliches Endosomenwissen bedeutet, habe ich sie einfach so genannt. Ich hätte sie x, y,
z nennen können, wie auch immer ich will, oder? Aber was ich tun werde ist
, dass ich sagen werde,
ob das Ende größer ist
als mein Anfang, genau wie wir es
bei einem früheren Fall getan hatten. Das Ende ist größer
als mein Anfang. Dann möchte ich
das Ende zurückgeben und meine Statistik verfolgen lassen. Es wird Anfang
und Ende minus eins sein. Also wird es das
immer und
immer und immer wieder tun . Und dann sollte es das Ende
zurückgeben. Jetzt buchstäblich fast wie die andere Frage, die
wir gerade gestellt haben. Wenn Sie aufpassen, können
Sie sehen, dass es wirklich fast so ist, wie wir es vor ein
paar Minuten getan haben. Also werden wir
weitermachen und es ausführen und
sehen , was sich daraus ergibt. Und da haben wir es. Wir haben
da drüben Tal von ich glaube
das sollte was sein? Fünfundvierzig. Ist es das? Ja. Ich glaube es sind 45. Das sagt
dir also nur, dass eins plus zwei plus drei plus vier
einfach was tun? Sie summieren sich auf zehn,
weil das der Unterschied
zwischen den anderen ist. Aber fünf plus sechs plus
sieben plus acht plus neun. Bis zu zehn, es
gibt dir wirklich genau was? Es gibt dir 45 selbst, oder? Da haben wir also tolle
Leute als wir sie haben.
17. Objektorientierte Programmierung: In Ordnung, das nächste,
was wir
untersuchen wollen, ist das, was heißt. Und das ist wahrscheinlich eines
der wichtigsten Dinge, die wir in Java
auf jeden Fall wissen wollen. Es ist Java, OOP, objektorientierte
Programmierung, oder? Und dafür steht
all P. O P bedeutet im Grunde
nur Objekt. Runter für dich. Die
objektorientierte Programmierung. Damit werden
Sie oft
in Kontakt kommen . Denken Sie also daran, dass es bei Prozedur oder
Programmierung darum geht Prozeduren oder Methoden zu
schreiben , die Operationen
an den Daten ausführen Während es bei der objektorientierten
Programmierung darum geht, Objekte zu
erstellen, die
sowohl Daten als auch Methoden enthalten . Aber offener Typ darüber, sowohl Daten als auch Methoden, oder? Also objektorientiert, darüber gibt es
einen Kandidaten für Bindestriche. Objektorientierte Programmierung hat gegenüber der
prozeduralen Programmierung
mehrere Vorteile, oder? Diese Vorteile
sind also Vorteile von 00 p gegenüber dem Verfahren. Alles Programmieren. Rollenprogrammierung. Der erste ist o p ist
wirklich schneller im Loch. Es ist auch in der Lage, schnell
erledigt und ausgeführt zu werden. Und das ist
definitiv der Wind Sie tun möchten, wenn Sie an Fristen und allem
arbeiten. Und eine andere Sache ist, dass
all P in einfach eine
klare Struktur
für Probleme für Programme bietet klare Struktur . Es gibt also eine klare
Struktur für Programme. Und auch OOP hilft dabei, den Java-Code trocken zu
halten. Und mit trocken meinen wir, dass Sie sich nicht wiederholen
müssen. Wiederhole das nicht. Das ist es, was Sie zu lösen treibt. Lass mich das einfach
richtig aufschreiben richtig ,
damit wir es haben. Du musst dich nicht
wiederholen. Und macht es daher einfacher,
den Code zu warten und zu ändern,
wenn Sie möchten. Und natürlich debuggen,
weil es Code gibt. Vor allem nach
vielen Dingen finden Sie die Bugs irgendwann in den Code
kommen und Sie möchten
den Wert aller Ps haben , die
es Ihnen ermöglichen, einfach,
ohne großen Aufwand,
wirklich zu debuggen oder hat Bugs aus deinem Code und
allen p entfernt. Und ermöglicht
die Erstellung wiederverwendbarer,
wiederverwendbarer wiederverwendbarer Anwendungen mit weniger Code und kürzerer Entwicklungszeit. Das ist
das Schöne daran. Das ist das Schöne daran, oder? Denken Sie also daran
, dass das DRY-Prinzip oder das Prinzip „
Nicht wiederholen darin besteht, die
Wiederholung von Code zu reduzieren. Sie sollten die
für
die Anwendung üblichen Aufrufe extrahieren , sie
dann an
einem einzigen Ort platzieren und wiederverwenden,
anstatt sie zu platzieren. Siehst du das?
Das ist also das Schöne an objektorientierter
Programmierung. Wenn wir über O P sprechen, können
wir nicht über
OOP sprechen, wir können nicht über ein gewisses Verständnis oder
ein gründliches Verständnis
von Klassen und Objekten sprechen gewisses Verständnis oder . Aber es ist der Unterschied
zwischen diesen beiden und was genau Erwachsenen. Verstehen Sie einfach, dass
Cluster selbst im Wesentlichen ein
Objekt sind und nicht die beiden Hauptaspekte der
objektorientierten Programmierung. Klassen und Objekte sind
zwei Hauptaspekte von o p. Und Sie können sich eine Klasse
wie eine Gruppe von Lebensmitteln vorstellen ,
zum Beispiel Obst. Die Objekte dieser
Klasse werden was sein? Die Objekte werden es sein. Die verschiedenen Früchte da drin. Du siehst, dass wir einen Apfel haben
könnten. Du könntest eine Mango haben, du könntest ein Paar haben. Du könntest eine Banane haben. Es könnten all diese Dinge sein. Du kannst dir eine Klasse
eher wie
etwas vorstellen , das andere
Dinge
enthält. Eher wie das, was Sie
hier gesehen
haben , ist ein Cluster, und dann haben wir
innerhalb der Klasse verschiedene Objekte, über die
wir sprechen können. Sie sehen, dass
die ganze Klasse derselben Klasse das sieht. Ein anderes Beispiel wäre
wahrscheinlich eine Klasse von Autos. Klasse von Autos. Und in Autos können
wir über Volvo sprechen, wir können über Kurven sprechen. Wir könnten darüber reden, wie Honda, ja, am Ende, Audi, richtig? Am
Ende des Tages sind sie also alle Kosten, aber die Klasse ist das
, was sie enthält. Sie können sich die
Klasse also als Vorlage für
Objekte und ein Objekt als
Instanz einer Klasse vorstellen . In Ordnung? Das ist der Begriff , den Sie oft hören werden, wenn
Sie ein Klassengewicht haben. Das ist also wichtig. Und wenn die einzelnen
Objekte dann erstellt werden, erben
sie alle Variablen und Methoden der Klasse. Und wir werden auf jeden Fall
etwas später ausführlicher darauf eingehen. Aber im
Moment ist das alles für den Moment. Okay, das
nächste, was wir uns ansehen
sollen, ist das , was wir die
Java-Klassen und -Objekte nennen. Ich meine, wir haben hier schon ein bisschen angefangen
, aber wir werden uns jetzt ein bisschen mehr mit ihnen
befassen. Wissen, dass Java selbst
eine objektorientierte
Programmiersprache ist , ist
alles in Java zusammen mit
seinen Attributen und Methoden mit
Klassen und Objekten verknüpft zusammen mit
seinen Attributen und Methoden mit
Klassen und Objekten . Zum Beispiel hat
das Chi im wirklichen
Leben, Kaizen-Objekt, Attribute
wie Gewicht, Farbe und Methoden wie Dr und
Break fast eine Surf-Methode oder C. Eine Klasse ist also ein Objektkonstruktor oder eine Blaupause zum Erstellen von
Objekten, oder? Also, um eine Klasse zu erstellen, verwenden
wir normalerweise, was benutzen wir? Wir verwenden das Schlüsselwort class. Ein Beispiel dafür wäre
wahrscheinlich
so etwas wie dieses. Zum Beispiel könnte ich öffentlich sagen. Das ist nur ein bisschen vorbei. Nur damit du
verstehst, wie du das machst. Öffentliche Klasse, wie Sie uns schon oft
gesehen haben. Mai. Dann werden wir natürlich diese geschweiften Klammern hier
haben. Niemand könnte sagen, dass x
gleich Phi ist, oder? Das ist also einfach etwas , das wir so oft
gesehen haben. Normalerweise hat er
das schon meistens für dich getan. Aber dann, wenn Sie
ihre Szenarien vorantreiben , in denen Sie dies vielleicht selbst tun
möchten. Aber im Moment ist
das alles, was Sie brauchen könnten. Das ist
vorerst in Ordnung, macht Sinn. Und natürlich werden wir hier ein Kinderspiel
haben, um es zu schließen. Aber nur weil
es ein Beispiel ist, werde
ich nicht so weit gehen,
um das zu zeigen, oder? Aber um dies zu
erstellen und eine Klasse zu erstellen, ist
es wirklich das. Was ist mit dem Erstellen eines Objekts? Und Objekt? Was soll ein Objekt erstellen? Was wir das machen wollen. In Java müssen wir zuerst
beginnen, ein ungeordnetes und in Java wird
ein Objekt
aus einer Klasse erstellt. Die Klasse main haben wir hier bereits erstellt. Das ist der Name der
Klasse, sie heißt main. Jetzt können wir dies verwenden
, um Objekte zu erstellen. Um ein Objekt von main zu erstellen, geben Sie den Klassennamen
gefolgt vom Objektnamen und verwenden Sie das Schlüsselwort. neu. Beispiel wäre
genau hier in der
gleichen Klasse hier, Nehmen wir an, wir sollten ein Objekt in say,
public static, void, main
erstellen ,
wir sagen, dass es
in dieser Objektzeichenfolge rekrutieren wird. Und ich werde
diesen Teil einfach hier übernehmen. Im wahrsten Sinne des Wortes
dasselbe, was wir wollen. Zeichenfolge. Und dann sagen wir
einfach im Haupt- und Doppelpunktobjekt mein Objekt. Also rufen wir
hier eine Methode auf und wir nehmen unser
gesamtes Objekt und wir sagen new, vielleicht sehen wir new main und
genau dort
sagen wir auch system dot
out, dot print LN. Und dann haben wir einfach
alles gesehen und das geschlossen. Dann
hätten wir
von x abgezogen werden können, wenn wir nicht
wirklich konsumiert hätten. Du hattest dort schon einen
Wert von x. Und das können wir ausführen. Siehst du. Also lass mich genau das kopieren und einfügen
, was wir hier gemacht haben. Und lass es uns gleich hier hinstellen. Nicht mehr in den Kommentaren, aber in der Tat, die im Moment noch laufen
wird. Nehmen wir an, schließen Sie es hier. Also hier
haben wir schon eine Klasse, also
müssen wir das nicht noch einmal machen. Dann sehen wir mal, hier haben
wir bereits eine öffentliche statische
Leere für uns erledigt, sodass wir es nicht noch einmal tun müssen. Wir können
hier buchstäblich dasselbe
nehmen und
es einfach dort unten platzieren. Und tröste diese Konsole schlecht. In Ordnung. Und wir können das nehmen, stellen Sie es hier oben hin, denn es ist ein
Online-Kurs, der allgemeine. Und wir haben bereits
alles vorbereitet. Okay, also hier
die Herausforderungen, die Bain im Sinn hat, dass wir unseren Klassennamen als
Hello World
haben, oder? Seit unserer Klasse
haben wir es nämlich schon als Hello bezeichnet. Hallo Welt,
wir werden es einfach die Welt nennen. Und wenn er
auch, Hello World, das ist der Standardname
, den wir hier haben. Von dem, wovon wir sprechen. Das ist kleines m, mein OB-Gen. Und es wird x heißen. Es ist kein Minus.
18. Klasse und Objekte: Okay, das nächste, was wir uns ansehen
wollen
, ist, uns wirklich
mehr auf die Java-Klasse
und Objekte zu konzentrieren , oder? Also werden wir uns einfach
mehr darauf konzentrieren, besonders. Und denken Sie daran,
dass Java als objektorientierte
Programmiersprache
alles, was wir in
Java tun,
entweder mit diesen beiden Dingen hier
in der Klasse oder mit einem Objekt verbunden ist , zusammen mit seinen
Attribute und Methoden. Also zum Beispiel ist
ein Auto im wirklichen Leben ein Objekt
und das Chi ist was? Es hat Eigenschaften
wie Gewicht und Farbe. Und Methoden
wie Dr. und Break. Sie können sich Methoden
als Handlungen vorstellen. Was ist zu tun. Siehst du das? Attribute wie
du aussiehst. Siehst du, kann ich das richtig
beschreiben? Also ist I plus wie ein Objektkonstruktor oder eine Blaupause zum
Erstellen von Objekten. Damit wir also eine Klasse erstellen können, ist
wirklich alles, was wir brauchen,
einfach
so etwas zu sagen und helloWorld der öffentlichen
Klasse zu sagen, oder? Also haben wir schon von
allen
Klassenjahren Hello World benannt . Normalerweise würde Java das für Sie
erledigen, aber es kann Szenarien geben,
in denen Sie vielleicht nicht, vielleicht möchten
Sie das selbst
tun. Aber im Moment ist es okay. Und dann könnten wir zum Beispiel sogar sagen, dass x
gleich fünf ist . Und, ähm, ja, das
könnte definitiv funktionieren. Und wenn wir dann vielleicht ein Objekt
erstellen wollen , das
das ursprüngliche war ,
als eine Klasse zu erstellen. Aber in diesem Fall
wollen wir ein Objekt erstellen. Um ein Objekt zu erstellen, müssen
Sie
bedenken, dass in Java ein Objekt
aus einer Klasse erstellt wird
und wir bereits
die Klasse namens
HelloWorld force erstellt haben , wie Sie es klar können
sieh hier drüben, richtig? Jetzt können wir dies verwenden
, um Objekte zu erstellen. Um also ein Objekt
von Hello World zu erstellen, müssen wir
den Klassennamen
gefolgt vom Namen angeben und dann das Schlüsselwort new verwenden. Ein Beispiel für Holz wäre
das Folgende. Sagen wir öffentlich, statisch, nichtig. Öffentliche statische Leere. Probieren wir es aus und sagen
einfach main string. Lass mich einfach so schnell umziehen. Fügen Sie das ein, kommen Sie zurück und ERGs. Und genau hier,
hallo Welt. Mein OBJ Objekt, eigentlich
Abkürzung für objects, new, hello-world und voila. Dann könnten wir auch
einfach sagen: Hey, wir wollen die Sprint-Zweifel
oder das System unserer Print-LN. Und dann drucken wir
meinen OBJ-Punkt x Punkt x. Also was auch immer das Objekt wirklich mit x
multipliziert wird, oder? Also was haben wir uns ausgedacht? Im Grunde haben wir uns nur fünf
ausgedacht, oder? Also bekommen wir den Wert
von fünf da drüben. Und so könnte es ein
Szenario geben, in dem wir vielleicht mehrere
Objekte einer Klasse
erstellen möchten . Und um das zu tun, wird
es immer noch
sehr, sehr einfach sein. Gar nichts kompliziertes. Was wir tun wollen
ist, dass du wirklich
nur sag hallo world
benutzen wolltest, und dann spezifizieren wir jetzt mein OBJ
und sagen es. Nehmen wir an, der erste
war religiös wie einer oder nur der Anfang einmal oder in zwei Teile
spezifiziert
und sagen einfach neu. Dann sagen wir hallo Welt. Und denken Sie daran
, dass wir hier die
Objektnummer haben ,
Einwände dagegen. Hier haben wir Objekt eins. Objekt eins, richtig? Was wir dann tun wollen und vielleicht könnten wir
beide wirklich ausdrucken, warum nicht? Sie könnten
dasselbe System wählen. Punkt aus, Punkt, Druck. Und dann mein OBJ, der erste. Die zweite,
weil wir bereits die erste
haben oder mit a. Und dann sagen wir einfach mit x, und normalerweise sollten wir
beide herausbringen. Das sind 55. Das ist also das Schöne
daran. Das ist
das Schöne daran. Im Wesentlichen
sagen wir ihr, dass sie alles
ausdrucken soll , was sie in dieser Klasse
findet, insbesondere den Umfang von X, wie wir
es dort drüben angegeben haben. Es könnte Szenarien geben
, in denen Sie das vielleicht müssen. Also ja, ich hoffe, das
hilft dir
definitiv dabei, das hilft dir definitiv. Das nächste, was wir uns ansehen
wollen, sind die
sogenannten Klassenattribute von Java. Richtig? Hier sind sie. In Java-Klasse Attribute, Attribute, was sie tun. Und dann ist
es auf Englisch einfach etwas , das die Eigenschaften
von etwas definiert, oder? Im vorherigen Szenario oder
weniger als wir
über Klassen und Objekte gesprochen haben. Und noch früher haben wir sogar
definiert, was unveränderlich bedeutet. Eine Variable ist also
eigentlich ein Attribut
einer Klasse, das es wirklich
wert ist, notiert zu werden. Variable ist ein
Attribut der Klasse. Um ein Beispiel zu geben:
Nehmen wir an, wir haben eine Klasse
namens remove all dies. Wir haben
hier eine Klasse, sie heißt zum Beispiel
Hello World. In diesem Sinne erstellen
wir daher Attribute. Es wird also x. Und x ist fast fünf,
wie wir es zuvor getan haben. Wir könnten zum Beispiel sogar eine
weitere in
y erstellen , die gleich
sieben ist. Diese beiden Dinge, x und y, unsere beiden Attribute, haben
wir
bis jetzt gesehen , dass
es Variablen gibt. Jetzt verstehen
Sie, dass es sich nicht nur um Variablen handelt, sondern auch um Attribute. Das sind sie,
das ist was die, und. Ein anderer Begriff für
Klassenattribute sind also Felder. Anstatt
sie also Attribute zu nennen, können
Sie
sie auch immer nur Felder nennen. Um auf
diese Attribute zuzugreifen, können
Sie auf sie zugreifen, indem Sie ein Objekt
der Klasse
erstellen und die Punktsyntax
verwenden. Dieses Beispiel, das ich Ihnen
jetzt zeigen werde, wird Ihnen helfen, ein Objekt
unserer Klasse mit dem Namen
my OBJ
zu erstellen unserer Klasse mit dem Namen , wie ich
sie verwendet habe, all mein Objekt. Und wir verwenden den genauen Tribut und das Objekt, um seinen Wert zu drucken. Um
Ihnen zu helfen , mehr zu verstehen
, wovon ich spreche, rufen
wir einfach public
static, void, main, string auf. Nimm einfach dieses RGS und lockere
einfach dieses Memo. Und ja, lass uns Klasse HelloWorld
und Colon, unser OBJ, haben. Denken Sie daran, dass es nicht
unbedingt alles sein muss. Man kann
es immer etwas anderes nennen. Also rufen wir jetzt eine neue Klasse auf. Dann drucken wir das einfach
aus. Du druckst es aus. Und mal sehen, was wir
von diesem schönen
, schönen, schönen haben. So
greifen wir definitiv auf diese Attribute zu. Dann könnten wir auch
die Attribute ändern, die wir bereits definiert haben. Ein Beispiel wäre, lass uns über genau
das sprechen, was ich hier gemacht habe. Nehmen wir an, ich rufe x auf, nur x in den folgenden
Minuten statt fünf, ich sage nur x und x. Ich könnte es hier ändern
und einfach mein Objekt hier sagen, und einfach so. Aber mein Objekt von x
entspricht fünf. Lass es mich einfach weglegen. Es
entspricht also fünf Tagen. Und dann führe ich mein Objekt von x. Und ich erhalte fünf. Wenn ich das auf 124 ändere, sollte
ich 124 bekommen,
weil ich es geändert habe. Siehst du, anfangs war
es nur x. Und habe es
gleich da drüben verändert. Okay, wenn es
zum Beispiel Herbst war, sind wir hier. Lass es uns einfach ausführen und
versuchen es zu verstehen. Es wird immer noch eine 124 sein. liegt daran, dass der
Anfangswert, den es erhält,
wirklich so ist , wie wir es sehen. Aber dann kommt es zu diesem
Stadium und sagt, dass der
ganze neue Wert von x
, den ich eingeben
sollte, 124 sein sollte. Weil es immer
bis zu Java geht, nimmt es
immer die neuesten
Informationen mit. Das ist die, die die vorhandenen Informationen
überschreibt. Das ist, das ist wirklich das,
was man dazu sagen kann. Also kann ich einfach
den CN-Kommentar abgeben und sagen, dass x jetzt 124 ist. Das ist es doch, oder? Wenn Sie also nicht
die Möglichkeit haben möchten ,
vorhandene Werte zu überschreiben, deklarieren Sie das Attribut hier immer als letztes Beispiel. Man könnte sagen, wenn Sie nicht möchten, dass es sich zu irgendeinem Zeitpunkt ändert, könnten
Sie ein letztes x sagen. Wie Sie jetzt sehen können, ist es für mich ein
Fehler, dies zu ändern. Ich darf es in nichts
ändern. Es ist dann für sich selbst
, weil es mir keinen Wert erlaubt , irgendeinen Wert anzunehmen. Überhaupt nicht, noch überhaupt kein
neuer Input. Ich verstehe. Also muss ich das loswerden und dann wird
alles in Ordnung sein. Und wenn ich das drucken würde, sollte
ich den Wert
von nur für sich selbst bekommen. Also Betas, die wir nicht haben. Ein anderes Szenario, mit dem Sie möglicherweise
arbeiten
könnten , ist vielleicht die
Arbeit mit mehreren Objekten. Und das ist schwierig, wenn Sie mehrere
Objekte in einer Klasse erstellen möchten, können
Sie die
Attributwerte in einem Objekt ändern ohne die
Attributwerte in der anderen zu beeinflussen. Beispiel, wenn Sie
den Wert von zusätzlichen 25 und
Objekt Nummer zwei ändern und x in Objekt Nummer
eins belassen und geändert haben möchten. Sie könnten etwas
der folgenden Art tun. Nehmen wir an, sie haben das. letzten brauchen wir hier
vorerst nicht. Wir haben zwei Objekte, also lass mich
mein zweites Objekt erstellen. Das zweite Objekt sind neue
Hallo-Welt und Daten. Und dann
kann mein, mein zweites Objekt auf
folgende Weise spezifiziert werden. Mein OBJ-Punkt x ist 24,
was bedeutet, dass
er, was den
Nennwert betrifft, nur für das zweite Objekt ausgedruckt
wird und 24 ausdruckt. Also werde ich beide
ausdrucken,
damit wir sie besser sehen können. Kopieren und fügen Sie sie ein und drucken Sie
einfach
beide aus, damit Sie den Unterschied
zwischen den beiden erkennen
können. Also sollte der erste für
das zweite Intervall sein .
Da ist es also. Nur der erste wurde geändert. Die zweite, seit
sie geändert wurde. Es hat sich geändert. Sie sehen, dass der
erste gleich bleibt, der zweite ändert sich. Das passiert also,
wenn Sie nur
mehrere Objekte in Betrieb haben möchten . Sie könnten auch mehrere
Attribute in Betrieb haben. Sie können also beliebig viele
Attribute angeben. Und damit du das tun kannst, würde es
wirklich bedeuten, dass würde es
wirklich bedeuten du etwas
überlaufendes tust. Nehmen wir an, ich würde das alles
entfernen. Und wir sprechen nicht darüber, dass ich das
auch bewegen darf, weil ich es nicht brauche. Dann sagen wir, ich würde sagen string FirstName
F9, gegeben von Tom. Dann muss ich
auch Syntax machen, belasten. Das ist mein Nachname hier. Sheppard aus dem
Spiel Mass Effect. Da ist es also. Und dann sprechen wir über das Alter
und sagen wir, er ist 26 Jahre alt. Und was wir also tun werden,
ist, dass wir nicht mehr brauchen. Ja, wirklich, das ist
nicht wichtig. Also könnte ich
mein eigenes Objekt haben und erstellen, oder? Wie Sie wahrscheinlich schon zu oft
gesehen haben. Was ich jetzt tun werde,
ist das. Was ich machen werde ist genau hier, ich will nur, dass wir etwas Interessantes
ausdrucken. Wir sagen
nur einen Namen, einen Namen. Und dann mit dem Namen. Wir gehen auch nur auf einen Doppelpunkt oder
Objektpunkt F Name ein, richtig? Und dann rufen wir auch
auf, in
Ordnung, ich gebe etwas Platz zwischen ihnen, nicht
wirklich Schlüsselbein. Und dann haben wir unser zweites Objekt, das unser Nachname ist. L für L name und dann lese
ich lösche das. Und genau hier auch. Ich werde
nur das Alter hier anrufen , damit
wir das Alter haben. Und wir nennen das Objekt und
Telefon genau hier das Zeitalter. Und lass es uns ausführen und
sehen, was wir bekommen. Wenn wir es ausführen. Da ist es. Wir haben Tom
Shepherd genannt, 260 Jahre alt. Das ist also definitiv sehr
wertvoll, sehr wertvoll, besonders wenn Sie mit
Codestapeln und einfach
so vielen Informationen zu tun Codestapeln und einfach
so vielen Informationen haben
, die Sie verarbeiten müssen und einfach alles
haben insgesamt,
habe es ganz. Dies sind einige wertvolle
Informationen, die Sie
unbedingt beachten sollten. Ich möchte auf jeden Fall daran denken. Okay, das nächste, worüber wir definitiv sprechen werden
, heißt nur
Java-Klassenmethoden, oder? Sie haben also aus
dem
Kapitel über Java-Methoden oder was auch immer gelernt , die Lektion, über die
wir sprechen, dass Methoden innerhalb einer Klasse
deklariert werden, dass sie verwendet werden, um bestimmte Aktionen
auszuführen. Damit Sie
also eine Methode erstellen können, um eine Methode zu
erstellen, wissen
Sie, dass
Sie auf jeden Fall Folgendes
haben möchten. Sie möchten die
folgenden Aktionen ausführen, oder? Nehmen wir an,
ich möchte
eine Methode erstellen , rufe meine Methode auf. Ja, lass es mich einfach meine Methode
nennen. Was ich also tun kann ist, dass ich
einfach statisch sagen kann, void, meine Mathematik vorwärts, öffne das und öffne es so. Das ist Methode. Ja. Dann schreib so. Ich brauche den
Kerl nicht mehr. Wirklich. Siehst du, lass mich den
Kerl
einfach ganz nach oben ziehen , damit wir uns
immer daran erinnern können , dass alles stimmt. Also haben wir eine alte Methode geschaffen,
wirklich gesehen, dass ein System, das LN
ausgibt, Punktdruck ausgibt. Dann könnten wir sagen, hey
, ihr wollt es. Und mal sehen. Richtig, okay, klar, hier ist
ein kleiner Fehler. Die Hauptmethode wurde nicht in der Klasse
HelloWorld gefunden, das passiert, bitte definieren Sie die
Hauptmethode public, static, void, main
method, oder? Also im Wesentlichen, ja, es sagt dir, dass es hier
definitiv ein Problem gibt. Was wir also tun werden ist, dass wir
einfach public,
static, void, main sagen . Und wir rufen diesen
Zug an und
ändern einfach unser Ding hier und
schaffen diese Quoten und ARDS. Und genau hier greifen wir
auf unsere Methode zurück, meine Methode. Lassen Sie es uns jetzt ausführen und sehen,
was passiert, wenn wir es ausführen. Schön, das ist
MyMethod, MyMethod, oder? Der Fehler wurde also
behoben und so gehen wir
definitiv mit Methyl um. Wenn Sie also eine
Methodenrekrutierungsmethode aufrufen, möchten
Sie sie in
ihre öffentliche statische Leere stellen und sie
dann in einer beliebigen
Methode ausführen. Es wird zeigen, dass es definitiv nach Ihren Wünschen
funktioniert. Das wirft die Frage auf, zu
verstehen, dass
das Ganze hier selbst ist. Die Öffentlichkeit
meint offensichtlich, dass es für jeden
zugänglich ist , ähm, kann notwendigerweise
auf Hardcover-Weise modifiziert und geändert werden. Aber dann
ist Static selbst ein bisschen interessant. Was bedeutet statisch? Nun, statisch, damit wir zu dem
Thema kommen ,
dass etwas statisch oder
nicht statisch ist, müssen
wir wirklich verstehen,
was vor sich geht, oder? Also statisch versus nicht statisch, darauf
konzentrieren wir uns jetzt.
19. Statische Vs Non-Static: In Ordnung, also gehen wir weiter
zur statischen und nicht statischen
Natur unserer Java-Programme. Und man sieht oft, dass
wir
in Java-Programmen unsere Geografie haben könnten. Java-Programme sind entweder statisch oder öffentlich in ihren Attributen
und Methoden, oder? Im vorherigen Beispiel
, das wir hier gemacht haben, haben wir eine statische
Methode erstellt, oder? Wie Sie sehen können, gibt es
eine statische Methode. Dies bedeutete, dass nur
darauf zugegriffen werden konnte , ohne
ein Objekt der Klasse zu erstellen, im Gegensatz zur Öffentlichkeit, auf
die nur Objekte zugreifen
können , oder? Schauen wir uns
das folgende Beispiel an , um die Unterschiede
zwischen statischen und
öffentlichen Methoden zu
demonstrieren , oder? Also lass mich das alles einfach
löschen. Wir brauchen es nicht mehr. Zumindest dieser Teil davon bis zu unserer öffentlichen Klasse dort
drüben, richtig? Gleich nach dem öffentlichen Unterricht werden
wir das einfach
benennen und
als Kommentar einfügen und die
statische Methode bleiben. Und unsere statische Methode wird
der folgende Typ sein: static void und nennt
sie meine statische Methode. So wird es viel
besser werden. Ein bisschen wie ein Tippfehler da drüben. Und dann stellen wir einfach sicher
, dass wir das in Klammern haben. Und wir öffnen es so. Dann sagen wir Just system
dot out, dot print LN. Und alles, was wir
hier beweisen müssen , ist
nur zu sagen , dass statische Methoden aufgerufen werden
können, ohne Objekte zu
erstellen. Ohne Objekte zu erstellen. Einfach so, oder? Und auf der anderen Seite
werden wir auch tun, werden wir auch tun dass wir
hier auch nur einen Unterschied mit einer öffentlichen Methode zeigen werden. Ich werde das
als Kommentar formulieren. Und mit unserer öffentlichen
Methode werde ich einfach
public void sagen , meine öffentliche Methode. Und lass das einfach so
öffnen. Und wir sagen einfach System
aus, Punktdruck LN. Und dann haben wir gerade erwähnt, dass öffentliche Methoden
aufgerufen werden müssen , indem Objekte erstellt werden. Wir brauchen also Objekte
mit öffentlichen Methoden. Das ist im Grunde der Unterschied
zwischen den beiden, oder? Das ist im Wesentlichen der
Unterschied zwischen den beiden. Dann nenne ich das
einfach meine,
meine Hauptmethode, wenn
du willst, oder? Das ist meine Hauptmethode. Die wichtigste, richtig? Also sage ich einfach etwas
wie public, static, void. Gemein, wie wir immer sagen. Und dann gleich
in unserer Sache hier, wir werden
einfach eine Zeichenfolge nennen. Und wie Sie wissen,
muss ich es
da rüber bringen, weil ich dieses
ERG S nicht von
Natur aus habe. Und komm einfach runter. Und wir nennen das einfach meine
statische Methode, oder? Und was
tun wir im Wesentlichen dadurch? Wir rufen die statische Methode auf. Das
passiert eigentlich hier. Also hier ist es mit kaudaler
statischer Methode. Wenn wir dann, wenn wir
vielleicht unsere öffentliche Methode aufrufen würden, wollen wir sehen, was passieren würde. Öffentliche Methode. drüben gibt es also eine öffentliche
Methode. Da drüben ist ein
kleiner Fehler. Warum ist das so? Da drüben ist ein Pfeil? Denn die Art und Weise, wie wir eine öffentliche Methode
aufrufen müssen ,
ist, dass wir sie aufrufen müssen. Wir müssen
zunächst ein Objekt erstellen , damit wir
darauf zugreifen können. Sie sehen das, um auf
die öffentlichen Methoden zuzugreifen. Das ist also eindeutig
ein Fehler hier. Nennen wir es, sagen wir einfach, kompilieren
wir einen Pfeil. Diese Kompilierungen und Fehler, bedeutet, dass wir damit was
bedeutet, dass wir damit einen Fehler erleben. Aber dann nennen wir
ihn in der Hauptklasse, die HelloWorld heißt. Und sag einfach mein Objekt. Dann sagen wir einfach neue
Hallo-Welt und schließen das. Und dann nennen wir es wieder
mein Objekt. Und dann mit dieser Zeit
sagten wir einfach dot meine öffentliche Methode. Es ist schon, man könnte
sagen dämlich, falsch, oder? Das. Und wie Sie sehen können, liegt
kein Fehler vor. Und im Wesentlichen
erstellen
wir hier ein Objekt von
Ein Objekt von Hello World, das ist eine Hauptklasse, oder? Und genau hier rufen wir
im Wesentlichen die public Methode für
das Objekt auf ,
das wir gerade erstellt haben. Wenn wir das also ausführen würden, schauen wir uns einfach an, was
wir im Wesentlichen bekommen. Normalerweise
gibt es, wie Sie sehen, überhaupt keinen Fehler. Dann sollten wir
die erste haben , die zeigt, dass
statische Methoden aufgerufen werden
können, ohne Objekte zu
erstellen. Voila. Dann
müssen auch öffentliche Methoden aufgerufen werden, indem Objekte
erstellt werden. Wie wir sehen können, mussten wir
ein Objekt erstellen , um den Tag zu fahren, oder? Das ist also im Grunde der Unterschied zwischen
den beiden, oder? Und um das weiter
auszuarbeiten, könnten
wir sogar darüber sprechen, wie wir auf Methoden innerhalb
eines Objekts zugreifen, oder? Nehmen wir an, Sie müssen erstellen, lassen Sie mich einfach die
Abwärtszugriffsmethoden mit einem Objekt verbinden. Verwenden wir es also, um ein Auto zu erstellen. Ein Autoobjekt namens mein Auto. Sie könnten einfach bei MF viel
Gas mit
Vollgas und
Übergeschwindigkeit direkt an meinem Auto anrufen Gas mit
Vollgas und
Übergeschwindigkeit . Objekt und dann
einfach das Programm ausführen. Und wenn das keinen Sinn ergibt, lassen Sie uns
ein Beispiel dafür nehmen. Also lass mich das alles
entfernen. Wir brauchen nichts
davon im Moment. Wahrscheinlich
könnte das nur sagen, dass ich immer wieder in
meine zweite Tastatur zurückgekehrt bin. Aber dann
lass uns das jetzt einfach machen. Lass uns einfach Vollgas geben. Erstellen Sie einen Tippfehler mit Vollgas, bei dem
Essen mit einem
großen T drüben geworfen wird . Und wir entwickeln hier
eine
Vollgasmethode, oder? Also im Grunde ist es das. Also sagen wir einfach public, void, foo, throttle. Und wir haben das, schließen Sie es so. Innerhalb dieser Methode druckt
diese Methode dann nur druckt
diese Methode Systempunkt und den
Punktdruck LN aus und gibt
die folgende Anweisung aus. Das Auto fährt
so schnell es geht. Ja, weil es
so schnell wie möglich geht. In Ordnung. Als Nächstes wollen wir auch eine Geschwindigkeitsmethode
erstellen. In Ordnung? Und füge einen Parameter hinzu. Also nennen wir es einfach
Public Void Speed. Die anfänglich öffentlichste
Lücke, Vollgas. Dieser verwendet die Geschwindigkeit der öffentlichen Leere. Und dann genau in diesem Teil hier
, der unseren Parameter
setzen
und ihn Höchstgeschwindigkeit nennen wird . Das ist der Name
unseres Integer-Werts , der da drin sein sollte. Sie sollte
die Höchstgeschwindigkeit darstellen. Also sagen wir einfach
System raus, drucken LN. Und genau da drin
werden wir die Höchstgeschwindigkeit nennen. Und die Höchstgeschwindigkeit ist, und direkt draußen
wird die Höchstgeschwindigkeit angerufen. Das ist der Integer-Wert
, den wir wollen, oder? Dann
wollen wir als Nächstes einfach, ähm, das ist
natürlich in Großbuchstaben. In Hello World. Wir wollen
die Methoden
für mein Autoobjekt aufrufen die Methoden , oder? Da haben wir es also
öffentlich, statisch, nichtig jetzt. Und dann haben wir alle Saiten hier mit einem RGS hier und
da haben wir es. Und wir rufen einfach Hello World an. Hello World, und
sag einfach zum Beispiel mein Auto. Und dann sagen wir einfach wieder neu
und Hallo Welt. Wie Sie wissen, erstellen
wir hier im Wesentlichen nur
mein Autoobjekt. Das ist was los ist.
Das Objekt existiert also. Wenn wir dies nun an die
Öffentlichkeit bringen wollten, könnten
wir das Objekt definitiv
nutzen. Also verknüpfen wir das einfach mit
unserer Gasmethode. Was
wir also im Wesentlichen tun
, ist, dass wir
die Vollgasmethode aufrufen . Dann sagen wir einfach noch einmal, mein Auto, und dann weisen wir vielleicht 25 zu
oder beschleunigen es. Beim Shadowing
nennen wir die Geschwindigkeitsrechnung PFAD. Das ist was hier vor sich geht. Richtig? Dann. Du willst nur sichergehen
, dass hier kein Platz ist. Es sollte nur eine
öffentliche statische Leere sein. Es sollte
hier eine Hauptleitung geben, die ich ausgelassen habe. Main. Ja, gut. Und wir fahren das und sollten uns zuerst sagen
, dass das Auto so schnell
wie möglich fährt zuerst sagen
, dass das Auto so schnell
wie möglich und uns dann auch die
Höchstgeschwindigkeit mitteilen. Da ist es also. Das Auto fährt
so schnell es geht, dass wir es haben. Und der MX B ist 25, oder? Also nur um zu erläutern, was hier weiter
vor sich geht. Zunächst haben wir ein
benutzerdefiniertes Hallo von Weltklasse erstellt. Das ist
mit dem Schlüsselwort class los. Und zweitens haben wir hier
die Vollgasmethode entwickelt . Nicht nur das Vollgas, sondern auch die Geschwindigkeitsmethode. Außer in der Geschwindigkeitsmethode hatten
wir einen Parameter, der eine Ganzzahl
ist, eine Ganzzahl
, was auch immer sich
darin als Parameter befindet. Aber unsere Ganzzahl hier
oder bei unserem Parameter ist eine Ganzzahl und wird als Maximalgeschwindigkeitsparameter bezeichnet
. Dann sagten wir einfach, damit
wir unsere mean, unsere,
unsere Hello Klasse,
HelloWorld Klasse verwenden können. Und es ist meine Schuld. Wir
müssen ein Objekt der Hello World Class erstellen, was genau das ist, was wir getan haben. Wir haben hier ein
Objekt geschaffen, oder? Dann
sagten wir als Nächstes
, dass wir ein Objekt erstellt haben offensichtlich mit dem new
Schlüsselwort dort drüben. Und dann rufen wir
die Vollgas - und Geschwindigkeitsmethoden für das
Glimmerobjekt auf und führen das Programm aus. Und name object
gefolgt vom Punkt, gefolgt vom
Namen der Methode , an der wir interessiert sind. Und es ist nur
erwähnenswert, dass wir innerhalb der
Geschwindigkeitsmethode
einen int-Parameter von
sogar 200 hinzufügen können einen int-Parameter von , richtig.
20. Bauherren: Denken Sie also daran, dass etwas
Bemerkenswertes genau das ist. Denken Sie daran, dass der Punkt den Zugriff auf die Objekte,
Objekte, Attribute
und Methoden verwendet wird. Es ist also nur
erwähnenswert,
dass das sehr
praktisch ist, wenn Sie Fortschritte machen,
insbesondere
in Bezug auf den gesamten
Aspekt dessen, was wir
im Moment noch tun, oder? Fantastisch. Das nächste
, was wir uns ansehen möchten, sind sogenannte Konstruktoren. Konstruktoren. Und das ist etwas, das
sich als sehr nützlich erweisen
wird , wenn Sie immer
weiter vorankommen. Sie also daran, dass
ein Konstruktor selbst. Der Konstruktor ist eine spezielle Methode, eine spezielle Methode, die
verwendet wird , um
so einfache Objekte zu initialisieren. Bratsche. also einfach den Konstruktor auf, Wir rufen also einfach den Konstruktor auf, wenn
ein Objekt einer Klasse
erstellt wird , und er kann verwendet
werden, um
Anfangswerte für
Objektattribute festzulegen . In Ordnung? Ein Beispiel dafür wäre
wahrscheinlich so etwas wie, kommen wir gleich hier hoch und
schauen , ob ich Ihnen
ein Beispiel dafür geben kann. Im Moment sprechen wir also
über einen Konstruktor. Nehmen wir an, wir
haben so etwas wie int x einfach so. Im Wesentlichen erstellen wir
ein Klassenattribut. Stellen Sie einfach sicher, dass dies ein Kommentar ist der den Klassenbaum Butte
erstellt hat. Wir haben dort drüben ein
Klassenattribut erstellt. Dann
erstellen wir als Nächstes einen Klassenkonstruktor. Jetzt konzentrieren wir uns auf das, was
wir gerade tun. Für unsere Klasse, die
die HelloWorld-Klasse ist. Fantastisch. Also sagen wir einfach öffentlich. Und dann sagen wir hallo Welt. Und dann machen wir das einfach
und schließen das Licht. Und ja, wir einfach sicher, dass es eher so
geöffnet ist. Und hier nennen wir einfach unser Attribut und geben
ihm zum Beispiel eine Sieben. Wenn wir ihm eine Sieben geben, haben
wir als Nächstes
nur unsere gemeinsame Methode, public void, main, string oder NGS. Und wir erstellen
im Wesentlichen ein Objekt , das
„Hello World“ sein wird. Und schick einfach mein OBJ. Und dann sagen wir new hello
world und schließen das. Das heißt, was haben wir getan? Wir haben ein
Objekt unserer Klasse erstellt, dem
ein Konstruktor aufgerufen wird, oder? Also haben wir
ein Objekt erstellt,
das die Struktur aufruft. Ruft das Objekt
unserer Cluster-BU definitiv einen Konstruktor auf? Also genau hier, was ich tun werde, ist, dass ich
einfach mein setze, dann haben wir x über dem, im Grunde drucken wir den Wert, den Wert von x. Also schauen wir mal, ob wir da drüben eine Sieben
bekommen . Das ist perfekt. Wir haben unsere sieben. Es ist also nur erwähnenswert, dass der Konstruktorname
mit dem Klassennamen übereinstimmen muss und keinen Rückgabetyp wie beispielsweise
int void haben
kann . Beachten Sie außerdem, dass der
Konstruktor aufgerufen wird, wenn das Objekt erstellt wird und alle Klassen standardmäßig
erstellt wurden. Und wenn Sie selbst keinen
Klassenkonstruktor erstellen, erstellt
Java einen für Sie. Dann können Sie jedoch
keine
Anfangswerte für
Objektattribute festlegen , oder? Eine weitere Sache, die es
wert ist, auf jeden Fall untersucht zu werden, ist das, was
als Konstruktor bezeichnet wird. Konstruktor-Parameter. Also ein Konstruktorparameter. Konstruktorparameter,
im Wesentlichen können sie, Konstruktoren selbst können
Parameter annehmen Parameter , die für alle
lie-Attribute verwendet wurden. Okay, hier ist
ein Beispiel, das wir definitiv
als Anwendung dessen verwenden
können , wovon wir
hier sprechen. Lassen Sie uns
hier einfach alles trösten , was wir bisher getan haben. Vielmehr sagen
wir
bis zu einigen Rätseln, dass x gleich y ist. Und dann haben wir y noch
nicht definiert. Aber was wir
tun werden, ist, dass wir es genau dort
definieren
und es int y nennen. Und dann auch hier drin. Was wir tun werden ist
einfach Objekt zu sagen. Und dann werden
wir hier eine Zahl setzen, werden
wir hier eine Zahl setzen die dem Wert von y
entspricht, weil
wir so erwähnt haben, dass hello world einen Parameter hat. Es ist eine Ganzzahl von y. Und immer wenn ich Hello World sehe, muss
ich sicherstellen
, dass ich es als
Ganzzahl y habe , wenn
ich das als Klasse sehe. Also was ich tun werde ist
einfach mein Ende zu sagen. Und dann sollten x und ich führe es
normalerweise acht sein, weil x gleich y ist. Also da ist es,
nur acht, oder? Einfach gegessen und du kannst so
viele Parameter haben, wie du willst. Hier könnte
es sich beispielsweise um eine Ganzzahl namens year handeln. Zum Beispiel wirklich nur
ein Beispiel. Und in dem zum Beispiel das
definitiv geändert werden müsste. Nehmen wir an, das war
wie ein Modell, ja, vielleicht
sprechen wir über Kosten, vielleicht. Das wäre also wie
dein Modell hier. Und dann willst du
wahrscheinlich darunter in die Saite schauen. Ich brauche diesen
Kommentar vorerst nicht. Und dann haben Sie eine Zeichenfolge
, die uns sagt wie der Name
dieses Automodells lautet. Und dann, weil
wir sie so haben deutet das darauf hin
, dass eine
ganze Zahl
hier der Luftstrom ist, der nur den Namen
anruft. Ja. Dann werden
wir ihnen im Wesentlichen nur
einen
Modellnamen geben , der im Wesentlichen nur
gleichbedeutend mit jemandem
wäre im Wesentlichen nur
gleichbedeutend mit jemandem
wäre , der ihn
nach dem Namen gefragt hat. Und dann wäre das Modell genau
so wie ich. Sag einfach was ist das Ja. Verbunden mit dem Auto, von dem
wir sprechen. Und dann sage ich einfach hier rein,
main, hier ist die
Hello World. Hier. Wir
geben ihm auf jeden Fall den Namen First. Nennen wir es ein Ford-Beispiel. Dann
beginnen wir bei dieser Furt eher mit dem Jahr zuerst. Es wird also 1967 sein. Und wir setzen den Namen
würde bekämpft werden, zum Beispiel 1967 Vorstand. Und es geht nur darum sicherzustellen, dass
wir jetzt gut gedruckt haben. Wie drucken wir das aus? Nun, es ist nicht mehr
nur ein Objekt, also nenne ich
es hier einfach mein Auto. Ich nenne das mein Auto Punkt. Dann müssen wir nur noch entscheiden, was
genau wir wollen. Wir haben es also auf
folgende Weise. Dann rufen wir nicht nur
das Jahr, sondern auch
den Namen sowie den modalen Namen auf. Es sollte also 1967 heißen, auch
Ford. Da ist es also. 1967. Ford macht die Ausgabe
, die wir bekommen, richtig? Das ist also im Wesentlichen alles, wenn es
darum geht, dies zu konstruieren. Das ist das Problem,
wenn es um
Konstrukteure in der Tat geht , oder?
21. Modifikatoren: Okay Leute,
das nächste, was wir uns auf jeden Fall ansehen sollen,
ist das , was man
Modifikatoren nennt, oder? Lassen Sie mich das einfach hier platzieren,
denn es gibt ein
paar Kommentare, die dort stattfinden
werden, wo hier. Also nennen wir sie Phi ist, richtig. Und sie waren auf Modifikatoren bedacht, etwas, das wir
bereits verwendet haben. Denken Sie daran,
dass zum Beispiel public
class helloWorld ein Modifikator ist, oder? Also geben wir Typen oder andere
Gruppen von Modifikatoren ein. Modifikatoren können in
Bezug auf die Zugriffsmodifizierer benannt oder eher gruppiert werden, was ein Beispiel
für unsere Öffentlichkeit ist. Wir können
Zugriffsmodifizierer haben oder wir können keine Zugriffsmodifizierer
haben. In Ordnung? Was sind Zugriffsmodifizierer? Zugriffsmodifizierer selbst sind von Natur aus diejenigen, die den
Zugriff kontrollieren , genau wie der Name schon sagt Greifen Sie
wirklich auf die
Codierung zu, die Sie haben, oder? Und dann ist dieser nicht. Sie kontrollieren nicht den Zugriff. Aber sie bieten Angebot. Andere Funktionen. Ja, großartig. Das sind also die
Nicht-Zugriffsmodifizierer. Public, zum Beispiel public, wie wir schon gesprochen haben, public ist ein Beispiel
für einen Zugriffsmodifizierer. Es. Und genau
damit, was ich
Ihnen zeigen werde , weil es ein bisschen wie ein Kommentar ist
,
der definitiv
hier drüben funktionieren würde, nur damit Sie genau
verstehen können ,
was wir hier tun. Und ich gebe ein Beispiel, das mit der Öffentlichkeit
beginnt. Was public also im Wesentlichen ist,
ist, dass public
diese erlaubt ist oder was
es bedeutet, dass wir über eine Klasse
sprechen, andere Klassen
zugreifen können. Es ist eine Klasse, die mit einem anderen Glas
zugänglich ist, wenn Sie möchten. Dann könnten wir auch über
einen Modifikator sprechen , der als
Standardmodifikator bezeichnet wird. All dies sind übrigens
Zugriffsmodifikatoren, die ihnen wahrscheinlich nur
klarstellen
sollten, dass sich um Zugriffsmodifizierer handelt. Wir haben auch Standard
und Standard. Das bedeutet, dass
die Klasse nur
für Klassen
im selben Paket zugänglich ist . Klasse. Einfache Bye-Klassen
im gleichen Paket. Nun, wenn Sie sich fragen,
was das gleiche Paket über das wir zum Beispiel sprechen könnten, ist
dies ein Paket, über das
wir sprechen. Wir könnten also
mehrere Pakete haben und aber es ist wirklich ein Container, der Klassen
enthält. Du kannst dir
das eher so vorstellen. Und das verwenden wir, wenn wir
keinen Modifikator angeben. Es bedeutet also, dass dies verwendet wird. Java verwendet das automatisch. Dies wird verwendet, wenn Sie nicht per Modifikator angeben, es ist die Standardeinstellung. Wenn du willst, könnte ich das
auf jeden Fall sagen. Ja. In Ordnung, und dann können
Sie
vier Attribute, Methoden und Konstruktoren verwenden. All das könnte wirklich
gebrauchen, nicht nur öffentlich. Und da wir wissen,
muss P klein sein t. Und dann vier Attribute, Attribute, Methoden und Konstruktoren. Wir könnten Folgendes haben. Wir könnten immer noch public gebrauchen. Hier. Dies würde bedeuten
, dass unser Code für alle Cluster
zugänglich ist. Dann wenn es privat ist. Wenn es privat ist, ist es
eine andere Sache. Der einzige Code ist
nur zugänglich. Wir haben dann die Klasse deklariert,
also ist sie privat. Und wenn es dann Standard ist, bedeutet das, dass wir darüber
sprechen. Das gleiche Paket. Sojabohnen sind immer noch dasselbe, was wir hier bereits
erwähnt haben. Also mache ich das nur, um zu verweisen oder Autotrophe zeigen,
dass es dasselbe ist, sondern hier nur
für den gleichen Paketcode der auf
derselben Paketbasis zugänglich ist. Dann hätten wir auch
schützen können. Und wenn ein Code oder was auch immer Sie ändern möchten,
geschützt ist bedeutet das, dass Code auch im
selben Paket
zugänglich ist . Und Unterklassen. Dies wird viel weiter sehen
und sehr hilfreich sein, besonders wenn wir über Vererbung,
Oberklassen und Unterklassen
sprechen .
Es ist sehr wertvoll, dass Sie das wissen. Ja. Richtig. Das nächste, was wir
uns ansehen möchten, ist das, was wir die Non-Access-Modifikatoren
nennen. Ja. Mit einem Non-Access-Modifikator lasse ich
sie einfach für uns ablegen. Wir sprechen über
Nan Zugriffsmodifizierer. Und mit den
Nicht-Zugriffs-Modifikatoren, richtig? Wirklich, Sie können entweder final oder abstract
verwenden. Das ist das, das ist das k
ist mindestens vier Klassen. Klassen. Sie können nur Final
it all up struct verwenden. Und wenn wir über
etwas Endgültiges sprechen,
sagen wir, dass die Klasse nicht vererbt werden kann,
die Klasse kann nicht vererbt werden, kann nicht
vom Prozess vererbt werden. Also noch einmal, das ist
sehr praktisch, oder besser gesagt, Sie verstehen
es weiter, während wir Vererbung durchführen,
was wir noch tun müssen. Das bin nur ich.
Darauf aufbauen. Ich bin hier mit abstrahierenden
Mitteln, dass die Klasse nicht zum Erstellen von Objekten verwendet
werden kann . Damit Sie auf eine abstrakte Klasse
zugreifen können, muss
sie
von einer anderen Klasse geerbt werden. In Ordnung? Also für, das war der
Fall für den Unterricht. Aber wenn wir dann
über Attribute und Methoden sprechen,
dann, wenn wir uns
darauf beziehen , dass etwas
endgültig ist, was bedeutet das? Das bedeutet, dass dieses
Ding oder dieses Attribut oder diese Methode nicht überschrieben
werden kann. Überschrieben. Zeig dir, dass du dich noch an das
Beispiel erinnern kannst, das wir Dies kann nicht noch
eine Stunde überschrieben werden oder
gibt es einige Leute, die
sogar einige modifizieren würden. Wenn es dann statisch ist, haben
wir auch static. Wenn etwas statisch ist von Attributen und
Methoden statisch sind, bedeutet das, dass unsere Attribute und Methoden zur Klasse gehören. Dan, eher als ein Objekt. Gehört zu. Sie gehören zur Klasse. Eher als Objekt. Ja. Und wenn es abstrakt ist, bedeutet das, was es bedeutet
, dass es nur verwendet werden
kann, nur in
einer abstrakten Klasse verwendet werden kann. Und kann nur N nur für Methoden verwendet werden, nichts anderes. Denken Sie also daran, dass die Methode keine Verkörperung hat. Zum Beispiel läuft so etwas wie
abstrakte Leere so, dass der Körper selbst von der Unterklasse bereitgestellt wird ,
die
von geerbt wurde, richtig. Es sind also nur einige
zusätzliche Informationen , die Sie beachten müssen. Wir könnten auch darüber sprechen, dass es auch Transiente
gibt, die nicht sehr häufig verwendet werden, aber immer noch existieren. Es bedeutet also, welche
Attribute und Methoden werden übersprungen, wenn
das Objekt, das sie enthält, serialisiert wird? Sende es übersprungen. Verwenden des in ihnen
enthaltenen Objekts. Dann haben wir auch synchronisiert. Was bedeutet synchronisiert also
im Wesentlichen? Wenn etwas synchronisiert ist, sagen wir
im Wesentlichen, sagen wir
im Wesentlichen dass ich glaube, dass ich
etwas hier gelassen habe. Die Sünde kolonisiert. Ja. Das ist die richtige Schreibweise. Synchronisiert. Das bedeutet, dass auf unsere
Methoden jeweils nur von einem Thread
zugegriffen werden kann , oder? Deshalb ist es wichtig, dass
ich hier feststelle, dass dies eine Methode ist, auf die ich mich
nur beziehe. Methoden kann jeweils nur von
einem Thread
zugegriffen werden von
einem Thread
zugegriffen . Dann wenn es Volatilität oder
eher volatil ist, wenn Sie möchten. Wenn ich Volatilität verwende
, bedeutet dies, dass der Wert
eines Attributs nicht lokal gecoucht ist
und dieser immer aus
dem Hauptspeicher gelesen wird, oder? Also noch einmal, definitiv nicht etwas, das Sie oft sehen würden. Aber wenn die Kosten, die Programmierung mit Java so hoch
ist, tut mir leid, es
hängt letztendlich davon ab , was
Sie zitieren. Diese großartigen Konzepte
, die wir schrittweise
lokal ausführen werden lokal ausführen und immer aus dem Arbeitsspeicher
gelesen werden. Das selbst war am
Montag nicht da. Ja, das sind also die axis n none Zugriffsmodifikatoren , die Sie auf jeden Fall im Hinterkopf behalten
möchten. Und jetzt werden wir
nur ein paar Beispiele das noch viel weiter untersuchen. Ein Beispiel dafür
wäre also in etwa so. Lassen Sie mich das alles einfach löschen. Das brauchen wir nicht mehr. Also heißt es final. Es gibt einen Modifikator in x für ein Attribut hier
und gib ihm vielleicht 19. Und dann sagen wir final double
Pi und Pi selbst, wie wir wissen, es ist durch 3.14 gegeben. Ja, 3.14 ist eigentlich 3,1428. Also lass mich einfach helfen und progressiv,
und so geht es weiter. Wir sagen also, dass unsere
Modifikatoren endlich sind. Das bedeutet, dass sie nicht überschrieben oder geändert
werden können. Wir können nicht dazu führen, einen
neuen Wert von X oder
den neuen Wert von Pi zu definieren , oder? Und dann kommt hier die Methode. Wir sagen public, static, void, main und
dann diese Zeichenfolge. Und wir stellen nur sicher
, dass wir in Ordnung sind, Tastatur über ihrem RGS und
wir nehmen es auf. Und genau da drin erstellen
wir ein Objekt. Also sagen wir hallo Welt. Und dann
entspricht mein J dem neuen
Hallo-World-Namen meiner Klasse. Ich komme einfach runter und dann als das und fange an,
etwas anderes zu erkunden. Fangen wir also so an. Sagen wir einfach mein OBJ
und dann sage ich x. Und dann schauen wir mal, was wir davon
bekommen,
wird interessant sein. Dinge sind falsch. Sie, warum ist dann ein Fehler? Nun, wie wir sehen können, ein Fehler. Okay, warum? Weil es keinen Wert von x
zuweisen kann, weil wir
es als final deklariert haben. Dies bedeutete, dass es in keiner Weise
geändert oder geändert werden kann. Auch wenn wir den Kuchen probieren
und einfach versuchen würden ,
unseren Pi zu modifizieren. Ähnliches würde definitiv mit fünf
passieren, wenn man sagt:
Oh, der neue Wert von Pi ist zum Beispiel
nur 3,14. ist nichts auszusetzen,
aber sie sind immer noch ein Fehler. Warum ist dann error
ein Fehler, weil wir den Wert
ändern, der als final
deklariert wurde. Das sollte sich nicht ändern. Kann keinen
Wert von Pi Sinus zuweisen, Ordnung, ja,
ja, ja, richtig. Also lass mich einfach versuchen
auszudrucken und einfach sagen: Hey, System, dot out, dot print. Und dann drucken wir zum Beispiel x
aus. Und wir sehen, was passieren wird. Wenn wir also x ausdrucken,
nur eines hier, denken Sie daran, dass wir es mit object
ausgedruckt haben. Da ist also mein Objekt. Mal sehen was, was wir bekommen. Jetzt. Offensichtlich werden
wir
es in einen Kommentar schreiben weil wir wissen, dass
dort ein Fehler vorliegt. Das brauchen wir nicht.
Und wir führen es aus. Und lass uns einfach sehen. Nehmen Sie sich hier etwas
Zeit zum Laden. Wird immer noch geladen. Das ist Maintain, weil wir x als 19
definieren, Objekt ist x. Und wenn ich
das zum Beispiel ändern
und das alles pi machen würde , dann schauen wir mal, was daraus
wird. Jetzt. Mal sehen, ob es uns 3.148 gibt. Das ist 3.1428, oder? Das ist ein Beispiel dafür, wie wir den finalen Modifikator
verwenden. Letzter Modifikator, von dem wir wissen, dass er
sich in einem Nicht-Zugriffs-Modifikator befindet Verwenden wir nun einen anderen
Non-Access-Modifikator
, der ein statischer Modifikator ist. Also oder verstehen sie
es viel weiter, oder? Also mit dem hier, Es ist
ein Metall von uns, das wir einfach verstehen, selbst
wenn wir etwas haben, das sich statisch
nennt. Statische Methode bedeutet, dass darauf zugegriffen
werden kann , ohne
ein Objekt einer Klasse zu erstellen. Im Gegensatz zu public, wo wir
bereits über dieses Thema gesprochen
haben, sprechen wir von
statisch versus nicht statisch. Warte! Um das ins rechte Licht zu rücken, lass mich einfach
alles hier entfernen. Ich werde diesen Typen wahrscheinlich einfach
hergeben , weil ich weiß, dass ich
keine Tastatur habe. Und erstelle einfach eine statische Methode. Ich sage nur statisch, void, meine statische Methode. Und es ist definitiv offen. Und nenne es einfach ein
System aus, punkt, drucke und schreibe da rein. Schreiben Sie wahrscheinlich
etwas wie static. Methoden können aufgerufen werden,
ohne Objekte zu erstellen. Ja.
22. Access & Non-Access: Dann schauen Sie sich einfach öffentliche Methode an und schauen Sie
in eine öffentliche Leere. Erstelle einfach so etwas wie public void und
nenne es dann einfach meine öffentliche Leere. Nun, öffentliche Methode, die eher hier ist, lasst uns
so etwas wie System ausdrucken, das beschnitten wird. Also sagen wir, öffentliche Methoden
müssen kalt sein. Durch das Erstellen von Objekten. Dann haben wir eine Menge. Manche Leute würden
sagen main method, aber wir nennen es einfach
unsere HelloWorld-Methode. Und dieser
wird einfach so etwas wie dieses öffentliche, statische, leere Main sein. Und wir reden über
diesen Zug G S vorbei und gehen einfach runter und
rufen einfach unsere statische Methode auf. Stellen Sie einfach sicher, dass ich die
geschweiften Klammern da drin habe. Ja, meine statische Methode, im Wesentlichen nenne ich
diese statische Methode colin, die statische Methode. Indem ich das tue. Wenn ich mir dann meine öffentliche Methode
ansehe und versuchen
würde,
dies zu nennen, wollen wir einfach sehen. Dies ist bereits ein Hinweis darauf , dass etwas nicht
stimmte, da es mir nicht vorgeschlagen
wurde,
dass ein Fehler vorliegt. Warum? Weil ich ein Objekt
erstellen muss, damit ich dieses
Recht nutzen kann. Hier ist ein Fehler. Also muss ich das
als Kommentar schreiben und einfach mein Hello World-Objekt
erstellen. Hallo. Okay, ich denke es ist
Zeit für eine Veränderung. Jetzt. Mein o, vorerst. Ich rufe mein OBJ zu oft an,
zu lange oder so. Und hallo Welt und mein OH, und diese farbige Mann öffentliche Methode, die für mich vorgeschlagen
wurde. Und im Grunde
rufe ich die Methode jetzt auf. Wenn ich das ausführe, sollte
es normalerweise funktionieren. Jetzt sollte ich in der Lage sein ,
sowohl die öffentliche als auch die statische
Methode
auszudrucken . Also sollte ich sehen, dass beide
Anweisungen rauchen, nur eine
davon sollte sehen, dass statische Methoden aufgerufen werden
können, ohne Objekte zu
erstellen. Und ich sollte in der Lage sein zu sehen, dass öffentliche Methoden auch durch das
Erstellen von Objekten aufgerufen werden
müssen. Mal sehen. Es wird auch geladen. Da ist es. Wir haben
beide. Statische Methoden können aufgerufen werden, ohne Objekte zu
erstellen. Und wir haben öffentliche
Methoden, die durch
das Erstellen
von Objekten als ein Muss bezeichnet werden können . Ja, wunderschön. Da haben wir es also. Da haben wir es. Dann ist die letzte Änderung
, die wir uns ansehen werden,
das , was wir den
abstrakten Modifikator nennen. Wie wir wissen,
gehört der
abstrakte Modifikator auch zum
Non-Access-Modifikator. Ja. Und es kann für Klassen
und vier Attribute funktionieren, oder? So abstrakt. Ich werde das alles einfach wieder
entfernen. Und wir stellen einfach sicher, dass
wir alles an seinem Platz haben. Okay, wunderschön. In Ordnung. Anstatt das also public zu
nennen, nennen
wir es einfach
abstraktes Hindernis. Es gibt abstrakte Klassen. Und mit Officer plus werden
wir einfach anrufen, ich brauche diese
statische Methode nicht mehr. Und dann
sage ich einfach etwas wie vielleicht public String fname
, der für meinen FirstName ist, und nenne es Will. Und öffentliches Ende. Alter auch, das 24 Jahre alt
ist. Und dann gibt es öffentliche abstrakte auch
öffentliche abstrakte
Leere. Studieren. Das bedeutet, dass dies eine abstrakte Methode
ist. Ja. Das ist eine abstrakte Methode. Ja, auf jeden Fall. Und wir stellen einfach sicher, dass
dies so geschlossen wird. Definitiv so. Gut. Dann, direkt darunter, werden wir so
etwas wie eine Unterklasse haben, die wir wirklich
von Hello World erben. Und bei allen Unterklassen
werden nur Cluster gesagt,
was bedeutet, dass es
Standard ist,
wenn Sie möchten, wenn wir
es als nur die Kosten belassen würden. Also, wenn sie
Student Big S angreifen und wir sagen, dass das
Erben jetzt verlängert wird, Hallo Welt. Und das machen wir auf. Die Möglichkeiten sind endlos. Jetzt wir also haben
wir also public und Close click Command. Okay, das nächste, was wir uns ansehen sollen, ist
die sogenannte Java-Kapselung. Also lass uns das einfach hier drüben haben
. Das ist Java-Kapselung. Was die Java-Kapselung bedeutet ist für uns, wirklich zu
verstehen, was es wirklich bedeutet, dass
wir verstehen müssen was
Kapselungskapselung ist. Es bedeutet sicherzustellen, dass vertrauliche Daten vor den Benutzern
verborgen bleiben. Und damit wir
das erreichen können, müssen
wir eine
Klassenvariablen deklarieren. Slash-Attribute schlagen natürlich tatsächlich als privat. Zweitens, stellen
wir sicher, dass wir die Public
get- und set-Methodenachse
und den Wert
der privaten Variablen bereitstellen get- und set-Methodenachse und den Wert . Ja, das ist also auch etwas
sehr Wichtiges. Also du, wir haben es bereits gemacht
, dass auf private Variablen
nur innerhalb
derselben Klasse zugegriffen werden kann nur innerhalb
derselben Klasse zugegriffen werden und außerhalb der
Klasse keinen Zugriff darauf hat. Wir wissen jedoch, dass es möglich
ist, auf
sie zuzugreifen , wenn wir öffentliche
Get- und Set-Methoden bereitstellen, oder? Also gibt die GET-Methode
den Variablenwert zurück und die
Set-Methode setzt die Variable. Die Syntax für
beide lautet also, dass sie entweder mit
get all set
beginnen,
gefolgt vom Namen der Variablen mit dem ersten Buchstaben in Großbuchstaben. Ein Beispiel dafür wäre, sagen
wir mal, public class. Wie sie
schon hier vorgeschlagen haben. Hallo Welt. Fantastisch. Und dann schreib da rein, was wir tun
wollen ist, dass wir so etwas wie
eine private Zeichenfolge setzen und sie
dann einen Namen nennen wollen. Und stellen Sie einfach sicher, dass
wir das geschlossen haben. Also Ben, beachte, dass privat,
wenn es privat ist, eingeschränkten Zugang bedeutet. Aus Sicherheitsgründen wollen
wir auf jeden Fall solche Dinge an Ort und Stelle
haben. Wir möchten nicht, dass jeder
Zugriff auf alles in Ihrem Code hat, da sie
definitiv
Ihre Dateien hacken und einfach eine Menge Informationen
aus Ihnen herausholen können. Dann haben wir GetName. Und das öffnen wir. Und wir sagen Rücksendename. Name zurückgeben. Dann ist das ein Getter. Jetzt haben wir auch unsere Setae. Und bei allen Einstellungen sagen
wir einfach
public void setName. Und rufen Sie einfach dieses
Training an, um einen neuen Namen zu erhalten. Und öffne das und
sag einfach diesen Namen als Äquivalent. Neuer Name. „Hervorragend“. Hervorragend“. Also wenn wir das machen,
schauen wir mal, was wir bekommen.
23. Kursprojekt: Okay, danke
euch, dass ihr mich für diesen Kurs und
euer Klassenprojekt begleitet. Ich möchte,
dass du, mit all den
dreiwertigen Dingen jetzt, hier eine Datei anhängst. Ich möchte, dass du
direkt in die Akte gehst. Das möchte ich durchlesen. Und es gibt auch einige Übungen , die ich beigefügt
habe und die ich
möchte, dass Sie sie durchgehen
und einfach für mich einreichen. In Ordnung, Prost, und ich
freue mich darauf, Sie
im Kosten-Dashpot zu sehen.