Java programming SIIC (international Italo-chinese school in Padova) prof Gottardo

In this page are available the programs developed during the programming lessons for the students of the first and second technological high school, carried out by prof. Marco Gottardo Ph.D.:

Eclipse JAVA enviroment installing and test

https://youtu.be/S2XtxZspOU4

//Nozioni minime da apprendere in prima liceo

1. Utilizzo dell’ambiente di programmazione
Eclipse
2. Tipi di Dato: int, double, char
3. Il costrutto If-Else, if- elseif, switch-case
4. Struttura iterativa: while, do-while, for

Sorgenti esercizi di base:

/******************************************************************************
prof. Marco Gottardo Ph.D.
Tipi di dato del Java

bool -> true o false
char -> carattere di 16 bit (codifica unicode 1.1)
byte -> intero a 8 bit con segno
short -> intero di 16 bit con segno
int -> intero di 32 bit con segno
long -> intero di 64 bit con segno
float -> numero in virgola mobile di 32 bit (IEEE 754-1985)
double -> numero in virgola mobile di 64 bit (IEEE 754-1985)

nota importante: Le variabili devono essere inizializzate o il
compilatore non compila il codice

I metodi del java possono essere sovracaricati (overload) nel senso
che accettano più tipi di dato diversi, ad esempio println accettano
sia il numero intero che la stringa.

Definizione di una costante con nome:

*******************************************************************************/

public class Main
{
public static void main(String[] args) {
int numero = 0; //Le variabili si definiscono dentro al main
final double Pi = 3.1415;
System.out.println(Pi);
}
}


//Questo programma mostra come acquisire un valore intero da tastiera

import java.util.Scanner;
public class LeggiValore {

public static void main(String[] args) {
System.out.println(“*****************************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** programma in JAVA legge da tastiera **”);
System.out.println(“** corso estivo 25/08/2021 **”);
System.out.println(“*****************************************”);

Scanner myInput = new Scanner (System.in);
int a;
System.out.print(“dammi un numero da tastiera -> “);
a = myInput.nextInt();
System.out.printf(“hai inserito il numero -> =%d\n “, a);
}
}


In java i tipi di dato principali sono:

int -> intero a 32 bit con segno
double -> numero in virgola mobile di 64 bit (IEEE 754-1985)
char -> carattere di 16 bit (codifica unicode 1.1)

Ma sono molto usate le stringhe, come array di caratteri per le quali sono implementate numerose classi.

Classe = struttura formata da campi e metodi e non solo da campi.

I campi sono i dati o le variabili di cui si compone mentre i medoti sono le funzioni che operano sui dati della classe.

La classe ha tre caratteristiche:
1) ereditariet
2) polimorfismo
3) incapuslamento

1) Una classe può “contenere” altre classi di cui ne eredita i metodi e i campi, in questo caso si parla di classe figlia di una classe madre.

Vale la sintassi di base del C++ vista durante l’anno scolastico.

Funzionano alla stessa maniera:

1) while
2) for
3) if
4) switch case

Esempio di dichiarazione della costante double.

public class Main
{
public static void main(String[] args) {
int numero = 0; //Le variabili si definiscono dentro al main
final double Pi = 3.1415;
System.out.println(Pi);
}
}


//esempio di utilizzo della variabile double, calcolo area di un cerchio

/******************************************************************************
prof. marco Gottardo Ph.D.
Java basic traning for SIIC students
lesson 1
Area del cerchio

*******************************************************************************/
public class Main
{
public static void main(String[] args) {
double raggio = 1.3;
double Pi = 3.1415;
double Area = 0.0;
Area = raggio*raggio*Pi;
System.out.println(“Circle area value is:”);
System.out.println(Area);
}
}


/******************************************************************************
prof. Marco Gottardo Ph.D.
esempio di definizione di variabile intera e di stringa
*******************************************************************************/

public class Main
{
public static void main(String[] args) {
int numero = 10; //Le variabili si definiscono dentro al main
System.out.println(“Hello World”);
System.out.println(numero);
}
}


Esempio di ciclo while
public class Main
{
public static void main(String[] args) {
int numero = 0; //Le variabili si definiscono dentro al main
while (numero<=10){
System.out.println(numero);
numero++;
}
}
}
Quando si vuole effettuare almeno il primo ciclo
si deve eseguire il:
do{
//
}while(espressione);


