Download Repaso de conceptos de clases

Repaso de conceptos de clases
Preparado por Eduardo Olivares.
Definiendo un objeto.
Las siguientes son opciones válidas para definir un objeto de una
clase:
public Persona persona1; //con acceso para otras clases
private Persona persona1; //para uso exclusivo de la clase
Un arreglo:
public Persona[] personas;
Para asignar el objeto a la variable:
persona1 = new Persona();
personas = new Persona[100];
personas = new Persona[maxPersonas];
Se puede hacer al mismo tiempo
private Persona personas = new Persona();
private Persona[] personas = new Persona[maxPersona];
Creando un constructor

Es posible crear varios constructores para una misma
clase, que hagan algo dependiendo del tipo de parámetros
que reciben. Esto se llama polimorfismo.
public Vagon() {
peso = 0;
}
Recordar:
*NO lleva definición
Tipo de dato de entrada.
*El nombre del constructor es
el mismo que el de la clase.
*Los constructores accesan directamente
las variables de instancia. No se usan
métodos para asignar los valores.
Cambiando los valores de las variables
de instancia.
Normalmente los valores de las variables de instancia los
declararemos como private.
 Para cambiar el valor de una variable de instancia se usan
metodos mutadores:
public void setEdad(int edad) {

this.edad = edad;
}
ó
public void setEdad(int e) {
edad = e;
}
Si la variable local que se
recibe se llama igual que la
variable de instancia se usa el this.
Por convención los métodos
Se inician con minúscula y cada palabra
que define el método va con mayúscula.
No olvidar el void.
Regresando el valor de una variable
de instancia
Los métodos que regresan un valor de variable de instancia
se declaran usando el valor de retorno. Y de denominan
métodos accesores.
public int getNumMaq() {
No recibe parámetros
return numMaq;
}
Creando métodos de la clase

Asegúrate de reflejar el valor de retorno en la definición del
método y recibir los parámetros.
private boolean setAutores(int numAutores) {
if (numAutores <= maxAutores) {
this.numAutores = numAutores;
return true;
} else {
return false;
}
}
public boolean agregaAutor(String nombre) {
autores[numAutores] = new Autor(nombre);
return setAutores(numAutores + 1);
}
Regresando un objeto.

El siguiente código muestra un ejemplo de retorno con un
objeto.
public Persona masEdad() {
int posMax = 0;
for (int i = 0; i <= numPersonas; ++i) {
If (personas[i].getEdad() > personas[posMax].getEdad()) {
posMax=i;
}
}
return personas[posMax];
}
Mandando llamar a los métodos de
una clase.
int i = 0;
String titulo;
String nombre;
do {
stdOut.print("Dame el título del libro");
stdOut.flush();
libro[i].setTitulo(stdIn.readLine());
stdOut.print("Dame el número de páginas");
stdOut.flush();
libro[i].setPagina(Integer.parseInt(stdIn.readLine()));
do {
stdOut.print("Dame el nombre del autor");
stdOut.flush();
libro[i].agregaAutor(stdIn.readLine());
stdOut.print("Deseas ingresar otro autor s/n?");
stdOut.flush();
cont = stdIn.readLine();
} while (cont.equals("s"));
stdOut.print("Deseas ingresar otro libro s/n?");
stdOut.flush();
cont = stdIn.readLine();
++i;
} while (cont.equals("s"));
Trabajando con valores de retorno.
stdOut.printLn(“La persona de mayor edad, tiene”
+persona1.masPeso().getPeso());
El método masEdad() regresa un objeto de tipo Persona
El objeto Pesona tiene un método getEdad();
Separando la instrucción:
Persona p1 = persona1.masPeso();
int edad = p1.getPeso();
stdOut.printLn(“La persona de mayor edad, tiene” +edad);
Convenciones y documentación.



Seguir la convención para nombrar Clases: Primera letra mayúscula y
cada palabra seguida iniciando con mayúscula.- MiClaseEsLaMejor
Cada variable se declara en una sóla línea. El nombre de la variable debe
ser representativo, ej. Usar vector1 en vez de v.
Después del tipo de dato se usa tabulador
int
String
Objeto

uno;
dos;
tres;
La indentación es debe ser correcta, la clase va en el primer nivel, las
variables y clases se definen en un nivel más adentro:
public class Clase {
public Clase () {
}
public void metodo() {
}
}


