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]
{
}

Tipos de datos en java

TIPOS DE DATOS

A. Tipos de datos simples
Es uno de los conceptos fundamentales de cualquier lenguaje de programación. Estos definen los métodos de almacenamiento disponibles para representar información, junto con la manera en que dicha información ha de ser interpretada.
Para crear una variable (de un tipo simple) en memoria debe declararse indicando su tipo de variable y su identificador que la identificará de forma única. La sintaxis de declaración de variables es la siguiente:

TipoSimple Identificador1, Identificador2;
Esta sentencia indica al compilador que reserve memoria para dos variables del tipo simple TipoSimple con nombres Identificador1 e Identificador2.
Los tipos de datos en Java pueden dividirse en dos categorías: simples y compuestos. Los simples son tipos nucleares que no se derivan de otros tipos, como los enteros, de coma flotante, booleanos y de carácter. Los tipos compuestos se basan en los tipos simples, e incluyen las cadenas, las matrices y tanto las clases como las interfaces, en general.
Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados, para darles valor. En este apartado se explican los tipos de datos simples (o primitivos) que presenta Java, así como los literales que soporta (sintaxis de los valores que se les puede asignar).

a.) Tipos de datos enteros

Se usan para representar números enteros con signo. Hay cuatro tipos: byte, short, int y long.
Tipo Tamaño
byte 1Byte (8 bits)
short 2 Bytes (16 bits)
int 4 Bytes (32 bits)
long 8 Bytes (64 bits)
Tabla 5: Tipos de datos enteros
Literales enteros
Son básicos en la programación en Java y presentan tres formatos:
• Decimal: Los literales decimales aparecen como números ordinarios sin ninguna notación especial.
• Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x ó 0X inicial, notación similar a la utilizada en C y C++.
• Octal: Los octales aparecen con un 0 inicial delante de los dígitos.
Por ejemplo, un literal entero para el número decimal 12 se representa en Java como 12 en decimal, como 0xC en hexadecimal, y como 014 en octal.
Los literales enteros se almacenan por defecto en el tipo int, (4 bytes con signo), o si se trabaja con números muy grandes, con el tipo long, (8 bytes con signo), añadiendo una L ó l al final del número.
La declaración de variables enteras es muy sencilla. Un ejemplo de ello sería:
long numeroLargo = 0xC; // Por defecto vale 12

b.) Tipos de datos en coma flotante

Se usan para representar números con partes fraccionarias. Hay dos tipos de coma flotante: float y double. El primero reserva almacenamiento para un número de precisión simple de 4 bytes y el segundo lo hace para un numero de precisión doble de 8 bytes.
Tipo Tamaño
float 4 Byte (32 bits)
double 8 Bytes (64 bits)
Tabla 6: Tipos de datos numéricos en coma flotante
Literales en coma flotante
Representan números decimales con partes fraccionarias. Pueden representarse con notación estándar (563,84) o científica (5.6384e2).
De forma predeterminada son del tipo double (8 bytes). Existe la opción de usar un tipo más corto (el tipo float de 4 bytes), especificándolo con una F ó f al final del número.
La declaración de variables de coma flotante es muy similar a la de las variables enteras. Por ejemplo:
double miPi = 314.16e-2 ; // Aproximadamente
float temperatura = (float)36.6; // Paciente sin fiebre
Se realiza un moldeado a temperatura, porque todos los literales con decimales por defecto se consideran double.

c.) Tipo de datos boolean

Se usa para almacenar variables que presenten dos estados, que serán representados por los valores true y false. Representan valores bi-estado, provenientes del denominado álgebra de Boole.
Literales Booleanos
Java utiliza dos palabras clave para los estados: true (para verdadero) y false (para falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los que el valor de falso se representaba por un 0 numérico, y verdadero cualquier número que no fuese el 0.
Para declarar un dato del tipo booleano se utiliza la palabra reservada boolean:
boolean reciboPagado = false; // ¡¿Aun no nos han pagado?!

d.) Tipo de datos carácter

