practica 1(polimorfismo)

Polimorfismo

El concepto de Polimorfismo es uno de los fundamentos para cualquier lenguaje orientado a Objetos, las mismas raíces de la palabra pueden ser una fuerte pista de su significado: Poli = Multiple, morfismo= Formas , esto implica que un mismo Objeto puede tomar diversas formas.
El poder manipular un Objeto como si éste fuera de un tipo genérico otorga mayor flexibilidad al momento de programar con Objetos, el término Polimorfismo también es asociado con un concepto llamado Late-Binding (Ligamiento Tardío),
EJEMPLO:

import java.util.*;

class Instrumento {
    public void tocar() {
 System.out.println("Instrumento.tocar()");
    }
    public String tipo() {
 return "Instrumento";
    }
    public void afinar() {}
}

class Guitarra extends Instrumento {
    public void tocar() {
 System.out.println("Guitarra.tocar()");
    }
    public String tipo() { return "Guitarra"; }
    public void afinar() {}
}

class Piano extends Instrumento {
    public void tocar() {
 System.out.println("Piano.tocar()");
    }
    public String tipo() { return "Piano"; }
    public void afinar() {}
}

class Saxofon extends Instrumento {
    public void tocar() {
 System.out.println("Saxofon.tocar()");
    }
    public String tipo() { return "Saxofon"; }
    public void afinar() {}
}

// Un tipo de Guitarra 
class Guzla extends Guitarra {
       public void tocar() {
         System.out.println("Guzla.tocar()");
       }
       public void afinar() {
         System.out.println("Guzla.afinar()");
       }
     }

// Un tipo de Guitarra 
class Ukelele extends Guitarra {
    public void tocar() {
 System.out.println("Ukelele.tocar()");
    }
    public String tipo() { return "Ukelele"; }
}

public class Musica {

    // No importa el tipo de Instrumento,
    // seguirá funcionando debido a Polimorfismo:
    static void afinar(Instrumento i) {
 // ...
 i.tocar();
    }

    static void afinarTodo(Instrumento[] e) {
 
 for(int i = 0; i < e.length; i++)
     afinar(e[i]);
    }


    public static void main(String[] args) {
 Instrumento[] orquesta = new Instrumento[5];
 int i = 0;
 // Up-casting al asignarse el Arreglo
 orquesta[i++] = new Guitarra();
 orquesta[i++] = new Piano();
 orquesta[i++] = new Saxofon();
 orquesta[i++] = new Guzla();
 orquesta[i++] = new Ukelele();
 afinarTodo(orquesta);
    }
} 

Clase Musica


En el código fuente de Musica.java son diseñadas diversas Clases que demuestran el uso de Polimorfismo:

• Instrumento: Es utilizada como la Clase Base para el resto de Clases y en ella son definidos tres métodos: tocar,tipo y afinar.
• Guitarra: Hereda ("Inherit") de la Clase Instrumento y redefine ("Override") los métodos de ésta.
• Piano: Hereda ("Inherit") de la Clase Instrumento y redefine ("Override") los métodos de ésta.
• Saxofon: Hereda ("Inherit") de la Clase Instrumento y redefine ("Override") los métodos de ésta.
• Guzla: Hereda ("Inherit") de la Clase Guitarra y redefine ("Override") los métodos de ésta.
• Ukelele: Hereda ("Inherit") de la Clase Guitarra y redefine ("Override") los métodos de ésta.

Las definiciones de la Clase principal Musica son descritas en los siguientes incisos:

• El primer método definido en esta Clase llamado afinar toma como valor de entrada una referencia del tipo Instrumento, sobre la cual es invocado el método tocar.
• Un segundo método nombrado afinarTodo toma como valor de inicia un arreglo de Instrumento, el cual es procesado por un ciclo que a su vez manda llamar el método afinar con los respectivos valores del arreglo.
• Dentro del método principal se define lo siguiente:
  • Primeramente se genera un arreglo de Instrumento para 5 Objetos.
  • Se inicializa un primitivo i con un valor de cero.
  • A través de la referencia orquesta son asignados distintos Objetos al arreglo, nótese que aunque el arreglo es de tipo Instrumento es posible asignar los Objetos: Guitarra,Piano,Saxofon,Guzla,Ukelele.
  • Finalmente se invoca el método afinarTodo con la referencia que representa el arreglo de Instrumento.

