Polimorfismo, metodos abstractos, clases abstractas

Contenido
POLIMORFISMO
CLARIFICACIÓN DEL POLIMORFISMO
CLASES ABSTRACTAS
INTERFAZ
MÉTODOS ABSTRACTOS
La clase boolean
La clase character
La clase double
La clase float
La clase integer
La clase long
La clase string
Ejemplos de programas en java con la clase de tipo string
EJEMPLO 1:
EJEMPLO 2: PROGRAMA CON CLASE STRING Y EL MÉTODO CONCAT




POLIMORFISMO
El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma general, en lugar de hacerlo en forma específica, En general nos sirve para programar objetos con características comunes y que todos estos compartan la misma superclase en una jerarquía de clases, como si todas fueran objetos de la superclase, esto nos simplifica la programación.

CLASIFICACION DEL POLIMORFISMO
Se puede clasificar el polimorfismo en dos grandes clases:
Polimorfismo dinámico (o polimorfismo paramétrico) es aquél en el que el código no incluye ningún tipo de especificación sobre el tipo de datos sobre el que se trabaja. Así, puede ser utilizado a todo tipo de datos compatible.
Polimorfismo estático (o polimorfismo ad hoc) es aquél en el que los tipos a los que se aplica el polimorfismo deben ser explicitados y declarados uno por uno antes de poder ser utilizados.
El polimorfismo dinámico unido a la herencia es lo que en ocasiones se conoce como programacion generica.
También se clasifica en herencia por redefinición de métodos abstractos y por método sobrecargado. El segundo hace referencia al mismo método con diferentes parámetros.
Otra clasificación agrupa los polimorfismo en dos tipos: Ad-Hoc que incluye a su vez sobrecarga de operadores y coerción, Universal (inclusión o controlado por la herencia, paramétrico o genericidad).


CLASES ABSTRACTAS
Una de las características más útiles de cualquier lenguaje orientado a objetos es la posibilidad de declarar clases que definen como se utiliza solamente, sin tener que implementar métodos. Esto es muy útil cuando la implementación es específica para cada usuario, pero todos los usuarios tienen que utilizar los mismos métodos

INTERFAZ
Una interfaz define una serie de métodos que debe implementar una clase. Es decir, una interfaz es una colección de métodos sin cuerpo, contiene únicamente lo que se denomina signatura del método.

Trabajar con interfaces permite abstraernos de la clase que la implementa. Una interfaz en java es una colección de métodos abstractos y propiedades. En ellas se especifica qué se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que describan la lógica del comportamiento de los métodos.

METODOS ABSTRACTOS
La clase boolean
Los valores //boolean// también tienen su tipo asociado //boolean//, aunque en este caso hay menos métodos implementados que para el resto de las clases numéricas.



declaraciones

la primera sentencia creará una variable boolean y la segunda un objeto boolean:

boolean b;
boolean b;

valores de boolean

boolean.true;
boolean.false;

métodos de boolean
boolean b.booleanvalue();
string b.tostring();
boolean b.equals( object obj );

La clase character
Al trabajar con caracteres se necesitan muchas funciones de comprobación y traslación. Estas funciones están empleadas en la clase character. De esta clase sí que se pueden crear instancias, al contrario que sucede con la clase math.


declaraciones
La primera sentencia creará una variable carácter y la segunda un objeto character:

char c;
character c;

comprobaciones booleanas

character.islowercase( c )
character.isuppercase( c )
character.isdigit( c )
character.isspace( c )


En este caso, si tuviésemos un objeto character c, no se podría hacer //c.islowercase//, porque no se ha hecho un new de character. Estas funciones son estáticas y no conocen al objeto, por eso hay que créalo antes.



traslaciones de caracteres

char c2 = character.tolowercase( c );
char c2 = character.touppercase( c );



traslaciones de carácter/dígito

int i = character.digit( c,base );
char c = character.fordigit( i,base );



métodos de la clase character

c = new character( 'j' );
char c = c.charvalue();
string s = c.tostring();

La clase double
Cada tipo numérico tiene su propia clase de objetos. Así el tipo //double// tiene el objeto //double//. De la misma forma que con la clase character, se han codificado muchas funciones útiles dentro de los métodos de la clase double.


declaraciones

la primera sentencia creará una variable double y la segunda un objeto double:

double d;
double d;


valores de double

double.positive_infinity
double.negative_infinity
double.nan
double.max_value
double.min_value


métodos de double

