Programmazione I - Preparazione A.A. 2010/2011 3 febbraio 2011 Matricola:........................................................................ Cognome:........................................................................ Nome:........................................................................... Nei seguenti quesiti, quando vi è richiesto di scrivere un programma, potete limitarvi al corpo del metodo main, assumendo se necessario che in e out siano due variabili di classe ConsoleInputManager e ConsoleOutputManager (rispettivamente), già dichiarate e inizializzate. 1. Considerate la seguente gerarchia di classi (rappresentata mediante un diagramma UML): B +f(long x): int A +f(string x): int C D e ipotizzate che tutte le classi abbiano un costruttore pubblico senza argomenti. Assumete le seguenti definizioni e inizializzazioni: A a = new D( ) ; B b = new B ( ) ; C c = new C ( ) ; A d = new A( ) ; Per ciascuna delle seguenti invocazioni di metodo, dire se essa è consentita e in caso affermativo indicare il nome della classe che contiene il metodo che verrà effettivamente eseguito e la segnatura del metodo: d.equals( a ):........................................... Object:equals(Object) a.f( 3 ):..............................................................D:f(double) b.f( 4 + "" ):........................................................ A:f(String) c.tostring():.................................................. Object:toString() 1
2. Sia la seguente definizione di variabili: int x = 1 ; int y = 2 ; Dite quale sarà il contenuto di x e y dopo l esecuzione degli assegnamenti indicati: Assegnamento x y x = ( y++ <= x )? ++x : ( x += y ) 4 3 x = x++ ; y = y 1 2 3. Sia la seguente definizione di variabili: int x = 3 ; int y = 4 ; boolean b = ( x = y ) > ++y ; Dite quale sarà il valore di verità delle seguenti espressioni booleane e quale sarà il contenuto delle variabili x, y e b dopo la valutazione delle espressioni indicate: Espressione Valore di verità x y b b & ( x == ( x += y ) ) false 8 5 false!b && b = ( ++x > ( x = x++ ) ) false 5 5 false 4. Considerate il seguente frammento di programma: int k = 0 ; for ( int i = 0 ; i < 4 ; i++ ) for ( int j = i ; j < 4 ; k += j, j++ ) ; Quale sarà il valore di k dopo la sua esecuzione? k:.............. 20 2
5. Un numero intero positivo n si dice triangolare se esiste un intero k tale che n = 0 + 1 + 2 + + k. Ad esempio, 21 è triangolare essendo 21 = 0 + 1 + 2 + 3 + 4 + 5 + 6; anche 10 è triangolare in quanto 10 = 0 + 1 + 2 + 3 + 4; chiaramente, 0 e 1 sono triangolari. Scrivete un metodo statico dal nome triangolare, con un argomento intero n, il quale restituisca true se n è triangolare, false altrimenti. Sfruttate poi il metodo statico triangolare sopra indicato per scrivere un programma che: chieda all utente un numero m e memorizzi m interi inseriti dall utente in un array A di dimensione m; se l utente inserisce un numero negativo, va emesso un messaggio d errore e richiesto il numero, stampi i numeri triangolari in A che superano la media di tutti i numeri pari contenuti in A. Se non sono stati inseriti numeri pari, il programma deve stampare tutti i numeri triangolari in A e la posizione del numero triangolare più grande. public s t a t i c boolean t r i a n g o l a r e ( int n ) { int k = 0 ; for ( int i = 0 ; k < n ; k += i, i++ ) ; return k == n ; int m = i n. r e a d I n t ( "Quanti:" ) ; int [ ] A = new int [m] ; int pos = 1, p = d = 0 ; for ( int i = 0 ; i < m; i++ ) { while ( ( A[ i ] = i n. r e a d I n t ( "Numero:" ) ) < 0 ) out. p r i n t l n ( "Il numero non deve essere negativo. Numero:" ) ; i f ( A[ i ] % 2 == 0 ) { p = p + A[ i ] ; d++; i f ( d > 0 ) { double media = ( double ) p / d ; for ( int i = 0 ; i < m; i++ ) i f ( t r i a n g o l a r e ( A[ i ] ) && A[ i ] > media ) { for ( int i = 0 ; i < m; i++ ) i f ( t r i a n g o l a r e ( A[ i ] ) ) { i f ( pos == 1 A[ i ] > A[ pos ] ) pos = i ; i f ( pos == 1 ) out. p r i n t l n ( "Non sono stati inseriti numeri triangolari " ) ; out. p r i n t l n ( "Il triangolare maggiore sta alla posizione "+pos ) ; 3
6. Realizzate una gerarchia di classi per la rappresentazione di solidi geometrici. Tale gerarchia è costituita da una classe astratta Solido e da due classi concrete Cubo e Sfera, figlie di Solido. La classe concreta Cubo, oltre chiaramente a possedere il costruttore, deve avere i metodi getlato(), getvolume(), tostring(), equals(object o) dall ovvio significato. La classe concreta Sfera, oltre chiaramente a possedere il costruttore, deve avere i metodi getraggio(), getvolume(), tostring (), equals(object o) dall ovvio significato. La classe astratta Solido deve avere il metodo astratto getvolume() ed il metodo concreto havolumemaggiore(solido s) dall ovvio significato. Fate poi in modo che la gerarchia appena costruita implementi l interfaccia Comparable confrontando i solidi per volume. class Cubo extends S o l i d o { private double l a t o ; public Cubo( double x ) { l a t o = x ; public double getlato ( ) { return l a t o ; public double getvolume ( ) { return l a t o l a t o l a t o ; public S t r i n g t o S t r i n g ( ) { return "Lato = "+l a t o ; public boolean e q u a l s ( Object o ) { i f ( o i n s t a n c e Cubo ) { Cubo c = (Cubo) o ; return l a t o == c. l a t o ; return f a l s e ; class S f e r a extends S o l i d o { private double r a g g i o ; public S f e r a ( double x ) { r a g g i o = x ; public double getraggio ( ) { return r a g g i o ; public double getvolume ( ) { return 4.0/3 Math. PI r a g g i o r a g g i o r a g g i o ; public S t r i n g t o S t r i n g ( ) { return "Raggio = "+r a g g i o ; public boolean e q u a l s ( Object o ) { i f ( o i n s t a n c e S f e r a ) { S f e r a s = ( S f e r a ) o ; return r a g g i o == s. r a g g i o ; return f a l s e ; 4
abstract class S o l i d o implements Comparable { public abstract double getvolume ( ) ; public boolean havolumemaggiore ( S o l i d o s ) { return getvolume ( ) > s. getvolume ( ) ; public int compareto ( Object o ) { S o l i d o s = ( S o l i d o ) o ; i f ( getvolume ( ) > s. getvolume ( ) ) return 1 ; i f ( getvolume ( ) < s. getvolume ( ) ) return 1; return 0 ; 7. Sfruttando la gerarchia all esercizio precedente, scrivete un programma SolidiGeometrici che operi come segue: accetti a linea di comando un intero positivo che rappresenta la dimensione di un array A entro cui inserire cubi e sfere; stampi i solidi contenuti in A in ordine crescente di volume; stampi i solidi di volume maggiore import prog. i o. ; import prog. u t i l. GestioneArrays ; class S o l i d i G e o m e t r i c i { public s t a t i c void main ( S t r i n g [ ] a r g s ) { ConsoleInputManager i n = new ConsoleInputManager ( ) ; ConsoleOutputManager i n = new ConsoleOutputManager ( ) ; S o l i d o [ ] A = new S o l i d o [ I n t e g e r. p a r s e I n t ( a r g s [ 0 ] ) ] ; char r ; for ( int i = 0 ; i < A. l e n g t h ; i++ ) { do { r = i n. readchar ( "Cubo (c) o Sfera (s):" ) ; while ( r!= c && r!= s ) ; i f ( r == c ) A[ i ] = new Cubo( i n. readdouble ( "Lato:" ) ) ; A[ i ] = new S f e r a ( i n. readdouble ( "Raggio:" ) ) ; GestioneArrays. ordina ( A ) ; for ( int i = 0 ; i < A. l e n g t h ; i++ ) for ( int i = 0 ; i < A. l e n g t h ; i++ ) i f ( A[ i ]. getvolume ( ) == A[A. l e n g t h 1 ]. getvolume ( ) ) 5