Al ser ejecutado este programa se obtienen los siguientes resultados:
$ java Musica
Guitarra.tocar()
Piano.tocar()
Saxofon.tocar()
Guzla.tocar()
Ukelele.tocar()

Herencias Múltiples

Herencia múltiple: una clase puede heredar características de una o más clases, por lo tanto, puede tener varios padres.
ejemplo:

import java.util.*;


interface PuedeCurar { 
    void curar();
}

interface PuedeConsultar { 
    void consultar();
} 

interface PuedeRecetar{ 
    void recetar();
}

class Cirujano { 
    public void operar() { System.out.println("Cirujano.operar()"); } 
} 

class Medico extends Cirujano
    implements PuedeCurar, PuedeConsultar, PuedeRecetar { 
    public void curar() { System.out.println("Medico.curar()"); } 
    public void consultar() { System.out.println("Medico.consultar()"); } 
    public void recetar() { System.out.println("Medico.recetar()"); } 
}

class Cardiologo { 
    static void r(PuedeCurar x) { x.curar(); }
    static void s(PuedeConsultar x) { x.consultar(); } 
    static void t(PuedeRecetar x) { x.recetar(); } 
    static void u(Cirujano x) { x.operar(); } 
 
   public static void main(String[] args) {
 Medico m = new Medico();
 r(m); 
 s(m); 
 t(m); 
 u(m); 
    }
}

Interfases PuedeCurar,PuedeConsultar,PuedeRecetar.

Cada una de estas interfases define un método el cual deberá ser implementado en las respectivas Clases que hagan uso de las interfases.

Clase Cirujano.

Esta Clase simplemente define un método llamado operar que imprime un mensaje a pantalla.

Clase Medico.

Contiene la mayor parte de código funcional de este archivo fuente:

• Es definida al igual que cualquier otra Clase con el vocablo class.
• Se utiliza el vocablo extends para heredar ("Inherit") el comportamiento de la Clase Cirujano.
• Seguido se implementan las interfases PuedeCurar,PuedeConsultar,PuedeRecetar a través de implements, esto obliga a que sean definidos los métodos de las diversas interfases.
• Son escritas las diversas implementaciones de los métodos de cada interfase, los cuales envían un mensaje a pantalla.

  Clase Cardiologo.

• Dentro del método principal (main) de esta Clase se genera una instancia de la Clase Medico.
• A través de dicha referencia son invocados los diversos métodos locales r,s,t,u.
• El método r manda llamar la función curar, nótese que aunque el dato de entrada aparece como PuedeCurar (Interfase) la invocación se lleva acabo directamente de la Clase Medico.
• El método s manda llamar la función consultar, nótese que aunque el dato de entrada aparece como PuedeConsultar (Interfase) la invocación se lleva acabo directamente de la Clase Medico.
• El método t manda llamar la función recetar, nótese que aunque el dato de entrada aparece como PuedeRecetar (Interfase) la invocación se lleva acabo directamente de la Clase Medico.
• El método u invoca la función operar disponible en la Clase Cirujano.
• 
  

Interfases

Una Interfase es una Clase abstracta llevada al extremo, la cual permite pre-definir el uso de métodos/campos en futuras clases tal como: Una jerarquía de Instrumentos restringido al uso de una Interfase Instrumento, o bien, una estructura de Figuras al uso de la Interfase Figura.
Una Interfase básicamente dice: "Todas las Clases que implementen esta Interfase deben contener su misma estructura", para definir una Interfase se utiliza el vocablo interface y para especificar que una Clase debe utilizar determinada Interfase se utiliza el vocablo implements.

Una característica especifica de Interfases que no es posible a través de Clases Abstractas es el uso de Herencias Múltiples ("Multiple Inheritance"), este concepto reside en diseñar Clases que adoptan el comportamiento de más de una Clase

ejemplo:

import java.util.*;

interface Instrumento {
    // Constante al compilar, automáticamente static y final 
    int i = 5;
    // Métodos Automáticamente Públicos 
    void tocar();
    String tipo();
    void afinar();
}

class Guitarra implements Instrumento {
    public void tocar() {
 System.out.println("Guitarra.tocar()");
    }
    public String tipo() { return "Guitarra"; }
    public void afinar() {}
}

class Piano implements Instrumento {
    public void tocar() {
 System.out.println("Piano.tocar()");
    }
    public String tipo() { return "Piano"; }
    public void afinar() {}
}