//Esempio di stampa di numeri da 0 a 10 con ciclo while

/******************************************************************************
prof. Marco Gottardo Ph.D.
stampa a monitor i numeri da 0 a 10
*******************************************************************************/

public class Main
{
public static void main(String[] args) {
int numero = 0; //Le variabili si definiscono dentro al main
while (numero<=10){
System.out.println(numero);
numero++;
}
}
}


//esempio di ciclo do{    ;;;;}while();

public class EsempioVeroFalso {

public static void main(String[] args) {
System.out.println(“******************************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** programma in JAVA legge da tastiera **”);
System.out.println(“** test del ciclo while( ) do **”);
System.out.println(“** Se il numero è minore di 10 ne chiede**”);
System.out.println(“** un altro se è ggiore si ferma **”);
System.out.println(“** corso estivo 25/08/2021 **”);
System.out.println(“******************************************”);

Scanner myInput = new Scanner (System.in);

int a = 0;
do{
System.out.print(“dammi un numero da tastiera -> “);
a = myInput.nextInt();
System.out.printf(“hai inserito il numero -> =%d\n “, a);
}while(a<10);
System.out.print(“Hai inserito un valore > di 10 -> programma terminato “);
}
}


// Questo programma esegue la somma di due numeri acquisiti da tastiera

import java.util.Scanner;
public class EsempioVeroFalso {

public static void main(String[] args) {
System.out.println(“*****************************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** programma in JAVA legge da tastiera **”);
System.out.println(“** somma di numeri interi **”);
System.out.println(“** corso estivo 27/08/2021 **”);
System.out.println(“*****************************************”);

Scanner myInput = new Scanner (System.in);

int a; //definizione del primo addendo
int b; //definizione del secondo addendo
int somma; //somma degli addendi

System.out.print(“dammi il primo addendo -> “);
a = myInput.nextInt(); //acquisizione primo addendo
System.out.println(); // vai a capo riga

System.out.print(“dammi il secondo addendo -> “);
b = myInput.nextInt(); //acquisizione primo addendo
System.out.println(); // vai a capo riga

somma = a + b;

System.out.printf(“La somma dei valori interi è -> =%d\n “, somma);
//nota bene il comando %d serve per dire che usiamo i numeri interi
}
}


//definizione di strutture e accesso ai campi

/******************************************************************************
prof. Marco Gottardo Ph.D.
Tipi di dato del Java

raggruppare un insieme di variabili su un singolo Nome
Esempio delle carte da gioco:

*******************************************************************************/
class suite{
final static int fiori = 1;
final static int quadri = 2;
final static int cuori =3;
final static int spade = 4;

}

public class Main
{
public static void main(String[] args) {
int numero = 0; //Le variabili si definiscono dentro al main
final double Pi = 3.1415;
System.out.println(Pi);
System.out.println(suite.fiori);
System.out.println(suite.quadri);
System.out.println(suite.cuori);
System.out.println(suite.spade);
}
}


// Definizione di vettori e somma di vettori

/*
Vettore A = 3,2,1,
Vettore B = 3,2,1,
La somma dei vettori è =
*/

public class MyClass {
public static void main(String args[]) {
int[] vettoreA = new int[3];
int[] vettoreB = new int[3];
int[] somma = new int[3];

System.out.print(“Vettore A = “);
for (int indexA = 0; indexA <3; indexA++) {
// azioni sul vettore di lettura e scrittura;
vettoreA[indexA] = 3 – indexA;
System.out.print(vettoreA[indexA]+”,”);
}
System.out.println();
System.out.print(“Vettore B = “);
for (int indexB = 0; indexB <3; indexB++) {
// azioni sul vettore di lettura e scrittura;
vettoreB[indexB] = 3 – indexB;
System.out.print(vettoreA[indexB]+ “,”);
}
System.out.println();
System.out.print(“La somma dei vettori è = “);
}
}


//Somma di vettori iterattiva cn acquisizione da tastiera