d.isnan();
double.isnan( d );
d.isinfinite();
double.isinfinite( d );
boolean d.equals();
string d.tostring();
int d.intvalue();
long d.longvalue();
float d.floatvalue();
double d.doublevalue();
int i = d.hashcode();
double v.valueof( string s );
long l = double.doubletolongbits( d );
double d = double.longbitstodouble( l );

La clase float

Cada tipo numérico tiene su propia clase de objetos. Así el tipo //float// tiene el objeto //float//. De la misma forma que con la clase character, se han codificado muchas funciones útiles dentro de los métodos de la clase float.


declaraciones

la primera sentencia creará una variable float y la segunda un objeto float:

float f;
float f;

valores de float

float.positive_infinity
float.negative_infinity
float.nan
float.max_value
float.min_value

conversiones de clase/cadena

string s = float.tostring( f );
f = float.valueof( "3.14" );



comprobaciones

boolean b = float.isnan( f );
boolean b = float.isinfinite( f );

La función //isnan()// comprueba si ##f## es un //no-número//. Un ejemplo de no-número es raiz cuadrada de -2.

Conversiones de objetos
float f = new float( float.pi );
string s = f.tostring();
int i = f.intvalue();
long l = f.longvalue();
float f = f.floatvalue();
double d = f.doublevalue();

otros métodos

int i = f.hashcode();
boolean b = f.equals( object obj );
int i = float.floattointbits( f );
float f = float.intbitstofloat( i );
La clase integer
Cada tipo numérico tiene su propia clase de objetos. Así el tipo //int// tiene el objeto //integer//. De la misma forma que con la clase character, se han codificado muchas funciones útiles dentro de los métodos de la clase integer.

declaraciones

la primera sentencia creará una variable int y la segunda un objeto integer:

int i;
integer i;



==== //valores de integer// ====

integer.min_value;
integer.max_value;


métodos de integer

string integer.tostring( int i,int base );
string integer.tostring( int i );
int i.parseint( string s,int base );
int i.parseint( string s );
integer integer.valueof( string s,int base );
integer integer.valueof( string s );
int i.intvalue();
long i.longvalue();
float i.floatvalue();
double i.doublevalue();
string i.tostring();
int i.hashcode();
boolean i.equals( object obj );

En los métodos //tostring()//, //parseint()// y //valueof()// que no se especifica la base sobre la que se trabaja, se asume que es base 10.

La clase long

Cada tipo numérico tiene su propia clase de objetos. Así el tipo //long// tiene el objeto// long//. De la misma forma que con la clase character, se han codificado muchas funciones útiles dentro de los métodos de la clase long.

declaraciones

la primera sentencia creará una variable long y la segunda un objeto long:

long l;
long l;
valores de long
long.min_value;
long.max_value;

métodos de long

string long.tostring( long l,int base );
string long.tostring( long l );
long l.parselong( string s,int base );
long l.parselong( string s );
long long.valueof( string s,int base );
long long.valueof( string s );
int l.intvalue();
long l.longvalue();
float l.floatvalue();
double l.doublevalue();
string l.tostring();
int l.hashcode();
boolean l.equals( object obj );

en los métodos //tostring()//, //parseint()// y //valueof()// que no se especifica la base sobre la que se trabaja, se asume que es base 10.


La clase string
Java posee gran capacidad para el manejo de cadenas dentro de sus clases string y stringbuffer. un objeto //string// representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. un objeto //stringbuffer// representa una cadena cuyo tamaño puede variar.

Los strings son objetos constantes y por lo tanto muy baratos para el sistema. la mayoría de las funciones relacionadas con cadenas esperan valores string como argumentos y devuelven valores string.

Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo cual es más conveniente usar character que char. No obstante, char se usa, por ejemplo, para leer ficheros que están escritos desde otro lenguaje.



existen muchos constructores para crear nuevas cadenas:

string();
string( string str );
string( char val[] );
string( char val[],int offset,int count );
string( byte val[],int hibyte );
string( byte val[],int hibyte,int offset,int count );


Tal como uno puede imaginarse, las cadenas pueden ser muy complejas, existiendo muchas funciones muy útiles para trabajar con ellas y, afortunadamente, la mayoría están codificadas en la clase string.




funciones básicas

la primera devuelve la longitud de la cadena y la segunda devuelve el carácter que se encuentra en la posición que se indica en ##indice##:

int length();
char charat( int indice );

funciones de comparación de strings

boolean equals( object obj );
boolean equalsignorecase( object obj );

lo mismo que //equals()// pero no tiene en cuenta mayúsculas o minúsculas.

int compareto( string str2 );


Devuelve un entero menor que cero si la cadena es léxicamente menor que ##str2##. Devuelve cero si las dos cadenas son léxicamente iguales y un entero mayor que cero si la cadena es léxicamente mayor que ##str2##.