Se usa para almacenar caracteres Unicode simples. Debido a que el conjunto de caracteres Unicode se compone de valores de 16 bits, el tipo de datos char se almacena en un entero sin signo de 16 bits.
Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.
Literales carácter
Representan un único carácter (de la tabla de caracteres Unicode 1.1) y aparecen dentro de un par de comillas simples. De forma similar que en C/C++. Los caracteres especiales (de control y no imprimibles) se representan con una barra invertida ('\') seguida del código carácter.
Descripción Representación Valor Unicode
Caracter Unicode \udddd
Numero octal \ddd
Barra invertida \\ \u005C
Continuación \ \
Retroceso \b \u0008
Retorno de carro \r \u000D
Alimentación de formularios \f \u000C
Tabulación horizontal \t \u0009
Línea nueva \n \u000A
Comillas simples \’ \u0027
Comillas dobles \" \u0022
Números arábigos ASCII 0-9 \u0030 a \u0039
Alfabeto ASCII en mayúsculas A.-Z \u0041 a \u005A
Alfabeto ASCII en minúsculas a.-z \u0061 a \u007A
Tabla 7: Caracteres especiales Java
Las variables de tipo char se declaran de la siguiente forma:
char letraMayuscula = 'A'; // Observe la necesidad de las ' '
char letraV = '\u0056'; // Letra 'V'

e.) Conversión de tipos de datos

En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el que fue declarado. Este proceso se denomina "conversión", "moldeado" o "tipado". La conversión se lleva a cabo colocando el tipo destino entre paréntesis, a la izquierda del valor que queremos convertir de la forma siguiente:
char c = (char)System.in.read();
La función read devuelve un valor int, que se convierte en un char debido a la conversión (char), y el valor resultante se almacena en la variable de tipo carácter c.
El tamaño de los tipos que queremos convertir es muy importante. No todos los tipos se convertirán de forma segura. Por ejemplo, al convertir un long en un int, el compilador corta los 32 bits superiores del long (de 64 bits), de forma que encajen en los 32 bits del int, con lo que si contienen información útil, esta se perderá.
Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe ser igual o mayor que el tipo fuente":
Tipo Origen Tipo Destino
byte double, float, long, int, char, short
short double, float, long, int
char double, float, long, int
int double, float, long
long double, float
float double
Tabla 8: Conversiones sin pérdidas de información

B. Vectores y Matrices

Una matriz es una construcción que proporciona almacenaje a una lista de elementos del mismo tipo, ya sea simple o compuesto. Si la matriz tiene solo una dimensión, se la denomina vector.
En Java los vectores se declaran utilizando corchetes ( [ y ] ), tras la declaración del tipo de datos que contendrá el vector. Por ejemplo, esta sería la declaración de un vector de números enteros (int):
int vectorNumeros[ ]; // Vector de números
Se observa la ausencia de un número que indique cuántos elementos componen el vector, debido a que Java no deja indicar el tamaño de un vector vacío cuando le declara. La asignación de memoria al vector se realiza de forma explícita en algún momento del programa.
Para ello o se utiliza el operador new:
int vectorNumeros = new int[ 5 ]; // Vector de 5 números
O se asigna una lista de elementos al vector:
int vectorIni = { 2, 5, 8}; // == int vectorIni[3]=new int[3];
Se puede observar que los corchetes son opcionales en este tipo de declaración de vector, tanto después del tipo de variable como después del identificador.
Si se utiliza la forma de new se establecerá el valor 0 a cada uno de los elementos del vector.

C. Cadenas

En Java se tratan como una clase especial llamada String. Las cadenas se gestionan internamente por medio de una instancia de la clase String. Una instancia de la clase String es un objeto que ha sido creado siguiendo la descripción de la clase.
Cadenas constantes
Representan múltiples caracteres y aparecen dentro de un par de comillas dobles. Se implementan en Java con la clase String. Esta representación es muy diferente de la de C/C++ de cadenas como una matriz de caracteres.
Cuando Java encuentra una constante de cadena, crea un caso de la clase String y define su estado, con los caracteres que aparecen dentro de las comillas dobles.
Vemos un ejemplo de cadena declarada con la clase String de Java:
String capitalUSA = "Washington D.C.";
String nombreBonito = "Amelia";