import java.util.Scanner;
public class MyClass {
public static void main(String args[]) {
System.out.println(“*****************************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** programma in JAVA somma di array **”);
System.out.println(“** corso estivo 25/08/2021 **”);
System.out.println(“*****************************************”);

Scanner myInput = new Scanner (System.in);

int[] vettoreA = new int[3];
int[] vettoreB = new int[3];
int[] somma = new int[3];

// caricamento del primo vettore
System.out.print(“Caricamento del primo vettore : “);
for (int index =0 ; index <3; index++){
System.out.print(“inserire il valore di indice -> ” + index +” -> “);
vettoreA[index] = myInput.nextInt();
}

System.out.println(); // va a capo riga

//caricamento del secondo vettore
System.out.print(“Caricamento del secondo vettore : “);
for (int index =0 ; index <3; index++){
System.out.print(“inserire il valore di indice -> ” + index +” -> “);
vettoreB[index] = myInput.nextInt();
}

System.out.println(); // va a capo riga

System.out.print(“La somma dei vettori vale: “);
for (int index =0 ; index <3; index++){
somma[index] = vettoreA[index]+vettoreB[index];
System.out.print(somma[index]+”,”);
}
System.out.println(); // va a capo riga
System.out.print(“Il programma è corretto, la sintassi va bene”);
// compilatore JAVA online, scrivere qui il programma
}
}


//Somma di array con acquisizione da tastiera

public class MyClass {
public static void main(String args[]) {
System.out.println(“*****************************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** programma in JAVA somma di array **”);
System.out.println(“** corso estivo 25/08/2021 **”);
System.out.println(“*****************************************”);
int[] vettoreA = new int[3];
int[] vettoreB = new int[3];
int[] somma = new int[3];

// caricamento del primo vettore
vettoreA[0] = 3;
vettoreA[1] = 1;
vettoreA[2] = 7;

//caricamento del secondo vettore
vettoreB[0] = 2;
vettoreB[1] = 1;
vettoreB[2] = 2;

System.out.print(“La somma dei vettori vale: “);
for (int index =0 ; index <3; index++){
somma[index] = vettoreA[index]+vettoreB[index];
System.out.print(somma[index]+”,”);
}
System.out.println(); // va a capo riga
System.out.print(“Il programma è corretto, la sintassi va bene”);
// compilatore JAVA online, scrivere qui il programma
}
}


//come definire una matrice in java.

/*************************************************
In matematica un array o vettore è una collezione
di dimensione finita e nota a priori di variabili
uguali.
Quando le variabili di un array sono a loro volta
degli array allora diventa una matrice.
Una matrice è un array di array.
*************************************************/

/************************************************
per gestire una matrice ci vogliono due indici,
uno per la scansione delle colonne e una per la
scansione delle righe.
La somma di due matrici è possibile solo se gli
addendi hanno la stessa dimensione ovvero se la
matrice A ha lo stesso numero di righe e di colonne
della matrice B.
Si ottiene una matrice somma anche essa della stessa
dimensione.
*************************************************/

public class MyClass {
public static void main(String args[]) {
int[][] matrix = new int[3][3];
//setupMatrix(mat);

for (int colonna = 0; colonna < 3; colonna ++ ){
for (int riga = 0; riga < 3; riga ++ )
System.out.print(matrix[riga][colonna] +” “);
System.out.println();
}
}
}


 

/***********************************************
Vogliamo sommare le matrice 2×2 A e B.
A= 3 2 B= 2 1
1 0 1 1
la somma A+B vale:

somma = 5 3
2 1
***********************************************/
import java.util.Scanner; //rende possibile leggere i valori dalla tastiera

public class MyClass {
public static void main(String args[]) {
System.out.println(“*****************************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** programma in JAVA somma di Matrici**”);
System.out.println(“** corso estivo 26/08/2021 **”);
System.out.println(“*****************************************”);
Scanner myInput = new Scanner (System.in);

int[][] matrixA = new int[2][2];
int[][] matrixB = new int[2][2];
int[][] somma = new int[2][2];

System.out.print(“Matrice A “);
System.out.println();
for (int colonna = 0; colonna < 2; colonna ++ ){
for (int riga = 0; riga < 2; riga ++ ){
matrixA[riga][colonna] = 1;
System.out.print(matrixA[riga][colonna] +” “);
}
System.out.println();
}

System.out.println();
System.out.print(“Matrice B “);
System.out.println();
for (int colonna = 0; colonna < 2; colonna ++ ){
for (int riga = 0; riga < 2; riga ++ ){
matrixB[riga][colonna]=2;
System.out.print(matrixB[riga][colonna] +” “);
}
System.out.println();
}

System.out.println();
System.out.print(“Somma Matrice A + Matrice B “);
System.out.println();
for (int colonna = 0; colonna < 2; colonna ++ ){
for (int riga = 0; riga < 2; riga ++ ){
somma[colonna][riga] = matrixA[colonna][riga] + matrixB[colonna][riga];
System.out.print(somma[colonna][riga] +” “);
}
System.out.println();
}
}
}


