Para manejar las excepciones y evitar que un programa termine por algun error se usa el bloque:
Try-catch
Las sentencias del bloque try, que se encuentran despues de la sentencia que causo la excepcion no se ejecutaran.
Try
{
Char x = (char)System.in.read();
}
Catch ( IOException ioe)
{
//cidigo para manejar el error
}
Catch ( Exception e)
{
//codigo para manejar excepciones
}
lunes, 2 de agosto de 2010
TIPOS DE EXCEPCIONES
Checked: Son las excepciones que revisa el compilador.
Unchecked: Son las excepciones que no revisa el compilador y se dan en tiempo de ejecución.
Unchecked: Son las excepciones que no revisa el compilador y se dan en tiempo de ejecución.
EXCEPCIONES EN JAVA
En todo programa existen errores inesperados en tiempo de ejecución, y también errores que no consideramos debido a nuestra propia inexperiencia como programadores. Unos de estos errores ocurren por ejemplo, al intentar acceder a un elemento del arreglo que está fuera del límite de nuestro arreglo, o cuando intentamos acceder a un archivo inexistente, entre otros. Normalmente estos errores interrumpen el flujo de ejecución de nuestros programas, hasta el extremo de provocar la terminación del programa en forma inmediata. Java hace uso de las excepciones1.1 para poder controlar los errores en tiempo de ejecución. En Java, casi todo los tipos de errores que puedan surgir en tiempo de ejecución lanzan excepciones, es decir, cuando ocurre un error dentro de un método de JAva, este método crea un objeto Exception, dicho objeto contiene información sobre la excepción, que incluye su tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún código para manejar el error. El manejo de excepciones en Java sigue una estructura como esta:
try {
//Codigo donde puede ocurrir un error
}
catch (ExcepcionA ex) { // Que se va a hacer en caso que
se lanze una Excepcion A }
...
catch (ExcepcionZ ex) { // Que se va a hacer en caso que
se lanze una Excepcion Z }
Dentro del bloque try{ } viene encerrado la parte del programa que se desea manejar sus excepciones. El código dentro de algún catch (TipoExcepcion e) se ejecuta en caso se que lanze una excepción TipoExcepcion o que pertenezca al grupo TipoExcepcion. El sistema de ejecución Java busca hacia atrás en la pila de llamadas para encontrar el método que esté interesado en manejar una excepción particular. Es decir si se lanza una excepción en el método $A$, pero si $A$ no está interesado en manejar dicha excepción, entonces el sistema de ejecución Java ve quién llamó a $A$ (supongamos que si existe, y es el método $B$), entonces se regresa a $B$ y ve si está interesado en dicha excepción, y así consecutivamente hasta llegar al método principal de nuestra aplicación. En caso de no encontrar alguien que quiera manejarlo, comunmente Java manda una lista de mensajes en nuestra ventana de consola, y en muchos casos se termina la ejecución de nuestro programa. Cuando manejamos excepciones, podemos manejar excepciones en forma específica (por ejemplo, usar un índice que está fuera de los límites de nuestro arreglo), o manejar una excepción de cierta categoría (por ejemplo, una excepción lanzada por mal uso de un arreglo de datos), o manejar todas las excepciones en su conjunto. Para el primer caso, es necesario este código catch(ArrayIndexOutOfBoundsException e){ }, para el segundo catch (ArrayException e){}1.2 y para el último catch (Exception e){ }. En la práctica no es recomendable hacer usar de manejadores de excepciones demasiado generales, como la del último caso. Las excepciones son parte de Java, y es muy común usarlos en las operaciones E/S, ya que es donde más probabilidad hay de que se lanze una. Conforme se vean los temas, se considerán muchos excepciones que son obligaciones de capturar por la propia sintaxis de java. Pero estos se considerarán conforme se vean los temas
try {
//Codigo donde puede ocurrir un error
}
catch (ExcepcionA ex) { // Que se va a hacer en caso que
se lanze una Excepcion A }
...
catch (ExcepcionZ ex) { // Que se va a hacer en caso que
se lanze una Excepcion Z }
Dentro del bloque try{ } viene encerrado la parte del programa que se desea manejar sus excepciones. El código dentro de algún catch (TipoExcepcion e) se ejecuta en caso se que lanze una excepción TipoExcepcion o que pertenezca al grupo TipoExcepcion. El sistema de ejecución Java busca hacia atrás en la pila de llamadas para encontrar el método que esté interesado en manejar una excepción particular. Es decir si se lanza una excepción en el método $A$, pero si $A$ no está interesado en manejar dicha excepción, entonces el sistema de ejecución Java ve quién llamó a $A$ (supongamos que si existe, y es el método $B$), entonces se regresa a $B$ y ve si está interesado en dicha excepción, y así consecutivamente hasta llegar al método principal de nuestra aplicación. En caso de no encontrar alguien que quiera manejarlo, comunmente Java manda una lista de mensajes en nuestra ventana de consola, y en muchos casos se termina la ejecución de nuestro programa. Cuando manejamos excepciones, podemos manejar excepciones en forma específica (por ejemplo, usar un índice que está fuera de los límites de nuestro arreglo), o manejar una excepción de cierta categoría (por ejemplo, una excepción lanzada por mal uso de un arreglo de datos), o manejar todas las excepciones en su conjunto. Para el primer caso, es necesario este código catch(ArrayIndexOutOfBoundsException e){ }, para el segundo catch (ArrayException e){}1.2 y para el último catch (Exception e){ }. En la práctica no es recomendable hacer usar de manejadores de excepciones demasiado generales, como la del último caso. Las excepciones son parte de Java, y es muy común usarlos en las operaciones E/S, ya que es donde más probabilidad hay de que se lanze una. Conforme se vean los temas, se considerán muchos excepciones que son obligaciones de capturar por la propia sintaxis de java. Pero estos se considerarán conforme se vean los temas
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);
}
}
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);
}
}
lunes, 21 de junio de 2010
ARREGLOS CON OBJETOS:
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.
package ejemplodearreglos;
/**
*
* @author Lalo
*/
public 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]);
}
}
--------DENTRO DEL MAIN----------
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here ArregloNombres a = new ArregloNombres();
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();
}
}
• 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.
package ejemplodearreglos;
/**
*
* @author Lalo
*/
public 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]);
}
}
--------DENTRO DEL MAIN----------
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here ArregloNombres a = new ArregloNombres();
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();
}
}
COMO DECLARAR 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;
EJEMPLO:
package inic2arreglo;
import javax.swing.JOptionPane;
/**
*
* @author Alumnos
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
final int LONGITUD_ARREGLO = 10; // constante
int arreglo[]; // referencia a un arreglo int
arreglo = new int[ LONGITUD_ARREGLO ]; // crear el arreglo
// calcular el valor para cada elemento del arreglo
for ( int contador = 0; contador < arreglo.length; contador++ )
arreglo[ contador ] = 2 + 2 * contador;
String salida = "Índice\tValor\n";
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += contador + "\t" + arreglo[ contador ] + "\n";
JTextArea areaSalida = new JTextArea();
areaSalida.setText( salida );
JOptionPane.showMessageDialog( null, areaSalida,
"Inicialización con enteros pares del 2 al 20",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
} // fin de main
}
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;
*******EJEMPLO
EJEMPLO:
package inic2arreglo;
import javax.swing.JOptionPane;
/**
*
* @author Alumnos
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
final int LONGITUD_ARREGLO = 10; // constante
int arreglo[]; // referencia a un arreglo int
arreglo = new int[ LONGITUD_ARREGLO ]; // crear el arreglo
// calcular el valor para cada elemento del arreglo
for ( int contador = 0; contador < arreglo.length; contador++ )
arreglo[ contador ] = 2 + 2 * contador;
String salida = "Índice\tValor\n";
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += contador + "\t" + arreglo[ contador ] + "\n";
JTextArea areaSalida = new JTextArea();
areaSalida.setText( salida );
JOptionPane.showMessageDialog( null, areaSalida,
"Inicialización con enteros pares del 2 al 20",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
} // fin de main
}
miércoles, 2 de junio de 2010
HERENCIA
QUE ES HERENCIA.?
La herencia es el mecanismo fundamental para implemetar la reutilizacion y extensibilidad del software. Atravez de ella los diseñadores pueden construir nuevas clases partiendo de una jerarquia de claseses ya existentes, evitando con ello el rediseño, la remodificacion y verificacion de la parte ya implementada. La herencia facilita la creacion de objetos a partir de otros ya existentes obteniendo caracteristicas(metodos y atributos) similares a los ya existentes.
Caracteristica muy importante que permite definir una clase tomando como base a otra clase ya existente.
En java la herencia es especifica agregando la clausula extends despues del nombre de la clase(en la clausula extends indicaremos el nombre de la clase base de la cual queremos heredar).
Al heredar de una clase base, heredaremos tanto los atributos como los metodos, mientras que los constructores son utilizados, pero no heredados.
La herencia es el mecanismo fundamental para implemetar la reutilizacion y extensibilidad del software. Atravez de ella los diseñadores pueden construir nuevas clases partiendo de una jerarquia de claseses ya existentes, evitando con ello el rediseño, la remodificacion y verificacion de la parte ya implementada. La herencia facilita la creacion de objetos a partir de otros ya existentes obteniendo caracteristicas(metodos y atributos) similares a los ya existentes.
Caracteristica muy importante que permite definir una clase tomando como base a otra clase ya existente.
En java la herencia es especifica agregando la clausula extends despues del nombre de la clase(en la clausula extends indicaremos el nombre de la clase base de la cual queremos heredar).
Al heredar de una clase base, heredaremos tanto los atributos como los metodos, mientras que los constructores son utilizados, pero no heredados.
Suscribirse a:
Entradas (Atom)