Las llaves abiertas van en la misma linea del estatuto, las llaves cerradas
van a la altura del estatuto que cierran.
Un estatuto por línea.
Convenciones y documentación.

Formato del if:
if (condición) {
estatutos;
} else {
estatutos;
}

Debe haber un espacio entre las palabras reservadas y el paréntesis.
while(
while (

Linea en blanco entre métodos, después de los encabezados de métodos, entre las
variables y el primer estatuto del método.
public void espera() {
int i;
for (i = 0; i< 1000; i++) ;
return true;
}
Convenciones. Continua.

Espacios en blanco: después de las comas de parámetros, entre cada operador
(exceptuando el punto, ++, --), después de una palabra clave (keyword) y el
paréntesis. Ejemplos:
public int miMetodo (BufferedReader br, double inicio) {
double acum = inicio;
while (br.ready()) {
StringTokenizer st = new StringTokenizer(br.readLine());
a = Integer.parseInt(st.nextToken())
b = Integer.parseInt(st.nextToken())
c = Integer.parseInt(st.nextToken())
acum += ((double) a + (double) b) / ((double) c * (double) a);
}
return acum;
}
Documentación.




Lo primero en la clase son los paquetes.
Después de una línea en blanco se ponen los imports.
Después de los imports va una linea en blanco.
La clase está documentada.
/**
* Descripción
Línea de espacio
*
* @author Nombre
*/
public class MiClase {
}

Después de cada método hay una línea en blanco.

Cada método viene comentado según el siguiente formato:
/**
* Descripción
*
* @param parámetro descripción
* @throws excepción
* @return descripción
*/

Los elementos a resaltar como tipo de dato están entre etiquetas <code></code>
Herencia.
Para definir una clase que hereda a otra, se utiliza la
palabra extends:
public class ChildClass extends ParentClass
En el caso anterior la clase ChildClass se dice que es
extendida de la clase ParentClass.
En Java, una clase puede extender solamente una clase, esto
es, no se permite la herencia múltiple.
Si una clase se declara como final no puede tener
descendencia:
public final class CannotBeAParent
Todas las clases de java al instanciarlas se convierten en
objetos, esto es, son hijas de java.lang.Object.

Hidden vs Overriding
Campos ocultos.
Un campo o variable de instancia se dice que está oculta “hidden” si el hijo la
vuelve a definir. No es necesario que los tipos de datos coincidan.
Padre:
Hijo:
public static int x;
public double x;
Método oculto.
Un método definido como estático en el padre se dice que está oculto “hidden” si lo
vuelve a definir el hijo. La firma y valor de retorno debe coincidir o la compilación fallará.
Padre:
Hijo:
public static void cling() {}
public static void cling() {}
Para accesar un método oculto del padre se utiliza la palabra super().
Métodos sobreescritos.
Un método de instancia (no estático) en el padre se dice que está sobreescrito
“Overriding” y consecuentemente no heredado, si el hijo define su propio método de
instancia con la misma firma y tipo de dato. Si el hijo sobreescribe un método de
instancia y lo hace estático la compilación falla.
Padre:
Hijo:
public void print() {}
public void print() {}
Un método de tipo final no se puede sobreescribir.
Overriding vs Overloading
La sobreescritura “overriding” de un método significa definir un
método que fue heredado con la misma firma y valor de retorno.
En cambio la sobrecarga se relaciona más con el concepto de
polimorfismo que con el concepto de herencia. Y significa que un
método comparte diferentes implementaciones. Esto es un mismo
método tiene diferentes firmas. Por ejemplo:
public boolean equals(Account acc) {
return getName() == acc.getName() && getBalance() ==
acc.getBalance();
}
public boolean equals(Range r) {
return getLo() == r.getLo() && getHi() == r.getHi();
}
El método equals va a funcionar diferente dependiendo del tipo
de dato que se envie. Esto es el mismo método se comportará
diferente dependiendo del tipo de dato. Para hacer overloading es
necesario compartir los identificadores por los métodos de la clase
donde se desea este comportamiento.
Clases abstractas
Una clase abstracta contiene al menos un método abstracto, el cual
debe ser implementado por quien lo hereda. Una clase que tenga
al menos un método abastracto debe ser declarada abstracta.
Una clase abstracta se denota con el modificador abstract, como
se muestra en el ejemplo:
public abstract class Animal {
private int age;
private int energy;
...
public void increaseEnergy(int amount) {
energy += amount; }
...
public abstract void eat(int amount);
public abstract void sleep(int hours); ...
}
Una clase abstracta no puede ser instanciada:
Animal myAnimal = new Animal(); // incorrecto!
Una clase abstracta, a diferencia de una interfaz, sí incluye
comportamiento (métodos con contenido) además de los
métodos abstractos.
Concepto de: Interface
Una interfaz es como una clase abstract en el sentido de que
puede tener métodos que no están implementados
(métodos abstract).
Sin embargo, y a diferencia de las clases abstract, todos los
métodos de la interfaz deben ser public y abstract.
Por cuestiones de estilo, estos modificadores no se
mencionan explícitamente en los métodos. De la misma
manera que las clases, las interfaces también pueden
tener campos de datos. Todos los campos de datos de una
interfaz son implícitamente public, static, y final.
Para definir una interfaz se usa el interface:
public interface miInterfaz {
Para utilizar una interfaz se usa el implements:
public class MiClase implements miInterfaz {
Paquetes
Un paquete es un conjunto de clases relacionadas.
Normalmente, cada clase reside en su propio archivo. Por
lo tanto, un paquete es análogo a un directorio en el
sentido de que es un conjunto de archivos relacionados.
A fin de tener acceso por default a una clase estas deben
estar en el mismo paquete.
La forma de definir un paquete es la siguiente:
package miPaquete;
Para utilizar un paquete se debe incuir un import:
import miPaquete.*;
Modificadores Java
Modificadores para Campos:
 modificadores de acceso





modificadores de existencia


public – se puede tener acceso a él desde cualquier parte
desde donde la clase que lo contiene pueda accesarse
protected – puede accesarse solamente desde adentro de su
clase, desde clases del mismo paquete donde está su clase y
por subclases de su clase
default (no se especifica el acceso) – puede accesarse
solamente desde adentro de su clase y por clases del mismo
paquete de su clase
private – pueden accesarse solamente desde adentro de su
clase
static – existe uno para toda la clase, en lugar de uno para
cada objeto de su clase
modificadores de uso

final – no puede modificarse (i.e., constante o de sólo lectura)
Modificadores Java
Modificadores para Métodos:
 modificadores de acceso





modificadores de existencia


public – se puede tener acceso a él desde cualquier parte desde
donde la clase que lo contiene pueda accesarse
protected – puede accesarse solamente desde adentro de su clase,
desde clases del mismo paquete donde está su clase y por subclases
de su clase
default (no se especifica el acceso) – puede accesarse solamente
desde adentro de su clase y por clases del mismo paquete de su
clase
private – pueden accesarse solamente desde adentro de su clase
static – existen para servir a su clase y no para servir a objetos
individuales de su clase; como consecuencia, los métodos static no
tienen acceso a variables de instancia ya que éstas pertenecen a los
objetos individuales, aún más, estos métodos no tienen acceso a this
ni a super.
modificadores de uso


final – no puede sobreescribirse
abstract – debe sobreescribirse para que sea útil
Modificadores Java
Modificadores para Clases:
 modificadores de acceso



public – se puede tener acceso a ella desde cualquier clase
default (no se especifica su acceso) – puede accesarse desde
adentro de cualquier clase de su mismo paquete, esto es, A
fin de tener acceso por default a una clase, estas deben estar
en el mismo paquete.
modificadores de uso


final – no puede extenderse(heredada)
abstract – debe extenderse (heredada) para que sea útil
If (condición) { } else { }

Formato:
Por convención se colocan los
corchetes aún y cuando java acepte su
omisión en caso de ser una sola línea
if (variable > 5) {
//Código que se ejecuta
} else {
//Aquí va lo que se debe hacer cuando la no fue mayor que 5
}

Donde usarse:




Para validar que condición
cumpla
antes
de hacer
algo..
El se
ELSE
(si no)
puede
omitirse
En la toma de decisiones, por ejemplo, para realizar algo ede acuerdo
al botón que haya sido presionado en un programa.
El único típo de dato válido para una condición de un if, es el boolean.
Formato alterno:


(condición) ? Valor que toma la expresión si es verdadero : Valor que
toma la expresión si es falso
Ej. return (a < 0) ? –1 : 0; //regresa –1 si el número es negativo, 0
en otro caso.
While (condición) {}

Formato:
Los corchetes no son
necesarios si solo se va a
ejecutar una instrucción
while (varible > 5) {
// Aqui se pone todas las instrucciones que se requieren
ejecutar mientras expresión regrese TRUE (que la condición
se cumpla)
}

Caso especial:
while (true) {
// Instrucciones a ejecutar
if (Variable > 5)
break;
}

break es palabra reservada.
Sirve para indicarle al
programa que termine el ciclo
Donde usarse:


Cuando se requiere repetir las instrucciones de un programa
hasta que ocurra algo (que expresión retorne FALSE)
Donde no se sabe cuantas veces se ejecutará cierto código
(que incluso puede no ejecutarse)
For (inicialización, condición,
modificador) {}
Formato:
for (int i = 0; i < 5; ++i) {
// Instrucciones a ejecutar
}
 Casos especiales:
for (int i = 0; i < 5000000; ++i) ;

for ( ; i < 5; ) {
// Instrucciones a ejecutar
}

for con la funcionalidad de un
while. Mejor usa el while
Donde usarse:





for usado comúnmente como
retardador (delayer). El tiempo
de retardo depende de la
computadora en que se ejecute
Cuando se requiere repetir las instrucciones de un programa hasta que ocurra
algo (que expresión retorne FALSE)
Se conoce de antemano el número de veces que se ejecutará por la naturaleza
de la condición
Recuerda que el for se puede ejecutar desde cero veces hasta un número
infinito (se cicla si la condición nunca se cumple).
Recuerda que la variable que se define en el ciclo (ej. i) sólo es accesible al
ciclo y no al resto del cuerpo del programa
Nota:

Muchas veces el while y for pueden ser usados indistintamente. Elije la que
más convenga recordando que el for tiene capacidad para manerar una variable
contadora más cómodamente.
Do { } while (condición);
Formato:
do {
//Instrucciones a ejecutar
}
while (variable > 5); //No olvides el punto y coma;
 Caso especial:
do {
if (variable > 5)

break;
}
while (true);
 Donde usarlo:

Donde se requiere que un ciclo se ejecute al menos una vez
sin importar lo que regrese la condición.
Switch
Si no se pone el break el switch
 Formato:
se sigue y prueba los demas
switch (variable) {
casos
case 3: { //Codigo para cuando la variable vale 3
break;
}
case 5: { //Codigo para cuando fue 5
break;
}
default: { //Codigo cuando la variable no fue ni 3 ni 5
}
}
No requiere break por ser el
último
 Donde usarlo:


Donde se requieren de varios ifs anidados. Por ejemplo, en
programas con muchos botones y widgets con ActionListener para
identificar el elemento presionado.
La variable del switch es entera.
Excepciones




Una de las mayores ventajas es el manejo de excepciones.
Se generan o lanzan (throw) comúnmente cuando el
usuario introduce datos no esperados por el programa o el
propio programa a fin de evitar problemas mayores.
Las excepciones pueden ser manejadas por el
programador (catch) o por el compilador.
Ejemplo de excepciones manejadas por el programador:
Metodo cualquiera que pide un número
• EJEMPLO 1
y lo guarda en la variable. La
public void metodo () {
excepción se lanza si no se introduce
try {
algún número convertible a entero
stdOut.println(“Escribe un número: ”);
int n = stdIn.readln();
}
catch (NumberFormatException nfe) {
status.setText(“Se genero error “+nfe.toString())
}
}
Excepciones
• EJEMPLO 2
public void actionPerformed(ActionEvent e)
try {
StringTokenizer st = new StringTokenizer(tf1.getText(), “_”)
String nombre = st.nextToken();
while (st.hasMoreTokens()){
calificaciones.add((int) (st.nextToken()))
//calificaciones es un vector
}
}
catch (NoSuchElementException nsee) {
//Introducir código para cuando no se introdujeron elementos
}
catch (NumberFormatException nfe) {
//Instrucciones para cuando no se tienen enteros donde deben
}
}
tf1 es un textfield que al ocurrir algún
ActionEvent, debe tener algo con formato:
Nombre_86_75_90
Excepciones
• EJEMPLO 3
public void metodo (int n) throws MiExcepcion {
if (n < 0) {
throw new MiExcepcion();
}
private void actionPerformed(ActionEvent e) {
Public class MiExcepcion extends
Exception{
try {
metodo(Integer.parseInt(tf1.getText()));
public MiExcepcion() {
}
catch (MiExcepcion me) {
status.setText(me.toString());
}
super();
}
}
String toString() {
metodo falla cuando n es
negativo. El actionPerformed
captura ese error y despliega
en status.
return “Se recibió un número
negativo”;
}
}
Diseño de Objetos



Al crear clases instanciables en Java, es necesario definir
ciertos métodos que son comunes y que están
contemplados implementarse por ser clases hijas de
Object.
Tal necesidad no solo se debe a cuestiones de estándar,
sino a que ciertas clases contenedoras (como Vector)
hacen uso de estos métodos de los objetos.
Tales métodos son:


public boolean equals(Object obj)
public String toString()
Nota: Se pueden definir más métodos (como el notify u
otros) según convenga. Para ver los métodos comunes a
todos los objetos, verifica la información de la clase
java.lang.Object.
Diseño de Objetos: equals() y
toString()
import java.io.*;
public class Alumno {
public class Prueba {
String nombre;
private static PrintWriter stdOut = new
PrintWriter(System.out, true);
public Alumno(String dato) {
nombre = dato;
public static void main(String args[]) throws IOException {
}
miObjeto m = new miObjeto(“Casa”);
miObjeto n = new mObjeto(“Plato”);
stdOut.println(“El Objeto m es “ + m.toString());
stdOut.print(“ El Objeto m “);
if (m.equals(n)) {
stdOut.print(“Los objetos son iguales “);
} else {
stdOut.print(“Los objetos son diferentes”);
stdOut.flush();
}
}
El criterio de igualdad
es que los Strings
nombre sean iguales
public String toString() {
return nombre;
}
public boolean equals(Object obj) {
if (obj instanceof Alumno) {
Alumno alumno = (alumno) obj
return
toString().equals(alumno.toString());
} else {
return false;
}
Diseño de Objetos: equals() y
toString()
import java.io.*;
public class ListaAlumnos extends LinkedList
{
public class Prueba {
public String toString() {
private static PrintWriter stdOut = new
PrintWriter(System.out, true);
private Lista miLista;
String acum = “”;
ListIterator li = listIterator(0);
while (li.hasNext()) {
acum += li.Next().toString() + “\n”;
}
public static void main(String args[]) throws IOException
{
miLista.add(new Alumno(“Juan”));
miLista.add(new Alumno(“Pedro”));
stdOut.println(ListaAlumnos.toString());
}
return acum;
}
}
}
RESULTADO:
Juan
Pedro
Regresa el string
acumulado.
BufferedReader
Ejemplos de manejo de BufferedReader, para archivo y para
un String:
BufferedReader br = new BufferedReader(new
FileReader("nombrearchivo.dat");
while (br.ready()) {
//hace algo con br.readLine();
}
BufferedReader br = new BufferedReader(new
StringReader(miClase.toString());
String linea = br.readLine();
while (linea != null) {
//hace algo con linea
linea = br.readLine();
}
StringTokenizer
Es importante tener en cuenta que si se desea usar un
StringTokenizer en una aplicación que está usando interfaz
gráfica, se indique directamente la librería a la que
pertence:
java.util.StringTokenizer st = new java.util.StringTokenizer(miObjeto.toString(),
"\n");
while (st.hasMoreTokens()) {
//hace algo con st.nextToken()
}

Uso del StreamTokenizer: Recordar que a diferencia del
StringTokenizer, regresa el dato con el casting, ya sea
double o String.
Otros temas




Repasa la tarea 9 de DowJones.
Repasa el examen práctico de la unidad 3
Uso de la clase Nodo y LinkedList.
Uso de la clase LinkedList del java.util.*


Uso de la clase Vector del java.util.*


Ver ejercicio en:
http://henry.carnegietech.org/~veerasam/ssd3/LinkedList/ind
ex.html
Ver ejercicio en:
http://henry.carnegietech.org/~veerasam/ssd3/Vector/index.
html
Realiza el examen de práctica de certificación:
https://henry.carnegietech.org/~bufano/ssl/cert-examsamples/ssd3/