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

---

---

Libro di testo a consultazione rapida solo per fare l’esame.

Da questo link puoi consultare il libro di testo per lo svolgimento dell’esame finale. Non è la versione finale, che verrà ultimata per il prossimo anno scolastico ma in questa edizione troverete già moltissime delle domande e delle risposte che normalmente vengino poste agli esami.  E’ molto utile anche in fase di addestramento per le scuole medie perchè contiene nozioni di ECDL ovvero uso del foglio elettronico, delle presentazioni multimediali, Word e altro.

downlod pdf -> SIIC road to exam

---

Studenti SIIC che faranno gli esami al Parini (programmi)

1. prima liceo
2. seconda liceo
3. terza liceo
4. quarta liceo

---

//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

---

Programmi per esami

Informatica classe 1à Liceo
Elementi di programmazione JAVA
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

Informatica classe 2à Liceo
Programmazione JAVA con editor Eclipse
1. Procedure e funzioni in Java
2. Passaggio parametri per valore
3. Gli array e le matrici
4. Le stringhe: le funzioni della libreria string

Programma per esame classe terza liceo
Le reti:
Topologie di reti
Tipologie di reti
Architetture
Modem, Router
Switch, Hub
Le basi di dati:
Introduzione ai database e relativi concetti
Sviluppo di semplici database
Internet e il web:
Linguaggi di markup
Introduzione alle pagine web
Creazione di pagine web con HTML
Cenni di CSS
Cenni di HTML5
Sviluppo di un sito web interdisciplinare

Vai alla pagina per l’esame di terza liceo 2021/2022

---

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
}
}

---

Riverca di un elemento in vettore

import java.util.Scanner;
public class Main
{
public static void main(String[] args) {
int[] vettore = new int[5];
int valore;
int trova;

System.out.print(“Vettore A = “);
for (int index = 0; index <5; index++) {
// azioni sul vettore di lettura e scrittura;
System.out.print(“iserisci valore => “);
Scanner myInput = new Scanner (System.in);
valore = myInput.nextInt();
vettore[index] = valore;

}

System.out.print(“Il vettore inserito vale “);
System.out.println();
for(int index=0; index<5; index++){
System.out.print(vettore[index]+” , “);
}

System.out.println();
System.out.print(“Quele elemento vuoi cercare nel vettore? “);
System.out.println();
Scanner ricerca = new Scanner (System.in);
trova =ricerca.nextInt();

for(int index=0; index<5; index++){
if(vettore[index]==trova){
System.out.print(“Elemento trovato in posizione “+index);
}

}
}
}

Scarica il programma ricerca elemento in un vettore ->Ricerca elemento nel vetttore

---

Ricerca bubble sort all’interno di un vettore

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

vettori in java: Algoritmi di ordinamento
Bouble sort

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

public class Main
{
public static void main(String[] args) {
int[] vettore = new int[11];
int swap;

System.out.print(“Vettore A = “);
for (int index = 0; index <10; index++) {
// azioni sul vettore di lettura e scrittura;
vettore[index] = 10 – index;
System.out.print(vettore[index]+” , “);
}

// ordinamento bubble short
System.out.println();
System.out.print(“Vettore in ordine crescente = “);
while(vettore[0]>=vettore[1]){
for (int index =0; index<9;index ++){
if(vettore[index]>vettore[index+1]) {
swap=vettore[index];
vettore[index]=vettore[index+1];
vettore[index+1] = swap;
//System.out.print(vettore[index]+” , “);
}
}
}

//stampa del vettore invertito
for (int index =0; index<10;index ++){
System.out.print(vettore[index]+” , “);
}

}
}

scarica algoritmo di ordinamento bubble sort -> bouble sort

 

---

//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();

}
}

************************************************************************

Algoritmi di ordinamento   18/01/2022

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

vettori in java: Algoritmi di ordinamento
Bouble sort

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

public class Main
{
public static void main(String[] args) {
int[] vettore = new int[11];
int swap;

System.out.print(“Vettore A = “);
for (int index = 0; index <10; index++) {
// azioni sul vettore di lettura e scrittura;
vettore[index] = 10 – index;
System.out.print(vettore[index]+” , “);
}

// ordinamento bubble short
System.out.println();
System.out.print(“Vettore in ordine crescente = “);
while(vettore[0]>=vettore[1]){
for (int index =0; index<9;index ++){
if(vettore[index]>vettore[index+1]) {
swap=vettore[index];
vettore[index]=vettore[index+1];
vettore[index+1] = swap;
//System.out.print(vettore[index]+” , “);
}
}
}

//stampa del vettore invertito
for (int index =0; index<10;index ++){
System.out.print(vettore[index]+” , “);
}

}
}

