Applets y Java
| ||
Los applets son pequeños programas escritos en lenguaje Java, diseñados para ser ejecutados desde internet, que podemos colocar en nuestro servidor, junto con el resto de ficheros que componen un sitio Web (documentos HTML, ficheros de imagen, sonido, etc.) para lograr múltiples efectos con texto, imágenes, sonidos, etc.
|
viernes, 20 de noviembre de 2015
POLIMORFISMO
El Polimorfismo es uno de los 4 pilares de la programación orientada a objetos (POO) junto con la Abstracción, Encapsulación y Herencia. Para entender que es el polimorfismo es muy importante que tengas bastante claro el concepto de la Herencia.
Para empezar con esta entrada, se ha de decir que el término “Polimorfismo” es una palabra de origen griego que significa “muchasformas”. Este termino se utiliza en la POO para “referirse a la propiedad por la que es posible enviar mensajes sintácticamente iguales a objetos de tipos distintos“. Como esta definición quizás sea algo difícil de entender, vamos a explicarla con el ejemplo que pusimos en la entrada de la herencia en la que queríamos simular el comportamiento que tendrían los diferentes integrantes de la selección española de fútbol; tanto los Futbolistas como el cuerpo técnico (Entrenadores, Masajistas, etc…). Para este ejemplo nos vamos a basar en el siguiente diagrama de clases:
ejemplo:
//Código de la clase Persona ejemplo aprenderaprogramar.com
public class Persona {
private String nombre; private String apellidos; private int edad;
public Persona() { nombre = ""; apellidos = ""; edad = 0; }
public Persona (String nombre, String apellidos, int edad) {
this.nombre = nombre; this.apellidos = apellidos; this.edad = edad; }
public String getNombre() { return nombre; }
public String getApellidos () { return apellidos; }
public int getEdad() { return edad; }
} //Cierre de la clase
|
public class Profesor extends Persona { //Ejemplo aprenderaprogramar.com
private String IdProfesor;
public Profesor () { super();
IdProfesor = "Unknown";}
public Profesor (String nombre, String apellidos, int edad) {
super(nombre, apellidos, edad);
IdProfesor = "Unknown"; }
public void setIdProfesor (String IdProfesor) { this.IdProfesor = IdProfesor; }
public String getIdProfesor () { return IdProfesor; }
public void mostrarDatos() {
System.out.println ("Datos Profesor. Profesor de nombre: " + getNombre() + " " + getApellidos() +
" con Id de profesor: " + getIdProfesor() ); }
} //Cierre de la clase ejemplo aprenderaprogramar.com
|
import java.util.Calendar; //Ejemplo aprenderaprogramar.com
public class ProfesorInterino extends Profesor {
private Calendar FechaComienzoInterinidad;
public ProfesorInterino(Calendar fechaComienzaInterinidad) {
super();
FechaComienzoInterinidad = fechaComienzaInterinidad; }
public ProfesorInterino (String nombre, String apellidos, int edad, Calendar fechaComienzaInterinidad) {
super(nombre, apellidos, edad);
FechaComienzoInterinidad = fechaComienzaInterinidad; }
public Calendar getFechaComienzoInterinidad () { return FechaComienzoInterinidad; }
public void mostrarDatos() { System.out.println("Datos ProfesorInterino. Comienzo interinidad: " +
FechaComienzoInterinidad.getTime().toString() ); }
} //Cierre de la clase
|
import java.util.ArrayList; //Ejemplo aprenderaprogramar.com
public class ListinProfesores{
private ArrayList <Profesor> listinProfesores;
//Constructor
public ListinProfesores () {
listinProfesores = new ArrayList <Profesor> (); }
//Métodos
public void addProfesor (Profesor profesor) {
listinProfesores.add(profesor); } // Cierre método addProfesor
public void listar() {
System.out.println ("Se procede a mostrar los datos de los profesores existentes en el listín");
for (Profesor tmp: listinProfesores) { //Uso de for extendido
tmp.mostrarDatos(); }
} //Cierre método
} //Cierre de la clase
|
import java.util.Calendar; //Ejemplo aprenderaprogramar.com
public class TestHerencia4 {
public static void main (String [ ] Args) {
Profesor profesor1 = new Profesor ("Juan", "Hernández García", 33);
profesor1.setIdProfesor("Prof 22-387-11");
Calendar fecha1 = Calendar.getInstance();
fecha1.set(2019,10,22); //Los meses van de 0 a 11, luego 10 representa noviembre
ProfesorInterino interino1 = new ProfesorInterino("José Luis", "Morales Pérez", 54, fecha1);
ListinProfesores listin1 = new ListinProfesores ();
listin1.addProfesor(profesor1);
listin1.addProfesor(interino1);
listin1.listar(); } //Cierre del main
} //Cierre de la clase
|
CLASES Y MÉTODOS ABSTRACTOS EN JAVA.
Supongamos un esquema de herencia que consta de la clase Profesor de la que heredan ProfesorInterino y ProfesorTitular. Es posible que todo profesor haya de ser o bien ProfesorInterino o bien ProfesorTitular, es decir, que no vayan a existir instancias de la clase Profesor. Entonces, ¿qué sentido tendría tener una clase Profesor?
A su vez, las clases abstractas suelen contener métodos abstractos: la situación es la misma. Para que un método se considere abstracto ha de incluir en su signatura la palabra clave abstract. Además un método abstracto tiene estas peculiaridades:
a) No tiene cuerpo (llaves): sólo consta de signatura con paréntesis.
b) Su signatura termina con un punto y coma.
c) Sólo puede existir dentro de una clase abstracta. De esta forma se evita que haya métodos que no se puedan ejecutar dentro de clases concretas. Visto de otra manera, si una clase incluye un método abstracto, forzosamente la clase será una clase abstracta.
d) Los métodos abstractos forzosamente habrán de estar sobreescritos en las subclases. Si una subclase no implementa un método abstracto de la superclase tiene un método no ejecutable, lo que la fuerza a ser una subclase abstracta. Para que la subclase sea concreta habrá de implementar métodos sobreescritos para todos los métodos abstractos de sus superclases.
Un método abstracto para Java es un método que nunca va a ser ejecutado porque no tiene cuerpo. Simplemente, un método abstracto referencia a otros métodos de las subclases. ¿Qué utilidad tiene un método abstracto? Podemos ver un método abstracto como una palanca que fuerza dos cosas: la primera, que no se puedan crear objetos de una clase. La segunda, que todas las subclases sobreescriban el método declarado como abstracto.
Sintaxis tipo: abstract public/private/protected TipodeRetorno/void ( parámetros … );
Por ejemplo: abstract public void generarNomina (int diasCotizados, boolean plusAntiguedad);
¿Es necesario que una clase que tiene uno o más métodos abstractos se defina como abstracta? Sí, si declaramos un método abstracto el compilador nos obliga a declarar la clase como abstracta porque si no lo hiciéramos así tendríamos un método de una clase concreta no ejecutable, y eso no es admitido por Java.
¿Una clase se puede declarar como abstracta y no contener métodos abstractos? Sí, una clase puede ser declarada como abstracta y no contener métodos abstractos. En algunos casos la clase abstracta simplemente sirve para efectuar operaciones comunes a subclases sin necesidad de métodos abstractos. En otros casos sí se usarán los métodos abstractos para referenciar operaciones en la clase abstracta al contenido de la sobreescritura en las subclases.
¿Una clase que hereda de una clase abstracta puede ser no abstracta? Sí, de hecho esta es una de las razones de ser de las clases abstractas. Una clase abstracta no puede ser instanciada, pero pueden crearse subclases concretas sobre la base de una clase abstracta, y crear instancias de estas subclases. Para ello hay que heredar de la clase abstracta y anular los métodos abstractos, es decir, implementarlos.
Qué es la herencia múltiple en Java
Los desarrolladores diseñaron desde el principio para que fuera un lenguaje de programación completo y orientado a objetos. Debido a esto, los conceptos integrales de la programación orientada a objetos son cada vez más importantes en la funcionalidad básica de Java. En particular, los conceptos de herencia de clase (y los problemas que surgen a partir de ella) son preocupaciones fundamentales de los programadores
Java. de estos problemas, la herencia múltiple, se puede atajar entendiendo cómo funciona la herencia y cómo usa Java las interfaces.
Herencia múltiple
En algún momento, un programador puede estar tentado a derivar una clase única de varias clases. Esto se conoce como "herencia múltiple" y aunque parece útil, puede provocar problemas, como el importante "problema del diamante". Este problema ocurre cuando dos clases heredan de la misma clase (como la clase B y C derivan de la clase A), mientras que otra clase (D) deriva de B y C. Cuando se crea un objeto D, el sistema lo trata como un de clase (clase "Ball" o bola y "Sphere" o esfera, por ejemplo). En el problema del diamante, el sistema no puede determinar de forma decisiva qué clase D (¿es tipo A-B-D o tipo A-C-D?) es la que causa problemas.
Ejemplo:
public class Persona {
}
public class Hijo{
}
interface iHijo{
//La interface pertenece a la clase Hijo
}
public class Alumno extends Persona implements iHijo{
}
}
public class Hijo{
}
interface iHijo{
//La interface pertenece a la clase Hijo
}
public class Alumno extends Persona implements iHijo{
}
Herencia Simple
La herencia nos permite definir una clase como extensión de otra: de esta manera decimos “la clase 1.1 tiene todas las características de la clase 1 y además sus características particulares”. Todo lo que es común a ambas clases queda comprendido en la clase “superior”, mientras lo que es específico, queda restringido a las clases “inferiores”. En nuestro ejemplo definiríamos una clase denominada Vehiculo, de forma que la clase Taxi tuviera todas las propiedades de la clase Vehiculo, más algunas propiedades y métodos específicos. Lo mismo ocurriría con la clase Autobus y otras que pudieran “heredar” de Vehiculo. Podríamos seguir creando clases con herencia en un número indefinido: tantas como queramos. Si piensas en el API de Java, hay cientos de clases que heredan de clases jerárquicamente superiores como la clase Object. En un proyecto propio, podremos tener varias clases que hereden de una clase común.
En java aunque no establezcamos de manera explicita la herencia siempre está presente, ya que todas las clases que creemos heredan de la clase Object, por eso es valido decir que en java todo es un objeto. La sintaxis para la composición es obvia pero, para realizar la herencia, hay una forma claramente distinta. Cuando heredamos, estamos diciendo "Esta nueva clase es como esa clase antigua", por ejemplo es decir que la clase Horas “es una” UnidadDeTiempo. Afirmamos esto en el código dando el nombre de la clase como siempre pero, antes de la apertura del límite cuerpo de clase, pondremos la palabra clave "extends" seguida por el nombre de la clase base. Cuando hagamos esto, obtendremos automáticamente todos los datos miembros y métodos de la clase base.
Primero veamos como seria la clase UnidadDeTiempo:
public class UnidadDeTiempo { int valor; int tope; public int forward(){ if(valor == tope) valor=0; else valor++; return valor; } public int reset(){ valor=0; return valor; } }
Y nuestra clase Horas:
public class Horas extends UnidadDeTiempo{ public Horas() { this.valor=0; this.tope=23; } }
De esta manera sin necesidad de tener que escribir nuevamente todos el código de UnidadDeTiempo lo tememos disponible en la clase Horas, pero que partes tenemos disponibles?, todos los atributos y los métodos de la clase padre están disponibles en la clase hija pero dependiendo de los modificadores de acceso o visibilidad de estos, por ejemplo los atributos y métodos de tipo friendly solo estarán disponibles para las clases hijas que heredan de una clase padre en el mismo paquete, los atributos y métodos de tipo public estarán disponibles para todas las clases que hereden de la clase padre sin importar que se halle o no en el mismo paquete; los miembros protected también son accesibles desde las clases hijas.
El código de nuestra clases hijas no tienen porque limitarse solo al código heredado, de hecho casi siempre la herencia se hace para extender la funcionalidad de las clases heredadas añadiendo nuevos métodos y atributos.
- Todo objeto es el ejemplo de una clase, y toda clase tiene 0 ó más objetos.
- Mientras las clases son estáticas, con semántica, relaciones y existencia fijas previamente a la ejecución de un programa, los objetos se crean y destruyen rápidamente durante la actividad de una aplicación.
El diseño de clases y objetos es un proceso incremental e iterativo. Debe asegurar la optimización en los parámetros:
- Acoplamiento: Grado de acoplamiento entre módulos.
- Cohesión: Mide el grado de conectividad entre elementos de un módulo, y entre objetos de una clase.
- Suficiencia: Indica que las clases capturan suficientes características de la abstracción para conseguir un comportamiento e interacción eficiente y con sentido.
- Completitud: Indica que la interface de la clase captura todo el significado característico de una abstracción, escrito en el mínimo espacio.
- Primitividad: Las operaciones deben implementarse si dan acceso a una representación fundamental de la abstracción. Cuales son operaciones primitivas y cuales no (se pueden realizar a partir de otras) es un asunto subjetivo y afecta a la eficiencia en la implementación.
Ejemplo:
public class Cronometro {
Horas h;
Minutos m;
Segundos s;
String cadena;
int seg,min,hor;
public Cronometro() {
seg=0;
min=0;
hor=0;
h = new Horas();
m = new Minutos();
s = new Segundos();
cadena = new String("0 : 0 : 0");
}
public String avanzar(){
seg = s.forward();
if(seg==0){
min=m.forward();
if(min==0){
hor=h.forward();
}
}
cadena = hor + " : " + min + " : " + seg;
return cadena;
}
public String reset(){
seg = s.reset();
min = m.reset();
hor = h.reset();
cadena = hor + " : " + min + " : " + seg;
return cadena;
}
}
jueves, 19 de noviembre de 2015
Bienvenidos a "Como Programar en JAVA" el tema de hoy es CLASES
La programación orientada a objetos se basa en la programación de clases; a diferencia de la programación estructurada, que está centrada en las funciones.
¿Que es una clase?
Es un molde del que luego se pueden crear múltiples objetos, con similares características.
Una clase es una plantilla (molde), que define atributos (variables) y métodos (funciones)
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente dicho.
La estructura de una clase es:
class [nombre de la clase] {
[atributos o variables de la clase]
[métodos o funciones de la clase]
[main]
}
A continuación vamos a ver un ejemplo de una clase en Java:
public class Carro{
String marca;
int kilometraje;
String color;
void encender(){
}
void acelerar(){
}
void apagar(){
}
}
Una clase puede contener cualquiera de los siguientes tipos de variables:
- Variables locales: Las variables definidas dentro de los métodos, los constructores o los bloques se denominan variables locales. Se declara la variable y se inicializa en el método y la variable será destruida cuando el método se ha completado.
- Variables de instancia: Las variables de instancia son variables dentro de una clase, pero fuera de cualquier método. Estas variables se crean instancias cuando se carga la clase. Las variables de instancia se puede acceder desde el interior de cualquier método, constructor o bloques de esa clase en particular.
- Variables de clase: Las variables de clase son variables declaradas dentro una clase y fuera de cualquier método. En el ejemplo anterior marca, kilometraje y color son variables de clase Carro.
Una clase en Java puede tener cualquier número de métodos para acceder o modificar el comportamiento de dicha clase. En el ejemplo anterior encender, acelerar y apagar son métodos de clase Carro.
Una vez que tenemos una idea general de que es una clase en Java y cuales son sus características es importante revisar los siguientes aspectos:
Suscribirse a:
Entradas (Atom)