class Saxofon implements Instrumento {
    public void tocar() {
 System.out.println("Saxofon.tocar()");
    }
    public String tipo() { return "Saxofon"; }
    public void afinar() {}
}

// Un tipo de Guitarra 
class Guzla extends Guitarra {
       public void tocar() {
         System.out.println("Guzla.tocar()");
       }
       public void afinar() {
         System.out.println("Guzla.afinar()");
       }
     }

// Un tipo de Guitarra 
class Ukelele extends Guitarra {
    public void tocar() {
 System.out.println("Ukelele.tocar()");
    }
    public String tipo() { return "Ukelele"; }
}

public class Musica3 {

    // No importa el tipo de Instrumento,
    // seguirá funcionando debido a Polimorfismo:
    static void afinar(Instrumento i) {
 // ...
 i.tocar();
    }

    static void afinarTodo(Instrumento[] e) {
 
 for(int i = 0; i < e.length; i++)
     afinar(e[i]);
    }


    public static void main(String[] args) {
        // Declarar un Arreglo SIN INSTANCIAS es válido en Clases Abstractas
 Instrumento[] orquesta = new Instrumento[5];
 int i = 0;
 // Up-casting al asignarse el Arreglo
 orquesta[i++] = new Guitarra();
 orquesta[i++] = new Piano();
 orquesta[i++] = new Saxofon();
 orquesta[i++] = new Guzla();
 orquesta[i++] = new Ukelele();
 afinarTodo(orquesta);
    }
}

Clases Abstractas.

Al ser utilizado Herencias ("Inheritance") y/o Polimorfismo es muy común que en la Clase Base existan métodos diseñados únicamente con el propósito de ofrecer una guia para las Clases heredadas, en Java existe un vocablo que permite prohibir el uso de métodos en Clases Base, este calificativo es : abstract.Al ser definido un método como abstract se restringe que éste sea llamado directamente, cuando una Clase contiene un método de este tipo a ésta se le llama: Clase Abstracta.
Al ser definida una Clase, además de ser declarados los métodos/campos como abstract también es necesario utilizar el vocablo abstract en la definición de cada Clase.
Una de las características de las Clases que Heredan("Inherit") de una Clase abstracta, es que éstas deben definir los mismos métodos definidos en la Clase Base; en Java existe otro mecanismo que permite llevar acabo diseños donde se parte de una Estructura o Cápsula.
ejemplo

import java.util.*;

abstract class Instrumento {
    public abstract void tocar();
    public String tipo() {
 return "Instrumento";
    }
    public abstract void afinar();
}

class Guitarra extends Instrumento {
    public void tocar() {
 System.out.println("Guitarra.tocar()");
    }
    public String tipo() { return "Guitarra"; }
    public void afinar() {}
}

class Piano extends Instrumento {
    public void tocar() {
 System.out.println("Piano.tocar()");
    }
    public String tipo() { return "Piano"; }
    public void afinar() {}
}

class Saxofon extends Instrumento {
    public void tocar() {
 System.out.println("Saxofon.tocar()");
    }
    public String tipo() { return "Saxofon"; }
    public void afinar() {}
}

// Un tipo de Guitarra 
class Guzla extends Guitarra {
       public void tocar() {
         System.out.println("Guzla.tocar()");
       }
       public void afinar() {
         System.out.println("Guzla.afinar()");
       }
     }

// Un tipo de Guitarra 
class Ukelele extends Guitarra {
    public void tocar() {
 System.out.println("Ukelele.tocar()");
    }
    public String tipo() { return "Ukelele"; }
}

public class Musica2 {

    // No importa el tipo de Instrumento,
    // seguirá funcionando debido a Polimorfismo:
    static void afinar(Instrumento i) {
 // ...
 i.tocar();
    }

    static void afinarTodo(Instrumento[] e) {
 
 for(int i = 0; i < e.length; i++)
     afinar(e[i]);
    }


    public static void main(String[] args) {
        // Declarar un Arreglo SIN INSTANCIAS es valido en Clases Abstractas
 Instrumento[] orquesta = new Instrumento[5];
        // Generar una INSTANCIA de una la Clase Abstracta no es valido 
        // Instrumento nuevo = new Instrumento();
 int i = 0;
 // Up-casting al asignarse el Arreglo
 orquesta[i++] = new Guitarra();
 orquesta[i++] = new Piano();
 orquesta[i++] = new Saxofon();
 orquesta[i++] = new Guzla();
 orquesta[i++] = new Ukelele();
 afinarTodo(orquesta);
    }
}