Cómo utilizar los tipos de datos de Java

public class DataTypes {
public static void main(String[] args) {

boolean isReal=true; // Los nombres son sensibles a // mayúsculas y minúsculas, // deben empezar por una letra y // pueden contener números,_,$

byte d= 122; // Deben ser inferiores a 127
short e= -29000; // Deben ser inferiores a 32767
int f= 100000; // Deben ser inferiores a 2100 mill.
long g= 999999999999L; // Deben poner L al final
float h= 234.99F; // Deben ser < 3E38; F al final

double i= 55E100; char cvalue= '4'; // char '4' no es el entero 4

//Las cadenas (strings) son objetos, no primitivos. //Ejemplo: String nombre= “Claudius”;

}

}

http://zarza.usal.es/~fgarcia/doc/tuto2/II_3.htm
Guía de Iniciación al Lenguaje JAVA
VERSIÓN 2.0 - Octubre de 1999
http://mit.ocw.universia.net/1.00/s02/class-sessions/lecture-3/lecture3.pdf
Nombre del documentó: Tipos de datos básicos en Java,
Estructuras de control.
Día de consulta 6-05-2010

Maquina visrtual de java

La Máquina Virtual Java

La Máquina Virtual Java (JVM) es el entorno en el que se ejecutan los programas Java, su misión principal es la de garantizar la portabilidad de las aplicaciones Java. Define esencialmente un ordenador abstracto y especifica las instrucciones (bytecodes) que este ordenador puede ejecutar. El intérprete Java específico ejecuta las instrucciones que se guardan en los archivos cuya extensión es .class. Las tareas principales de la JVM son las siguientes:
• Reservar espacio en memoria para los objetos creados
• Liberar la memoria no usada (garbage collection).
• Asignar variables a registros y pilas
• Llamar al sistema huésped para ciertas funciones, como los accesos a los dispositivos
• Vigilar el cumplimiento de las normas de seguridad de las aplicaciones Java
Esta última tarea, es una de las más importantes que realiza la JVM. Además, las propias especificaciones del lenguaje Java contribuyen extraordinariamente a este objetivo:
• Las referencias a arrays son verificadas en el momento de la ejecución del programa
• No hay manera de manipular de forma directa los punteros
• La JVM gestiona automáticamente el uso de la memoria, de modo que no queden huecos.
• No se permiten realizar ciertas conversiones (casting) entre distintos tipos de datos.
Por ejemplo, cuando el navegador encuentra una página web con un applet, pone en marcha la JVM y proporciona la información que aparece en la etiqueta
... . El cargador de clases dentro de la JVM ve que clases necesita el applet. Dentro del proceso de carga, las clases se examinan mediante un verificador que asegura que las clases contienen código válido y no malicioso. Finalmente, se ejecuta el applet.

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/introduccion/virtual.htm
Última actualización:
Programación en lenguaje Java
nombre del articulo: Curso de Lenguaje Java: Enero de 2000
Procedimientos Numéricos en Lenguaje Java: Diciembre de 2001

hora de consulta 5-05-2010

Caracteristicas de java

CARACTERÍSTICAS DE JAVA

A. Introducción
No es arriesgado afirmar que Java supone un significativo avance en el mundo de los entornos software, y esto viene avalado por tres elementos claves que diferencian a este lenguaje desde un punto de vista tecnológico:
• Es un lenguaje de programación que ofrece la potencia del diseño orientado a objetos con una sintaxis fácilmente accesible y un entorno robusto y agradable.
• Proporciona un conjunto de clases potente y flexible.
• Pone al alcance de cualquiera la utilización de aplicaciones que se pueden incluir directamente en páginas Web (aplicaciones denominadas applets).
Java aporta a la Web una interactividad que se había buscado durante mucho tiempo entre usuario y aplicación.
A lo largo de este apartado se estudian en detalle las principales características de Java.
B. Potente

