Ciao.
Questa è la stanza sul tetto.
E bentornato.
Quindi guardiamo come accedere a occhiali e pacchetti.
Ora vediamo come possiamo creare i nostri pacchetti ora nella lezione precedente.
Abbiamo visto questo segmento di importazione.
Il nome del pacchetto è Jawad o euro.
E questo appartiene all'API jalla ma dato che ora vogliamo vedere come possiamo creare i nostri pacchetti, prendiamo
un esempio diverso.
Poiché il nome della mia azienda è semantico quadrato, potrei voler creare le mie classi in pacchetti che
includono lo script semantico dei nomi, quindi potrei volere che tutti i nomi dei miei pacchetti inizino con la semantica del punto di
testo in cui in genere i nomi dei pacchetti hanno almeno due o tre componenti che sono separati da componenti olandesi
qui sono quadrati calmi e semantici.
Non preoccupiamoci ancora della struttura del nome del pacchetto.
Ecco perché ha più componenti o cosa significano quei componenti.
Ne discuteremo più avanti.
Ora, se ricordi, è stato menzionato all'inizio del capitolo che i pacchetti non sono altro
che directory sul filesystem.
Quindi significa che dobbiamo creare alcune directory corrispondenti al nome del pacchetto noto come nome del pacchetto
che coinvolge un singolo componente.
Quindi il pacchetto è sostanzialmente una singola directory sul nome della directory sarebbe il nome del pacchetto stesso.
Quindi, se il nome del pacchetto è di base, allora si creerebbe una directory chiamata di base, ma se
il nome del pacchetto coinvolge più componenti, il pacchetto corrisponderebbe alla struttura della directory degli investitori,
come mostrato qui.
Cioè se il nome del pacchetto è calmo e non di base semantico al punto quadrato allora ogni
componente in questo nome di pacchetto corrisponde alla tua directory nella struttura di directory nidificata.
Ora, se i nostri democratici di base dovessero essere in questo tipo di pacchetto, allora dobbiamo creare una
tale struttura di directory e posizionare la demo di base nell'ultima directory come mostrato qui.
Quindi è una cosa che dobbiamo fare creando la struttura di directory e un'altra cosa da
fare è avere un'istruzione di pacchetto nel plus sull'istruzione del pacchetto e qual è il pacchetto di parole chiave
seguito dal nome del pacchetto qui fa l'istruzione di pacchetto per il nostro esempio sull'istruzione del pacchetto deve essere il primo
a significare nella classe.
In caso contrario, viene visualizzato un errore del compilatore, anche le istruzioni di importazione devono seguire le istruzioni del pacchetto.
Ed ecco un esempio di come sembrerebbero i nostri principi di base Democratici, quindi un'istruzione tascabile è seguita da
tutte le dichiarazioni di importazione che sono seguite dalla definizione della classe e nota che un file sorgente può ora
solo una istruzione di pacchetto.
Quindi sostanzialmente per mettere la nostra classe in un pacchetto dobbiamo assicurarci che ci sia una struttura di directory corrispondente
e quindi posizionare la classe nell'ultima directory.
E abbiamo anche bisogno di mettere un'istruzione di pacchetto in cima alla classe ora un effetto importante nel collocare una classe
nei pacchetti che una volta compilata la classe il nome del pacchetto diventa parte della media della
classe e per questo non è più possibile eseguire la classe che usa diventa semplice e devi usare il nome completo
della classe che includerà il nome del pacchetto come mostrato qui.
Quindi sarebbe il nome del pacchetto seguito dal punto seguito dal nome della classe.
Ora andiamo avanti e vediamo di cosa abbiamo appena discusso in azione.
OK, questa demo sarà un po 'lunga perché discuteremo molti dettagli come l'impostazione delle parti di classe dovrebbe essere
molta attenzione, ma mi assicurerò che tutto sia spiegato in modo molto chiaro e molto sistematico
quindi ecco come demo di base e per questa particolare demo facciamo parte di un pacchetto e chiamiamo il nome
del pacchetto come punti base della carriera di semantica in modo che sappiamo che la dichiarazione del pacchetto
deve essere lì e deve essere la prima istruzione.
Va bene, quindi deve essere in cima alla classe, va
bene.
Questa è la dichiarazione del pacchetto.
Ora sappiamo anche che abbiamo bisogno di come una struttura di directory corrispondente sul file system.
E quindi dobbiamo collocare questa particolare classe all'interno di quella struttura diretta.
Ora potresti aver notato che abbiamo già creato questa particolare struttura di directory nel nostro corso giusto.
Quando abbiamo iniziato a scrivere i nostri programmi abbiamo creato questa struttura di directory.
Quindi dobbiamo solo andare nella struttura della directory e dobbiamo compilare questa particolare classe, quindi questa è la
struttura della directory.
Avevamo la profondità di Java tra cui avevamo creato il sorgente e creato un CRC e all'interno di questa struttura di
directory abbiamo la struttura Nestor che corrisponde direttamente al nome del pacchetto.
OK, quindi l'abbiamo già fatto.
Se non fosse presente, avremmo creato questa struttura di directory.
Quindi questa particolare classe sappiamo che è già qui.
Quindi compiliamo solo che K
compila bene.
Eseguiamolo in modo che non riesca proprio a trovare la demo di base del caricamento della classe principale.
Questo perché, come abbiamo discusso in precedenza nelle diapositive quando compiliamo questo file che ha una tale
istruzione di pacchetto, il nome del pacchetto diventerebbe parte del nome della classe.
Quindi non possiamo eseguire direttamente il nome della classe semplice.
Questo si chiama come un semplice nome di classe.
Quindi abbiamo detto che dobbiamo dare il nome completo che include il nome del pacchetto seguito dal punto seguito
dal nome della classe.
Quindi facciamolo
ora, dice ancora che non è stato possibile trovare il costo.
Il motivo è che l'interprete Java sta cercando questa struttura di directory all'interno della
directory di base.
Quindi si aspetta che ci sia una directory chiamata come here and veted that square semantic.
E all'interno delle basi e all'interno della democrazia di base.
Ma non è così.
Questa struttura di directory è proprio qui.
Va bene.
Si trova nella directory SA view.
Quindi l'interprete Java sta cercando chi sta cercando questa struttura direttamente.
Quindi per questo dobbiamo trasferirci qui in SA.
Quindi
facciamolo e ora se lo eseguiamo eseguirà uno dei metodi.
Quindi questo è uno di questi metodi nel file etichettato continua.
Quindi funziona bene, ma qui è qualcosa che accade implicitamente sotto il cofano.
Quindi ciò che l'interprete Java sta facendo qui è quindi la prima cosa che fa è controllare se la parte della classe
di variabili di ambiente è stata impostata o meno.
Quindi nel secondo capitolo abbiamo esaminato la parte di classe e una variabile significava.
E se ricordi che abbiamo detto che una variabile d'ambiente parte di classe è specifica di Java.
Come suggerisce il nome parte della classe.
Viene utilizzato per individuare i classificatori che i classificatori DOT.
Ed è utilizzato sia dal compilatore Java che dall'interprete Java.
Questa è la JVM, quindi è la prima cosa che farà se c'è una parte di classe o no.
Ora tieni presente che il percorso di classe sul percorso sono parti diverse, un percorso di cosa generico è anche
una variabile di ambiente e una parte è utile per eseguire questo eseguibile stesso.
Giusto.
Ne abbiamo discusso molto bene.
Quindi, se si desidera eseguire Zella, combinare tutti i comandi Java, quindi quelli eseguibili dovrebbero trovarsi in.
Ma dovrebbero trovarsi in una delle parti nella variabile d'ambiente PAC, ma la parte trasversale
è specifica per Java.
Ed è per localizzare classificatori sia dal compilatore che dall'interprete Java.
In questo esempio particolare l'interprete Java sta cercando di esaminare questo particolare classificato.
OK.
Fondamentalmente la classe più punti.
Ora, se vuoi, puoi effettivamente fare riferimento a quella lezione particolare perché aveva alcuni dettagli sulla classe ma quindi
la prima cosa che succede è che controlla se il percorso della classe è lì o no.
E se non c'è, diciamo che se il percorso della classe non è stato impostato, allora ciò che fa è l'interprete Java
Val.
Quindi il comando viene eseguito nella directory social.
Quindi controllerà se il 10 questa directory Assad vede dove viene eseguito il comando se ha
questa struttura di directory.
OK.
Quindi, per impostazione predefinita, controllerà se la directory Assad see ha questa struttura di directory particolare
che avrebbe la classe basata esterna.
Quindi lo farebbe nella directory corrente in cui viene eseguito il comando.
OK.
Questo è quando il percorso di classe non è presente ma nel mio caso è stato impostato il percorso di classe.
Quindi lascia che ti mostri la mia parte di classe.
Quindi tutto ciò che farò è eseguire questo set di core di comando.
Classe ma questa è la mia parte di classe e la parte di classe include parti diverse qui.
Quindi questo è il comando.
Ora questo è sul mio computer Windows.
Ora se stai usando una macchina basata unica come Ubuntu o Mac OS, il comando sarebbe.
Ecco qui.
Sarebbe un dollaro spaziale di base e in base alla tua classe, ma OK ora puoi guardare la sezione
delle risorse. Ho un documento che includerebbe questi comandi e forse alcune altre istruzioni per
farlo qui.
Nel mio caso il percorso di classe è lì.
Quindi, ciò che l'interprete Java sta per fare è guardare ognuna di queste parti.
Ora qui su Windows i vasi sono separati da punti e virgola, come in questo caso c'è un punto seguito
da punti e virgola, ma sui sistemi basati su Unix sarebbe due punti.
Quindi guarderà.
Scansionerà questo valore di parte della classe che è tutta questa cosa e controllerà che controllerà ciascuna di queste
parti e vedrà se è in grado di individuare questa classe in una di quelle parti.
Quindi cercherà questa struttura di directory in ciascuna di queste parti finché non la troverà.
Ora qui punto implica il percorso corrente, il che significa che la posizione in cui stiamo eseguendo il comando.
Quindi ha il punto qui.
Quindi nel mio caso particolare.
Quindi guarderà questo e vedrà un punto.
E controllerà se quello in questa directory corrente dove stiamo eseguendo il comando se questa struttura di directory
è piacevole sotto demo di base come parte di quella struttura di directory.
OK.
Ecco come andrà a vedere.
OK.
Ora se non stai usando la classe parte della classe ma non è stata impostata, allora sembra anche nella directory corrente e
suppongo sia a causa della classe.
Ma avere questo punto è il motivo per cui è in grado di eseguirlo.
Ora lascia che te lo mostri rimuovendo questa parte di classe.
Quindi un modo in cui possiamo farlo è solo percepire che la parte di classe è uguale.
Quindi, se lo fai, la parte della classe viene cancellata, il che significa che la parte della classe non è presente.
E questo funziona solo per questa particolare sessione del terminale.
OK.
E su Windows o sui sistemi Unix diresti che una parte della classe di esportazione uguale a te sa
che sarebbe solo una supposizione qualcosa del genere, quindi lasciami dire set.
Classe n.
Quindi dice che sono definiti modelli di classi di variabili d'ambiente.
OK.
Perché abbiamo detto così abbiamo iniziato a svuotare.
Quindi ora fammi correre.
Quindi ora non abbiamo la classe ma.
OK.
E questo è solo per la sessione se apri un nuovo terminale allora possiamo ancora vedere la sessione.
Quindi fammi eseguire.
E come puoi vedere funziona benissimo.
OK.
Quindi prima vedrà se le feste di classe lì o no.
Se non è lì, funziona proprio come in questo caso.
Ma se la parte della classe è presente, controlla se una delle parti della parte 10 di quella classe
avrebbe questa struttura di directory.
Quindi con DOT abbiamo visto che quel punto funzionerà solo se eseguo questo comando da qui da ISC
perché ASIC ha questa struttura di directory.
Ora vediamo se voglio eseguire questo particolare comando con successo da qualsiasi parte della mia macchina.
Quindi devo distinguere la classe come vedo.
OK.
Quindi lasciami fare anche questo, quindi fammi aprire un nuovo terminale qui, quindi fammi solo copiare e incollare questa cosa.
Quindi, come puoi vedere, non è stato trovato il classificato non è stato trovato.
Quindi ora dobbiamo distinguere la classe e dovrebbe avere quella directory particolare.
Quindi invece di usare la sottoclasse.
Ma lascia che te lo mostri.
Separiamoci permanentemente.
Quindi ho anche dimostrato che e quella lezione nel secondo capitolo diceva come possiamo distinguere la classe o anche
parte che è stata mostrata anche in una delle lezioni.
Quindi andiamo solo su Windows.
Stiamo solo andando al pannello di controllo e puoi entrare nel sistema, apre le proprietà del sistema qui fai clic su
Impostazioni di sistema avanzate e nella scheda Avanzate fai clic su Variabili d'ambiente.
E qui abbiamo parte di classe.
OK.
Quindi, se non è presente, ne creeresti di nuovi e lo aggiungeresti.
Ma se è lì, diresti semplicemente modifica.
Quindi questo è un nome variabile alla fine.
Vorrei aggiungere la nuova parte OK.
Quindi è quello.
Vedere.
OK.
OK e fammi creare questo in una nuova directory, copia anche questa volta ancora, scusa, lasciami aprire un nuovo terminale perché la modifica che
abbiamo appena fatto non si rifletterà in quel particolare terminale.
Quindi ora fammi eseguire questo e puoi vedere che funziona.
OK.
Quindi sono nella mia home directory qui a due isolati da qui.
E funzionerebbe da qualsiasi luogo adesso.
OK.
Quindi, lasciatemi dire solo il set di vetro ma potete vedere che è stato aggiunto alla fine.
Quindi è quello che faresti se desideri impostarlo in modo permanente affinché funzioni in tutte
le sessioni.
Quindi dovresti impostarlo lì.
E quella lezione particolare mostra anche come è arrivata nel secondo capitolo mostra anche come si
può fare su un Mac.
E il processo sarà molto simile su Linux, quindi è così.
Quindi abbiamo creato un pacchetto che le basi la maggior parte è ora parte di un pacchetto.
Ora andiamo avanti e creiamo un'altra classe su importiamola.
OK, lascia che te lo mostri, quindi ho un po 'di codice qui.
Ora creiamo.
Quindi, come mai la carriera della semantica si basa sulle basi ed è qui che si trova la demo delle basi.
Ora creiamo un nuovo pacchetto che diventerebbe un quadrato semantico sul test di base.
E così nella directory semantica quadrata le persone sono una nuova directory chiamata test di base senza controllo che aggiungeremo
una nuova classe.
E da quella classe useremo queste basi Democratici e anche nella classe demo delle basi ho
aggiunto questo nuovo metodo chiamato foo qui.
Quindi invocheremo questo particolare metodo da quella nuova classe.
E questa è la nuova classe qui.
Quindi farebbe parte di questo pacchetto chiamato test di base e stiamo importando un elenco di array.
Quindi questo proviene dalla libreria Java di fronte alla libreria Java e stiamo importando la classe demo di base che
si trova nelle basi.
Quindi stiamo dicendo che l'importazione del nome di questo pacchetto viene prima di tutto, quindi l'importante nella definizione della classe.
E qui stiamo dicendo che stiamo creando un'istanza di demo di base.
E stiamo invocando il metodo foo, quindi per prima cosa ho bisogno di creare quella directory.
Quindi lasciami andare qui in piazza semantica qui.
Sarebbe giusto test di base.
Quindi ora diciamo che questo ragazzo ha bisogno di passare al test di base e si chiama B un test di sei demo ora lascia che
ti mostri qualcosa qui.
Dimostreremo qualcos'altro ora.
Abbiamo questa classe ma lasciatemi impostare questa classe ma a svuotare.
Ciò significa che stiamo rimuovendo la parte di classe.
Ora lasciami provare a compilare questa particolare classe.
Quindi questo test demo di base mi permette di copiare la directory qui e ho intenzione di fare per creare OK.
Quindi sono dentro.
Test di base
Ora voglio compilare quella classe e quella classe ma ora è stata rimossa.
Quindi
Jarvik lo sai quando dico basi demo test o Java sta dando errori.
Dice che non può importare questi esterni.
Quindi sono qui anche noi lo stiamo istanziando.
Quindi, entrambi questi posti sta dicendo che non può guardare a questi classificatori che, poiché abbiamo rimosso questa struttura
di directory questa particolare parte, di fatto abbiamo rimosso l'intera parte di classe.
Quindi non è in grado di leggerlo e contrastare questa dichiarazione di importazione.
Quindi sta provando a compilare questo file java dot ma quando sta provando a compilarlo nel contesto la frase chiamata
import of lo fa e non è in grado di guardarlo nella classe, ma nel nostro caso non c'è una parte
della classe giusta.
Non abbiamo avuto la parte di classe.
Quindi cercherà nella directory corrente se questa struttura di directory è nella directory corrente che
è questa espressione e non è lì.
Ora anche anche se l'aspetto di un box di classe è impostato come parte di classe uguale a qualcosa diciamo che esiste
questa cartella chiamata D2.
Anche se ho questo non funzionerà perché i dati non funzionano come questa struttura di directory particolare.
È solo all'interno di Java approfondire vedere.
OK.
Quindi, se è lì, allora funzionerebbe perché sarà in grado di trovare questo file di classe.
La demo di base classifica la directory 10 all'interno essenzialmente perché ha la struttura della directory.
Quindi, ma puoi vedere che non succede per l'altro elenco.
Questo perché il nostro elenco appartiene alla libreria Java.
Quindi per il lotto individuare le classi nella libreria Java non utilizza la parte della classe ma per
qualsiasi altra cosa come le classi definite dall'utente come quella che abbiamo scritto o talvolta possiamo scaricare alcune librerie
di terze parti Librerie Java IME che potremmo usalo alcune librerie open source.
Quindi quelli devono entrare nella classe ma il percorso della classe è essenzialmente per localizzare i file di classe.
OK.
E quei file di classe sono classificatori definiti dall'utente se si tratta di una libreria Java.
Quindi non ci sono problemi.
Non è così.
La classe non entra in gioco, quindi dobbiamo impostarla.
Quindi lasciami impostare in questo modo.
Vorrei solo dire che ha detto parte della classe in realtà.
OK.
Quindi abbiamo visto due modi per distinguere la classe nel modo giusto.
Uno sta usando la parte di classe e l'altra dalla destra delle proprietà di sistema.
Per impostarlo in modo permanente.
Ora c'è un altro modo per farlo.
E cogliamo l'occasione per farlo.
Quindi puoi davvero farlo Jack.
E Al dice ciao amico C P C P sta per parte di classe o puoi sapere come.
Classe seconda parte.
E poi questo pezzo così il trattino di Ruby C P R classe di trattino ma ognuno di loro va bene e faremo come la nostra parte.
Quindi sarà in quella barra come la nostra C e questo particolare file che è fondamentalmente più test OK, dice che la
demo di base non è pubblica.
Quindi lasciami andare alla demo di base in modo che la classe demo di base non abbia il modificatore di accesso pubblico.
Quindi, se si desidera accedere a qualcosa in un pacchetto diverso che deve avere il modificatore di accesso pubblico sui
modificatori di accesso, verrà discusso in seguito.
Quindi questo è tutto ciò che serve.
Ma potrei doverlo compilare.
Quindi fammi solo compilare.
Quindi invece di andare in quella directory.
Ora lasciami dire solo calma.
Possiamo anche compilare da qui in questo modo.
Quindi questo è il mio altro prompt dei comandi.
Il primo
Va bene così possiamo anche compilare da qui.
Ma dobbiamo dare la parte corretta come questa.
Ecco qui.
No no è compilato e ha il modificatore pubblico qui.
Va bene.
Ora ho intenzione di compilare il mio test demo di base più test.
Facciamolo.
Ora si compila bene perché stiamo specificando la classe ma.
Quindi, facendo così.
Significa che funziona solo per il comando specifico.
Quindi, se imposti il percorso di classe, funzionerebbe per l'intera sessione nel terminale.
Ma se lo imposti in questo modo funzionerà solo per questo particolare comando stesso.
Quindi, non appena il comando viene eseguito, il percorso della classe non verrà più applicato.
Va bene.
E se vuoi separarti definitivamente, lo sappiamo già.
Quindi sei stato bravo nelle proprietà del sistema.
Quindi è tutto.
Questo è quello che volevo dimostrare qui.
Quindi ora siamo in grado di vedere che la parte di classe viene utilizzata sia dal compilatore che dall'interprete Java.
Quindi abbiamo iniziato guardando come viene utilizzato dall'interprete Java.
Ora nel Mar Java quando stiamo usando il compilatore non avrà problemi a localizzarlo
perché questo viene specificato qui come il file dot java ma se questo file java usa un'altra
classe e quella particolare classe deve far parte della classe ma così stava usando una classe dall'altro pacchetto.
OK.
Il pacchetto di base.
Ecco perché quella particolare classe deve essere nella classe, ma allo stesso modo se stiamo usando altre classi
da una libreria di terze parti, allora tutte quelle classi devono essere nella classe.
Questo è quello.
Ora diamo anche un'occhiata a qualcosa chiamato pacchetti secondari statunitensi, è un concetto molto semplice.
Lasciatemi andare avanti così, eccolo qui.
Quindi questa è l'API Java.
E qui abbiamo i pacchetti ora qui se scorro verso il basso ho questo punto Java Uta
e Java punto digitale com corrente.
Quindi alcuni.
Quindi sappiamo che un pacchetto viene utilizzato per organizzare in modo significativo le lezioni.
Giusto.
Perché ora abbiamo molte classi che votano anche in un singolo pacchetto.
A volte potremmo avere troppe classi su alcune di esse, potrebbe essere utile per eseguire
alcune funzioni specializzate.
Gruppi di classi in tal caso è possibile raggruppare ulteriormente tali classi in due sotto-pacchetti, ad esempio qui Tutor
Java è un pacchetto nella libreria Java che ha tutte le classi di utilità.
Quindi, se faccio clic su, possiamo vederli qui tutte le classi di utilità specifiche che rappresentano le
strutture di dati e le esamineremo più avanti.
Poi c'è questo un pacchetto chiamato Jawad o due contemporaneamente che ha anche classi di utilità ma
che sono specifiche della concorrenza che non è altro che multi-training.
Allo stesso modo ora abbiamo tutti questi diversi tipi di sotto-pacchetti e questo è un sotto-pacchetto pacchetto.
Significa solo che esiste questa struttura di directory per Java dot Udall e pensiamo che quando diciamo
simultanea è come un pacchetto che sarebbe una directory chiamata simultanea e nel senso che quel
particolare sotto pacchetto avrà tutte le classi specifiche figlia di Giava al conquistatore.
Non penso che questo tutorial sul gelato o concorrente sia un'altra ristrutturazione diretta del
tenero pacchetto giovanile all'interno della solita directory.
Non è così.
E quando importiamo se vogliamo importare qualcosa da Java punto dici a un fondo di classe solo da Java
punto a non da Java Roger che sono simultanei si direbbe importare punto Java.
Ora se vuoi importare qualcosa da Java punto dici a dot com current una classe
da cui dovresti avere quella separatamente che ti prefiggerai di fare un sacco di punti calcolabili futuri futuri.
Va bene perché il futuro calcolabile è una classe in questo pacchetto particolare.
Quindi è così.
Non pensare che se vuoi accedere a tutte queste classi in concomitanza solo per fare ciò che desideri,
puoi fare qualcosa come l'importazione di DOD Java Joe ti ha ordinato di aggiungere tutto ciò che suppongo questo funzionerà non funzionerà, ma non dare per scontato
che importerebbe tutte le classi in tutti i pacchetti che non funzionerà, quindi
ora importeranno tutte le classi in Newton se si desidera importare
qualcosa da Java simultaneo logico o simultaneo dovresti specificare in modo esplicito che devi specificare il nome
della classe tutto ciò che ti serve per vedere Star per importare tutte le classi in questo
pacchetto OK, quindi le autorità e il settore delle utility qui avranno una directory chiamata simultanea e avrà
allo stesso modo nella nostra demo di base abbiamo la cartella qui di base.
Ora vediamo se vogliamo creare una sottodirectory qui come sottotitolo per la chiamata di un pacchetto, quindi creeresti
qualcosa del genere come sottotitolo.
Ok, diciamo che è un pacchetto.
E inseriresti qualsiasi classe nel sotto-pacchetto in questo particolare sotto-pacchetto.
Quindi sarebbe calmo non semantico al quadrato non essere un sei punti in su
che è un'istruzione di pacchetto e se vuoi usare una di
quelle classi allora diresti import con una semantica punto crea punti base punto punto punto classe quindi sono punto stella per l'importazione tutto
OK quindi con quello e un'ultima cosa che voglio mostrare qui perché così abbiamo questa cosa chiamata nozioni di base ora abbiamo
come tutte queste classi se vuoi compilare tutte queste classi come il test dello studente
studente e tutte in una volta poi puoi semplicemente farlo, avrai questo e puoi semplicemente dire Star da Java, quindi è qualcosa del genere.
Quindi, per esempio, lasciatemi solo aggiungere un'altra volta andando in quella directory così
è tutto.
E li avrebbe compilati tutti.
Finora stavamo compilando solo una classe alla volta, così come puoi vedere ha creato tutti i classificatori, quindi
questa è la cosa che io e io aggiungeremo anche una nota a riguardo.
Quindi mi piace avviare Java in modo da poterlo guardare anche.
Non è importante, ma aggiungerò qualcosa nella sezione delle risorse, quindi questa è la parte della classe e
tieni presente che tutta questa faccenda di cui discutiamo la parte della classe e tutto il resto.
Quindi è davvero utile quando hai a che fare con i pacchetti e quando lo facciamo in questo modo sul prompt dei
comandi.
Ma quando passiamo a I. T. come eclissi l'idea che non farai uso
della classe ma si occuperà di tutte queste cose di cui abbiamo discusso internamente.
OK.
Quindi è quando passiamo a I. T. ma ora dal momento che non stiamo usando un I. T ..
Quindi è così che funzionerebbe su I. T. faresti anche qualcosa di
simile, ma è solo che non dobbiamo impostare esplicitamente la classe ma per accedere alle classi da altri pacchetti.
Quindi questo è tutto.
E spero che ti sia piaciuto imparare a creare pacchetti e spero che sia anche molto chiaro.
E questo è tutto.
Grazie.
Codifica infelice.