Salve ragazzi sono mesi che sto studiando java 8/11 inizio che dire che il mio primo linguaggio che studio e mi approccio alla programmazione in generale, ora dopo mesi di studio e ristudio pure capendo i vari concetti fondamentali in java riesco a scrivere le cose principali delle varie classi però quando devo fare una modificare o implementare le vari operazioni/condizioni del codice non me ne riesco ad uscire e mi blocco sapete consigliere come me ne esco da questa situazione ?
Si sto seguendo un corso in java. Il problema nel codice sta qua devo andare a modificare o aggiungere metodi, variabili o condizioni.
La domanda lascia uno spazio molto ampio per le risposte, quindi mi permetto di fare un giro un po' largo per provare a toccare il problema.
Innanzitutto, mi sembra di capire, di istinto, che ci siano dei problemi nell'utilizzare i metodi della varie classi, il sovrascrivere alcuni di essi, l'utilizzo degli attributi, quindi in generale, un problema di fondo nello sfruttare a pieno la programmazione ad oggetti.
Sicuramente sono ancora lontano dal reale "blocco" ma almeno provo a sondare.
Assumendo che tu conosca le basi, sai che una Classe, parafrasando, è una sorta di Classe in un Gioco di Ruolo. Ogni Personaggio di una particolare Classe ha i suoi Parametri (Attributi) come Punti Vita, Attacco, Difesa, quelli che possono essere degli interi definiti nella classe.
Oltretutto, ogni Personaggio ha la possibilità di utilizzare varie abilità (Metodi) che gli permetto, ad esempio, di variare i propri parametri o interagire con l'ambiente.
Userò un po' di pseudo-codice ma cercherò il più "java" possibile:
Class Personaggio(){
int PV = 100;
int Attacco = 20;
int Difesa = 10;
public Personaggio(){}
public void attaccaAvversario(Personaggio nemico){
nemico.PV -= 5;
}
public void convertiPVinAttacco(){
this.PV -= 10;
this.Attacco += 4;
}
}
Come vedi, il metodo convertiPvInAttacco() modifica degli Attributi appartenenti all'Oggetto della classe Personaggio che lo invoca, mentre il metodo attacccaAvversario(Personaggio nemico) interagisce con, potenzialmente, Oggetti della stessa classe differenti da quello che sta invocando il metodo; in parole più povere,
se dichiari due oggetti della classe Personaggio, avrai modo di invocare il metodo attaccaAvversario(Obj ...) sull'uno ed ottenere effetti sull'altro, facendo interagire i due Oggetti.
pseduo-code:
...
Personaggio player1 = new Personaggio();
Personaggio player2 = new Personaggio();
...
player1.attaccaPersonaggio(player2);
// i PV di player1 restano 100
// i PV di player2 diventano 95
Fare interagire Oggetti di varie classi è piuttosto semplice. Proviamo ad inserire una condizione per la chiamata di un metodo nel codice, cercando di capire se vi siano problemi simili al seguente.
Suppniamo che il metodo attaccaPersonaggio(Obj ...) non possa essere chiamato senza prima assicurarsi che i PV dell'avversario siano maggiori di 60.
Piccola Nota: normalmente per ottenere gli attributi di una classe è buona norma creare dei "Getter e Setter", ovvero, metodi presenti, in questo caso, nella classe Personaggio e che hanno la seguente forma:
Il seguente ti consente di impostare i PV del personaggio
public void setPv(int PV){
this.PV = PV;
}
Mentre questo ti permette di ottenere i PV del personaggio
public int getPv(){
return PV;
}
Detto questo, torniamo al voler chiamare il metodo di attacco solo quando i pv dell'attaccato sono superiori a 60
...
if(player2.PV > 60){
player1.attaccaAvversario(player1);
}else{
System.out.println("I Punti Vita dell'avversario sono inferiori o uguali a 60, non è consentito l'attacco.");
}
Supponiamo adesso che la classe Personaggio contenga altri due metodi:
public void dannoCritico(Personaggio nemico){
if(nemico.PV => 20){
nemico.PV -= 20;
}else{
nemico.PV = 0;
}
}
public void fatality(Personaggio nemico){
nemico.PV = 0;
}
Se si vogliono gestire più metodi a seconda di vari casi basta usare degli qualche else if o switch:
if(player2.PV > 60){
player1.attaccaAvversario(player2);
}else if(player2.PV >= 25 & player2.PV <= 60){
player1.dannoCritico(player2);
}else{
player1.fatality(player2);
}
Se vogliamo che una nuova classe Personaggio2 contenga le abilità e gli attributi della classe Personaggio e ne aggiunga altre o diverse, basta usare i famosi "extends" ed "Override"
Class Personaggio2 extends Personaggio{
...
@override
public void attaccaAvversario(Personaggio nemico){
nemico -= 30;
}
...
}
La classe Personaggio2 porterà con sé i Campi ed i Metodi della classe Personaggio ma quando chiamerà il metodo attaccaAvversario(Obj ...) farà più danno rispetto all'altra classe di personaggio. (magari è un Barbaro rispetto ad un Ladro, boh!)
In generale, è buona norma, avere delle Interfacce che ti aiutino a capire come devono essere fatte le classi che userai.
Ad esempio, si potrebbe decidere che tutte le classi PersonaggioN abbiamo alcuno metodi da dover Implementare.
In questo caso, è possibile creare una interfaccia PersonaggioInterface che al suo interno contenga dei metodi come attaccaPersonaggio(Obj ...){} e che può essere comune a tutte le classi Personaggio, come già detto.
Interface PersonaggioInterface{
public void attaccaAvversario(Obj ...) {}
}
Class PersonaggioX implements PersonaggioInterface{
@override
public void attaccaAvversario(Obj ...){
//corpo del metodo...
}
}
è una veduta molto ampia e forse basilare o, ancora, inefficace per il tuo caso. Perdonami la forse non totale accuratezza, ho scritto un po' di fretta ed in un buco temporale ma spero che l'utilizzo dei vari elementi sia comunque arrivato.
Ci tengo a sottolineare che il codice non è controllare ed è comunque abbastanza pseudo-java e che qualche definizione degli elementi trattati potrebbe essere un po' sballata.
Detto questo, spero possa averti dato almeno una visione differente del tutto.
mi scuso per eventuali omicidi grammaticali, ho controllo davvero di fretta
Innanzitutto, mi sembra di capire, di istinto, che ci siano dei problemi nell'utilizzare i metodi della varie classi, il sovrascrivere alcuni di essi, l'utilizzo degli attributi, quindi in generale, un problema di fondo nello sfruttare a pieno la programmazione ad oggetti.
Sicuramente sono ancora lontano dal reale "blocco" ma almeno provo a sondare.
Assumendo che tu conosca le basi, sai che una Classe, parafrasando, è una sorta di Classe in un Gioco di Ruolo. Ogni Personaggio di una particolare Classe ha i suoi Parametri (Attributi) come Punti Vita, Attacco, Difesa, quelli che possono essere degli interi definiti nella classe.
Oltretutto, ogni Personaggio ha la possibilità di utilizzare varie abilità (Metodi) che gli permetto, ad esempio, di variare i propri parametri o interagire con l'ambiente.
Userò un po' di pseudo-codice ma cercherò il più "java" possibile:
Class Personaggio(){
int PV = 100;
int Attacco = 20;
int Difesa = 10;
public Personaggio(){}
public void attaccaAvversario(Personaggio nemico){
nemico.PV -= 5;
}
public void convertiPVinAttacco(){
this.PV -= 10;
this.Attacco += 4;
}
}
Come vedi, il metodo convertiPvInAttacco() modifica degli Attributi appartenenti all'Oggetto della classe Personaggio che lo invoca, mentre il metodo attacccaAvversario(Personaggio nemico) interagisce con, potenzialmente, Oggetti della stessa classe differenti da quello che sta invocando il metodo; in parole più povere,
se dichiari due oggetti della classe Personaggio, avrai modo di invocare il metodo attaccaAvversario(Obj ...) sull'uno ed ottenere effetti sull'altro, facendo interagire i due Oggetti.
pseduo-code:
...
Personaggio player1 = new Personaggio();
Personaggio player2 = new Personaggio();
...
player1.attaccaPersonaggio(player2);
// i PV di player1 restano 100
// i PV di player2 diventano 95
Fare interagire Oggetti di varie classi è piuttosto semplice. Proviamo ad inserire una condizione per la chiamata di un metodo nel codice, cercando di capire se vi siano problemi simili al seguente.
Suppniamo che il metodo attaccaPersonaggio(Obj ...) non possa essere chiamato senza prima assicurarsi che i PV dell'avversario siano maggiori di 60.
Piccola Nota: normalmente per ottenere gli attributi di una classe è buona norma creare dei "Getter e Setter", ovvero, metodi presenti, in questo caso, nella classe Personaggio e che hanno la seguente forma:
Il seguente ti consente di impostare i PV del personaggio
public void setPv(int PV){
this.PV = PV;
}
Mentre questo ti permette di ottenere i PV del personaggio
public int getPv(){
return PV;
}
Detto questo, torniamo al voler chiamare il metodo di attacco solo quando i pv dell'attaccato sono superiori a 60
...
if(player2.PV > 60){
player1.attaccaAvversario(player1);
}else{
System.out.println("I Punti Vita dell'avversario sono inferiori o uguali a 60, non è consentito l'attacco.");
}
Supponiamo adesso che la classe Personaggio contenga altri due metodi:
public void dannoCritico(Personaggio nemico){
if(nemico.PV => 20){
nemico.PV -= 20;
}else{
nemico.PV = 0;
}
}
public void fatality(Personaggio nemico){
nemico.PV = 0;
}
Se si vogliono gestire più metodi a seconda di vari casi basta usare degli qualche else if o switch:
if(player2.PV > 60){
player1.attaccaAvversario(player2);
}else if(player2.PV >= 25 & player2.PV <= 60){
player1.dannoCritico(player2);
}else{
player1.fatality(player2);
}
Se vogliamo che una nuova classe Personaggio2 contenga le abilità e gli attributi della classe Personaggio e ne aggiunga altre o diverse, basta usare i famosi "extends" ed "Override"
Class Personaggio2 extends Personaggio{
...
@override
public void attaccaAvversario(Personaggio nemico){
nemico -= 30;
}
...
}
La classe Personaggio2 porterà con sé i Campi ed i Metodi della classe Personaggio ma quando chiamerà il metodo attaccaAvversario(Obj ...) farà più danno rispetto all'altra classe di personaggio. (magari è un Barbaro rispetto ad un Ladro, boh!)
In generale, è buona norma, avere delle Interfacce che ti aiutino a capire come devono essere fatte le classi che userai.
Ad esempio, si potrebbe decidere che tutte le classi PersonaggioN abbiamo alcuno metodi da dover Implementare.
In questo caso, è possibile creare una interfaccia PersonaggioInterface che al suo interno contenga dei metodi come attaccaPersonaggio(Obj ...){} e che può essere comune a tutte le classi Personaggio, come già detto.
Interface PersonaggioInterface{
public void attaccaAvversario(Obj ...) {}
}
Class PersonaggioX implements PersonaggioInterface{
@override
public void attaccaAvversario(Obj ...){
//corpo del metodo...
}
}
è una veduta molto ampia e forse basilare o, ancora, inefficace per il tuo caso. Perdonami la forse non totale accuratezza, ho scritto un po' di fretta ed in un buco temporale ma spero che l'utilizzo dei vari elementi sia comunque arrivato.
Ci tengo a sottolineare che il codice non è controllare ed è comunque abbastanza pseudo-java e che qualche definizione degli elementi trattati potrebbe essere un po' sballata.
Detto questo, spero possa averti dato almeno una visione differente del tutto.
mi scuso per eventuali omicidi grammaticali, ho controllo davvero di fretta
DISCUSSIONI SIMILI
- Release
- In evidenza
-
- 29
-
- 8K
- In evidenza
-
- 20
-
- 13K