a.) Orientación a objetos
En este aspecto Java fue diseñado partiendo de cero, no siendo derivado de otro lenguaje anterior y no tiene compatibilidad con ninguno de ellos.
En Java el concepto de objeto resulta sencillo y fácil de ampliar. Además se conservan elementos "no objetos", como números, caracteres y otros tipos de datos simples.
b.) Riqueza semántica
Pese a su simpleza se ha conseguido un considerable potencial, y aunque cada tarea se puede realizar de un número reducido de formas, se ha conseguido un gran potencial de expresión e innovación desde el punto de vista del programador.
c.) Robusto
Java verifica su código al mismo tiempo que lo escribe, y una vez más antes de ejecutarse, de manera que se consigue un alto margen de codificación sin errores. Se realiza un descubrimiento de la mayor parte de los errores durante el tiempo de compilación, ya que Java es estricto en cuanto a tipos y declaraciones, y así lo que es rigidez y falta de flexibilidad se convierte en eficacia. Respecto a la gestión de memoria, Java libera al programador del compromiso de tener que controlar especialmente la asignación que de ésta hace a sus necesidades específicas. Este lenguaje posee una gestión avanzada de memoria llamada gestión de basura, y un manejo de excepciones orientado a objetos integrados. Estos elementos realizarán muchas tareas antes tediosas a la vez que obligadas para el programador.
d.) Modelo de objeto rico
Existen varias clases que contienen las abstracciones básicas para facilitar a los programas una gran capacidad de representación. Para ello se contará con un conjunto de clases comunes que pueden crecer para admitir todas las necesidades del programador.
Además la biblioteca de clases de Java proporciona un conjunto único de protocolos de Internet.
El conjunto de clases más complicado de Java son sus paquetes gráficos AWT (Abstract Window Toolkit) y Swing. Estos paquetes implementan componentes de una interfaz de usuario gráfica básica común a todos los ordenadores personales modernos.

C. Simple

a.) Fácil aprendizaje
El único requerimiento para aprender Java es tener una comprensión de los conceptos básicos de la programación orientada a objetos. Así se ha creado un lenguaje simple (aunque eficaz y expresivo) pudiendo mostrarse cualquier planteamiento por parte del programador sin que las interioridades del sistema subyacente sean desveladas.
Java es más complejo que un lenguaje simple, pero más sencillo que cualquier otro entorno de programación. El único obstáculo que se puede presentar es conseguir comprender la programación orientada a objetos, aspecto que, al ser independiente del lenguaje, se presenta como insalvable.
b.) Completado con utilidades
El paquete de utilidades de Java viene con un conjunto completo de estructuras de datos complejas y sus métodos asociados, que serán de inestimable ayuda para implementar applets y otras aplicaciones más complejas. Se dispone también de estructuras de datos habituales, como pilas y tablas hash, como clases ya implementadas.
Existirá una interfaz Observer/Observable que permitirá la implementación simple de objetos dinámicos cuyo estado se visualiza en pantalla.
El JDK (Java Development Kit) suministrado por Sun Microsystems incluye un compilador, un intérprete de aplicaciones, un depurador en línea de comandos, y un visualizador de applets entre otros elementos.

D. Interactivo y orientado a red

