Transkripte
1. Willkommen zu diesem Kurs!: Hallo Leute und
willkommen zu den Ergebnissen auf der IntelliJ Idea IDE. Mein Name ist Alex und ich bin ein Software-Ingenieur
, der seit
den besten drei Jahren
Code innerhalb dieser IDE dampft . Als ich von der
Möglichkeit hörte,
einen Kurs zu erstellen , um alle Funktionen zu erklären, die er hat. Ich war sehr begierig darauf
, einen zu entwickeln. Dieser Kurs wird in
neun Lektionen strukturiert , die
praktische Schritte enthalten, die Sie unternehmen müssen, um zu verstehen,
wozu diese IPE fähig sind und wie Sie
dieses Wissen beim Programmieren
nutzen können Einheit in Ihrem eigenen Tempo. Ich zeige Ihnen, wie Sie Enter in einem Projekt
erstellen können und wie alle wichtigen
Funktionen davon funktionieren. Dinge wie Debuggen,
Codevervollständigung, Refactoring und
Versionskontrolle. Wenn Sie an einer
neuen IDE interessiert sind, in der Sie Code schreiben können,
sollten Sie diesen Kurs für Sie in Betracht ziehen. Es gibt keine anderen
Anforderungen als eine
Internetverbindung für das
Projekt dieser Klasse, es wird äußerst
praktisch sein und Sie müssen
die
im Kurs dargestellten Schritte befolgen . So können Sie auf
Ihrer Reise beginnen,
Code zu schreiben , mit einem riesigen
Wissensblock auf Ihrem Gürtel. So arbeiten Sie in einem Code-Editor mit
professionellen Einstellungen. Wir dachten das Set, ich glaube, du siehst dich
schon in
der ersten Lektion.
2. Einrichten der Umgebung: Leute, willkommen wieder
in diesem Tutorial. In diesem Tutorial werden
wir natürlich
anfangen zu lernen,
indem wir unsere Umgebung auf unserer lokalen Maschine
vorbereiten. Als Framework, dass
es Java-Code verwendet, müssen
wir natürlich sicherstellen, dass
das JDK auf
unserem lokalen Computer installiert ist. BIP stammt also aus dem Java SDK. Sdk stammt aus dem
Softwareentwicklungskit. Für dieses Tutorial. Wir werden die Version von
einem Punkt Punkt 01 für Java 16
verwenden . Zuallererst
müssen Sie sicherstellen, dass Sie diese JDK auf Ihrem Computer
installiert haben. Jetzt habe ich einen
Windows-Computer hier. Wie würden Sie überprüfen, ob
Sie dieses JDK bereits auf Ihrem Computer
installiert haben oder nicht haben,
Sie müssen nur Ihren CMD ausführen. Also deine Eingabeaufforderung
mit Administration und schreibe dann in jede
Java-Dash-Version. Wie Sie sehen können, habe ich es nicht
installiert. Und das, was
auf meinen Bildschirm bringt, ist, dass Java nicht als interner
oder externer Befehl
erkannt
wird, nicht installiert ist. Auf diese Weise können Sie bestätigen , dass Sie es nicht installiert
haben. Wenn es installiert worden wäre, wäre
die Nachricht so etwas wie Java-Version und dann
wird sie Ihnen die Version dann einige andere
landwirtschaftliche Nachrichten mitteilen. Aber jetzt, da wir wissen, dass
wir es nicht installiert haben, werden
wir es mit
dem Image speichern. Wenn Sie es bereits installiert
haben, können
Sie dem nächsten Schritt in wenigen Minuten fortfahren
. Aber im Moment, wie würdest du es
installieren, zu dem Link
zu gehen , den ich auf
diesem Bildschirm hier bereitgestellt habe, und das sind oracle.com,
Java-Technologien. Java SE lädt den HTML-Code herunter. Das können Sie sehen, dass wir hier den Java SE
Download-Job haben, ich sehe 16. Und wir können unter dem
Oracle JDK auf den JDK-Download klicken. Jetzt wird es uns zum
Java Development Kit 60 umleiten. Sie sehen also Java SDK und scrollen
dann nach unten, Sie können die Version
für Ihr
Betriebssystem auswählen , in meinem Fall ist es ein Windows 64-Beats, also ist es die Version genau hier. Ich wähle direkt
die ausführbaren Dateien damit wir die Vereinbarung
überprüfen und dann auf Download klicken können. Sie können sehen, dass die ausführbare gerade
heruntergeladen
wird. In nur wenigen Sekunden
ist es erledigt, damit wir auf den Nagel klicken
können. Und wie Sie sehen können, dass Sie diese Installation
starten, willkommen bei der Installation. Wir können auf Weiter klicken. Nun, das Standardbad, in dem
es installiert werden würde. Und ich schlage vor, dass Sie
es verlassen SEC ist C Program Files ,
Java, Dish und dann
die JDK-Version davon. Der Grund, warum ich Ihnen sage, es so
belassen sollen,
liegt darin, dass wir später einige
Variablen der Umgebung festlegen
werden . Die Spezifikation. Und wenn Sie es ändern, müssen
Sie sich daran
erinnern, dass Beth die beiden
geändert hat und es
möglicherweise im
Notepad-Dokument basiert. Aber im Moment können wir einfach
weitermachen und auf Weiter klicken. Und wie Sie sehen können,
wird es im Grunde genommen GDK
installieren, dass es
vollständig installiert wurde. Wir können es schließen. Und einfach so ist
der erste Schritt dieses Tutorials erledigt. Im zweiten Schritt müssen
wir, wie gesagt, eine
Umgebungsvariable festlegen, genauer gesagt die Umgebungsvariable Java
Home. Und wir müssen es auf
das Bad hinweisen , wo wir diese JDK
stoppen. Um dies zu tun, müssen Sie zur Schaltfläche Suchen
gehen und
dann die Systemumgebungsvariablen schreiben. Klicken Sie auf Enter. Dann hier zu
Umgebungsvariablen. Dann können wir auf Neu klicken. Dann haben wir den Variablennamen
, der Java unter Home
sein wird, und dann das Suchverzeichnis. Und dann
geht das Verzeichnis zu BSA sagte Local Disk C Program Files, und dann natürlich Java, und dann dieses JDK für
die Schulden, es hat uns erwischt. Das wird also in Ordnung sein. Und wie Sie hier sehen können, wird jetzt
die
Systemvariable Java Home hinzugefügt und der Wert davon
ist der eigentliche Beth. Jetzt können wir, abgesehen davon, dass
wir die
Systemvariable von Java Home mit dem Wert des
Pfades hier bei bat hinzufügen, dem Wert des
Pfades hier bei bat hinzufügen, dies bearbeiten
und auch neue hinzufügen müssen. Und dann müssen wir Grafiken für die Bin-Ordner-Schulden
mit edit hier machen. Und wie Sie sehen können, der Java JDK und
dieser Ordner, der
direkt hier war , nachdem ich erreicht habe, meinen Computer
gestartet. Denn wenn Sie es
nicht neu starten, können
Sie nicht sehen,
dass das Java installiert wenn Sie es neu starten und die Java-Dash-Version
eingeben.
Sie können sehen, dass es
Ihnen tatsächlich einige Informationen über die Attribute und insbesondere die
Tatsache, dass das JDK erfolgreich
auf Ihrem Computer
installiert wurde. Wieder einmal habe ich die
Systemvariablen im
Java-Unterstrich hinzugefügt , die
auf den Pfad eingestellt wurden, in
dem der GDK installiert wurde,
und ich habe es hinten hinzugefügt. Benutzervariablen für Ihren Benutzer, klicken Sie
darauf, klicken Sie auf Bearbeiten und
dann neuen Browser
und dann den bin-Ordner von
JDK Installation Breath. Wenn Sie dies nach
der Installation des JDK tun , das Sie über diesen Link
erhalten, werden
Sie
das JDK
erfolgreich auf Ihrem Computer installiert das JDK
erfolgreich auf Ihrem Computer und die
ersten beiden Schritte ausführen. Vorerst. Es ging um den Enter. Ich danke euch
sehr, dass du bis zum Ende
dieser Vorlesung bei
mir geblieben bist.
3. Installieren von IntelliJ IDEA: Hallo Leute und willkommen
zurück zum Tutorial. Für dieses Tutorial müssen wir offensichtlich eine IDE haben, mit
der wir Code springen können. Und dafür werden wir die IntelliJ-Ideen-IDE
verwenden, die meiner Meinung nach die beste
IDE für Java ist. Aber wir können einfach
anfangen, für
Intelligent zu wachsen und dann auf
die Website Download on
JetBrains klicken . Dies führt Sie zum
Download der Intel G Idee. Jetzt werden wir
natürlich die Community-Version verwenden. Nicht das ultimative ist kein
Code für das Unternehmen zu schreiben. Wir werden diese einfach bequem
von zu Hause aus nutzen . Aber wenn Sie
das mit allen Mitteln tun wollen, wenn Sie ein Unternehmen
oder ähnliches haben, können
Sie sich für dieses Tutorial entscheiden, das ultimative ist einfach tot, wir werden
mit diesem Punkt EXE gehen. Und wie Sie sehen können, hat der
Download im Grunde genommen begonnen. Ich werde mich wieder bei
euch melden, sobald es fertig ist. Okay, also bin ich zurück,
dass Intel Beats
heruntergeladen hat und jetzt, wenn wir auf diese ausführbare Datei
klicken, werden
wir von
einem Installationsprozess begrüßt. Sie können sehen, dass das Setup-Wochenende
einfach weiter installiert wird. Es isst unseren
Standardzielordner im Laufwerk C. Der 64-Bit-Längengrad
ist das
, was Sie hier auswählen müssen. Dann verknüpfen wir die Java-Dateien,
die wir benötigen. Dann können wir
das Kontextmenü aktualisieren das Projekt „Ordner öffnen ist“
bearbeiten. Die
Launcher-Verzeichnisse zum Bett. Ich glaube nicht, dass das
notwendig ist, dass wir Dinge aus
der eigentlichen Anwendung öffnen , damit
wir auf
Weiter klicken und dann installieren können . Nachdem es installiert wurde, werden
Sie
mit diesem letzten Fenster begrüßt. Und Sie können
sich entscheiden, Intel J auszuführen, nachdem Installation
abgeschlossen und wir können auf Schulden klicken. Wir haben bestätigt, dass wir Weiter
gelesen und auf „Weiter“ klicken. Sie können sehen,
dass sich die Intel G ID gerade öffnen wird. Und es wird
uns außerdem auffordern , ein Projekt zu eröffnen
oder ein neues zu erstellen. Und dann natürlich einige Plug-Ins und das
Anpassungsfenster in Bezug auf Farbthemen
und ähnliches. Es ging also darum
mit der Installation von GID für den Job , den wir in diesem Tutorial
verwenden werden. Es ist ein ziemlich einfaches und
geradliniges WordPress ist, aber ich dachte, ich sollte das Tutorial dazu machen,
nur um sicherzustellen , dass ihr
euch bewusst seid,
wie du aufstehen wirst . Hoffentlich hast du etwas
aus diesem Tutorial herausgeholt
und ich freue mich sehr darauf, dich im nächsten zu
sehen. Vielen Dank, dass Sie bis
zum Ende
dieser Vorlesung bei
mir geblieben sind.
4. Erstelle unser erstes Projekt: Hallo Leute und willkommen zu intelligenten
IPE-Tutorial wird besser verstehen, wie wir effizienten Code mit
dieser modernen IDE
schreiben können , die
speziell für Java entwickelt wurde. Sie haben in der
vorherigen Vorlesung gesagt ,
in der
wir IntelliJ j installiert haben, haben wir
die 2021 diese eine Version heruntergeladen, die derzeit die
neueste Version ist wenn ich diesen Kurs aufnehme
und Sie öffnen sich bis g, Sie werden mit
diesem Fenster begrüßt , das Sie auch in
der letzten Vorlesung gesehen haben. Auf der linken Seite gibt
es verschiedene Banner, gibt
es verschiedene Banner die eine andere
Art von Sachen machen. Und wir werden jeden von
ihnen
durchlaufen und erklären, was sie tun. Der erste, der
automatisch ausgewählt wird Osterprojektschritt. Es sagt Ihnen im Grunde Willkommen bei der
Intel GIT, unserer IDE. Sie können entweder
ein neues Projekt erstellen , um von vorne zu
beginnen. Wenn Sie dies wünschen, können
Sie ein
bestehendes Projekt öffnen. Und hier haben Sie zwei Möglichkeiten. Sie können es entweder
von Ihren Zähnen aus öffnen, wenn Sie dieses Projekt
bereits auf
Ihrem lokalen Computer gespeichert haben, oder Sie können es von einem
Versionskontrollsystem aus öffnen. Ich werde nicht so schwer in
das
Versionskontrollsystem einsteigen . Wenn Sie jedoch
ein GitHub-Repository oder
Mercurial oder eine Subversion haben , können
Sie die URL darauf verweisen und
es wird natürlich auf Ihren lokalen Computer
klonen und es wird sie außerdem öffnen. Und natürlich hat die
IT die Versionskontrolle
integriert. Und es ist viel einfacher
für Sie, Schulden
zu verwenden , um eventuelle
Zweigstellen zu machen und so weiter. Nach dem Projektschritt haben
wir den angepassten Stempel, dem Sie das
Intel J-Thema angeben können, das leicht
Windows zehn sein kann, oder? Dracula, das ist dieser, hoher Kontrast, der
so aussieht. Wie du siehst. Das Fenster Stem Light
ist eine inspirierte Dr. Domäne, die Schuldenthema hat, aber die dunkle Farbe
ist standardmäßig, und wir werden das ICDs sein lassen. Und Sie können sich natürlich auch Synchronisierung mit
dem Betriebssystem
entscheiden, das Sie haben,
was bedeutet, dass es mit
dem von Ihnen verwendeten
Betriebssystemteam
synchronisiert wird . Und dann die
Barrierefreiheitsoptionen , die Sie erhalten, diese Schriftart. Und Sie können sehen, dass Sie es so
auswählen können, dass es viel größer ist, aber standardmäßig
ist es bei 12, denke ich. Wir werden es Schulden überlassen. Dann können wir Farben
für Rot-Grün-Mangel anpassen. Und dann können wir auch einige Key Maps
verwenden, die wir
natürlich später eingehen werden. Sie können jedoch auch Einstellungen
importieren, wenn Sie noch einige Legacy-Einstellungen
auf Ihrem lokalen Computer haben. Sie können auch auf
Alle Einstellungen klicken,
um direkt von diesem Startfenster aus alle
Einstellungen der IDE zu gelangen, was wir nicht tun werden. Wir werden das tun,
wie ich später sagte. Verwalten Sie am kommenden Wochenende
unsere Plugins, die unsere IDE
uns auf der dritten Registerkarte zur Verfügung stellt.
Wenn Sie sich fragen, welche Plugins
es gibt, gibt es einige Funktionen,
die die Kernfunktionalität erweitern. dieses Detail hat GID bereits. Durch die Installation dieser Plugins können
Sie einige
zusätzliche Funktionen nutzen. Nehmen wir zum Beispiel an, Sie möchten Docker in Ihrem
Java-Projekt
verwenden, das Sie mit
der Intel GID erstellen
werden , kann
weitermachen und dr schreiben. Hier ist es. Sie können sehen, dass es dieses Plugin hat und Sie
können auf Installieren klicken. In der Tat. Verknüpfen Sie es außerdem und
installieren Sie es mit Ihnen, wo ich BIN. Und natürlich hat es auch eine kleine Beschreibung
hier auf der rechten Seite. Aber hier oben haben Sie alle Plugins,
die
verfügbar sind, und Sie haben auch
die Installierten Plugins. Sie müssen hier
aufpassen, um auf
dem Marktplatz nach einem neuen
und nicht nach dem installierten zu suchen . Natürlich haben wir hier eine Schaltfläche
unter Einstellungen, am Wochenende hat
die
Plug-Ins deaktiviert, die wir herunterladen. Wir können Plug-Ins stoppen, die wir lokal auf unserem Computer
haben. Und natürlich können wir
die Plugin-Repositorys und -Zertifikate
und einige
andere HTTP-Proxy-Einstellungen verwalten . Im letzten Schritt haben wir
die IntelliJ-Idee, wo sie einige Tutorials
verweisen, die von ihrer Website aus
verlinkt sind. Und es gibt auch
eine Schulung , die Sie
direkt an ihrer ID machen können
, nämlich interaktiv,
es ist genau wie. Fangen wir mit
dieser Art von Ding an. Und wenn Sie das möchten, können
Sie auf das
Lernbeginn klicken und es wird Sie zu
einem grundlegenden Standardprojekt
weiterleiten , das sie haben, und Ihnen dort
einige Dinge zeigen. Aber das werden wir nicht tun. Wir werden einfach
ein neues Projekt über diesen
Button erstellen. Wir können einfach den Java-Typ des Projekts
ohne zusätzliche Bibliotheken
oder Frameworks für diese grundlegenden Projekte verwenden, die wir erstellen werden, um die verschiedenen Funktionen
hervorzuheben die diese IDE uns
zur Verfügung stellt. Wenn Sie nun auf Weiter klicken, können
wir ein Projekt aus der
Vorlage der
Befehlszeilen-App erstellen . Und das ist, wie Sie der
Beschreibung genau hier entnehmen können, nur eine Java-Anwendung, die eine Klasse mit
der Hauptmethode
enthält, was natürlich nützlich ist denn wenn Sie wollen
etwas läuft, wir drucken etwas auf
den Bildschirm, um zu überprüfen
, ob Sie
mit dem JDK arbeiten. Vielleicht möchtest du das machen. Aber etwas, das ich
vergessen habe zu erwähnen. Stattdessen haben wir hier das GDK direkt
nach dem Projekt
ausgewählt. Sdk. Software-Entwicklungskit ist in unserem Fall
ein Java Development
Kit, das ich Ihnen gezeigt habe,
wie Sie installieren können. Und es ist hier schon verlinkt. Darum musst du
dir darüber keine Sorgen machen. Aber wenn Sie diese Vorlesung nicht
befolgt haben, können
Sie auch ein
bestimmtes JDK herunterladen oder hinzufügen wenn
es hier nicht bereits standardmäßig
verknüpft ist ,
wie es in meinem Fall der Fall war, das ist sehr wichtig. Sie müssen das GDK verlinkt haben damit Ihr Code kompiliert wird. Nachdem wir
diese Vorlage auch überprüft
haben, können wir unsere
Projektnamenzelle auswählen. Nun, wir werden
dieses als Intel GIDL-Projekt bezeichnen. Und es wird es standardmäßig
in die C-Benutzer eingefügt, dann sind Sie ein Windows-Benutzer. Dann der Ordner Idea-Projekte und dann der Name
von Ihnen sind Projekt. Dies ist nur für Sie, um zu wissen
, wo es standardmäßig ist. Oder Sie können das natürlich von diesen
drei Punkten direkt hier
ändern und auf den Desktop
oder woanders legen.
Es ist bequemer
für Sie, darauf zu klicken. Und Sie können auch
aus dem Basispaket auswählen, dem es sich standardmäßig um
das Verhaltensunternehmen handelt. Und das werde
ich nicht ändern. Aber wie Sie sehen können, hat es unser neu
erstelltes Projekt eröffnet. Nur damit wir wissen, dass
alles funktioniert. Wir werden jetzt etwas
anderes auf den Bildschirm bringen . Wir werden
diesen Systempunkt herausbringen, Punktdrucklinie, Hallo Welt. Und wir werden
rennen, damit wir alles zum Laufen
bringen. Es wird eine Weile dauern, wenn
Sie es
zum ersten Mal von
der Zellen-ID aus ausführen , da es
einige Dinge im Back-End aufstellt. Aber wie Sie sehen können, lief
es und alles
hat gut geklappt. So können
Sie also
ein erstes Projekt in Intelligenz erstellen . So einfach ist es
und Sie können schon sehen, dass wir
etwas auf dem Bildschirm ausgedruckt haben. Und wir werden mit
einigen visuellen Komponenten
, die wir in
diesem Code-Editor in
der nächsten Vorlesung sehen, ausführlicher einigen visuellen Komponenten
, die wir in
diesem Code-Editor in
der nächsten Vorlesung sehen werden. Wenn das also interessant klingt, suche
ich nach den Jungs dort. Aber ich weiß es sehr zu schätzen, dass du mir bis zum
Ende dieses Tutorials
gefolgt bist und gesagt hast, ich freue mich darauf,
euch im nächsten zu sehen.
5. Ein Projekt führen: Hallo Leute, willkommen zurück
zu dieser IntelliJ-Idee. Wie können wir mit diesem Editor
in Java effizienter codieren . In diesem Vortrag werden wir verschiedene Möglichkeiten
diskutieren, verschiedene Möglichkeiten
diskutieren das
in Java geschriebene Projekt
auszuführen , dass wir eine nette IDE haben. Wenn wir über
Schulungsprojekte in diesen GID oder IDE sprechen, sollten
Sie darüber nachdenken. Korrelieren Sie diese, die das Projekt
ausführen mit dem Begriff
APP-Konfigurationen. Die Konfigurationen sind im Grunde
eine Möglichkeit, Code auszuführen. In Intelligent haben Sie mehrere
Arten von Konfigurationen. Wir werden jeden einzelnen von
ihnen
durchlaufen und verstehen,
was sie sind, wie sie nützlich sein können, was für jeden von ihnen
anders ist . Die erste Art von
Konfiguration, die es
in jeder temporären
Konfiguration gibt , die ich hier erstellt
habe, eine weitere
Hauptfunktion, die auch andere Hauptklasse hat, die
auch eine Hauptmethode enthält. Nur diese Methode,
drucke hallo world. Wissen wir, wie wir zwischen
ihnen
unterscheiden können, um zu wissen, welche von ihnen und
daher ausgeführt werden. Wir haben also diese beiden
Klassen und jede von ihnen hat eine Hauptfunktion. Wie wir zufällige Hauptklasse. Und natürlich standardmäßig
die Hauptmethode davon. Der einfachste Weg möglich. Nun, das ist mit Hilfe
einer temporären Konfiguration. Die temporäre Konfiguration
wird verfügbar gemacht , wenn wir mit der rechten Maustaste auf die
Klasse klicken, die wir ausführen möchten. Die Hauptfunktion. Haben wir diesen Run-Button? Oder wir haben auch die
Verknüpfung Control Shift F, dann funktionieren beide. Wenn wir darauf klicken,
bekommen wir die Hello World. Die Hauptmethode wurde ausgeführt. Und das Gleiche gilt für
diese Hauptfunktion. Wenn Sie mit
der rechten Maustaste darauf klicken und auf Hauptteil zwei ausführen klicken, wurde
die Hello World to angezeigt, was bedeutet, dass diese Hauptfunktion ausgeführt
wurde. Auf der anderen Seite haben
wir auch permanente
Konfigurationen, die in diesem Dropdown-Menü
verfügbar gemacht werden in diesem Dropdown-Menü
verfügbar , das sich im
oberen Teil des Bildschirms befindet. Um zwischen
verschiedenen Konfigurationen zu wechseln. Sie können auf Konfigurationen
bearbeiten klicken und diese werden ständig zur Verfügung
gestellt. diesem Grund werden sie als
permanente Konfigurationen bezeichnet. Wenn Sie
sie bearbeiten möchten, ändern Sie sie, fügen Sie einige davon hinzu oder entfernen Sie sie. Sie können im Dropdown-Menü auf
diese
Schaltfläche „Konfiguration bearbeiten“ klicken . Und wie Sie hier sehen können, werden
die Anwendungskonfigurationen zur Verfügung gestellt , die es gibt. Und der Hauptmann war schon
hier und es wurde geschaffen. Sie können sehen, dass
wir im
rechten Teil des Bildschirms seine Eigenschaften haben. Zuallererst haben wir
den Namen dafür, spezifisch mit
dem Klassennamen oder
der ausgeführten
Methode korreliert . Da die Methode jedoch so
ziemlich
ständig main genannt wird , sollte
sie mit dem Namen
Ihrer Klasse oder etwas,
das Sie tun wollten, korreliert
werden . Aber beende einfach diesen Namen. Wir müssen Optionen erstellen
und ausführen. Zuallererst haben
wir natürlich das JDK, das Java Development Kit, hier
speziell ausgewählt, damit die Intel G IDE weiß welches JDK tatsächlich verwendet werden soll, um Ihren Code
zu kompilieren. Dann nach rechts. wichtigste Teil
der Konfiguration, nämlich der FQDN oder der vollqualifizierte Name für die Klasse, die
die Hauptmethode enthält. Und wenn Sie es ändern möchten, können
Sie hier auf dieses
Papier klicken. Und Sie können hier sehen, dass
wir beide Klassen von
der Kampfgesellschaft haben. Wir können
hier die Hauptklasse auswählen und sie wird,
wie Sie sehen können, zwei
zufällige Hauptmethoden
dieser Klasse genau hier kennen wie Sie sehen können, zwei
zufällige Hauptmethoden . Ansonsten ist das
Arbeitsverzeichnis bereits
standardmäßig für das Bad ausgewählt. Darum musst du dir
keine Sorgen machen. Der einzige Unterschied
bei mir,
es einzugeben , bestand darin, den
Namen auch für mich zu ändern
und die Klasse zu ändern, von der
die Hauptfunktion ausgeführt werden
soll. Zwei, Main, zwei. Um nun eine neue Konfiguration hinzuzufügen, können
Sie direkt
hier auf diese
Plus-Button klicken und eine
Anwendungskonfiguration auswählen. Und schreiben Sie natürlich
seinen Namen und
wählen Sie dann die Klasse aus, für die
sie konfiguriert werden soll. werde ich
jetzt nicht machen, weil ich es bereits mit diesen beiden
Hauptkonfiguration gemacht habe. Um die Konfiguration zu löschen, können
Sie jedoch genau hier auf dieses
Minuszeichen klicken und Sie werden ein wenig lesen. Es gibt auch
einige Vorlagen für Konfiguration, wenn
Sie
beispielsweise eine Gretel- oder
Groovy-Anwendung ausführen möchten. Sie haben natürlich eine Vorlage für jeden dieser Personen,
je nachdem, was
Sie mit
Ihrem Projekt und der Art
des Projekts machen möchten , das Sie haben. Aber es geht um die
permanenten Konfigurationen. Und wie Sie hier sehen können, haben
wir sowohl die
Haupt-2M, die Hauptkonfiguration,
als auch Haupt-2M, die Hauptkonfiguration, wenn wir eine von ihnen auswählen, den Schaltflächen verbunden sein
, die wir hier haben. Genauer gesagt
das Build-Projekt. Dann kann der Lauf reichen, was natürlich zufällig von den beiden
Hauptklassen
funktioniert, wir geben den Debug-Main an
, was ein völlig
anderes Thema ist. Wir werden einen
ganzen Vortrag über das
Debuggen widmen , um zu verstehen,
wie es in dem gemacht wird was es tatsächlich
intelligent ist und auch mit Berichterstattung
begegnet wird. Und wie Sie gesehen haben, wird die Hello
World-Nachricht angezeigt, wenn wir den Run Mittelwert
auswählen, um zu hören. Und das ist ein gutes Zeichen,
denn
das bedeutet, dass die zwei Hauptkonfiguration ausgewählt
wurde und die Hauptmethode der
Mittelklasse tatsächlich ausgeführt wurde. ging also darum, es passt in Konfigurationen
Teil dieses Tutorials und auch die Durchführung
des Projekts, das Sie in Intel J
haben Wie Sie sehen können, ist es
ziemlich einfach
und nicht nur das, es ist ziemlich vielseitig und flexibel angesichts der Tatsache, dass Sie zwei Möglichkeiten
haben, Ihre Klassen auszuführen,
entweder indem
Sie sie vorübergehend mit der rechten Maustaste
auf die Klasse ausführen und laufende Option oder die Tastenkombination
Control Shift F M. Oder Sie können eine
bestimmte Konfiguration erstellen , die hier dauerhaft
gespeichert wird. Und indem Sie es auswählen, können
Sie außerdem Ronald debuggen,
schuldenspezifische Konfiguration. Also hoffe ich, du hast etwas
aus dieser Vorlesung herausgeholt. Im nächsten werden
wir
über die
Grundelemente dieser ID sprechen . Also die visuellen Elemente, die Sie auf dem Bildschirm
sehen
, um zu verstehen, was jeder visuelle Teil von Bs ID
xy yz und was es tut. Wenn das für Sie
interessant klingt, freue
ich mich darauf, Sie
dort zu sehen und danke Ihnen bis
zum Ende dieser Vorlesung bei mir geblieben sind.
6. Visuelle Elemente der IDE, IDE, IDE, die IDE,: Hallo Leute. Willkommen zurück zu diesem IntelliJ IDE-Tutorial,
in dem wir besser verstehen, wie wir mit Hilfe dieser IDE
effizienteren Code in
Java schreiben können . In diesem Vortrag werden
wir uns noch besser mit der
IntelliJ-IDE
vertraut machen, indem die visuellen
Elemente
diskutieren, die diese IDE, den Entwickler, präsentiert. Das können wir natürlich tun, damit wir
einfach schneller werden. Wann möchten wir eine
Aktion mit unserem Code ausführen? Wir können natürlich
schneller vorgehen, wenn wir wissen, wo sich jeder Artikel visuell
in der IDE befindet. Das wird unsere
Entwicklungsreise viel einfacher machen. Natürlich hat der erste Teil,
dass diese Delta G IDE heutzutage
viele Anwendungen
hat jeweils die Menüleiste oben auf dem Bildschirm. Es bietet natürlich die grundlegenden Optionen
und Aktionen, die sich auf beide Projekte beziehen. Also Code-Refactoring,
neue Projekte erstellen, sie öffnen, bauen, ausführen, Systemsteuerungen
für sie
versionieren und so weiter. Sie können sehen, dass wir die
Datei haben, während Sie durch Code navigieren, analysieren, überarbeiten, Run-Tools
neu erstellen und dann Fenster und Hilfe erstellen. Und D bis D Stempel
zeigen viele Optionen an. Für sie. Wir werden einige
von ihnen in den zukünftigen Vorträgen analysieren . Aber im Moment
müssen wir nur wissen, dass Sie in dieser Datei
beispielsweise von hier aus ein neues
Projekt erstellen
können. Und Sie können natürlich
einige Klassen erstellen , die bereits
existierende Projekte haben, sodass wir sie nicht wirklich
erstellen müssen. Sie können, wie ich Ihnen zuvor gezeigt habe, ein neues Projekt
für ein Repository
erstellen. Wir können ein
Projekt eröffnen und schließen. Wir können die
Einstellungen für die IDE öffnen. Und dann natürlich, in der Bearbeitung, die grundlegenden Befehle von copy, gut basiert und so weiter. Jedes Kontextmenü enthält
verwandte Dinge, die den
Haupt-Header
vorgeschlagen werden , den wir sehen ,
und natürlich haben
wir auch die
Dienstprogramm-GID und Namen, den
Namen des Projekts. Wir haben n. Dann haben wir den Namen
der Klasse, in der wir uns
befinden, direkt unter der Menüleiste haben
wir die Symbolleiste angezeigt, die eigentlich genau
diese rechte Hälfte von der Bildschirm von diesem
Hammer rechts davon. Und dies bietet Verknüpfungen zum R1 und natürlich zum
Debuggen, Erstellen und Auswählen der
gewünschten Konfiguration für Ihr spezifisches Projekt. Diese 0s, außer
als Symbolleiste bezeichnet. Und auf der rechten Seite
haben wir die Navigationsleiste, Sie diese Intel
GID- oder SRC-Comp-Unternehmen sehen können, die Hauptklasse und Hauptmethode, die natürlich die
Angabe gibt, dass wir uns
im aktuellen Moment befinden und es ermöglichte es, die
Navigation innerhalb eines Projekts zu erleichtern. Und diese Funktion kann
natürlich nützlich sein, da Ihr Projekt immer
komplexer und natürlich groß wird . Jetzt haben wir auch die beiden Stempel , die wir auf der linken
Seite des Bildschirms sehen. Also haben wir das Projekt,
und dann
haben wir hier die Struktur und
dann den Favoriten. In diesem zweistufigen Schritt
können wir auf einige wichtige
Tools wie Datenbanken zugreifen. Wenn wir jemanden hätten, das
Wichtigste ist,
das wir haben, ist das Projektsite-Menü, das uns natürlich alle Dateien in
unserem Projekt MBE lagert. Es ist dem
Solution Explorer ziemlich ähnlich, den wir auf Visual Studio IDE
hatten. Wenn du das jemals benutzt hast. Wie gesagt, kann die
Projekt-Dep auch als
DAP-Projekt-Perspektive bezeichnet werden und
zeigt verschiedene Elemente. Es kann, wie gesagt,
entweder die Struktur, ihr
Favorit, das Projekt zeigen . gesamte linke Teil
, den Sie hier sehen, wo wir gerade das Projekt
und die Struktur
anzeigen , wird als
Projekt-Perspektive bezeichnet. Schließlich haben wir den sechsten Teil
, der eigentlich der
letzte in diesen ist, der wichtigste Teil,
das Editor-Fenster. Und wie Sie vielleicht schon
intuitiv denken, ist
es der Ort, an
dem der Entwickler die meiste
Zeit
damit verbracht hat, Code zu schreiben und den Code für die Datei zu schreiben, die Sie
aus Projekt-Perspektive auswählen. Es hebt auch die
Syntax für den Sprungcode hervor und verwendet einige andere
nützliche Funktionen. Am unteren Rand
des Fensters befindet sich eine Statusleiste, die
einige zusätzliche Attribute anzeigt. Und Sie können sehen, dass wir
das Ausführungsfenster haben , das angezeigt wird, wenn wir versuchen,
das Skript auszuführen, das wir das Projekt erstellt
haben,
oder debuggen, so weiter. Dann können wir auch Probleme mit einer
Aufgabenliste haben , die
gelöscht werden können, wenn wir einen Fehler haben. Wenn wir also unseren
Code mit Fehlern in,
in Probleme mit B schreiben würden , hier
anzeigen, dann Determiner, haben
wir auch ein Terminal, das
dem Windows Cmd
ziemlich ähnlich ist , nur für den Fall Sie wollten
vielleicht direkt Aussagen von
hier erhalten oder manuell
mit dem JDK erstellt werden. Und dann Leslie, wir
haben ein Fenster gebaut, das ausgelöst
wird, wenn wir
versuchen, unser Projekt zu erstellen. Sie können sehen, dass unsere
Projekt-Builds erfolgreich erstellt wurden. Es gibt keine Probleme dort. Das war
außer Schulden ziemlich einfach, einige wichtige Dinge
finden Sie in
der Datei und dann auf der Registerkarte Einstellungen. Von hier aus können wir
unsere Plugins natürlich verwalten, da wir sie bereits in
den Eröffnungsfeucht gesehen haben, den wir
beim Öffnen des
Intel GID-Editors bekommen . Ich werde es nicht noch einmal
durchmachen. Ich habe Ihnen bereits
die Definition gegeben, was sie tun, wie sie dort nützlich sein
können, aber sie können von hier aus
zugänglich sein sobald Sie Ihr Projekt bereits
erstellt haben. Aber hier haben wir Schlüsselkarten,
Editoren, Versionskontrolle und natürlich
einige andere Einstellungen, die ausführlicher zur Verfügung gestellt
werden. Und wir werden
sie bei einem späteren Vortrag durchlaufen. Aber im Moment ging es darum, mit diesem, wo wir uns
nur genauer angeschaut und verstanden haben, wo
jeder wichtige Punkt im PSI B
tatsächlich positioniert ist. Und das wird uns natürlich helfen, wie ich in Zukunft sagte, effizienteren
Code
zu schreiben und uns dabei zu helfen, schnell an den Ort des
Projekts zu
gelangen, das wir machen wollten. Verändern Sie und wissen Sie auswendig, wo alles befindet und
jedes Feature positioniert ist. Ich danke euch, dass ihr
bis zum Ende dieser
Vorlesung bei mir geblieben seid. Im nächsten werden wir
diskutieren, wie
Refactorings innerhalb der GID-IDE
verfügbar gemacht werden können ?
Das klingt interessant. Ich freue mich sehr darauf, euch dort zu
sehen.
7. Code: Hallo Leute und willkommen zurück zu diesem IntelliJ IDE-Tutorial, in dem wir verstehen,
wie wir mit dieser IDE
besseren und effizienteren
Java-Code schreiben können . In dieser Vorlesung werden wir das Code-Refactoring diskutieren. Falls Sie noch nie von Refactoring
gehört haben, erhöht sich die
Refactorierung
zuerst auf einen Prozess , der die Verbesserung Ihres
von Ihnen geschriebenen Quellcodes
impliziert . Diese Verbesserung erfolgt jedoch ohne
neue Funktionen zu schaffen. Diese Refaktorierung
sollte,
wenn es richtig durchgeführt wird, dazu beitragen, dass Ihr
Code sehr organisiert ,
gepflegt, solide
und in Zukunft
einfach zu warten ist. Dies sagte ich, es ist im Grunde
eine Möglichkeit,
einige der
Funktionen neu zu schreiben , die Sie bereits angeborene
breitere Begriffe haben. Nur damit mehr Menschen es verstehen
können und es ist besser
zusammengestellt. Bei der Code-Refactoring gibt es einige verschiedene Prozesse, die mit
dem Factoring-Prozess in Verbindung gebracht werden
können. Intelligenz hat viele dieser Prozesse, die sich
auf das Refactoring beziehen. Wenn Sie beispielsweise
versuchen,
etwas im Zusammenhang mit einem Schlüsselwort umzugestalten , können
Sie auf dieses Schlüsselwort klicken und
dann Strg Alt, Shift Enter drücken. Wie Sie sehen können, erscheint das
Refactoring-Kontextmenü auf dem Bildschirm mit
verschiedenen Alternativen von Aktionen, die Sie außerdem
auswählen können, um etwas zu
dem von Ihnen ausgewählten Objekt
umzugestalten . Also
habe ich in unserem Fall das Gebäude
des App-Desks gewählt
, der Testfunktion ist. Dieses ganze Java-Projekt
war ein älteres Projekt von mir, in dem ich das Framework für
Komponententests erklärt habe. Aber ich habe mich nur dafür entschieden, hier
darauf zu verweisen, dass es mehr als
nur eine Klasse mit einigen Objekten
und im Grunde mehr Code hat nur eine Klasse mit einigen Objekten , den wir umgestalten können. Also mach dir keine Sorgen, wenn du
etwas siehst , das du
nicht verstehst. Darum geht es nicht. Sie sollten sich einfach auf
den feuerfesten Prozess konzentrieren .
In dieser Vorlesung. Sie können sehen, wie
das Gebäude getestet wird, wie gesagt, es testet Glas, wie
Sie hier sehen können. Und wir haben einige Maßnahmen , die wir in Bezug auf
die Refactorierung antun können. Wir können es zunächst umbenennen oder Migration darauf eingeben. Dann können wir die Mitglieder dieser
Klasse an einen anderen Ort bringen. Wir können die Klasse kopieren oder
wir können es sicher glauben,
was bedeutet, dass
alle zu essenden Referenzen gelöscht werden ohne einige
andere Teile Ihres Codes zu gefährden. Sie können etwas in
Bezug auf Extrakt oder das
Einführen von Wärme tun. Und genauer gesagt können
Sie eine Konstante einführen, die
Sie benötigen oder ein Feld. Sie können einen Parameter
oder einen Funktionsparameter einführen, oder Sie können sogar
Parameter eingeben oder minus supremum es sei denn, Sie können
diese beiden Einträge auch x migrieren, aber das ist nicht wirklich
der Fall hier. Nehmen wir zum Beispiel an, wir
möchten ein neues Feld einführen. Nun, wenn wir das
aufschlüsseln, werden
wir sehen, dass
wir es in
einer aktuellen Methode oder
Felddeklaration oder einem Co-Instruktor initialisieren können . Und wenn wir das tun,
können Sie sehen, dass wir es entweder in
der aktuellen Methode,
in der Felddeklaration,
im Konstruktor oder in
die Setup-Funktion
initialisieren in der Felddeklaration, im Konstruktor oder in
die können, die Sie hier sehen. Im Grunde genommen werden
alle Optionen vorgestellt , die
Ihnen zu diesem Zeitpunkt zur Verfügung stehen. Jetzt ist eine weitere sehr nette
Funktionalität, die es hat, in Bezug auf den
Umbenennungsprozess des Refactorings. Sie können dies also auch tun,
indem Sie auf Anleihenklasse
klicken, mit der
rechten Maustaste darauf klicken und sehen , dass es die Option Refaktor hat. Bis hier rauf. Sie können wieder viele Optionen
bezüglich Refactoring sehen. Nehmen wir zum Beispiel an, dass wir den Namen der
Rechtschreibbohr-App am besten
ändern möchten , sagen
wir Abrechnungs-Gap-Desk. Und wenn wir Refactor sagen, es automatisch
alle Währungen
der Abrechnungslücke in
unserer Anwendung mit
den Building Gap Tests geändert der Abrechnungslücke in
unserer . Auf diese Weise lassen Sie keine
anderen Funktionen zurück , die Fehler darin auftreten
würden. Denn wenn es nur den Namen der Klasse
ändern würde, wäre
es hier ohne ein S und wir
müssten uns hier
als Fehler mit Klammer befassen . Und auf diese Weise wird, wenn man kalt ist, immer
größer. Und Ihre Codebasis wird
viel Quellcode enthalten. Refaktorierung des
Namens einer Klasse könnte sich
tatsächlich auf Tausende
von tatsächlichen Wörtern beziehen , die geändert werden
müssen. Und diese Funktionalität spart uns
natürlich Zeit und ist auch anfällig Fehlerfaktor, der
ebenfalls vermieden wird, weil Sie möglicherweise den
alten Namen verpassen und ihn nicht ändern. Und darüber hinaus
scheitern Sie in dieser Hinsicht. Dann ein weiterer Fehler
beim Rennen und so weiter, der viel
Entwicklungszeit
verschwendet. nun Wenn intelligente Ideen nun auf
Probleme mit dem
Refaktor stoßen , den Sie ihr geben, wird
sie sich
zumindest als Konflikte und
ihre kurze Beschreibung öffnen und Sie müssen sich befassen
mit jedem von denen. Jetzt
haben wir auch in der Datei in den Einstellungen, wenn wir zum Editor- und
Codebearbeitungsbereich der
Einstellungen gehen , die ausschließlich
die Mittel widerspiegeln. Hier haben wir natürlich einige zusätzliche Einstellungen
, die wir auswählen können. Wir können die
Optionen eines Refactorings angeben. Genauer gesagt
ist das entweder
im Editor oder in
Modelldialogen zu tun. Wir haben auch einige Überprüfungen bezüglich des aktuellen
Symbolnamens für die neue Umbenennung und
überarbeiten, ob dies gelobt, ausgewählt
werden soll oder nicht. Und auch die Inline, die
den Dialog für
lokale Variablen zeigt . Einige
der beliebtesten
Refactoring-Aktionen, der beliebtesten
Refactoring-Aktionen die unterstützt und auch im Intel GIT,
unserem IPE,
ausgeführt werden, sind das sichere Löschen, das sicherstellt, dass
Sie keine
Dateien löschen die
in Ihrem Quellcode referenziert werden. Und D für die RD wird
Sie auffordern, sich in einem Konflikt
mit ihnen zu befassen. Wie gesagt, hat die Sicherheitsleitung die Tastenkombination
Alt und dann löschen. Sie können auch ein Element kopieren
oder verschieben , das auch
Morph-Refactorings genannt wird. Und die Kopie erfolgt mit einem
F5 zu Filmen, die in F6 gestartet wurden. Dann haben wir die Extraktion einer Methode, mit
der Sie die Codeduplizierung
reduzieren können . Und das bezieht sich auf einen Prozess
, bei dem Sie eine Folge von
Codezeilen an mehr
als einer Stelle haben Codezeilen an mehr
als einer Stelle und die als Methode
extrahiert werden können. Und diese Methode kann in den Bereichen
aufgerufen werden, in
denen dieselben Codezeilen
nacheinander vorhanden wären. So wäre die
Code-Duplizierung. Reduziere tatsächlich das Los. Und das ist eine gute
Vorgehensweise, den Code nicht sehr stark
duplizieren zu lassen. Dies kann also
mit der Methode „Extrahieren oder mit der Verknüpfung Control M geschehen. Wenn
wir beispielsweise
diese beiden Zeilen hier
für den Refaktor auswählen würden , könnten
wir tatsächlich
auf die Extraktmethode klicken. Und wie Sie sehen können, extrahieren Sie eine Methode
für uns und lassen Sie
uns den Namen dafür eingeben. Und wie Sie sehen können, hat es nur die Methoden gekostet , die hier
von selbst implementiert werden. Es hat alle Schulden
ganz von selbst gemacht. Nun, wie ich schon sagte MEIN Kopf, extrahieren
sie konstante
Parameter-Mitarbeiteroptionen. Wir haben auch die
eingeführte Variable mit der Abkürzung Control Alt V. Dann die Umbenennung eines Elements
, das ich
euch bereits im
Bauglas gezeigt habe. Und diese Umbenennung
hat auch die Abkürzung, wie gesagt, Shift F6. Wir haben auch die
Steuerungsverknüpfung F6, die sich auf die Änderung
der Kostensignatur
einer Methode oder einer Klasse bezieht . Wie Sie gesehen haben, ist ein großer Teil
der Prozesse, die an der
Code-Refaktorierung von
Garvey-Bedeutungen beteiligt sind, oder nur an
der Bewegung eines Codes, wo
er nicht hingehört, nicht dupliziert und
extrahieren int-Methode, sehr intuitiv und leicht verständliches Benennen
für Variablen. Solche Dinge können mit Refactoring
gemacht werden
, wodurch Ihr Code
viel sauberer ist. Vermindern Sie die allgemeinen
bewährten Praktiken. Es ging um diese Vorlesung über die
Code-Refactoring-Verarbeitung. Die IntelliJ-IDE. Wie Sie gesehen haben, verfügt
der Code-Editor
über viele Funktionen in Bezug auf
genau diesen Prozess. Es sollte also
einfacher sein, Codes zu schreiben. Schulden sind, wie ich schon
sagte, gut geschrieben. Die nächste Vorlesung. Wir werfen einen kurzen
Blick auf den
Debugging-Prozess in Intel J. Wenn das für Sie
interessant klingt, freue
ich mich darauf, Sie dort zu
sehen. Und nochmals vielen Dank, dass
Sie bis zum Ende dieser
Vorlesung bei mir geblieben sind.
8. Debugging: Hallo Leute, und willkommen zu diesem GID-Tutorial, in dem
wir verstehen, wie wir mit dieser ID besseren und
optimierten und effizienteren Code
in der Programmiersprache
Java schreiben können . Natürlich werden
wir in dieser Vorlesung
die Debugging-Funktion besprechen , die dieser Code-Editor den Programmierern
zur Verfügung stellt. Und besprechen Sie auch das Konzept
des Debuggens von Key General. Ich lösche zunächst die beiden Hauptfunktionen,
die wir in einer
unserer letzten Vorträge
erstellt haben . Damit ich Ihnen die
Konfigurationsfunktion zeigen kann
, die die ID hat. Damit Sie eine Funktionsklasse
löschen können, können
Sie mit der rechten Maustaste darauf klicken
und dann auf Löschen klicken. Sie müssen die
Suchoption für Sicherheitsretweet aktiviert haben. Wir müssen auch nach Textwährungen
suchen. Wie Sie sehen können, ist die
beiden Hauptklasse verschwunden. Wenn wir die Konfiguration überprüfen, ist
ihre Konfiguration
immer noch die, die hier übrig ist, aber Sie können sehen, dass es in der
rechten oberen Ecke
eine x-rote Markierung hat . Und wenn wir auf
die Konfiguration bearbeiten klicken und auf Fehlkonfiguration
klicken, können
Sie sehen, dass es
eine Warnung
gibt, die angibt, dass kein Modul für die Klasse gefunden
wurde. Sie können die
Konfiguration einfach löschen, wenn Sie eine bestimmte Konfiguration für
eine der Klassen
einrichten bestimmte Konfiguration für
eine der Klassen
einrichten , die Sie ausführen möchten. Das machen wir standardmäßig. Wenn Sie nun zum
Debugging-Teil des
Tutorials zurückkehren, haben Sie, wie gesagt, die Möglichkeit, Ihren Code mit diesem IPE zu debuggen. sich ein wenig
auf den Grund eingehen, warum Sie Ihren
Code debuggen möchten und was die Leute essen. Nun, im Grunde ist es ein
Prozess, bei dem Sie die Ausführung Ihres
Codes in einer bestimmten Zeile
stoppen können . Wo Sie sehen können,
passiert etwas nicht Gutes und checken Sie den
Wert Ihrer Variablen aus. Und darüber hinaus, wie Ihr Code
von diesem Zeitpunkt an ausgeführt wird. Sie können diese Punkte erstellen, indem Sie tatsächlich Haltepunkte erstellen. Sie können den
Haltepunkt erstellen, indem Sie rechts neben der Zeilennummer , an der
Ihr Code angehalten werden soll. Wenn wir beispielsweise einen Haltepunkt
in Zeile sieben erstellen wollten , können
wir hier klicken. Und Sie können sehen, dass
die
gesamte Linie mit der roten Farbe hervorgehoben wird. Und dieser rote Punkt
wird auch erscheinen, wie ich in der nächsten Zeile gesagt habe. Nun, wie gesagt, wenn Sie
zum Beispiel Ihren Code
als normaler Programmierer schreiben , würde es irgendwann
tun. Du siehst offensichtlich, dass
etwas nicht vor sich geht. Nachdem Sie es erstellt
und ausgeführt
haben, sehen Sie, dass
tatsächlich das falsche Ergebnis angezeigt wird oder der
falsche Schreibtisch ausgeführt wird. Und du fragst dich
, was passiert. Man schaut sich dann die
Cola
an, um sie visuell zu debuggen. Und schauen Sie sich im Grunde einfach den Code an und sehen Sie, ob
Sie etwas falsch geschrieben haben. Codezeile, die man sehen
kann, die
die Abfolge der Schritte falsch macht . Aber das kann man nicht sehen. Und mehr als
andere Option
wäre hier , einige
Logs in den Code zu erstellen. Zum Beispiel
baut es nicht richtig auf. Oder wenn Sie
den Wert einer Variablen protokollieren möchten, können
Sie dies auch tun. Sie können Variablen sperren, aber dies ist kein S Good, eine Lösung als Debuggen. Und das liegt daran, dass Sie
Ihren Code tatsächlich erneut erstellen
müssen , um
herauszufinden, was dieser Wert erleichtert. Und beim Debuggen
erstellen Sie einfach den Haltepunkt und wenn Sie ihn
dann debuggen, wie wir sehen werden, können Sie dies
von dieser Schaltfläche aus direkt hier tun . Die Ausführung wird beendet,
während der Code läuft. Und Sie werden
zu diesem Zeitpunkt alle Variablen und
Werte sehen können. Wenn alles lokal ist, ist
das kein großer
Unterschied zwischen dem bloßen Protokollieren der Variablen
und dem tatsächlichen Debuggen. Stellen Sie sich jedoch vor, Sie
schreiben Code in Ihrem Job und
haben tatsächlich ein Produkt, das in der Cloud
bereitgestellt wird. gesamte Debugging-Prozess
wird viel komplexer und schwieriger zu machen,
wenn Sie alles lokal haben,
ja, wir haben hier einige
integrale Variablen. Dies ist ein sehr einfaches Szenario, aber Sie können nicht sehr komplex werden. Und die Hinrichtung kann eine Weile
dauern. Möglicherweise müssen Sie die Ausgabe
auch
auf einen anderen Computer kopieren , in diesem Szenario kann sehr komplex
werden. Und das Gebäude mit dem Baumstamm kann viel Zeit in Anspruch nehmen,
anstatt es einfach zu arbeiten. Das wäre also ein
Grund, warum Sie Ihren
Code debuggen
möchten, anstatt
nur einige Variablen zu protokollieren, von denen Sie glauben nicht
den richtigen Wert haben dass sie
nicht
den richtigen Wert haben, den Sie haben sollen. Dies sagte ich, die
praktikabelste Lösung vor dem
Debuggen, gut. Schauen Sie sich den Code an und
versuchen Sie nur zu verstehen,
was los ist. In diesem Fall funktioniert
es nicht. In den meisten Fällen
verstehen Sie jedoch möglicherweise nicht, indem Sie den Code
durchschauen, die indem Sie den Code
durchschauen, die Vernetzung,
da die Ausführungsschritte seltsame Verschwendung erfordern
könnten. Auch hier kann viele
Funktionen haben , die
ineinander aufgerufen werden. Und der gesamte Workflow
und die Kosten Deck könnten viel
komplizierter werden. Debuggen wäre
die beste Lösung. Sie werden in nur einem
zweiten Schritt in Funktionen sehen , die aufgerufen werden, und dann
wird das Steuerelement dorthin gehen und so weiter. Dies ist also eine sehr gute
Funktion, die Sie in Ihrer IDE haben können. Sie werden
Fehler in Ihrem Code haben. Und natürlich werden Sie Fehler
haben, weil niemand perfekten Code
schreibt. Aber jetzt komme ich
wieder in die IDE. Und wie Sie sehen können, habe ich diese
Hauptfunktion erstellt, bei der wir einige Integrale
haben, die
einige Operationen ausführen. Es hat auch eine
Funktion namens print
example , die
aufgerufen und ausgeführt wird. Es wird einfach etwas auf
dem Bildschirm drucken , damit
Sie alles aktuell machen. Aber ich habe gerade diesen
einfachen Flow erstellt, um Ihnen zu zeigen, wie das Debuggen auf der Delta G IDE
funktioniert. Es gibt zwei Möglichkeiten,
mit dem Debuggen
einer Ihrer Klassen zu beginnen. Die erste ist, indem Sie mit der rechten Maustaste
auf neuere Kunststoffe klicken, die Sie debuggen
möchten, und dann auf diesen Debug Main
klicken. Oder Sie können natürlich aus
diesem Dropdown-Menü
auswählen, dass Sie
konfigurieren möchten ,
und klicken Sie dann direkt hier auf dieses Fehlerzeichen. Das wird das Gleiche tun. Jetzt müssen Sie
bedenken, dass
Sie Ihre Haltepunkte vor dem
Start festlegen und debuggen möchten . Die Ausführung
stoppt also an dem Punkt, an dem
der Haltepunkt gesetzt ist. Zum Beispiel
setze ich hier einen
Haltepunkt in Zeile 13, gleich am Anfang
der Hauptfunktion. Und wir klicken auf die Schaltfläche Debuggen,
um mit dem Debuggen
dieser Anwendung zu beginnen. Sie können hier sehen, wenn Sie
auf die Debug-Schaltfläche klicken, wird das
Debug-Menü
automatisch ausgelöst und aus
der unteren Leiste hier ausgewählt. In diesem Menü
haben Sie viele Optionen, aus denen Sie beim Debuggen auswählen
können. Wie Sie hier sehen können, ist uns aufgefallen, dass wir
an der Linie 13 von Maine sind. Und beachten Sie auch das
Paket, das Verhaltensunternehmen. Wenn wir den Code
durchgehen wollen, haben
wir diese Schaltflächen
, die Sie hier sehen. Zunächst einmal haben
wir den Schritt
Over oder die F8-Verknüpfung dafür,
was es tut, ist fortgeschritten, in der Ausführung
auszurichten. Dann haben wir die
Schaltfläche Step Into oder die Verknüpfung
für diese F7,
die, wenn Sie sich in einer Zeile befinden,
in der eine Funktion aufgerufen wird, wenn Sie diese Taste drücken, wenn Sie diese Taste drücken,
sie in die
Funktionsausführung gelangt. Es wird also einen Schritt
tiefer in den Kostenschritt eingehen. Und dann wäre die Step-Up-Taste oder die
Shift-F8-Verknüpfung dafür, was es
tun wird, wir gehen einen Schritt tiefer in die
Call-Stack-Zellwand. Es wird rückwärts gehen. Natürlich haben wir auch
den Cursor-Button, der ziemlich
selbsterklärend ist. Es läuft einfach zu der Zeile,
in der der Cursor Tage ist. Und dann können wir auch
aufhören zu debuggen. Wir können das Programm fortsetzen. Dies wäre also das Äquivalent zum Kontinuum
von Visual Studio. Oder wenn Sie
damit nicht vertraut sind, wird
es einfach weiter ausgeführt und das Pausieren
des Programms beendet. Und es wird den
nächsten Haltepunkt treffen wenn er existiert oder wenn nicht, er wird nur mit
der Ausführung bis zum
Ende des Programms durchlaufen . Jetzt können wir
die Haltepunkte auch hier einsehen. Und wenn wir darauf klicken, können
Sie sehen, dass wir online
einen Haltepunkt haben 13. Es ist selbst da. Jetzt können wir die
Haltepunkte stumm schalten und was das isst,
deaktiviert den Breakpoint. Sie sind also immer noch da,
aber sie wurden noch nicht getroffen. Diese Ys. Eine sichere Lösung,
wenn Sie sie behalten möchten, aber das
Programm noch einmal ausführen möchten. Sie müssen
nicht
jeden Haltepunkt durchlaufen , um sie
einzurichten und zu deaktivieren. Denn das würde viel
Zeit in Anspruch nehmen und Sie können auch vergessen wo die Haltepunkte
, die Sie
eingerichtet haben , an erster Stelle. Hier haben wir noch ein paar Knöpfe. Wir können den
Thread-Dump bekommen, wenn das der Fall ist. Wir können
hier einige Einstellungen anzeigen , die die Rückgabewerte der
Methode zeigten. Automatische Variablenmodi, sortieren Sie
Werte alphabetisch und heben die Stummschaltung von Haltepunkten
beim Ende der Sitzung Und das ist die Pin-Tab, was die gesamte Debug-Registerkarte bedeutet. Hier. Wie gesagt, hier
haben wir den Rahmen. Wo ist die
Hinrichtung an dieser Stelle? Hier haben wir die
Variablen, die gesetzt sind. Hier werden alle
Variablen angezeigt, die wir deklariert haben. Also a, B, C, D und so weiter. Ich habe ziemlich einfache
Namen für diese Variablen
gewählt damit wir uns nicht darauf
konzentrieren können, sondern auf den Debugging-Prozess. So ziemlich DCC selbst. In der ersten Zeile erkläre ich
nur a und B, um sie auch mit den Werten 1365 zu initialisieren. Und wenn wir, wie gesagt, zur
nächsten Zeile gehen wollen, können
wir auf die Schaltfläche Step
Over klicken oder auf F8 klicken. Wenn wir das tun, ging
die Ausführung, wie Sie sehen können ,
auf Zeile 15 über. Sie können die Zeile sehen,
mit
der Sie gerade sind , weil diese
indische Ausführung, da sie mit
dieser hellblauen Farbe hervorgehoben ist , wie
Sie auf dem Bildschirm sehen können. Jetzt
wurde auch der Variablenschritt mit den
Werten von a und B aktualisiert, denen es sich um Variablen handelt, die wir inzwischen
initialisiert haben ,
und auch ihren Werten zu diesem Zeitpunkt. Wenn Sie sich daran erinnern müssen, dass diese Werte die
Werte sind, die die Variablen der Zeile des Codes
haben in dem sie sich befinden,
zu diesem Zeitpunkt. Wie Sie auch hier sehen können, ändert sich
der Rahmen, weil wir gerade online 15
sind. Hier in dieser Zeile haben wir eine Druckbeispielfunktion
, die def genannt wird. Wir wollen uns darauf einlassen. Wie gesagt,
können wir auf diese Schaltfläche „ Step Into“ klicken
oder einfach auf F7 klicken. Und wenn wir auf diesen Button klicken, werden
wir tatsächlich mit der Ausführung
in das Aufrufen von Of
Predict Sample
verschoben in das Aufrufen von , das
nur etwas auf dem Bildschirm
ausgibt. Es gibt keine Variablen hier. Methode. Wir können jetzt entweder
auf den Step Out klicken, der das Intro
zur aufrufenden Methode fortsetzt, die in unserem Fall hauptsächlich ist. Oder wir gehen einfach bis zum Ende
der Funktion über. In der Tat werden wir das Gleiche tun. Diese Funktion wurde ausgeführt. Zu diesem Zeitpunkt
der Ausführung diese Sprachen auf dem Bildschirm
gedruckt. Das sieht man an dieser Stelle
genau hier in der Konsole, also wurde das Beispiel
bereits gedruckt. An dieser Stelle haben wir uns mit der Ausführung in
Zeile 15 bewegt , die
aus den Frames entkam. Und auch hier
wird es zeigen, dass
wir in der Hauptfunktion die Variablen a
und b mit ihren Werten haben. Jetzt führe ich eine
neue variable Daten ein, ich wende einen neuen Wert darauf an. Und das
hängt sowohl von B als auch von B ab, also ist es mal B minus 45. Und wenn wir nun hinübergehen und zur nächsten Funktion
gehen, können
Sie sehen, dass die
neue Variable, die wir in den Code eingeführt haben auch in
das Variablenfenster aktualisiert wird. Und sein Wert ist 1905, was das Ergebnis von
30 mal 65 minus 45 ist. Jetzt deklariere ich noch
eine andere Variable b, die den
Fehler von C plus a aufweist. Um
uns zu helfen, IntelliJ zu bleiben, wird
IDE uns auch
die Werte der Variablen geben , die verwendet werden die Anweisung, die wir
an der Linie haben, wo wir sind und auch in den vorherigen Zeilen , die wir bis zu diesem Punkt bereits
übertroffen haben. Sie können also sehen, dass die
Werte hier für
jede Zeile und für jede
Variablen festgelegt werden jede Zeile und für jede , die in die Frist
verwiesen werden. In Zeile 19 beziehen
wir uns beispielsweise auf C und
a und am Wochenende sehen wir die
Werte, die sie haben. Und wenn wir hinübergehen, können
Sie das wieder sehen, D wird initialisiert und WTP
in den Variablenschritt. Und jeder Zeilenwert beträgt 1935
SB, der ab 1905 erwartet wird, was c plus a entspricht, was 30 war. Dies ist sehr nützlich
, da Sie möglicherweise nicht verstehen,
warum der Wert von D
am Ende Ihres Programms 1935 beträgt. Sie können verstehen
, warum dies der Fall ist, indem tatsächlich jede Zeile
des Codes mit diesem Debug
durchlaufen . Indem Sie Schritt für Schritt gehen
und leicht verstehen, warum alle Variablen den Wert haben
, den sie haben und warum
die Ausführung stattfindet, wie Sie geschrieben haben, wenn Sie erwartet haben, dass
etwas anderes passiert. Dies sind natürlich
ziemlich grundlegende Beispiele. Aber im
Produktionscode kann es, wie gesagt, viel
hässlicher werden. Und es wird sehr
nützlich für dich sein ,
diese Art von Sachen zu haben. Wir können sehen, dass
ich hier den Wert
für c durch inkrementiertes
Essen mit dieser Zahl aktualisiere . Wenn wir darüber hinausgehen, können
Sie sehen, dass der Wert für C GOT aktualisiert wurde. Und hier wird es
in dieser orangefarbenen Farbe gezeigt. In der letzten Zeile drucken
wir C, was ziemlich einfach ist. Und wenn wir nur noch einmal
vorangehen, können
Sie sehen, dass der Build in Sekunden erfolgreich
abgeschlossen wurde. Also hat es tatsächlich das
ganze Projekt für uns gebaut. Das Debuggen wurde gestoppt
und das Beispiel
1915 wurde auf dem Bildschirm angezeigt. In unserem Fall
ist alles passiert, während wir es unterstützen. Aber Sie wissen vielleicht nie
für Ihr eigenes Projekt was passieren kann und welches seltsame Ergebnis
Sie am Ende haben könnten. Ich verstehe nicht, warum das so ist. Und hier ist, wo
Debugging-Schritte durchgeführt werden. ging darum, tut es für
diese Vorlesung genau hier. Ich hoffe, ihr
habt wirklich was da rausgeholt. Im nächsten
werden wir über
die
Funktion zur Codevervollständigung sprechen , die dies hat. Das klingt interessant. Ich freue mich darauf, euch dann zu
sehen. Ich danke Ihnen noch einmal, dass Sie
bis zum Ende
dieser Vorlesung bei
mir geblieben sind.
9. Code: Hallo Leute, Symbol. Kommen Sie zurück zu diesem
intelligenten Ideen-Tutorial, in dem wir lernen, wie wir
besseren und effizienteren Code
in der
Programmiersprache von Java schreiben können besseren und effizienteren Code . In dieser Vorlesung hier werden
wir
die Funktion zur Codevervollständigung besprechen , die in dieser IDE verfügbar
ist, wie sie funktioniert, wie sie nützlich ist wie viele Arten von Codevervollständigung
es in dieser IDE. Und obwohl C
ein ziemlich intuitives
offensichtliches Feature ist,
kann es natürlich ein ziemlich intuitives
offensichtliches Feature ist, kein guter
Aspekt sein, Essdetails zu kennen. Jetzt gibt es zwei Arten der Codevervollständigung, die in der Intel GID
verfügbar sind. Die erste ist die
grundlegende Codevervollständigung, und dieser hilft Ihnen nur dabei die Namen zu
vervollständigen, die
Sie bereits mit der Eingabe beginnen. Verschiedene Sachen, die
du schreiben kannst. Zum Beispiel Geldbörsen, Methoden oder Felder, sogar Schlüsselwörter. Wenn Sie diese
Codevervollständigung aufrufen, obwohl
in den meisten Fällen eine Krankheit
standardmäßig ausgelöst wurde. Intelligente Idee analysiert
den Kontext,
in dem
Sie diese Codevervollständigung verwenden, und Sie möchten, dass er ausgelöst werden soll. Und es schlägt
Mark-Entscheidungen vor, die von der aktuellen
Charaktergenauigkeit
erreichbar sind , und auch Entscheidungen, die gut zusammenpassen
würden. Wenn wir zum Beispiel hier
anfangen zu tippen, können
Sie sehen, dass das erste,
was uns vermarktet, der erste Vorschlag, den wir
machen, darin besteht, einzutippen. Dann
gibt es natürlich eine Reihe anderer Dinge, die uns
zum Beispiel vorschlagen, keine Interaktionen mehr zu überprüfen, was eine Methode in diesem
Unit-Test-Framework ist. Und die Rückkehr zum Aufruf der
realen Methode und so weiter. Dies ist die grundlegende
Codevervollständigung, die in der
IntelliJ-Ideen-IDE
verfügbar ist
und standardmäßig
aktiviert ist. Sie werden also feststellen
, dass Sie, wenn Sie
GID installieren und anfangen, Dinge
zu schreiben, werden
Sie
das standardmäßig sehen,
wenn Sie anfangen, etwas zu
schreiben, das ist etwas, das Sie
gehen ständig Vorschläge zu haben, worauf
Sie schreiben,
worauf Sie schreiben möchten,
was Sie vielleicht abschreiben möchten, was Sie
am besten schreiben oder sogar was Sie schreiben möchten. Aber mit dem einfachen
Drücken einer Tab-Taste wird
es automatisch vervollständigt, damit
es schneller wird. Und natürlich gibt es noch
ein paar andere Abkürzungen. Wie Sie beispielsweise sehen, ist
einer von ihnen, wenn Sie SO in Drücken der Tabulatortaste
schreiben, wird
es automatisch automatisch
vervollständigt. Drucken Sie den Typ lm, was im Grunde
etwas auf einem Bildschirm ist. Abgesehen von dieser
grundlegenden Codevervollständigung die zur Verfügung gestellt wird, gibt es auch die
typübereinstimmende Art der Codevervollständigung, die hier verfügbar
ist. Diese
Codevervollständigung des Typs ist intelligenter, als der grundlegende
Punkt und was er tut, filtert nur die
Vorschlagsliste und
zeigt nach unten die Typen
an, die für den aktuellen Kontext gelten. Und die
Vervollständigung des Typs ist in einigen
Situationen sehr nützlich, in denen es
möglich ist , den
tatsächlich geeigneten Typ
für die Variable zu bestimmen , die Sie instanziieren
möchten. Zum Beispiel hier, wenn wir
diese Initialisierung
des Objekts
intensiv löschen diese Initialisierung
des Objekts und Neu neu schreiben und dann auf Leerzeichen klicken. Es wird standardmäßig, wie Sie wissen, durch das Parsen dieses Objekts vom Typ ist,
der diesen Test erstellt. Und standardmäßig werden wir
aufgefordert, das
Objekt dieses Typs zu deklarieren. Und wir müssen nur auf
Tab klicken und an dieser Stelle
wäre alles in Ordnung. Noch ein cooles Zeug
über die IntelliJ IDE. Stattdessen kannst du
eine Menge Sachen kopieren. Sie können dann tatsächlich in
die Kopier-Zwischenablage mit
der Control Shift
und F und C schauen die Kopier-Zwischenablage mit ,
alles, was Sie kopiert haben. Nehmen wir zum Beispiel an, Sie
möchten einige Wörter in
einer bestimmten
Vorkommenssequenz aus Here kopieren in
einer bestimmten
Vorkommenssequenz und
sie woanders einfügen. Nun, Sie können das
Schlüsselwort auswählen, das Sie kopieren möchten, geben Sie Control C ein und dann
ein anderes Schlüsselwort Control C. Dann ein anderes Schlüsselwort Control C. Wenn Sie Strg
Shift drücken und Sie sehen können , dass alle , die Sie bis zu
diesem Zeitpunkt kopiert haben, sind hier. Und Sie können eines dieser
beiden entweder einfügen oder
einfach nur einfügen. Einfach so. Dies ist ein weiteres
sehr nützliches
Feature-Set , das in der GID verfügbar ist. Nun ging es um den ETF für
das Feature zur Codevervollständigung der IDE. Wie Sie gesehen haben, ist es sehr gut verarbeitet und kann
sich
in einigen Situationen als sehr nützlich erweisen, in denen Sie in einem größeren Projekt viele Funktionen
haben würden. Und wenn Sie ein Objekt
instanziieren möchten, verlieren
Sie sich möglicherweise sogar bei
einigen ähnlichen
Benennungsenden , dass stattdessen
diese Codevervollständigung ein Lebensretter für Sie
wäre. Vertrau mir. Vielen Dank, dass Sie bis
zum Ende dieser Vorlesung bei mir geblieben sind und ich freue mich darauf,
euch im nächsten zu sehen.
10. Versionskontrolle: Hallo Leute und willkommen zurück
zu diesem IDEE-IDE-Tutorial, in dem wir verstehen,
wie wir Java-Code mit dieser IDE besser
schreiben können . In diesem Vortrag
werden wir
es mit dem
Versionskontrollsystem besprechen es mit dem
Versionskontrollsystem , das im Inneren
der DSGVO-IDE zur Verfügung gestellt wurde. Und genauer gesagt werden
wir
genau verstehen, wie diese Funktion in den Code-Editor
integriert ist in den Code-Editor
integriert und wie wir sie
in unserem eigenen Projekt verwenden können. Jetzt beginnt
der erste Bildschirm, den
wir sehen, wenn wir
unsere IntelliJ IDE öffnen. Sie können sehen, dass es direkt
Testprojekte veranlasst, bei denen wir eventuelle Projekte
suchen können , die wir bereits auf
unserem lokalen Computer haben. Wir können ein Projekt eröffnen wenn wir kein neues
erstellen wollen. Aber wir haben auch die
Möglichkeit , es aus dem
Versionskontrollsystem zu holen. Was diese Typen im Grunde genommen Repository
klonen, das Sie irgendwo in Ihrem Konto
haben. Jetzt werde ich nicht tief darauf
eingehen, was
Klonen vorantreibt,
begeht und so weiter. Das sind Wissen über das
Versionskontrollsystem. Aber wie Sie sehen können, können Sie, wenn Sie auf „
Von Versionskontrolle abrufen“ klicken, GitHub auswählen und Ihren GitHub
anmelden oder unser
Token verwenden, damit Sie einfach ein Repository
abrufen können Ihren GitHub
anmelden oder unser
Token verwenden , damit Sie einfach , ohne geben Sie tatsächlich Ihr Passwort ein. Sie haben auch das
GitHub Enterprise. Wenn Sie
für Ihr Unternehmen arbeiten, das diese Art von
Funktion aktiviert
hat. Sie können es auch aus dem Speicherplatz oder nur von der
Repository-URL abrufen. Neben Gate haben wir auch andere Versionskontrollsysteme wie Myokard oder Subversion. Und ich muss
derzeit kein Repository haben. Also bekomme ich
mein Projekt nicht von einem
Versionskontrollsystem. Ich werde nur ein neues Projekt
erstellen. Und nachdem ich es erstellt
habe, zeige ich Ihnen,
wie Sie
das Versionskontrollsystem aktivieren können ,
sobald Sie in Ihrem Projekt sind. Sagen wir die beiden, ein neues Projekt
von Grund auf neu auf
Ihrem lokalen Computer
starten . Und Sie möchten es
irgendwo in der Cloud in
Ihr Repository legen . Entweder
aus dem Grund, sich zusammen
mit anderen Teammitgliedern zu engagieren mit anderen Teammitgliedern , die
zu diesem Projekt beitragen. Oder nur damit Sie die Version in der Cloud
sichern können. Abweichung der Projekte
geht zu dem Diagramm,
an dem gearbeitet wird, wollen Sie für diese beiden offensichtlich
Aktivator-Versionierungssteuerungssysteme. Und Sie können dies tun, indem Sie
auf die
Option VCS klicken, die vom
Versionskontrollsystem stammt , die alle diese
Dropdown-Optionen im oberen Menü
anzeigen. Hier haben wir einige Optionen wir ermöglichen können, die Integration der
Versionierungssteuerung ist, ich sagte, hier sind einige Anwendungen für
Versionskontrollsysteme. Wir können Chargen anwenden. Wir können von
der Versionskontrolle
einige andere Projekte bekommen . Wir können durchsuchen, Repositorys, wir können importieren, teilen oder wir können sogar direkt
von hier aus
ein Repository erstellen , ohne dass überhaupt über den Webbrowser
in
Ihre Teetasse einloggen müssen Story. dann hierher zurückkehren, können
Sie direkt
aus der gesamten GI-Ideen-IDE
ein Git-Repository
für Ihr Konto erstellen . Das werde ich nicht machen. Sie jedoch mit dem
Versionierungssteuerungssystem arbeiten, müssen
Sie nur auf die Integration
der
Versionskontrolle aktivieren klicken . Und Sie müssen System- und Versionskontrollsystem verwenden, das
Sie mit
der Projektwahrheit
verknüpfen müssen , damit es einige Dinge in
einige der Dateien
schreiben kann, damit es weiß, dass dies
der Versionskontrollsystem, es ist Southfield entfötet. Wir wählen
Git aus und klicken dann auf OK. Sie können hier sehen,
dass es get aktiviert hat. Wir haben ein Git-Repository erstellt , das nur lokal auf
Ihrem lokalen Computer
im Titel Idea-Projekte vorhanden ist. Wie Sie sehen können, hatten
wir hier das Untermenü, das viele Optionen
bietet. Hier sehen Sie
die lokalen Änderungen. Wir können uns verpflichten, Änderungen einzusehen. Wir sehen auch die Details hier und alle Zweige im
rechten Teil des Bildschirms. Und Sie können das Gehirn
Situ oder beim Schreiben von Code direkt in
der rechten unteren Ecke sehen. Also sind wir auf dem
Git-Filial-Master. Und hier kannst du eine neue Filiale für
diese Filiale
erstellen und die Schulden, irgendwie gute Sachen. Sie können Ihren
Zweig auch umbenennen und so weiter und so weiter. Aufgrund der Tatsache
, dass ich momentan
kein GitHub-Konto
habe, werde ich nicht darauf eingehen. Aber Sie sehen die wichtigsten Optionen, die in dieser JID
verfügbar sind. Darüber hinaus
sehen Sie, dass neben dem Konfigurations
- und Trainingsprogramm genau hier rechts
daneben ist. Wir haben auch ein neues Menü einigen Optionen, die für Sie sehr praktisch sind, wenn Sie Ihre Arbeit einchecken
möchten. Sie können Ihr Projekt aktualisieren. Sie können Ihr Projekt verpflichten. Sie können auch
die
Schaltfläche „Änderungen
“ und „Verlauf anzeigen“ drücken ,
die natürlich den Verlauf Ihrer Datei mit allen
Änderungen, die von verschiedenen Teammitgliedern während des Zeitraums von Zeit, in der
Sie ein Repository sind, war eingeschaltet. Und Sie können auch einen Rollback
bei einer Überprüfung durchführen , nur
für den Fall,
dass Sie wahrscheinlich einen Fehler bei dem Code
gemacht haben, den Sie geschrieben haben oder der Build möglicherweise nicht ausgelöst hat
oder ein Fehler aufgetreten ist. Es kann eine Menge Dinge geben, die
Sie vielleicht zurücksetzen möchten. Du wurdest für ihn engagiert. Dies ist jedoch die
allgemeine Implementierung der Versionierung der
Distanzkontrolle in Intelligenz. Sie können auch sehen, dass hier
die Schaltfläche vorhanden ist das vorherige
VCS-Dropdown
ersetzt. Hier haben wir natürlich auch
viele Möglichkeiten in Bezug auf die Steuerung des
Versionssystems. Hier geht es noch detaillierter in Bezug auf den Pool
kann der Abruf sein, der März, Rebase,
Verwaltung der Zweige, Zurücksetzen des Kopfes,
Zeichnen des Git-Logs. Sie können ein anderes
Repository klonen und sogar auf
die VCS-Operationen klicken , um diese schwebende
Registerkarte mit
allen Optionen, die Ihnen vom Gate aus zur Verfügung stehen, wieder
zu
haben . Es ging um diese
Vorlesung. Ich hoffe, ihr
habt wirklich was da rausgeholt. Und ich
möchte mich wirklich bei Ihnen bedanken bis zum
Ende dieses Tutorials bei mir
geblieben sind. Wenn Sie Fragen haben, zögern Sie nicht
, mich zu kontaktieren. Ich werde mein Bestes tun, um
Ihnen in kürzester
Zeit zu antworten . Und zögern Sie auch nicht, die Quadrate hier zu
verlassen. Das würde für
mich Wunder bei den Klassifizierungen meines Kurses zu den
Aufwärtspositionen dieser Themen bewirken. Nochmals vielen Dank, dass Sie
bis zum Ende dieses Tutorials bei mir
geblieben sind, und ich
freue mich sehr darauf,
euch in einigen zukünftigen zu sehen und ich
freue mich sehr darauf,
euch in einigen zukünftigen zu sehen.