APRENDIENDO JAVA: EJEMPLOS DE PROGRAMAS
|
|
Tema 3: Objetos y clases
En esta sección definiremos clases y métodos de clases. Veremos que una clase
puede tener varios
constructores con el mismo nombre y que normalmente definiremos sus campos de tipo
private para que sólo sean accesibles por los métodos de la propia clase.
Trabajaremos con las clases String y ArrayList propias
de Java y con algunos de su métodos como format y split.
Para interactuar con el usuario emplearemos el paquete Scanner para leer y escribir en la consola.
También trataremos algunas excepciones y, obviamente, emplearemos las estructuras básicas (tipos primitivos, bucles
for, while, switch, if / else...
PROBLEMA 1
Se quiere imprimir una matriz bidimensional de números comprendidos entre 0 y 999. La forma básica de imprimir cada número podría provocar que la matriz no esté alineada, por ejemplo:
1 23 456 789
234 56 782 123
1 2 3 123
Queremos que la matriz quede alineada utilizando 0's:
001 023 456 789
234 056 782 123
001 002 003 123
Examinar la documentación del método format de la clase String de Java para escribir una
rutina que imprima en el formato indicado.
Ver código
En la web de Oracle
encontramos la información necesaria. Tenemos el ejemplo para un objeto Calendar c:
String s = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c);
1 public static void toString(int [][] mat)
2 {
3 String s="";
4 int f = mat.length;
5 int c = mat[1].length;
6
7 for( int i=0; i<f; i++)
8 {
9 s+="\n";
10 for (int j=0; j<c; j++)
11 {
12 int m=mat[i][j];
13 if (0<=m && m<10)
14 s+= String.format("00%1$1s", m);
15 else
16 if (m<100)
17 s+=String.format("0%1$2s", m);
18 else
19 s+=String.format("%1$1s", m);
20 s+=" ";
21 }
22
23 }
24 System.out.println(s);
25 }
Observaciones:
-
Escribimos sólo el método.
-
Entradas: una matriz de enteros (un array de enteros).
Se presupone que los enteros están en el rango 0-999.
-
Salida: el método es de tipo void, por lo que no
no devuelve nada. Sólo imprime la matriz con el formato especificado.
-
El algoritmo del método es sencillo: para cada fila de la matriz mat se amplia
el String s. Como sabemos que en cada posición de la matriz hay un entero, sólo tenemos
que saber si es de 1, 2 ó 3 cifras para añadir 2, 1 ó 0 ceros.
-
Los dos bucles anidados son los típicos para al acceso a una matriz.
PROBLEMA 2
Implementar la clase Polynomial para representar polinomios de una sola variable
y escribir un programa de pruebas. La funcionalidad de la clase Polynomial es
la siguiente:
-
proporciona al menos tres constructores: uno de cero parámetros que
hace que el polinomio sea cero, uno que crea una copia independiente de un
polinomio existente y otro que crea un polinomio basado en una especificación
String. Este último constructor puede generar una excepción si la
especificación String no es válida (que el lector elija la
especificación que sea válida).
negate devuelve el negado del polinomio que se proporciona
como parámetro.
-
add y substract devuelven nuevo polinomio
que es igual a la suma y diferencia, respectivamente, de dos polinomios que
se proporcionan como parámetro. Ninguno de estos métodos han de modificar los
polinomios originales.
-
el polinomio está representado por dos campos: degree, que representa el
grado del polinomio; y coeff, representa los coeficientes (el elemento de la posición k es el
coeficiente de xk ).
Ver código
Consideraciones previas:
-
Como no se especifica, los campos de la clase Polynomial serán degree de tipo
int y coeff de tipo ArrayList<Double>.
Las razones por las que elegimos este tipo para coeff es que al ser un ArrayList de
doubles, los coeficientes pueden ser números reales. Elegimos ArrayList porque
tiene una mayor flexibilidad que los array, especialmente por su capacidad de
expansión dinámica.
Añadimos el método crear para crear nuevos polinomios a través del terminal (Scaner). Este método
pregunta por el grado del polinomio y por sus coeficientes
(ordenados de grado menor a mayor).
-
Para el tercer constructor que se pide en el enunciado, por simplicidad, escogemos
que la forma del String sea sólo el conjunto de los coeficientes del polinomio
que se desea crear, incluyendo los coeficientes que son 0, de grado menor a mayor.
Mostraremos el código por partes para hacer algunos comentarios.
La estructura de la clase es la siguiente:
1 import java.util.Scanner;
2 import java.util.ArrayList;
3 public class Polynomial
4 {
5 private int degree;
6 private ArrayList coeff;
7
8 public Polynomial()
9 {
10 degree = 0;
11 coeff = new ArrayList();
12
13 coeff.add(0.0);
14 }
15
16 public Polynomial (String coefi)
17 {
18 //Omitimos código
19 }
20
21 public Polynomial (int deg, ArrayList coe)
22 {
23 //Omitimos código
24 }
25
26
27 public Polynomial (Polynomial p)
28 {
29 //Omitimos código
30 }
31 public static Polynomial copy (Polynomial a)
32 {
33 //Omitimos código
34 }
35 public static Polynomial crear ()
36 {
37 //Omitimos código
38 }
39
40 public static Polynomial add (Polynomial a, Polynomial b)
41 {
42 //Omitimos código
43 }
44
45 public static void negate (Polynomial a)
46 {
47 //Omitimos código
48
49 }
50
51 public static Polynomial substract(Polynomial a, Polynomial b)
52 {
53 //Omitimos código
54 }
55
56 public static String toString (Polynomial p)
57 {
58 //Omitimos código
59 }
60
61 public static void main (String [] args)
62 {
63 //Omitimos código
64 }
65 }
Comentarios:
-
Las líneas 1 y 2 son las directivas para los paquetes que vamos a usar
para poder trabajar con ArrayList<.> y con Scanner (entrada/salida).
En las líneas 5 y 6, los dos campos de la clase Polynomial,que
son degree y coeff,
se declaran como private, lo que significa que sólon pueden acceder a ellos los
métodos de la clase Polynomial.
-
En la clase tenemos 4 constructores y 6 métodos (uno de ellos es el main). Los métodos son los que
empiezan con public static.
Los argumentos de los cuatro constructores son: ninguno; un String coefi; un
int deg y un ArrayList<Double> coeff; y un Polynomial p.
Según el número y tipo de parámetros que se utilicen (argumento), se utilizará utilizará
un constructor u otro.
Los códigos de los constructores son:
1 public Polynomial()
2 {
3 degree=0;
4 coeff = new ArrayList<Double>();
5 coeff.add(0.0);
6 }
Si no se proporciona ningún parámetro, se crea el polinomio nulo. Por tanto,
el grado tiene que ser 0 y el único elemento de coeff también.
Notemos que el ArrayList coeff tiene que crearse ya que no es un
tipo primitivo.
1 public Polynomial(String coefi)
2 {
3 String [] arr = coefi.split("\\s");
4 double k;
5 coeff = new ArrayList<Double>();
6
7 for(int i=0; i<arr.length; i++)
8 {
9 try
10 {
11 k = Double.parseDouble(arr[i]);
12 coeff.add(k);
13 }
14 catch (NumberFormatException e)
15 {
16 System.out.println("A non-double was encountered");
17 }
18 }
19 degree = coeff.size()- 1;
20 }
-
Este constructor es quizás el más complicado por tratar con un
String.
Lo que hacemos es crear un vector de String en la línea 3 con el
método split() que proporciona la clase String. Lo que hace el método es
guardar en el vector cada uno de los elementos separados por un espacio ("\\s") en la
cadena.
Como estos elementos son los coeficientes, tenemos que guardarlos en coeff, pero
han de ser de tipo double. Por ello tenemos un try en la línea 9: si
el elemento del vector no se puede tratar como un double, se genera la excepción
NumberFormatException que muestra un mensaje por pantalla.
1 public Polynomial(int deg, ArrayList<Double> coe)
2 {
3 degree = deg;
4 int a = coe.size();
5 coeff = new ArrayList();
6
7 for(int k=0; k<a; k++)
8 coeff.add(coe.get(k));
9 }
Este constructor es muy sencillo: lo único que hacemos es crear una clase cuyos campos
ya conocemos. Como es habitual, el ArrayList lo copiamos elemento a elemento.
Los métodos get(), set() y add() son los propios de la clase
ArrayList.
1 public Polynomial(Polynomial p)
2 {
3 degree = p.degree;
4 ArrayList coeff = new ArrayList();
5
6 for(int k=0; k<p.coeff.size(); k++)
7 coeff.add(p.coeff.get(k));
8 }
Ahora mostramos los códigos de los métodos, pero no los comentaremos debido a su simplicidad:
1 public static Polynomial copy (Polynomial a)
2 {
3 Polynomial cop = new Polynomial(a);
4 return cop;
5 }
1 public static Polynomial crear ()
2 {
3 int dg;
4 Polynomial crear;
5 ArrayList<Double> coe = new ArrayList();
6
7 System.out.println(Introducir grado:");
8 Scanner in = new Scanner (System.in);
9 dg = in.nextInt();
10
11 System.out.println("Coeficientes de menor a mayor:");
12 Scanner in2 = new Scanner (System.in);
13
14 for(int i=0; i<=dg; i++)
15 coe.add(in2.nextDouble());
16 crear = new Polynomial(dg, coe);
17 return crear;
18 }
1 public static Polynomial add (Polynomial a, Polynomial b)
2 {
3 Polynomial ad = new Polynomial();
4 int aS = a.coeff.size();
5 int bS = b.coeff.size();
6 int max = Math.max(aS,bS);
7
8 ad.degree = max-1;
9 ad.coeff.set(0,a.coeff.get(0)+b.coeff.get(0));
10 for(int i=1; i<=max; i++)
11 ad.coeff.add(0.0);
12 for(int i=1; i<aS; i++)
13 ad.coeff.set(i, ad.coeff.get(i)+a.coeff.get(i));
14 for(int i=1; i<bS; i++)
15 ad.coeff.set(i, ad.coeff.get(i)+b.coeff.get(i));
16 return ad;
17}
1 public static void negate (Polynomial a)
2 {
3 for(int i=0; i<=a.degree; i++)
4 a.coeff.set(i,-1*a.coeff.get(i));
5 }
1 public static Polynomial substract(Polynomial a, Polynomial b)
2 {
3 Polynomial subs;
4 negate(b);
5 subs = add(a,b);
6 return subs;
7 }
1 public static String toString (Polynomial p)
2{
3 String str="";
4 int pS = p.degree;
5
6 if (pS==0)
7 str=Double.toString(p.coeff.get(0));
8 else
9 {
10 for(int i=pS; i>=0; i--)
11 if(p.coeff.get(i)!=0)
12 {
13 if(i!=pS)
14 str+=" + ";
15 str+=Double.toString(p.coeff.get(i));
16
17 switch (i)
18 {
19 case 0:
20 break;
21 case 1:
22 str+="x";
23 break;
24 default:
25 str+="x^"+Integer.toString(i);
26 break;
27 }
28 str+=" ";
29 };
30 }
31 return str;
32}
1 public static void main (String [] args)
2 {
3 Polynomial pol, pol2, pol0, ad;
4
5 System.out.println("Polinomio 1:");
6 pol = crear();
7 System.out.println(toString(pol));
8 System.out.println("------------");
9
10 System.out.println("Polinomio 2:");
11 pol2 = crear();
12 System.out.println(toString(pol2));
13 System.out.println("------------");
14
15
16 System.out.println("\n");
17 System.out.println("La resta de ambos polinomios es");
18 System.out.println(toString(pol));
19 System.out.println("\n - \n");
20 System.out.println(toString(pol2));
21 System.out.println("___________\n");
22 ad = substract(pol,pol2);
23 System.out.println(toString(ad));
24
25 }
Como comentario final diremos que en ocasiones necesitamos que una función (un método) devuelva
varios valores. Esto es imposible en Java, pero una método sí puede devolver un objeto formado
por varios campos (como por ejemplo un Polynomial ). Por tanto, si necesitamos un método
que devuelva varios elementos, podríamos crear una clase para ello.
Volver al índice de temas
Matesfacil.com by J. Llopis is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.