---

Semplici esercizi risolti.

1. Il problema delle carrucole.  Due carrucole coassiali formano un sistema detto paranco, che serve a moltiplicare le forze. Fare un programma che calcola il valore del pesso sollevabele in funzione della difefrenza dei raggi.

package calcolo;

import java.util.Scanner;
public class calculu {

public static void main(String[] args) {
Scanner MyInput=new Scanner (System.in);
double kgR = 0.0;
double R = 0.0;
double r =1.0;
double kgr = 0.0;
System.out.println(“inserire valore di R ” );
R=MyInput.nextInt();
System.out.println(“inserire valore di kgR ” );
kgR=MyInput.nextInt();
System.out.println(“inserire valore di r ” );
r=MyInput.nextInt();
kgr=(R*kgR)/r;
System.out.println(“kgr vale -> “+kgr );
}

}

Scarica il programma ->  carrucole

---

2. La spinta di archimede.

Una bottiglia, assimilabile a un cilindro omogeneo, è immersa nell’acqua per 2/3 della sua lunghezza. Ha ul Diametro D ed è lunga L.   Trovare il peso della bottiglia.

Soluzione: Applicare la spinta di Archimede e considerare la densità dell’acqua pari a 1kg/dm3.

package Bottiglia_Archimede;
import java.util.Scanner; //rende possibile leggere i valori dalla tastiera
//import java.math;

public class Bottiglia {
static void archimede() {
double immersa = 0.23;
double diametro = 0.15;
double Pi = 3.1415;
double r = 0;
double swap =0;
double swap2 = 0;
double volumeSommerso =0;
double pesoBottiglia = 0;

r= diametro/2;
swap=Math.pow(r,2);
swap2= swap * Pi;
volumeSommerso =((swap2*immersa)/3)*2;
System.out.println(“volume immerso “+volumeSommerso);
pesoBottiglia = volumeSommerso * 1000;
System.out.println(“Peso della bottiglia “+pesoBottiglia+” kg”);
}

public static void main(String[] args) {
System.out.println(“**********************************”);
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** La spinta di Archimede **”);
System.out.println(“** scuola SIIC PD 23/02/2022 **”);
System.out.println(“**********************************”);
Scanner myInput = new Scanner (System.in);
archimede();

}

}

scarica il programma spinta di Archimede -> message_in_a_bottle

---

3.  Data la funzione della retta Tracciare almeno 4 punti.

Soluzione: Nota la funzione Y=mX+Q eseguire un ciclo for che passa alla variabile libera una sequenza di valori. Viene restituita una sequenza di valori della variabile dipendente in funzione del coefficiente angolare m e, per chi riesce a sviluppare, dell’intercetta con l’asse Y.

package funzioni_piane;

import java.util.Scanner;

class punzioni {

public static void main(String[] args) {

double y = 0.0;

double q = 0.0;
System.out.println(“** prof Marco Gottardo Ph.D **”);
System.out.println(“** funzione della retta **”);
System.out.println(“**scuola cinese SIIC Padova **”);
System.out.println(“** anno scolastico 2021/2022**”);
System.out.println();

//richiedere e calcolare almeno 4 punti di ogni retta
Scanner myInput_m = new Scanner (System.in);
double m = 0.0;
System.out.println(“Inserire il coefficiente angolare della retta m -> “);
m = myInput_m.nextDouble();

Scanner myInput_x = new Scanner (System.in);
double x = 0.0;

for (int Xn = 0; Xn <=3; Xn++) {
System.out.println(“coordinata X, “+Xn+”, della retta ->”);
x = myInput_x.nextDouble();
y=m*x+q;
System.out.println(“Punto della retta = “+ y);
}
}

}

download programma calcolo delle rette -> retteJava

---

Come leggere tipi di dato stringa da tastiera

import java.util.Scanner;  // Import the Scanner class

class Main {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);  // Create a Scanner object
    System.out.println("Enter username");

    String userName = myObj.nextLine();  // Read user input
    System.out.println("Username is: " + userName);  // Output user input
  }
}

Esempio di lettura di vari tipo di dati con la classe scanner

import java.util.Scanner;

class Main {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);

    System.out.println("Enter name, age and salary:");

    // String input
    String name = myObj.nextLine();

    // Numerical input
    int age = myObj.nextInt();
    double salary = myObj.nextDouble();

    // Output input by user
    System.out.println("Name: " + name);
    System.out.println("Age: " + age);
    System.out.println("Salary: " + salary);
  }
}

---

---

Temi d’esame proposti

1. Sviluppare in java, in ambiente Eclipse, il triangolo di Tartaglia.