a.) Interactivo y animado
Uno de los requisitos de Java desde sus inicios fue la posibilidad de crear programas en red interactivos, por lo que es capaz de hacer varias cosas a la vez sin perder rastro de lo que debería suceder y cuándo. Para se da soporte a la utilización de múltiples hilos de programación (multithread).
Las aplicaciones de Java permiten situar figuras animadas en las páginas Web, y éstas pueden concebirse con logotipos animados o con texto que se desplace por la pantalla. También pueden tratarse gráficos generados por algún proceso. Estas animaciones pueden ser interactivas, permitiendo al usuario un control sobre su apariencia.
b.) Arquitectura neutral
Java está diseñado para que un programa escrito en este lenguaje sea ejecutado correctamente independientemente de la plataforma en la que se esté actuando (Macintosh, PC, UNIX…). Para conseguir esto utiliza una compilación en una representación intermedia que recibe el nombre de códigos de byte, que pueden interpretarse en cualquier sistema operativo con un intérprete de Java. La desventaja de un sistema de este tipo es el rendimiento; sin embargo, el hecho de que Java fuese diseñado para funcionar razonablemente bien en microprocesadores de escasa potencia, unido a la sencillez de traducción a código máquina hacen que Java supere esa desventaja sin problemas.
c.) Trabajo en red
Java anima las páginas Web y hace posible la incorporación de aplicaciones interactivas y especializadas. Aporta la posibilidad de distribuir contenidos ejecutables, de manera que los suministradores de información de la Web pueden crear una página de hipertexto (página Web) con una interacción continuada y compleja en tiempo real; el contenido ejecutable es transferido literalmente al ordenador del usuario.
Los protocolos básicos para trabajar en Internet están encapsulados en unas cuantas clases simples. Se incluyen implementaciones ampliables de los protocolos FTP, HTTP, NNTP y SMTP junto con conectores de red de bajo nivel e interfaces de nombrado. Esto le permite interactuar con esos servicios de red poderosos sin tener que comprender realmente los detalles de bajo nivel de esos protocolos. Este lenguaje está diseñado para cumplir los requisitos de entrega de contenidos interactivos mediante el uso de applets insertados en sus páginas HTML. Además, las clases de Java admiten muy bien estos protocolos y formatos. El envío de las clases de Java a través de Internet se realiza con gran facilidad, ya que existe una interfaz unificada, resolviendo así los típicos problemas de diferencia de versiones.
Java proporciona un conjunto de clases para tratar con una abstracción de los conectores de red (sockets) originales de la versión UNIX de Berckley, encapsular la noción de una dirección de Internet o conectar sockets con flujos de datos de Entrada/Salida.
Con todas estas posibilidades aumenta el dinamismo y competitividad de la Web, puesto que es capaz de captar el interés del usuario durante largo tiempo y permite a los programadores convertir la Web en un sistema de entrega de software.
d.) Applets
Una applet (miniaplicación) es un pequeño programa en Java transferido dinámicamente a través de Internet. Presentan un comportamiento inteligente, pudiendo reaccionar a la entrada de un usuario y cambiar de forma dinámica. Sin embargo, la verdadera novedad es el gran potencial que Java proporciona en este aspecto, haciendo posible que los programadores ejerzan un control sobre los programas ejecutables de Java que no es posible encontrar en otros lenguajes.

E. Y mucho más

a.) Seguridad
Existe una preocupación lógica en Internet por el tema de la seguridad: virus, caballos de Troya, y programas similares navegan de forma usual por la red, constituyendo una amenaza palpable. Java ha sido diseñado poniendo un énfasis especial en el tema de la seguridad, y se ha conseguido lograr cierta inmunidad en el aspecto de que un programa realizado en Java no puede realizar llamadas a funciones globales ni acceder a recursos arbitrarios del sistema, por lo que el control sobre los programas ejecutables no es equiparable a otros lenguajes.
Los niveles de seguridad que presenta son:
• Fuertes restricciones al acceso a memoria, como son la eliminación de punteros aritméticos y de operadores ilegales de transmisión.
• Rutina de verificación de los códigos de byte que asegura que no se viole ninguna construcción del lenguaje.
• Verificación del nombre de clase y de restricciones de acceso durante la carga.
• Sistema de seguridad de la interfaz que refuerza las medidas de seguridad en muchos niveles.
En futuras versiones se prevé contar también con encriptación y técnicas similares.
b.) Lenguaje basado en C++
Java fue desarrollado basándose en C++, pero eliminando rasgos del mismo poco empleados, optándose por una codificación comprensible. Básicamente, encontramos las siguientes diferencias con C++:
• Java no soporta los tipos struct, union ni punteros.
• No soporta typedef ni #define.
• Se distingue por su forma de manejar ciertos operadores y no permite una sobrecarga de operadores.
• No soporta herencia múltiple.
• Java maneja argumentos en la línea de comandos de forma diversa a como lo hacen C o C++.
• Tiene una clase String que es parte del paquete java.lang y se diferencia de la matriz de caracteres terminada con un nulo que usan C y C++.
• Java cuenta con un sistema automático para asignar y liberar memoria, con lo que no es necesario utilizar las funciones previstas con este fin en C y C++.
c.) Gestión de la Entrada/Salida
En lugar de utilizar primitivas como las de C para trabajar con ficheros, se utlizan primitivas similares a las de C++, mucho más elegantes, que permiten tratar los ficheros, sockets, teclado y monitor como flujos de datos.
De este modo se pueden utilizar dichas primitivas para cualquier operación de Entrada/Salida.
d.) Diferentes tipos de aplicaciones
En Java podemos crear los siguientes tipos de aplicaciones:
• Aplicaciones: Se ejecutan sin necesidad de un navegador.
• Applets: Se pueden descargar de Internet y se observan en un navegador.
• JavaBeans: Componentes software Java, que se puedan incorporar gráficamente a otros componentes.
• JavaScript: Conjunto del lenguaje Java que puede codificarse directamente sobre cualquier documento HTML
• Servlets: Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas CGI (Common Gateway Interface) a la hora de dotar de interactividad a las páginas Web.

