Repaso de conceptos de clases



Descargar 29,83 Kb.
Fecha de conversión09.09.2017
Tamaño29,83 Kb.

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.
  • 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.
  • public Vagon() {
  • peso = 0;
  • }

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;
  • }
  • 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() {
  • return numMaq;
  • }
  • No recibe parámetros

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 uno;
  • String dos;
  • Objeto 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
  • *
  • * @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
  • Línea de espacio

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: public static int 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: 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: public void  print()  {}
  • Un método de tipo final no se puede sobreescribir.
  • Hijo: public double x;
  • Hijo: public static void  cling()  {} 
  • Hijo: public void  print()  {}

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
    • 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
  • modificadores de existencia
    • 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
    • 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
  • modificadores de existencia
    • 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:
    • 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 se cumpla antes de hacer algo..
    • 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.
  • Por convención se colocan los corchetes aún y cuando java acepte su omisión en caso de ser una sola línea

While (condición) {}

  • Formato:
    • 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;
    • }
  • 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)
  • Los corchetes no son necesarios si solo se va a ejecutar una instrucción
  • break es palabra reservada. Sirve para indicarle al programa que termine el ciclo

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
  • }
  • Donde usarse:
    • 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.
  • for usado comúnmente como retardador (delayer). El tiempo de retardo depende de la computadora en que se ejecute
  • for con la funcionalidad de un while. Mejor usa el while

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

  • Formato:
  • switch (variable) {
  • 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
  • }
  • }
  • 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.
  • No requiere break por ser el último

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:
      • EJEMPLO 1
      • public void metodo () {
      • try {
      • stdOut.println(“Escribe un número: ”);
      • int n = stdIn.readln();
      • }
      • catch (NumberFormatException nfe) {
      • status.setText(“Se genero error “+nfe.toString())
      • }
      • }
  • Metodo cualquiera que pide un número y lo guarda en la variable. La excepción se lanza si no se introduce algún número convertible a entero

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) {
      • try {
      • metodo(Integer.parseInt(tf1.getText()));
      • }
      • catch (MiExcepcion me) {
      • status.setText(me.toString());
      • }
      • }
  • metodo falla cuando n es negativo. El actionPerformed captura ese error y despliega en status.
      • Public class MiExcepcion extends Exception{
      • public MiExcepcion() {
      • super();
      • }
      • String toString() {
      • 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 Prueba {
  • private static PrintWriter stdOut = new PrintWriter(System.out, true);
  • 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();
  • }
  • }
  • public class Alumno {
  • String nombre;
  • public Alumno(String dato) {
  • nombre = dato;
  • }
  • 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 Prueba {
  • private static PrintWriter stdOut = new PrintWriter(System.out, true);
  • private Lista miLista;
  • public static void main(String args[]) throws IOException { miLista.add(new Alumno(“Juan”));
  • miLista.add(new Alumno(“Pedro”));
  • stdOut.println(ListaAlumnos.toString());
  • }
  • }
  • RESULTADO:
  • Juan
  • Pedro
  • public class ListaAlumnos extends LinkedList {
  • public String toString() {
  • String acum = “”;
  • ListIterator li = listIterator(0);
  • while (li.hasNext()) {
  • acum += li.Next().toString() + “\n”;
  • }
  • return acum;
  • }
  • }
  • 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.*
    • Ver ejercicio en: http://henry.carnegietech.org/~veerasam/ssd3/LinkedList/index.html
  • Uso de la clase Vector del java.util.*
    • 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-exam-samples/ssd3/




La base de datos está protegida por derechos de autor ©absta.info 2019
enviar mensaje

    Página principal