funciones de comparación de subcadenas

boolean regionmatch( int thisoffset,string s2,int s2offset,int len );
boolean regionmatch( boolean ignorecase,int thisoffset,string s2,
int s2offset,int 1 );

comprueba si una región de esta cadena es igual a una región de otra cadena.

boolean startswith( string prefix );
boolean startswith( string prefix,int offset );
boolean endswith( string suffix );

devuelve si esta cadena comienza o termina con un cierto prefijo o sufijo comenzando en un determinado desplazamiento.

int indexof( int ch );
int indexof( int ch,int fromindex );
int lastindexof( int ch );
int lastindexof( int ch,int fromindex );
int indexof( string str );
int indexof( string str,int fromindex );
int lastindexof( string str );
int lastindexof( string str,int fromindex );

devuelve el primer/último índice de un carácter/cadena empezando la búsqueda a partir de un determinado desplazamiento.

string substring( int beginindex );
string substring( int beginindex,int endindex );
string concat( string str );
string replace( char oldchar,char newchar );
string tolowercase();
string touppercase();
string trim();

ajusta los espacios en blanco al comienzo y al final de la cadena.

void getchars( int srcbegin,int srcend,char dst[],int dstbegin );
void getbytes( int srcbegin,int srcend,byte dst[],int dstbegin );
string tostring();
char tochararray();
int hashcode();



funciones valueof


la clase string posee numerosas funciones para transformar valores de otros tipos de datos a su representación como cadena. todas estas funciones tienen el nombre de //valueof//, estando el método sobrecargado para todos los tipos de datos básicos.


veamos un ejemplo de su utilización:

string uno = new string( "hola mundo" );
float f = 3.141592;

string pi = uno.valueof( f );
string pi = string.valueof( f ); // mucho más correcto

funciones de conversión

string valueof( boolean b );
string valueof( int i );
string valueof( long l );
string valueof( float f );
string valueof( double d );
string valueof( object obj );
string valueof( char data[] );
string valueof( char data[],int offset,int count );


usa arrays de caracteres para la cadena.

string copyvalueof( char data[] );
string copyvalueof( char data[],int offset,int count );

crea un nuevo array equivalente para la cadena.

Ejemplos de programas en java con la clase de tipo string

EJEMPLO 1:
package string;
import javax.swing.*;
public class equals {
public static void main(String[] args)
{
System.out.println("iguales");
System.out.println("kary vs Edgar ="+"kary".equals("kayr"));
System.out.println("kary vs EDGAR ="+"kary".equals("KARY"));
System.out.println("KARY vs KARY ="+"KARY".equals("KARY"));
}
}
EJEMPLO 2: PROGRAMA CON CLASE STRING Y EL METODO CONCAT
package string3;
public class concat {
public static void main(String[] args)
{
String cade1 = "hola ";
String cade2 = "mundo";
System.out.println("cadena1="+cade1);
System.out.println("cadena2="+cade2);
String cade3=cade1.concat(cade2);
System.out.println("concatenacion= "+cade3);
}
}

Arreglos en java

Un arreglo es una colección de objetos numerados del mismo tipo, en donde cada variable o celda en el arreglo tiene un índice. Las celdas están numeradas del 0 al N-1, donde N es el número de celdas del arreglo es decir su capacidad.
Los índices de un arreglo en Java deben estar dentro de los límites, 0 – N-1, de lo contrario se generará un error durante la ejecución.

Java implementa los arreglos como objetos que pueden ser tratados como cualquier otro objeto.

Para utilizar un arreglo en Java:
1. Declare una variable para que contenga el arreglo
2. Cree un nuevo arreglo de objeto y asígnelo a la variable de arreglo
3. Almacene información en ese arreglo
4. Realice operaciones de almacenamiento y recuperación con los elementos del arreglo
Declaración:
Se agrega un par de corchetes vacíos
[ ]
Al objeto o tipo de datos, o al nombre de variable.
Ejemplos:
String palabrasDificiles [ ];
Point hits [ ];
int donaciones [ ];

O bien:

String [ ] palabrasDificiles;
Point [ ] hits;
int [ ] donaciones;
Creación de objetos de arreglos:

Después de haber declarado la variable arreglo, el siguiente paso es crear un arreglo de objetos y asignarlo a esa variable. Las formas de hacerlo son:
• a través del operador new
• inicializando directamente el contenido del arreglo
Ejemplos:

String [ ] nombreJugadores = new String [10];
int [ ] temps = new int [99];