http://zarza.usal.es/~fgarcia/doc/tuto2/I_3.htm
Nombre del documento Guía de Iniciación al Lenguaje JAVA
VERSIÓN 2.0 - Octubre de 1999
hora de consulta 5-05-2010

Caracteristicas de la POO

Características de la programación orientada a objetos

Hay un cierto desacuerdo sobre exactamente qué características de un método de programación o lenguaje le definen como “orientado a objetos”, pero hay un consenso general en que las características siguientes son las más importantes (para más información, seguir los enlaces respectivos):

• Abstracción: Cada objeto en el sistema sirve como modelo de un “agente” abstracto que puede realizar trabajo, informar y cambiar su estado, y “comunicarse” con otros objetos en el sistema sin revelar cómo se implementan estas características. Los procesos, las funciones o los métodos pueden también ser abstraídos y cuando lo están, una variedad de técnicas son requeridas para ampliar una abstracción.
• Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar la cohesión de los componentes del sistema. Algunos autores confunden este concepto con el principio de ocultación, principalmente porque se suelen emplear conjuntamente.
• Principio de ocultación: Cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas, solamente los propios métodos internos del objeto pueden acceder a su estado. Esto asegura que otros objetos no pueden cambiar el estado interno de un objeto de maneras inesperadas, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstracción. La aplicación entera se reduce a un agregado o rompecabezas de objetos.
• Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado. Cuando esto ocurre en “tiempo de ejecución”, esta última característica se llama asignación tardía o asignación dinámica. Algunos lenguajes proporcionan medios más estáticos (en “tiempo de compilación”) de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.
• Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener que reimplementar su comportamiento. Esto suele hacerse habitualmente agrupando los objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común. Cuando un objeto hereda de más de una clase se dice que hay herencia múltiple; esta característica no está soportada por algunos lenguajes (como Java).

Escrito por juananruiz
Septiembre 19, 2007 a 5:40 pm
http://frameworkphp.wordpress.com/2007/09/19/caracteristicas-de-la-programacion-orientada-a-objetos/

dia de consulta 5-05-2010

Que es la POO

La Programación Orientada a Objetos (POO u OOP) es un paradigma de programación que define los programas en términos de “clases de objetos”, objetos que son entidades que combinan estado (propiedades o datos), comportamiento (procedimientos o métodos) e identidad (propiedad del objeto que lo diferencia del resto).
La programación orientada a objetos expresa un programa como un conjunto de estos objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y módulos más fáciles de escribir, mantener y reutilizar.

Escrito por juananruiz
Septiembre 19, 2007 a 5:29 pm
http://frameworkphp.wordpress.com/2007/09/19/definicion-de-programacion-orientada-a-objetos/

dia de consulta 5-05-2010