lunes, 12 de julio de 2010

POLIMORFISMO

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.

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

QUE ES UNA 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 logica del comportamiento de los métodos.

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 crealo 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.

PROGRAMAS CON LA CLASE STRING:

package string;
//import javax.swing.*;
/**
*
* @author lalo
*/
public class equals {

/**
* @param args the command line arguments
*/
public static void main(String[] args)
{
System.out.println("iguales");
System.out.println("edgar vs Edgar ="+"edgar".equals("Edgar"));
System.out.println("edgar vs EDGAR ="+"edgar".equals("EDGAR"));
System.out.println("EDGAR vs EDGAR ="+"EDGAR".equals("EDGAR"));
}

}
PROGRAMA CON CLASE STRING Y EL METODO CONCAT
package string3;

/**
*
* @author lalo
*/
public class concat {

/**
* @param args the command line arguments
*/
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);

}

}