Todas las posiciones se inicializan automáticamente (0 para arreglos numéricos, false para booleanos, ‘\0’ para arreglos de carácter y null para objetos)

También se puede crear e inicializar un arreglo al mismo tiempo. Encierre los elementos del arreglo entre llaves, separándolos con comas:

String [ ] chiles = { “jalapeno”, “de árbol”, “serrano”, “habanero”};


Al crear elementos con valores iniciales, el arreglo es del mismo tamaño que la cantidad de elementos que ha incluido en las llaves.
Ejemplo:

class ArregloNombres
{
String[] nombres = { "Dennis", "Grace", "Bjarne", "James"};
String[] apellidos = new String[nombres.length];

void imprime()
{
int i = 0;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
}

public static void main (String arguments[])
{
ArregloNombres a = new ArregloNombres();
a.imprime();
System.out.println("-----");
a.apellidos[0] = "Ritchie";
a.apellidos[1] = "Hopper";
a.apellidos[2] = "Stroustrup";
a.apellidos[3] = "Gosling";
a.imprime();
}
}

El tamaño de un arreglo se almacena en la variable length, que puede ser accesada a través del operador . y el nombre del arreglo:

nombreArreglo.length


Modificar la clase anterior para que tenga una mejor estructura de control. Investigar quiénes son las personas que aparecen mencionadas.
Arreglos bidimensionales:

Ejemplo:

/**
* Demuestra el uso de un arreglo bidimensional
* Crea las tablas de multiplicar del 0 al 10 y las imprime
*/
public class Tablas
{
public static void main (String [] args)
{
final int MAXT = 11;
int [] [] tabla = new int [MAXT][MAXT];

//Se inicializan los valores de tabla
for (int i = 0; i < MAXT; i++)
for (int j = 0; j < MAXT; j++)
tabla [i][j] = i*j;
//Se imprime tabla
System.out.println ("Las tablas de multiplicar del 0 al 10 son:\n");
for (int i = 0; i < MAXT; i++)
{
for (int j = 0; j < MAXT; j++)
System.out.print (tabla [i][j] + "\t");
System.out.println ();
}
}
}

Programa que calcula cual es el numero mayor y menor de tres nùmeros

package mayor;
import javax.swing.*;

public class mayor {


public static void main(String[] args) {

// TODO code application logic here
String k, j, l;
int a, b, c;
k = JOptionPane.showInputDialog("DA UN NUMERO: ");
j = JOptionPane.showInputDialog("DA UN NUMERO: ");
l = JOptionPane.showInputDialog("DA UN NUMERO: ");
a = Integer.parseInt(k);
b = Integer.parseInt(j);
c = Integer.parseInt(l);

if ((a < b) && (c < b))
{
JOptionPane.showMessageDialog(null,"EL MAYOR ES : "+b);
}
else if ((b < a) && (c < a))
{
JOptionPane.showMessageDialog(null,"EL MAYOR ES : "+a);
}
else if ((b < c) && (a < c))
{
JOptionPane.showMessageDialog(null,"EL MAYOR ES : "+c);
}


if ((a < b) && (a < c))
{
JOptionPane.showMessageDialog(null,"EL MENOR ES : "+a);
}
else if ((b < a) && (b < c))
{
JOptionPane.showMessageDialog(null,"EL MENOR ES : "+b);
}
else if ((c < b) && (c < a))
{
JOptionPane.showMessageDialog(null,"EL MENOR ES : "+c);
}

if ((a == b) && (a < c))
{
JOptionPane.showMessageDialog(null,"EL MENOR ES : "+a);
}
else if ((a == c) && (a < b))
{
JOptionPane.showMessageDialog(null,"EL MENOR ES : "+a);
}
else if ((b == c) && (b < a))
{
JOptionPane.showMessageDialog(null,"EL MENOR ES : "+b);
}

if ((a == b) && (a > c))
{
JOptionPane.showMessageDialog(null,"EL MAYOR ES : "+a);
}
else if ((a == c) && (a > b))
{
JOptionPane.showMessageDialog(null,"EL MAYOR ES : "+a);
}
else if ((b == c) && (b > a))
{
JOptionPane.showMessageDialog(null,"EL MAYOR ES : "+b);
}


if ((b == c) && (b == a))
{
JOptionPane.showMessageDialog(null," TODOS SON EL MISMO NUMERO: "+a);
}
}

}

programa de un empleado al cual se le facilitan preestaciones.

package empleado;
import javax.swing.*;