//Somma di matrici

import java.util.Scanner;
public class EsempioVeroFalso {

public static void main(String[] args) {
System.out.println(“*****************************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** programma in JAVA somma di matrici **”);
System.out.println(“** corso estivo 27/08/2021 **”);
System.out.println(“*****************************************”);

Scanner myInput = new Scanner (System.in);

int[][] matA = new int[2][2];
int[][] matB = new int[2][2];
int[][] sommAB = new int[2][2];

//leggi la la matrice A
System.out.println(” Inserire la matA di 4 elementi, 2 rige e 2 colonne “);
for (int colonnaA = 0; colonnaA < 2; colonnaA ++ ){
for (int rigaA = 0; rigaA < 2; rigaA ++ ){
matA[rigaA][colonnaA] = myInput.nextInt();
}
}

//stampa la marice A
System.out.println();
System.out.println(“matA inserita è “);
for (int colonnaA = 0; colonnaA < 2; colonnaA ++ ){
for (int rigaA = 0; rigaA < 2; rigaA ++ ){
System.out.print(matA[rigaA][colonnaA] +” “);
}
System.out.println();
}

//leggi la la matrice B
System.out.println(” Inserire la matB di 4 elementi, 2 rige e 2 colonne “);
for (int colonnaB = 0; colonnaB < 2; colonnaB ++ ){
for (int rigaB = 0; rigaB < 2; rigaB ++ ){
matB[rigaB][colonnaB] = myInput.nextInt();
}
}

//stampa la marice B
System.out.println();
System.out.println(“matB inserita è “);
for (int colonnaB = 0; colonnaB < 2; colonnaB ++ ){
for (int rigaB = 0; rigaB < 2; rigaB ++ ){
System.out.print(matB[rigaB][colonnaB] +” “);
}
System.out.println();
}

//stampa la marice somma
System.out.println();
System.out.println(“La somma delle matrici è “);
for (int colonnaSomma = 0; colonnaSomma < 2; colonnaSomma ++ ){
for (int rigaSomma = 0; rigaSomma < 2; rigaSomma ++ ){
sommaAB[rigaSomma][colonnaSomma] = matA[rigaSomma][colonnaSomma] + matB[rigaSomma][colonnaSomma];
System.out.print(sommaAB[rigaSomma][colonnaSomma] +” “);
}
System.out.println();
}

//System.out.printf(“hai inserito il numero -> =%d\n “, a);
}
}


La classe gatto.

Questo esempio, anche se semplificato è di fondamentale importanza.  Viene realizzata la classe gatto, con alcuni metodi e campi, e la classe padrone che contiene il metodo main.  Può essere usata come punto di partenza per lo sviluppo di classi più complesse e iterative.

download  classe gatto  (Dedicata al mio gatto Mimù che ci ha lasciati ‘8 novembre 2021, dopo circa vent’anni di felice convivenza).

class Gatto{
int anni;
float peso;
float altezza;
String colore;
String razza;

public String qualeRazza(String tipoGatto){
//String risposta1 = “Sono un gatto siamese” + tipoGatto;
String risposta1 = “Sono un gatto siamese”;
return risposta1;
}

public String Occhi(String tipoGatto){
String risposta1 = “ho gli occhi azzurri”;
return risposta1;
}

public void dorme(){
System.out.println(
“Buona notte, ci vediamo domani”);
}

public void mangia(){
System.out.println(
“Ho fame…dammi uno snack!”);
}
public String dice(String unaFrase){
String risposta = “OK!! OK!! ” + unaFrase;
return risposta;
}
}

public class Padrone {
public static void main(String[] args) {
String reazione;
String i_miei_occhi;
String diRazza;
Gatto mioGatto = new
Gatto ();
mioGatto.mangia();
diRazza = mioGatto.qualeRazza(“Sono un gatto siamese”);
System.out.println(diRazza);

i_miei_occhi = mioGatto.Occhi(“Sono un gatto siamese”);
System.out.println(i_miei_occhi);

reazione = mioGatto.dice(“Miao!! Miao!!”);
System.out.println(reazione);

mioGatto.dorme();

}
}