BANQUITOS

ejercicio herencia

herencia

La herencia en java

Java permite el empleo de la herencia , característica muy potente que permite definir una clase tomando como base a otra clase ya existente. Esto es una de las bases de la reutilización de código, en lugar de copiar y pegar.

En java, como ya vimos la herencia se especifica agregando la claúsula extends después del nombre de la clase. En la claúsula extends indicaremos el nombre de la clase base de la cuál queremos heredar.

Al heredar de una clase base, heredaremos tanto los atributos como los métodos, mientras que los constructores son utilizados, pero no heredados.
Practicas:

Construyamos la clase Taxista.java con el siguiente código:

public class Taxista extends Persona {

private int nLicencia;

public void setNLicencia(int num)

{

nLicencia = num;

}

public int getLicencia()

{

return nLicencia;

}

}

operador this

Apuntador this

Cuando hacemos una llamada a una función miembro de un objeto, el compilador se encargará de pasar implícitamente como argumento: a un apuntador que contenga la dirección del objeto.
A este apuntador se lo llama, el apuntador this (palabra reservada del lenguaje C++). Además de este uso implícito por parte del compilador, se puede usar this explícitamente para referirse al objeto.
Dependiendo del tipo de función en la cual se use this, tendrá diferente tipo.
En una función miembro no constante:

NomObjeto * const
//(apuntador constante a un objeto no constante)

En una función miembro constante:

const NomObjeto * const //(apuntador constante a un objeto constante) 

A continuación veremos cómo utilizar el apuntador this, de manera implícita (como veníamos haciendolo) y de manera explícita.
Cabe recalcar que cuando lo usemos de manera explícita, utilizaremos -> (un menos y el mayor) ya que se trata de un apuntador y no del objeto en sí dónde deberíamos usar simplemente el . (punto).

#include <iostream>
using std::cout;
using std::endl;
class Prueba
{
 public:

  Prueba(int y = 0)
    {
      this->x = y; //usamos apuntador this explicito.

    }
  int Obtener(void)
  {
    return x; //usamos apuntador this implicito

  }
 private:
  int x;
};
int main()
{
  Prueba objeto1(5);
  cout << objeto1.Obtener() << endl;

  return 0;
}

Para compilar este programa utilizaremos:

g++ apuntThis.cpp -o apuntThis.out

ejercicio en clase

mapa del uso de calificadores

cuenta

Alumno

Alumno

que hace el código

operaciones

PRIYECTO

switch

encapsulamiento

El encapsulamiento es el proceso por el cual los datos que se deben enviar a través de una red se deben colocar en paquetes que se puedan administrar y rastrear. El encapsulado consiste pues en ocultar los detalles de implementación de un objeto, pero a la vez se provee una interfaz pública por medio de sus operaciones permitidas. Considerando lo anterior también se define el encapsulado como la propiedad de los objetos de permitir el acceso a su estado únicamente a través de su interfaz o de relaciones preestablecidas con otros objetos.

POLIMORFISMO

Característica de Java que permite tomar como algo igual a un nivel superior dos cosas que son diferentes a
un nivel más bajo. Ejemplo: animal, gato y perro. Los dos son animales a un nivel alto de abstracción (animal) pero diferentes a un nivel inferior. El polimorfismo básicamente permite olvidarse de ciertas carcterísticas específicas de varios objetos para centrarse en lo que tengan en común, en lo que los haga iguales

ENCAPSULAMIENTO DE CLASES

private: Solo se puede acceder a las variables desde el codigo de la propia clase.

 protected: Se pude acceder a las variables desde las clases que esten en el mismo paquete o que "hereden" de esa clase.

public: Se puede acceder a las variables desde cualquier otra clase (no solo las del paquete).

TIPOS DE SUBCLASES

Tipos de Clases

Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son:
abstract

Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.

final

Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.

public

Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.

synchronizable

Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban.

subclase

Un mecanismo clave que permite obtener estas ventajas es la redefinición, que especializa el comportamiento para algunos métodos. En ausencia de redefinición, cualquier alteración del comportamiento (aunque se trate de una alteración compatible) podría forzar una reimplementación completa

herencia

La idea de la herencia es permitir la creación de  nuevas clases basadas en clases existentes.
Cuando heredamos de una clase existente, reusamos  (o heredamos) métodos y campos, y agregamos nuevos campos y métodos para cumplir con la situación nueva.
Cada vez que encontremos la relación "es-un" entre dos clases, estamos ante la presencia de herencia.