public class empleados {
String nombre,puesto;
double sueldo,sn,deducciones,prestaciones;
int np;
public empleados()
{
nombre=JOptionPane.showInputDialog("NOMBRE");
puesto=JOptionPane.showInputDialog("PUESTO");
sueldo=Double.parseDouble(JOptionPane.showInputDialog("SUELDO"));
}

public double calimpuestos()
{
sn=sueldo-(sueldo*.08);
return sn;
}
public double prestadicionales()
{
String con;
con=JOptionPane.showInputDialog("CONCEPTO");
prestaciones = Double.parseDouble(JOptionPane.showInputDialog("MONTO DE PRESTACION"));
return prestaciones;
}
public String DatosEmp()
{
String x="\nNOMBRE:"+nombre+"\nPUESTO:"+puesto;
x=x+"\nSUELDO:"+sueldo;
return x;
}
}






package empleado;
import javax.swing.*;

public class Emple {


public static void main(String[] args) {
// TODO code application logic here
double d,p=0,totalpres=0,total;
int b=0,i;

empleados E=new empleados();
d=E.calimpuestos();
int a=Integer.parseInt(JOptionPane.showInputDialog("EL EMPLEADO TIENE PRESTACIONES ADICIONALES: \n1.-SI \n2.-NO"));
if(a==1)
b=Integer.parseInt(JOptionPane.showInputDialog("CUANTAS PRESTACIONES TIENE: "));
for(i=0; i {
p=E.prestadicionales();
totalpres=totalpres+p;
}
total=totalpres+d;
JOptionPane.showMessageDialog(null,"\nNOMINA: "+ E.DatosEmp()+"\nSUELDO MENOS IMPUESTOS: "+d+" \nTOTAL DE PRESTACIONES: "+totalpres +" \n TOTAL INGRESOS: " +total);
}
}

Programa que calcula el factorial de un nùmero

package calcular;
import javax.swing.*;

public class Main {


public static void main(String[] args) {
// TODO code application logic here
int numero=1,a;
String num;
double factorial=1;
num= JOptionPane.showInputDialog("dame el numero del factorial");
numero= Integer.parseInt(num);
while ( numero!=0) {
factorial=factorial*numero;
numero--;
System.out.println(factorial);
}
}

}

Que es Herencia?

HERENCIA: En orientación a objetos la herencia es el mecanismo fundamental para implementar la reutilización y extensibilidad del software. A través de ella los diseñadores pueden construir nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y verificadas) evitando con ello el rediseño, la remodificación y verificación de la parte ya implementada. La herencia facilita la creación de objetos a partir de otros ya existentes, obteniendo características (métodos y atributos) similares a los ya existentes.
Es la relación entre una clase general y otra clase más especifica. Por ejemplo: Si declaramos una clase párrafo derivada de una clase texto, todos los métodos y variables asociadas con la clase texto, son automáticamente heredados por la subclase párrafo.
La herencia es uno de los mecanismos de la programación orientada a objetos, por medio del cual una clase se deriva de otra, llamada entonces superclase, de manera que extiende su funcionalidad. Una de sus funciones más importantes es la de proveer Polimorfismo y late binding.



Ejemplo de Herencia:

public class Mamifero
{

private int patas;
private String nombre;

public void imprimirPatas()
{
System.out.println(nombre + " tiene " + patas + " patas\n");
}

public Mamifero(String nombre, int patas)
{
this.nombre = nombre;
this.patas = patas;
}
}

public class Perro extends Mamifero {
public Perro(String nombre){
super(nombre, 4);
}
}

public class Gato extends Mamifero {
public Gato(String nombre){
super(nombre, 4);
}
}

public class CreaPerro {
public static void main(String [] args) {
Perro bobi = new Perro("Bobi");
bobi.imprimirPatas(); /*Está en la clase mamífero*/
}
}

Que es un constructor y sus caracteristicas

Cuando se construye un objeto es necesario inicializar sus variables con valores coherentes, imaginemos un objeto de la clase Persona cuyo atributo color de pelo al nacer sea verde, un estado incorrecto tras construir el objeto persona. La solución en los lenguajes orientados a objetos es emplear los constructores. Un constructor es un método perteneciente a la clase que posee unas características especiales:
• Se llama igual que la clase.
• No devuelve nada, ni siquiera void.
• Pueden existir varios, pero siguiendo las reglas de la sobrecarga de funciones.
• De entre los que existan, tan sólo uno se ejecutará al crear un objeto de la clase.
Dentro del código de un constructor generalmente suele existir inicializaciones de variables y objetos, para conseguir que el objeto sea creado con dichos valores iniciales.
Para definir los constructores se emplea la siguiente sintaxis:
[modifVisibilidad] nombreConstructor (listaParámetros) [throws listaExcepciones]
{
}