From 40c9df42d4cbf84a66efb8847ff79af155ab7a17 Mon Sep 17 00:00:00 2001 From: Vichingo455 Date: Fri, 17 Oct 2025 09:47:08 +0200 Subject: [PATCH] Verifica --- SuperVerificaMeravigliosa/.classpath | 10 ++ SuperVerificaMeravigliosa/.project | 28 ++++ SuperVerificaMeravigliosa/src/Main.java | 157 ++++++++++++++++++++ VerificaTest/README.md | 18 +++ VerificaTest/src/Main.java | 186 ++++++++++++++++++++++++ 5 files changed, 399 insertions(+) create mode 100644 SuperVerificaMeravigliosa/.classpath create mode 100644 SuperVerificaMeravigliosa/.project create mode 100644 SuperVerificaMeravigliosa/src/Main.java create mode 100644 VerificaTest/README.md create mode 100644 VerificaTest/src/Main.java diff --git a/SuperVerificaMeravigliosa/.classpath b/SuperVerificaMeravigliosa/.classpath new file mode 100644 index 0000000..57bca72 --- /dev/null +++ b/SuperVerificaMeravigliosa/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/SuperVerificaMeravigliosa/.project b/SuperVerificaMeravigliosa/.project new file mode 100644 index 0000000..9ffd7ec --- /dev/null +++ b/SuperVerificaMeravigliosa/.project @@ -0,0 +1,28 @@ + + + SuperVerificaMeravigliosa + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + + + 1758261738047 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + + diff --git a/SuperVerificaMeravigliosa/src/Main.java b/SuperVerificaMeravigliosa/src/Main.java new file mode 100644 index 0000000..7121aa3 --- /dev/null +++ b/SuperVerificaMeravigliosa/src/Main.java @@ -0,0 +1,157 @@ +/* +NB. aggiungere dei parametri ai metodi dove indispensabile + +Drawable (interfaccia) +void draw(); stampa le coordinate e le dimensioni del bottone. + +Component (classe astratta) +classe base astratta che implementa Drawable e rappresenta un generico componente GUI. +Contiene le proprietà comuni a tutti i componenti: posizione (x, y) e dimensioni (width, height). + +Button (classe concreta) +Estende Component e rappresenta un pulsante. +Aggiunge un'etichetta (label) e implementa i metodi: +click() → simula il click del bottone. + +TextField (classe concreta) +Estende Component e rappresenta un campo di testo. +Aggiunge la gestione del contenuto testuale (text) e implementa i metodi: +setText() e getText() → gestione del contenuto. + +Frame +Classe che rappresenta una finestra contenente componenti. +Gestisce: +Il titolo e le dimensioni della finestra. +Un array di componenti con numero massimo definito. +metodi addComponent() +draw() → disegna il frame e tutti i componenti e può lanciare una eccezione +Eccezioni da gestire: +OutOfFrameException → se un componente esce dai limiti della finestra + +Main +Contiene il metodo main() che: +1. Crea un oggetto Frame. +2. Aggiunge un Button e un TextField. +3. Disegna la finestra e i componenti. +4. Simula un click sul bottone. +5. Cambia il testo nel TextField. +6. Ridisegna la finestra per mostrare il nuovo stato. + + +Drawing Frame: 'La mia finestra' size [800x600] +Components: +Drawing Button 'OK' at (50,100) size [100x40] +Drawing TextField with text 'Inserisci testo...' at (200,100) size [200x40] +Button 'OK' clicked! +Drawing Frame: 'La mia finestra' size [800x600] +Components: +Drawing Button 'OK' at (50,100) size [100x40] +Drawing TextField with text 'Inserisci testo...' at (200,100) size [200x40] +!!! Eccezione catturata !!! Il componente TextField esce dai limiti del frame (La mia finestra) + + +*/ + +class OutOfFrameException extends Exception { + OutOfFrameException(String message) { + super(message); + } +} + +class MaxComponentsException extends Exception { + MaxComponentsException(String message) { + super(message); + } +} + +interface Drawable { + void draw() throws OutOfFrameException; +} + +abstract class Component implements Drawable { + protected int x,y,width,height; +} +class Button extends Component { + String label; + Button(int x, int y, int width, int height, String label) { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + this.label = label; + } + public void draw() throws OutOfFrameException { + System.out.println("Drawing Button '" + label + "' size [" + width + "x" + height + "] at position (" + x + "," + y + ") status OK."); + } + public void click() { + System.out.println("Clicked button '" + label + "'"); + } +} +class TextField extends Component { + TextField(int x, int y, int width, int height) { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + protected String text; + public void draw() { + System.out.println("Drawing TextField with text '" + text + "' size [" + width + "x" + height + "] at position (" + x + "," + y + ") status OK."); + } + public void setText(String text) { + this.text = text; + } + public String getText() { + return text; + } +} + +class Frame extends Component { + protected int maxComponents = 10; + protected int componentNumber = 0; + protected String title; + protected Component[] componentlist = new Component[maxComponents]; + Frame(int width, int height, String title) { + this.width = width; + this.height = height; + this.title = title; + } + public void draw() throws OutOfFrameException{ + System.out.println("Drawing Frame '" + title + "' size [" + width + "x" + height + "]"); + System.out.println("Drawing components..."); + for (int i = 0; i < componentNumber; i++) { + if (componentlist[i].width > this.width || componentlist[i].height > this.height) { + throw new OutOfFrameException("ERROR! The component is out of the frame limits!"); + } + else { + componentlist[i].draw(); + } + } + } + public void addComponent(Component c) throws MaxComponentsException{ + if (componentNumber == maxComponents) { + throw new MaxComponentsException("ERROR! Maximum number of components reached!"); + } + else { + componentlist[componentNumber] = c; + componentNumber++; + } + } +} + +public class Main { + public static void main(String[] args) throws Exception { + try { + Frame frame = new Frame(800,600,"La mia finestra"); + TextField field = new TextField(60,10,801,11); + field.setText("Inserisci Testo..."); + Button button = new Button(30, 40, 90, 30, "OK"); + frame.addComponent(button); + frame.addComponent(field); + frame.draw(); + button.click(); + } catch (OutOfFrameException e) { + System.out.println(e.getMessage()); + } + } +} diff --git a/VerificaTest/README.md b/VerificaTest/README.md new file mode 100644 index 0000000..7c03a53 --- /dev/null +++ b/VerificaTest/README.md @@ -0,0 +1,18 @@ +## Getting Started + +Welcome to the VS Code Java world. Here is a guideline to help you get started to write Java code in Visual Studio Code. + +## Folder Structure + +The workspace contains two folders by default, where: + +- `src`: the folder to maintain sources +- `lib`: the folder to maintain dependencies + +Meanwhile, the compiled output files will be generated in the `bin` folder by default. + +> If you want to customize the folder structure, open `.vscode/settings.json` and update the related settings there. + +## Dependency Management + +The `JAVA PROJECTS` view allows you to manage your dependencies. More details can be found [here](https://github.com/microsoft/vscode-java-dependency#manage-dependencies). diff --git a/VerificaTest/src/Main.java b/VerificaTest/src/Main.java new file mode 100644 index 0000000..e31d39d --- /dev/null +++ b/VerificaTest/src/Main.java @@ -0,0 +1,186 @@ +import java.util.ArrayList; +import java.util.List; +record Arma(String nome, int danno) { } +interface Attaccante { + void attacca(Personaggio p); + int dannoMassimo(); + void aggiungiArma(Arma arma); +} +interface Curatore { + void cura(Personaggio p); + int puntiCura(); +} +abstract class Personaggio { + private final String nome; + private int puntiVita; + + public Personaggio(String nome, int puntiVita) { + this.nome = nome; + this.puntiVita = puntiVita; + } + + public String getNome() { + return nome; + } + + public int getPuntiVita() { + return puntiVita; + } + + public void riceviDanno(int danno) { + if (puntiVita - danno <= 0) { + puntiVita = 0; + throw new RuntimeException(nome + " è stato sconfitto!"); + } + puntiVita -= danno; + } + + public void riceviCura(int cura) { + puntiVita += cura; + } + + @Override + public String toString() { + return getClass().getSimpleName() + + " {nome='" + nome + "', puntiVita=" + puntiVita + "}"; + } +} +class Mago extends Personaggio implements Attaccante, Curatore { + private final int potereMagico; + private final List armi = new ArrayList<>(); + + public Mago(String nome, int puntiVita, int potereMagico) { + super(nome, puntiVita); + this.potereMagico = potereMagico; + } + + @Override + public void aggiungiArma(Arma arma) { + armi.add(arma); + } + + @Override + public int dannoMassimo() { + return potereMagico * 6; + } + + @Override + public void attacca(Personaggio p) { + if (armi.isEmpty()) return; + int danno = dannoMassimo() / 2 + armi.get(0).danno(); + System.out.println(getNome() + " lancia un incantesimo su " + p.getNome() + " (danno: " + danno + ")"); + p.riceviDanno(danno); + } + + @Override + public int puntiCura() { + return potereMagico * 2; + } + + @Override + public void cura(Personaggio p) { + int cura = puntiCura(); + System.out.println(getNome() + " cura " + p.getNome() + " di " + cura + " punti vita."); + p.riceviCura(cura); + } + + @Override + public String toString() { + return super.toString() + " [potereMagico=" + potereMagico + "]"; + } +} +class Guerriero extends Personaggio implements Attaccante { + private final int forza; + private final List armi = new ArrayList<>(); + + public Guerriero(String nome, int puntiVita, int forza) { + super(nome, puntiVita); + this.forza = forza; + } + + @Override + public void aggiungiArma(Arma arma) { + armi.add(arma); + } + + @Override + public int dannoMassimo() { + return forza * 10; + } + + @Override + public void attacca(Personaggio p) { + if (armi.isEmpty()) return; + int danno = dannoMassimo() / 2 + armi.get(0).danno(); + System.out.println(getNome() + " colpisce " + p.getNome() + " (danno: " + danno + ")"); + p.riceviDanno(danno); + } + + @Override + public String toString() { + return super.toString() + " [forza=" + forza + "]"; + } +} +class Guaritore extends Personaggio implements Curatore { + private final int cura; + + public Guaritore(String nome, int puntiVita, int cura) { + super(nome, puntiVita); + this.cura = cura; + } + + @Override + public int puntiCura() { + return cura * 4; + } + + @Override + public void cura(Personaggio p) { + int punti = puntiCura(); + System.out.println(getNome() + " guarisce " + p.getNome() + " di " + punti + " punti vita."); + p.riceviCura(punti); + } + + @Override + public String toString() { + return super.toString() + " [cura=" + cura + "]"; + } +} + +public class Main { + public static void main(String[] args) { + var guerriero = new Guerriero("Thor", 100, 8); + var mago = new Mago("Merlino", 90, 12); + Curatore guaritore = new Guaritore("Elrond", 80, 25); + + Arma bastone = new Arma("Bastone Incantato", 20); + Arma spada = new Arma("Spada del Destino", 50); + + mago.aggiungiArma(bastone); + mago.aggiungiArma(spada); + guerriero.aggiungiArma(spada); + guerriero.aggiungiArma(bastone); + + System.out.println(mago); + System.out.println(guerriero); + System.out.println(guaritore); + System.out.println(); + + try { + guerriero.attacca(mago); + mago.attacca(guerriero); + System.out.println(mago); + System.out.println(guerriero); + + guaritore.cura(guerriero); + mago.cura(mago); + System.out.println(mago); + System.out.println(guerriero); + System.out.println(); + + guerriero.attacca(mago); // deve sollevare eccezione + } catch (RuntimeException e) { + System.out.println("⚠️ " + e.getMessage()); + } + } +}