La clase ya existente es llamada superclass, o clase base, o clase padre.
La clase nueva es llamada subclase, clase derivada, o clase hija.

A través de la herencia podemos agregar nuevos campos, y podemos agregar o sobre montar métodos (override). Sobre montar un método es redefinirlo en la case heredada.

destructor?

Cuando un objeto no va a ser utilizado, el espacio de memoria de dinámica que utiliza ha de ser explícitamente.

El recolector de basura será el encargado de liberar una zona de memoria dinámica que había sido reservada mediante el operador new, cuando el objeto ya no va a ser utilizado más durante el programa (por ejemplo, sale del ámbito de utilización, o no es referenciado nuevamente).

constructor

El constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase.
Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un objeto de dicha clase.

public class Arboles  {

    public Arboles() {
      System.out.println("Un árbol genérico");
    }
 
    public Arboles(String tipo) {
     System.out.println("Un árbol tipo " + tipo);
    }

    public Arboles(int altura) {
     System.out.println("Un árbol de " + altura + " metros");
   }

    public Arboles(int altura,String tipo) {
     System.out.println("Un " + tipo + " de " + altura + " metros");
   }
 
    public static void main(String args[]) {
Arboles arbol1 = new Arboles(4);
        Arboles arbol2 = new Arboles("Roble");
        Arboles arbol3 = new Arboles();
        Arboles arbol4 = new Arboles(5,"Pino");
     }
}

definicion de un metodo

como se crea

cuenta1.depositar(300);
Esta línea de código invoca al método despositar y provoca un cambio de valor en el atributo saldo del objeto de la clase CuentaBancaria cuya referencia es cuenta1: antes de la llamada, el saldo era de 1000, pero después será de 1300.


Ejemplo:
...

public void retirar(double cantidad) throws NoFondosDisponiblesException {

if (saldo >= cantidad) {

saldo = saldo - cantidad;

}

else

throw new NoFondosDisponiblesException("No hay suficientes fondos");

}

public void depositar(double cantidad){

if(cantidad > 0){

saldo = saldo + cantidad;

}

}
...

metodo

Los métodos permiten a las clases modificar el comportamiento de los objetos, cambiando los valores de los atributos e interactuando con otros métodos de la clase que expongan una determinada funcionalidad precisada
Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases:

• Un bloque de código que tiene un nombre,
• recibe unos parámetros o argumentos (opcionalmente),
• contiene sentencias o instrucciones para realizar algo (opcionalmente) y
• devuelve un valor de algún Tipo conocido (opcionalmente).

objeto

un objeto es una representacion  de una entidad real, de manera que  cuando nos referimos a este estamos hablando del conjunto de características que posee.
 
un objeto consta de atributos y métodos.

 como se crea?

se definen las características del objeto(en este caso uno de clase 'persona' )

class Persona
  {
     string Nombre; // Campo de cada objeto Persona que almacena su nombre
     int    Edad;   // Campo de cada objeto Persona que almacena su edad     string NIF;    // Campo de cada objeto Persona que almacena su NIF
 
     void Cumpleaños()   // Incrementa en uno la edad del objeto Persona
     {
              Edad++;
     }
                       
     Persona (string nombre, int edad, string nif) // Constructor
     {
              Nombre = nombre;
              Edad = edad;
              NIF = nif;
     }
  }

clase

una clase explica los atributos y métodos que puede tener un objeto que pertenezca a esa clase (un objeto una representacion de las cualidades de una entidad real).

Como se crea:
1. Importar un paquete io de JAVA (import java.io.*;)
2. Definir el flujo de caracteres de la entrada :

public class readData {
public static String readStr() {
String sdato = "";
try{
BufferedReader readIn = new BufferedReader(new InputStreamReader(System.in));
sdato = readIn.readLine();
} catch( IOException e) {
System.err.println("Error: " + e.getMessage());
}
return sdato;
}
}
 compilacion:
Así que des pues de esto compilamos, la clase para crear el *.class, una vez compilada la clase podemos utilizarla en nuestros programas, nada mas que solo nos serviría para datos de tipo String. Aquí un ejemplo de como se utilizaría:
import java.io.*;
class testRead01{
public static void main(String args[]){
String Nombre = "";
System.out.println("Escribe tu nombre: "); Nombre = readData.readStr();
System.out.println("Tu nombre es: " + Nombre);
}
}