Apuntes PROII

Normalmente, las constantes son de tipo “static”, porque queremos que la compartan todos los
objetos de la clase. Los métodos “static” son de la Clase, no de los objetos.
-El método ‘trim()’ elimina los espacios en blanco en ambos extremos del string.
-El método ‘String.valueOf(dni)’ convierte el parámetro pasado a String.
‘Integer.toString(dni)’
// este método tamb
String cuco=”Hola”;
int longitud=cuco.length();
-El método ‘charAt()’ devuelve la letra correspondiente a la posición que le pasemos. Devuelve
un char.
-El método equals() devuelve true si dos cadenas son iguales s2.equals( s3 )
*Un objeto de la clase String es inmutable, no puede cambiar aplicándole sus propios métodos.
Tienes que apuntarle al mismo objeto s = s.trim()
*Un objeto de la clase StringBuilder NO es inmutable, puede cambiar aplicándole sus propios
métodos.
-Los métodos estáticos no van a poder acceder a los atributos de cada objeto, porque
pertenece a la Clase como tal.
int x = Integer.parseInt("9");
double c = Double.parseDouble("5");
// estos métodos arrojan la excepcion
NumberFormatException e
EXCEPCIONES
Cuando se produce un error en un método, el método crea un objeto y lo pasa al sistema de
ejecución. El objeto (objeto excepción) contiene información sobre el error, incluyendo su tipo y
el estado del programa cuando se produjo el error.
Crear un objeto de excepción y pasárselo al sistema de ejecución se denomina lanzar una
excepción.
En las excepciones hay 2 procesos: se lanza el error y se captura para responder al error. El
‘lanzar’ lo va a hacer automáticamente el sistema o lo podemos lanzar nosotros también. La
captura la tenemos que programar.
Excepciones NO Controladas -> se lanzan automáticamente por el sistema, sin necesidad de
que hagamos nada (no hay necesidad de poner ‘throws’ en la cabecera del método, ni tampoco
lanzar un ‘throw new’).
Excepciones Controladas -> las lanzamos nosotros como programadores
Siempre, cuando se ha capturado una ‘excepción’ en un bloque catch, el programa continúa
después del catch que capturó la excepción, NO volvemos adonde se ha producido el error, o sea
las sentencias después del ‘throw new’ NO se ejecutan.
Normalmente en el ‘main’ siempre es bueno tener un ‘’try,catch” ; aunque se pueden tener en
los propios métodos también(échale un vistazo al proyecto).
Usando la estructura while sólo se pasa a ejecutar su contenido si se comprueba una condición lo
que puede ocurrir 0, 1 o más veces. Do While funciona de forma similar, sólo que nos aseguramos de que
el contenido sea ejecutado al menos una vez, es decir que aunque su condición no se cumpla, su
contenido se ejecuta.
String nombre;
// Java no los inicializa. Ni a “”, ni a 0 en caso de enteros
int numero;
int [] matriz=new int [4];
// Sin embargo Java inicializa todas las posiciones de
un array a 0.
String [] matrizz=new String [4];
// Los Strings, al ser objetos; Java los inicializa a ‘null’
Si yo invoco desde un método ( ejemplo: un método toString() ), otro método que puede
lanzar una excepción ( ejemplo: get( i ) ); puedo meter el try..catch en el método toString().
Para leer los valores del teclado, la profe crea un método :
‘ public static Coche leerCoche() {…} ’
Main.
en la misma clase donde se encuentra el método
En el método Main para crear el objeto hacemos:
Coche coche1 = leerCoche();
Si tengo declarada la plantilla del enum en una clase Coche
public class Coche {
public static enum Tipo { MONOVOLUMEN, FAMILIAR, COMPACTO, BERLINA ,
CAMIONETA };
…
…}
en el método main para usar el método values() de los enumerados tendría que poner
Coche.Tipo[] mamerto=Coche.Tipo.values();
A la hora de pedir datos en un formulario, me puede dar el número de la opción
correspondiente, teclear el string de la opción en sí, o teclear un carácter inicial de alguna de
las opciones. (Leer como número, o leer como cadena son más recomendables, pues en caso de
necesitar añadir más categorías al enumerado, no tendríamos que tocar más nada en el código).
El método ‘valueOf()’ de los enumerados te permite convertir un string en una de las
opciones del enumerado(pero el string debe coincidir exactamente con una de las opciones del
enumerado.)
Coche.Tipo ferrari;
ferrari=Coche.Tipo.valueOf("MONOVOLUMEN");
Puedo tratar diferentes excepciones localmente dentro de un método sin necesidad de
arrojarla fuera, pero para ello no puedo poner el ‘throws’ en la cabecera del método.
En las excepciones poner primero siempre las más específicas y abajo la más general. La
Clase Exception siempre irá al final, porque es la más general y engloba a todas las demás.
try{
leerNumeros();
//
5 , 6 , 1 , 0 , 2 , 3 = 17
}
catch (NumberFormatException e){
System.err.println("Formato Erróneo : " + e.getMessage());
}
catch (Exception e){
System.err.println("No puedes poner ni 0 ni número negativo : " +
e.getMessage());
}
IOException (hereda de Exception) -> es un tipo de excepción ‘Controlada’ , o sea que la
lanza el programador. Sirve para indicar que se ha producido una excepción de E/S.
String cad;
cad =String.format( "’%6.2f’\n", 5.6 );
System.out.print(cad);
*El bloque finally se ejecutará tanto si se tira la excepción como sino.
System.out.println("Hola Mundo");
//El ‘out’ y el ‘err’
System.err.println("Error Mundo");
//son objetos de tipo
//PrintStream
La filosofía es que si se captura el error(catch) ; le demos otra
oportunidad al usuario. El try-catch tendría que estar dentro de
un bucle ‘do while’ ó ‘while’.
&
evalúa ambos lados de la operación.
&& evalúa el lado izquierdo de la operación, si es true continúa y evalúa el lado derecho.
Si le pongo ‘final’ a un objeto (dígase de tipo StringBuilder, o de tipo array); no puedo hacer que ese objeto
apunte a otro, pero si podría modificarlo internamente o a través de sus métodos.
// el append también se puede encadenar
// toret.append("Cliente ").append(getNombre()).append(" con DNI ").append(getDni());
// en el throw new Exception puede haber un mensaje entre paréntesis
if (getNumClientes() >= maxClientes) {
throw new Exception ("inserta(): sobrepasa max.: " + maxClientes);
}
Importante: cuando un método llama a otro y este llama a otro y así hasta el último, si en este
último arrojo una excepción (‘throw new Exception()’), y quiero propagar la excepción hasta el
primer método inicial que empezó la llamada en cascada ; debo ir poniendo en la cabecera de cada
método intermedio ‘throws’ sin necesidad de try-catch. Así propagamos la excepción hasta el
método donde queramos tratarla con un try-catch.
En el proyecto, la profe reconduce todos las excepciones a tratarlas en el método public
void ler(); que es dónde se originan todas las llamadas a métodos que luego arrojan
excepciones.
-Podemos definir la herencia como la capacidad de crear clases que adquieren de
manera automática los miembros (atributos y métodos) de otras clases que ya existen, pudiendo al
mismo tiempo añadir atributos y métodos propios.
-A veces, un método de la superclase vale para todas las clases que heredan de ella, en ese
caso, las subclases no tienen que sobrescribir ese método en su cuerpo. Lo podrían invocar aunque
no aparezca declarada en el cuerpo de la subclase, ya que lo heredan de su clase padre.
- Una subclase puede sobrescribir un método de su clase padre, adaptándolo a sí misma.
-El constructor para la superclase construye la porción de la superclase del objeto, y el
constructor para la subclase construye la parte de la subclase.
-Los atributos declarados ‘private’ en la superclase, NO son accesibles desde las clases que
heredan de ella. Para acceder a ellas, debemos implementar ‘getters’ y ‘setters' públicos en la
superclase.
OJO: cualquier clase hereda de la clase Object de Java. Por eso una clase que nosotros
creemos puede usar el método ‘toString()’ sin necesidad de haber reescrito el método. Pero claro,
te devolverá algo ininteligible, devolverá una especie de puntero a un espacio de memoria. Por eso
se reescribe en cada clase, para que se adapte a cada clase.
Enlace tardío en el UPCASTING  es cuando habiendo convertido los objetos de la subclase a objetos de la
superclase: ej:
ArbolGeneral <Integer> arbol = new EnlazadoArbolGeneral <Integer>(-1);
El compilador sabe distinguir cuál es el método sobrescrito que le corresponde a cada objeto en dependencia del
tipo de subclase que es, aunque este objeto se trate como superclase.
Si bien siempre es seguro tratar de apuntar a una subclase con una referencia a la superclase, lo
contrario no lo es (DOWNCASTING). Pero puede ser útil saber si una figura general es un círculo o un
rectángulo:
if ( f instanceof Rectangulo ) {
System.out.format( "%s, superficie: %.2f\n",f, f.calculaArea() );
};
Una clase que hereda de otra no necesariamente tiene que sobrescribir todos los métodos de su clase
padre. Puede ser que algunos métodos le sirvan tal cual están implementados en la clase padre. O sea que
puede usar métodos de su clase padre sin necesidad de reescribirlos si estos le sirven a su propósito.
-Si no quiero que se creen instancias de la superclase (‘Figura’), sólo de las subclases
(‘Rectángulo’, ’Círculo’, etc.) tengo que declarar esa superclase como abstracta
(‘abstract class Figura{…}’).
OJO - una clase abstracta puede tener atributos y métodos, NO es una interface
HE AQUÍ CÓMO SE USA EL CONSTRUCTOR super() que es de la superclase.
El enlace dinámico lo usarán los métodos de las diferentes clases que heredan de la misma
superclase, que tienen el mismo nombre.
Ej: los
@Override
public double calculaArea(){…}
// de cada figura en concreto que hereda de la superclase Figura
los otros métodos propios de cada subclase se pueden poner como ‘public final’.
En la composición hay dos opciones. Si una clase ‘Publicación’ tiene como atributo un objeto de la clase ‘Autor’;
podría pasarle al constructor de ‘Publicación’ una referencia externa de un autor ya creado en el método ‘Main’ , o la
opción menos convencional -> crearlo dentro del propio constructor sin que haga falta incluir un campo Autor en la
cabecera del constructor.
OJO: si inicializas un ArrayList así --- ArrayList<Integer> a=new ArrayList<>(10);
No significa que el ‘a.size ()’ te va a dar 10.
El ‘.size()’ dará la cantidad de elementos que le añadas.
a.add(1);
a.add(2);
//// 3 elementos en este caso
a.add(3);
Por cierto el ArrayList tiene ‘toString()’ ,
para que dejes de poner ‘for’ para mostrar todos
los elementos.
El ‘add’ en ArrayList, añade un elemento
corriendo un espacio a los elementos que están a
su derecha. El ‘set’ es el que sirve para modificar.