CodigoByte

Operadores Condicionales

2010-05-28T22:13:00.000-04:30

Generalmente los operadores condicionales se usan en combinación con los operadores ralacionales para determinar si una condición es true o false. Los tres operadores condicionales se listan a continuación:

&&: el operador && (AND) se usa para determinar si las condiciones a ambos lados del operador resultan en true o false. Primero se evalúa el resultado de la condición a la izquierda del operando, si resulta en true, entonces el resultado de la condición a la derecha del operador es evaluado. Si ambas condiciones resultan en true, entonces esta operación también resulta en true. Si la condición a la izquierda del operador resulta en false, la condición a la derecha del operador no es evaluada, y la operación completa resulta en false. La siguiente expresión ilustra el uso de este operador:

(a < b) && (b < c)

||: El operador || (OR) se usa para determinar si al menos uno de las dos condiciones en alguno de los lados de este operador es true. Si la condición a la izquierda de este operador resulta en false, entonces la condición a la derecha es evaluada, si esta última condición resulta en true, entonces el resultado de la operación es true. Si la condición a la izquierda de este operador es true, entonces la condición a la derecha no es evaluada, y el resultado de la operación es true. La siguiente expresión ilustra el uso de este operador:

(a < b) || (b < c)

!: El operador ! (NOT) se usa para negar el resultado obtenido en una operación. Si el resultado de una operación es true, entonces el resultado de esta operación después de aplicar el operador ! Es false, y al contrario, el caso que la operación es false, la operación completa es true. La siguiente expresión ilustra el uso del operador NOT:

!(a < b)

He aquí un programa que demuestra el operador &&. El programa determina si el valor de d es un factor de n. Lo hace al realizar una operación de módulo. Si el sobrante de n/d es cero, entonces d es un factor. Sin embargo, como la operación de módulo incluye una división, la forma del operador condicional de && se usa para evitar un error de división entre cero.

// Demuestra los operadores Condicionales

class CCops{

public static void main(String args[]) {

int n, d, q;

n = 10;

d = 2;

if(d != 0 && (n % d) == 0)

System.out.println(d +” es un factor de “ + n);

d = 0; //ahora, fijamos d en cero

// Como d es cero, el segundo operando no se evalúa.

if(d != 0 (n % d) == 0)

System.out.println(d + “ es una factor de “ + n);

}

Operadores Relacionales

2010-05-27T15:00:00.006-04:30

Los operadores relacionales se usan para comparar dos valores almacenados en variables. Los diferentes operadores relacionales se listan a continuación:

<: El operador menor que < se usa para determinar si el valor almacenado en una variable es menor que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a < b

>: El operador mayor que > se usa para determinar si el valor almacenado en una variable es mayor que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a > b

<=: El operador menor o igual que <= su usa para determinar si el valor almacenado en una variable es menor o igual que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a <= b

>=: El operador mayor o igual que >= se usa para determinar si el valor almacenado en una variable es mayor o igual que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a >= b

==: El operador de igualdad == se usa para determinar si el valor almacenado en una variable es igual al valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a == b

!=: El operador de no igual != se usa para determinar si el valor almacenado en una variable es diferente al valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a != b

Tómese como ejemplo, dos números, 35 y 65, y determine que sucede cuando se usan los diferentes operadores relacionales en ellos:

35 < 65 resulta en true
35 > 65 resulta en false
35 <= 65 resulta en true
35 >= 65 resulta en false
35 == 65 resulta en false
35 != 65 resulta en true

En Java es posible comparar todos los objetos para saber si son iguales o no empleando == y !=. Sin embargo, los operadores de comparación <, >, <= o >= sólo pueden aplicarse a los tipos que soportan una relación de orden. Por lo tanto, todos los operadores relacionales pueden aplicarse a todos los tipos numéricos y a tipos char. Sin embargo, los valores de tipo boolean sólo pueden compararse para igualdad o desigualdad porque los valores “true” y “false” no están ordenados. Por ejemplo, true > false no tiene significado en Java.

Operadores Aritméticos

2010-05-26T21:00:00.005-04:30

Java define los siguientes operadores aritméticos:

Operador: Significado

+ Suma

- Resta

* Multiplicación

/ División

% Módulo

++ Incremento

– Decremento

Los operadores +, -, * y / funcionan de la misma manera en Java que en cualquier otro lenguaje de cómputo (o el álgebra, si ese es el caso). Estos operadores pueden aplicarse a cualquier tipo numérico de datos y usarse en objetos de tipo char.

Aunque las acciones de los operadores aritméticos le resultan familiares a todos los lectores, existen unas cuantas situaciones especiales que requieren cierta explicación. En primer lugar, recuerde que cuando / se aplica a un entero, cualquier resto se truncará: por ejemplo, 10/3 será igual a 3 en una división entre enteros. Para obtener la fracción de la división debe usar el operador de módulo %. Este operador funciona de la misma forma en Java que en otros lenguajes: presenta el sobrante de una división entre enteros como, por ejemplo, 10%3 es 1. en Java, el % puede aplicarse a tipos enteros y punto flotante. Por lo tanto, 10.0 % 3.0 también es 1. El siguiente programa demuestra el operador de módulo.

//Demuestra el operador %.

class ModDemo {

public static void main(String args[]) {

int iresult, irest;

double dresult, drest;

iresult = 10 / 3;

irest = 10 % 3;

dresult = 10.0 / 3.0;

dresult = 10.0 % 3.0;

System.out.println(“Resultado y sobrante de 10 / 3: “ + iresult + “ “ + irest);

System.out.println(“Resultado y sobrante de 10.0 / 3.0: “ + dresult + “ “ + drest);

}

A continuación se muestra la salida del programa:

Resultado y sobrante de 10 / 3: 3 1

resultado y sobrante de 10.0 / 3.0: 3.33333333333333 1.0

Como verá, % presenta un sobrante 1 para ambas operaciones, de entero o de punto flotante.

Incremento y decremento

++ y – son los operadores de incremento y decremento en Java. Como verá, tienen algunas propiedades especiales que los hacen interesantes. Empecemos por revisar de manera precisa las acciones que los operadores de incremento y decremento llevan a cabo.

El operador de incremento agrega 1 a su operando y el de decremento resta 1. De ahí que,

x = x + 1;

es lo mismo que

x++;

x = x – 1;

es lo mismo que

--x;

Ambos operadores pueden preceder (prefijo) o seguir (sufijo) al operando. Por ejemplo,

x = x + 1;

puede escribirse como

++x; // forma de prefijo

o como

x++; // forma de sufijo

En el siguiente ejemplo, el que el incremento se aplique como prefijo o como sufijo no representa ninguna diferencia. Sin embargo, se presenta una diferencia importante cuando se usa un incremento o decremento como parte de una expresión más larga, cuando un operador de incremento o decremento precede a su operando, Java realiza la operación correspondiente antes de obtener el valor del operando con el fin de que el resto de la expresión use dicho valor. Si el operador sigue a su operando, Java obtendrá el valor del operando antes de incrementarlo o decrementarlo. Tome en cuenta lo siguiente:

x = 10;

y = ++x;

En este caso, y será 11. Sin embargo, si el código se escribe como:

x = 10;

y = x++;

entonces y será 10. en ambos casos, x aún tendrá un valor de 11; la diferencia es el momento en que ocurre. Tener la capacidad de controlar el momento en que la operación de incremento o decremento tiene lugar implica ventajas importantes.

Operadores en Java

2010-05-26T11:32:00.002-04:30

Cuando se escribe un programa, se usan numerosas expresiones para calcular algunos valores específicos. Estas expresiones hacen uso de varios operadores y son similares a expresiones aritméticas que usan muchos operadores. Las variables usadas en estas expresiones se llaman operandos. Existen algunos operadores que solo necesitan un operando, son llamados operadores unarios (ejemplo: ++). Los operadores que requieren dos operandos se llaman operadores binarios (por ejemplo, +), y los operadores que requieren tres operandos se llaman operadores ternarios (ejemplo: ,?:).

Java soporta los siguientes tipos de operadores:

Operadores aritméticos.
Operadores relacionales.
Operadores condicionales.
Operadores Ternarios.
Operadores de bits.
Operadores de Asignación.

El Alcance y la Vida de las Variables

2010-05-25T21:00:00.005-04:30

Hasta ahora, todas la variables que hemos usado se declararon al principio del método main(). Sin embargo, Java permite que las variables se declaren dentro de cualquier bloque. El inicio de un bloque se marca con un carácter '{', y el fin del bloque, con el correspondiente carácter '}'. Un bloque puede contener otro bloque (o cualquier número de bloques) dentro de él, estos se denominan bloques anidados. Un bloque define el alcance; por lo tanto, cada vez que inicia un nuevo bloque, está creando un nuevo alcance. Un alcance determina cuáles objetos son visibles a otras partes de su programa. Así mismo, determina la vida de dichos objetos.

Casi todos los demás lenguajes de cómputo definen dos categorías generales de alcance: global y local. Aunque están soportadas por Java, no constituyen las mejores formas de categorizar los alcances de Java. Los alcances más importantes son los definidos por una clase y los definidos por un método.

El alcance definido por un método inicia con su llave de apertura. Sin embargo, si dicho método contiene parámetros, éstos se incluyen también dentro de su alcance.

Como regla general, las variables que están declaradas dentro de un alcance no son visibles (es decir, accesibles) a un código que esté definido fuera de este alcance. Por lo tanto, cuando declara una variable dentro del un alcance, localiza esa variable y la protege de acceso no autorizado, de modificación o de ambas posibilidades. Por supuesto, las reglas de alcance proporcionan la base del encapsulamiento.

Así mismo, los alcances pueden están anidados. Por ejemplo, cada vez crea un bloque de código, crea un nuevo alcance anidado. Cuando esto ocurre, el alcance exterior encierra al interior. Esto significa que los objetos declarados en el alcance exterior se volverán visibles al código dentro del alcance interno. Sin embargo, la situación contraria no aplica: los objetos declarados dentro del alcance interior no serán visibles fuera de él.

Para comprender el efecto del los alcances anidados, considere el siguiente programa:

// Demuestra el alcance del bloque.

class AlcanceDemo {

public static void main(String args[]) {

int x; // conocido a todo el código en main

x = 10;

if (x == 10) { //inicia nuevo alcance

int c = 20; //conocido sólo a este bloque

// x y c son conocidos aquí.

System.out.println(“ x y c : “+ x +” “+ c);

x= c * 2;

}

c = 100 // Error. A c no se le conoce aquí, está fuera de su alcance.

// x es aún conocido aquí.

System.out.pritnln(“x es “ + x);

}

Como lo indica el comentario, la variable x se declara al principio del alcance de main() y es accesible a todo el código posterior dentro de main(). Dentro del bloque if, está declarada c. Debido a que un bloque define un alcance, c sólo es visible dentro del código de su bloque. Por tal motivo, fuera de su bloque, la línea c = 100; hará que ocurra un error en tiempo de ejecución porque c no es visible fuera de su bloque. Dentro del bloque if, x puede usarse porque el código dentro del bloque (es decir, un alcance anidado) tiene acceso a variables declaradas por un alcance incluido.

Dentro de un bloque, las variables pueden declararse en cualquier punto; sin embargo, sólo son válidas después de ser declaradas. De manera que, si define una variable al inicio de un método, ésta estará disponible para todo el código dentro del método . Por el contrario, si declara un variable al final de un bloque, ésta carecerá de uso porque ningún código tendrá acceso a ella.

A este respecto, hay que recordar otro elemento: las variables se crean cuando se introduce su alcance y se destruye cuando se abandona su alcance. Esto significa que una variable no contendrá su valor una vez que se haya salido de sus alcance. Por lo tanto, las variables declaradas dentro de un bloque perderán su valor cuando se abandone el bloque. Así, la vida de una variable está confinada a su alcance.

Declaración e Inicialización de Variables

2010-05-24T22:43:00.003-04:30

Java es un lenguaje fuertemente tipificado, es decir, toda variable debe tener un tipo de dato asociado. Esto ayuda a saber el tipo de dato almacenado dentro de la variable o el tipo de dato que necesita ser almacenado dentro de la variable. Las variables se declaran usando esta forma de instrucción:

tipo nombre-var;

Donde tipo es el tipo de datos de la variable y nombre-var es el nombre de la variable. Puede declarar una variable de cualquier tipo válido. Cuando crea una variable, está creando una instancia de su tipo. Por lo tanto, las capacidades de una variable están determinadas por su tipo. Por ejemplo, una variable de tipo boolean no puede utilizarse para almacenar valores de punto flotante. Más aún, el tipo de una variable no puede cambiar durante su existencia. Una variable int no puede convertirse en un char, por ejemplo.

Todas las variables en Java deben declararse antes de ser utilizadas. Esto es necesario porque el compilador debe saber qué tipo de datos contiene una variable antes de poder compilar apropiadamente cualquier instrucción que emplee la variable. También le permite a Java realizar una revisión estricta del tipo.

Inicialización de una variable

En general, debe proporcionar a una variable un valor antes de usarla. Una manera de hacerlo es mediante una instrucción de asignación, como ya lo ha visto. Otra manera consiste en proporcionarle un valor inicial cuando se declara. Para ello, coloque un signo de igual después del nombre de la variable y luego incluya el valor asignado. Aquí se muestra la forma general de inicialización:

tipo var = valor;

En este caso, valor es el valor que se le da a var cuando se crea. El valor debe ser compatible con el tipo especificado. He aquí algunos ejemplos:

int cuenta = 10; // proporciona a cuenta un valor inicial de 10

char ch = 'X'; // inicializa ch con la letra X

float f = 1.2F; // f se inicializa con 1.2

Cuando se declaran dos o más variables del mismo tipo empleado una lista separada por comas puede dar a una o más de estas variables un valor inicial. Por ejemplo:

int a, b = 8, c = 19, d; // b y c tienen inicializaciones

En este caso, sólo b y c están inicializadas.

Inicialización dinámica

Aunque en los ejemplos anteriores sólo se han usado constantes como inicializadores, Java permite que las variables se inicialicen dinámicamente empelando cualquier expresión válida en el momento en que se declara la variable. Por ejemplo, he aquí un programa corto que calcula el volumen de un cilindro dados el radio de su base y su altura.

// Demuestra la inicialización dinámica.

class InicDin{

public static void main(String args[]) {

double radio = 4, altura = 5;

// inicializa dinámicamente el volumen

double volumen = 3.1416 * radio * radio * altura:

System.out.println(“El volumen es “ + volumen);

}

En este caso, están declaradas tres variables locales (radio, altura y volumen). Las primeras dos (radio y altura) están inicializadas. Sin embargo, volumen está inicializada dinámicamente al volumen del cilindro. La clave aquí es que la expresión de inicialización puede ser cualquier elemento válido en el tiempo de la inicialización, incluidas llamadas a métodos, así como otras variables o literales.

Identificadores (variables)

2010-05-18T20:53:00.001-04:30

Cuando se escribe un programa se necesita almacenar los valores usados en el programa. Estos valores se almacenan en la memoria, se necesita tener un método simple para acceder a estas posiciones en la memoria. Por esto se usa un identificador o variable para referirnos a estas posiciones en memoria.

Convenciones de Nombres

Hay algunas reglas que tienen que seguirse al momento de nombrar variables en Java. Estas son:

Los nombres de variables deben comenzar con una letra, subrayado (_) o dólar($). Sin embargo, no hay restricción en el número de letras que se pueden usar.
Los nombres de variables pueden contener letras, números, el subrayado (_) y el carácter dólar ($).
No debe haber espacio entre los caracteres.
No hay límite de longitud del nombre de la variable.
Las palabras clave de Java no pueden usarse como nombres de variables.
Para una mejor legibilidad, los nombres de variables deben componerse de dos o más palabras significativas. La primera letra de la variable será siempre en minúsculas y las primeras letras de las palabras subsecuentes en mayúsculas (Ejemplo: numeroCuenta).
En el caso de nombres de clase, todas las palabras que son parte del nombre de la clase deben comenzar con una letra mayúscula (Ejemplo: StringBuffer).

Manejo de String

2010-05-17T20:35:00.000-04:30

El manejo de cadenas de caracteres (string) en Java se hace usando las clases String o StringBuffer, ambas clases se usan para almacenar y manipular cadenas de caracteres. Sin embargo, hay una diferencia principal entre estas dos clases en la forma en la que son manejados por el sistema de tiempo de ejecución de Java.

La Clase String

El literal string se usa para almacenar valores string (cadena de caracteres). La clase String se usa para denotar un literal string. Se puede especificar strings al cerrar el texto dentro de comillas dobles, es importante notar la diferencia entre comillas simples y dobles: 'z' no es equivalente a “z”. La primera es el carácter z, la segunda es una cadena de caracteres (string) de una carácter. El siguiente código muestra la declaración de una variable String.

String str = “Hola”;

El fin de una cadena de caracteres es usualmente indicado por '\0'.

La clase String es inmutable, lo que significa que su valor no puede ser cambiado una vez que se crea un objeto del tipo String.

Se pueden usar métodos definidos en la clase String para hacer lo siguiente:
Examinar los diferentes caracteres que componen una cadena de caracteres.
Buscar una sub-vadena dentro de una cadena de caracteres.
Comparar dos cadenas de caracteres.
Crear otra cadena de caracteres que tengan todos los caracteres de la primera cadena de caracteres en mayúsculas o minúsculas.

Dos cadenas de caracteres pueden ser concatenadas usando el operador “+”. Como String es inmutable, esta concatenación es actualmente implementada usando internamente la clase StringBuffer por Java.

String uno = “abcde”;

String dos = “fhgij”;

String tres;

tres = uno + dos;

System.out.println(tres);

El objeto tres es creado y tiene el valor abcdefghij.

La clase StringBuffer

La clase StringBuffer es similar a la clase String y se usa para denotar a un literal string. Sin embargo, StringBuffer es mutable, a diferencia de la clase String. Esto significa que los valores almacenados por objetos de esta clase pueden ser cambiados. StringBuffer juega un rol vital en la concatenación de cadenas de caracteres, actualmente se implementa a través de la creación de objetos StringBuffer, y luego se usa el método append() sobre los obejtos creados. Esto es una alternativa mejor que usar el operador “+” sobre dos objetos String.

Los objetos StringBuffer se pueden usar en aplicaciones multihilos, ya que los métodos que operan en estos objetos pueden ser sincronizados para evitar la ocurrencia del interbloqueo.

La clase StringBuilder

Esta clase proporciona un API compatible de StringBuffer, pero no se garantiza su bajo escenarios de sincronización. Fue diseñada para usarla como el reemplazo de StringBuffer en donde el stringsea utilizado por un solo hilo (generalmente es el caso). En lo posible, se recomienda que esta clase sea utilizada preferiblemente en lugar de StringBuffer pues será más rápida en la mayoría de los casos.

Las operaciones principales de StringBuilder son los métodos append e insert, cuando son sobrecargados para aceptar datos de cuallquier tipo. Cada uno convierte con eficacia un dato dado a un string y añade o inserta los caracteres de ese string al string en construcción. El método append agrega siempre estos caracteres al final de la secuencia de caracteres en construcción; el método insert agrega los caracteres en un punto especificado.

Por ejemplo, si x se refiere a un objeto StringBuilder que contiene “lava”, después de la llamada x.append(“manos”) del método haría que la secuencia construida contenga “lavamanos”, mientras que x.insert(4,”nos”) alteraría la construcción de la secuencia para contener “lavanosmanos”.

Las instancias StringBuilder no son seguras para el uso con múltiples hilos. Si se necesita o requiere la sincronización entonces se recomienda que StringBuffer sea utilizado.

Diferencias entre String, StringBuilder y StringBuffer

String es inmutable mientras que StringBuffer y StringBuilder pueden cambiar sus valores.

La única diferencia entre StringBuffer y StringBuilder es que StringBuilder es asíncrono mientras que StringBuffer es síncrono. Por lo tanto cuando una aplicación necesita funcionar solamente con un hilo entonces es mejor utilizar StringBuilder. StringBuilder es más eficiente que StringBuffer.

Criterios para elegir entre String, StringBuffer y StringBuilder:

Si el texto no va a cambiar usar la clase String porque un objeto String es inmutable.
Si el texto puede cambiar y es accedido solamente por un hilo, utilizar un StringBuilder porque StringBuilder no es síncrono.
Si el texto puede cambiar, y es accedido por múltiples hilos, utilizar un StringBuffer porque StringBuffer es síncrono.

Math Clases Colaboradoras sobre los Tipos de Datos

2010-05-14T21:57:00.002-04:30

Math Clases Colaboradoras sobre los Tipos de Datos

Existen otras dos clases en Java, una de ellas se ocupa de los enteros de precisión arbitraria inmutables, y la otra de números decimales con signo de precisión arbitraria inmutables. La primera está representada por java.math.BigInteger y la segunda clase por java.math.BigDecimal. Dado, que ambas clases tratan también con números en Java, se va a discutir acerca de ellas brevemente.

Los tipos primitivos enteros de Java no pueden efectuar operaciones sobre números largos, por esto Java provee un paquete llamado Math, que tiene dos clases, son estas: BigInteger y BigDecimal, para realizar operaciones matemáticas sobre números largos.

La Clase java.math.BigInteger

Esta clase provee la abstracción de enteros de un “tamaño de palabras infinito” representados por el tipo de datos int. Esta clase es inmutable, lo que significa que el valor representado por esta clase no puede cambiar; representa enteros de precisión arbitraria. BigInteger se representa usando la forma de complemento dos, como en el caso del tipo de dato primitivo int. Todos los operadores que se pueden usar con el tipo de dato primitivo entero tienen operadores análogos que se pueden usar con BigInteger. Usando BigInteger,se pueden realizar manipuaciones de bits, verificar si un número es primo,generar un número primo, calcular el Máximo Común Divisor, etc.

La Clase java.math.BigDecimal

Esta clase se usa para representar dígitos a la derecha del punto decimal en una escala deun entero de 32-bit.BigDecimal usa un valor sin escala que es entero de precisión arbitraria. Esta clase provee métodos que permiten realizar operaciones aritméticas básicas y manipulaciones de escala, también ayuda a comparar dos valores BigDecimal y a convertir el formato de los valores BigDecimal. La clase BigDecimal también permite especificar el comportamiento del redondeo para los valores decimales proporcionando ocho modos de redondeo.

Uso de las clases envolventes en Java

2010-05-13T21:58:00.003-04:30

Uso de las clases envolventes en Java

El código que sigue usa varios métodos estáticos y métodos de instancia en las clases envolventes. El programa mostrará el uso de las clases envolventes para Integer y Float.

/*Definición de la clase EnvolventesEjemplo comienza aquí*/

public class EnvolventesEjemplo {

/*El método main comienza aquí */

public static void main(String args[]) {

Integer i = new Integer(5);

String s = “250.47”;

System.out.println(“Valor de i es: “

+ i.toString());

System.out.println(“Valor de s es: “

+ Float.parseFloat(s));

Float f = Float.valueOf(s);

float primitivoFloat = f.floatValue();

int primitivoInt = f.intValue();

System.out.println(“Valor del primitivo float es: “

+ primitivoFloat);

System.out.println(“Valor del primitivo int es: “

+ primitivoInt);

}/*El método main termina aquí */

}/*Definición de la clase EnvolventesEjemplo termina aquí */

La salida del código anterior es la siguiente:

Valor de i es: 5

Valor de s es: 250.47

Valor del primitivo float es: 250.47

Valor del primitivo int es: 250

Clases Envolventes

2010-05-12T21:57:00.005-04:30

Clases Envolventes

Java provee clases envolventes para cada uno de los de datos primitivos. Una clase envolvente da la funcionalidad de una clase para un tipo de datos primitivo. Estas clases envolventes tienen métodos que permiten manipular el tipo de dato primitivo correspondiente que ellos envuelven.

Los tipos de datos primitivos tienen conjuntos de operaciones que se pueden usar con ellos. Sin embargo, cuando se quiere proveer algunas funciones utilitarias para un tipo de dato en particular, se usan las clases envolventes y se proveen funciones primitivas dentro de las clases envolventes.

Hay ciertas clases, que vienen como parte de la librería de Java, que requieren de un objeto en vez de una variable de tipo de dato primitivo. Los objetos de las clases envolventes se pueden usar también para este propósito.

Java provee clases envolventes para todos los tipos de datos primitivos.

La Clase java.lang.Boolean

La clase Boolean es la representación en objeto del tipo de dato primitivo boolean. Esta clase, es una clase envolvente para el tipo primitivo boolean, por lo tanto, tiene un miembro del tipo boolean. También tiene ciertos métodos que se pueden usar para manipular el valor del boolean almacenado internamente.

La clase Boolean tiene el método booleanValue(), que retorna el valor del boolean que está envuelto en este objeto. También tiene los métodos equals(), toString()yhashCode()que son sobrescritos de la clasejava.lang.Object.

La claseBooleantiene el métodostatic valueOf()para convertir una representación de objetoStringen un valorBoolean.

La Clase java.lang.Byte

La claseBytees la representación en obejto del tipo de dato primitivobyte. Esta clase, por ser una clase envolvente para el tipo de dato primitivobyte, tiene un miembro del tipobyte. Esta clase tiene métodos que permiten obtener el valor delbytealmacenado en el objetoByteen la forma debyte, short, int, float o double. Esto se hace usando los siguientes métodos:

byteValue()
shortValue()
intValue()
floatValue()
doubleValue()

La claseBytetambién tiene métodos que son sobrescritos de la clasejava.lang.Object. Estos métodos son los siguientes:

equals()
toString()
hashCode()

Además de estos métodos, la clase Byte tiene el métodostatic valueOf()para convertir una representación de objetoStringen un valorbyte.

La Clase java.lang.Short

La claseShortes la representación en objeto del tipo de dato primitivoshort. Esta clase, por ser una clase envolvente para el tipo primitivoshort, tiene un miembro del tiposhort. Esta clase tiene métodos que permiten obtener el valor delshortalmacenado en el objetoShorten la forma debyte, short, int, float, odouble. Esto se hace usando los métodos:

byteValue()
shortValue()
intValue()
floatValue()
doubleValue()

La claseShorttambién tiene los métodosequals(),toString()yhashCode()que son sobrescritos de la clasejava.lang.Object.

La claseShorttiene el métodostatic valueOf()para convertir una representación delobjetoStringen un valorShort.

La Clase java.lang.Character

la claseCharacteres la representación en objeto del tipo de dato primitivochar. La claseCharacter, al ser una clase envolvente, tiene un campo del tipo primitivochar. Se pueden usar los métodos provistos por esta clase para manipular variables que mantienen valores del tipo primitivochar. Algunas de las funciones importantes provistas por esta clase dan la posibilidad de determinar el tipo de carácter y convertir un carácter en minúscula a mayúscula y viceversa. Los métodos definidos en la claseCharacterestán basados en la tabla de atributos Unicode. Esta tabla asocia a cada código Unicode definido con un nombre. Los caracteres están encerrados dentro de comillas simples. Así, 'a' es el caráctera. Se pueden obtener caracateres especiales usando secuencias de escape. '\n' es la secuencia de escape para el carácter de nueva línea.

Se puede usar el métodocharValue()de esta clase para obtener el valorcharalmacenado por el objeto en la forma del tipo de dato primitivochar.

La Clase java.lang.Integer

La claseIntegeres la representación en objeto del tipo de dato primitivoint. Un objetoIntegertiene un campo, que es del tipo primitivoint. Es posible usar los métodos provistos por esta clase para manipular variables que mantienen valores del tipo primitivoint.

Algunas de las funciones más importantes provistas por esta clase son la posibilidad de convertir uninta unStringcon el métodotoString(), y de unStringa unintusando el métodoparseInt(String s). Cuando la encuentra valoresinten el código, los interpretará como enteros. Cuando se usa un número como2, la JVM asume que es de tipoint. Si se quiere que la JVM lo interprete como algo diferente a unint, se debe proveer información más específica. Si se quiere que la JVM “piense” que es del tipolong, se debe usar una “L” después del entero. Los otros tipos de datos enterosbyteyshortno pueden ser especificados. Estos serán convertidos al momento de la asignación de valores. Así, la sentenciabyte b = 120;convertirá 120 deintabyte, siempre y cuando el valor pertenezca al rango válido para unbyte.

Esta clase tiene métodos que permiten obtener el valor delintalmacenado en el objetoIntegeren la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), shortValue(), intValue(), floatValue(), ydoubleValue()respectivamente.

La Clase java.lang.Long

La claseLonges la representación en objeto del tipo primitivolong. Esta clase, por ser una clase envolvente del tipo primitivolong, tiene un miembro del tipolong. Sta clase tiene métodos que permiten obtener el valor dellongalmacenado en el objetoLongen la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), longValue(), intValue(), floatValue()ydoubleValue()respectivamente. La claseLongtiene también los métodosequals(), toString()yhashCode()que son sobrescritos desde la clasejava.langObject.

La claseLongtiene un métodostatic valueOf()para convertir una representación del objetoStringen un valorLong.

La Clase java.lang.Float

La claseFloates la representación en objeto del tipo de dato primitivofloat. Esta clase, por se una clase envolvente del tipo primitivofloat, tiene un miembro del tipofloat. También tiene métodos que permiten obtener el valor delfloatalmacenado en el objetoFloaten la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), shortValue(), intValue(), floatValue(), longValue()ydoubleValue()respectivamente.

La clase Float también tiene los métodosequals(), toString()yhashCode()que son sobrescritos de la clasejava.lang.Object.

La claseFloattiene el métodostatic valueOf()para convertir una representación del objeto String en un valor Float.

La Clase java.lang.Double

La claseDoublees la representación en objeto del tipo de dato primitivodouble. Esta clase, por ser una clase envolvente para el tipo primitivodouble, tiene un miembro del tipodouble. También tiene métodos que nos permiten obtener el valor deldoublealmacenadoen el objetoDoubleen la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), shortValue(), intValue(), floatValue()ydoubleValue()respectivamente.

La claseDoubletambién tiene los métodosequals(), toString()yhashCode()que son sobrescritos de la clasejava.lang.Object, así como el método static valueOf() para convertir una representación del objetoStringen un valorDouble.

Tipos de Datos Boolean

2010-05-11T21:56:00.004-04:30

Tipo de Datos Boolean

El tipo boolean representa valores de verdadero/falso. Java define los valores verdadero y falso empleando las palabras reservadas true y false. Por lo tanto, una variable o expresión de tipo boolean será uno de estos dos valores.

He aquí un programa que demuestra el tipo boolean:

//Demuestra valores boolean.

Class BoolDemo {

public static void main(String args[]) {

boolean b;

b = false;

System.out.println(“b es “ + b);

b = true;

System.out.println(“b es “ +b);

//Un valor boolean puede controlar la instrucción if

if(b) System.out.println(“ Esto se ejecuta.”);

b = false;

if(b) System.out.println(“ Esto no se ejecuta.”);

// La salida de un operador relacional es un valor boolean

System.out.println(“10 > 9 es “ + (10 > 9));

}

La Salida generada por este programa se muestra aquí:

b es false

b es true

Esto se ejecuta

10 > 9 es true

Hay que observar aquí tres aspectos interesantes acerca de este programa. En primer lugar, como puede ver, cuando se da salida a un valor boolean con println() se despliega “true” o “false”. En segundo lugar, el valor de una variable boolean es suficiente, en sí misma, para controlar la instrucción if. No es necesario escribir una instrucción if como ésta:

if(b == true) …

En tercer lugar, la salida de un operador relacional , como <, es un valor boolean. Por eso la expresión 10 > 9 despliega el valor “true”. Más aún, el conjunto extra de paréntesis alrededor de 10 > 9 es necesario porque el operador + tiene una mayor precedencia que >.

Caracteres en Java

2010-02-27T14:42:00.003-04:30

En Java, los caracteres no son cantidades de 8 bits como en casi todos los demás lenguajes de cómputo. En cambio, Java usa Unicode. Unicode define un conjunto de caracteres que puede representar todo los caracteres encontrados en el lenguaje humano. Por lo tanto, en Java, char es un tipo de 16 bytes sin signo que tiene un rango de 0 a 65,536. El conjunto de caracteres ASCII estándar de 8 bits es un subconjunto de Unicode y va de 0 a 127. Por consiguiente, los caracteres ASCII aún son caracteres válidos de Java.

Es posible asignar un valor a una variable de carácter al encerrar éste entre comillas. Por ejemplo, para asignar a la variable carácter la letra X:

char ch;

ch = 'X';

Puede dar salida a un valor char empleando la instrucción println(). Por ejemplo, esta línea da salida al valor de ch:

System.out.println(“Este es ch: “ + ch);

Debido a que char es un tipo de 16 bits sin signo, es posible realizar varias manipulaciones aritméticas en una variable char. Por ejemplo, considere el siguiente programa:

// Las variables de carácter se manejan como enteros.

Class CarAritDemo {

public static void main(String args[]) {

char ch;

ch = 'X';

System.out.println(“ch contiene “ + ch);

ch++; //incrementa ch

System.out.println(“ch ahora es “ + ch);

ch = 90; // da a ch el valor Z

System.out.println(“ch es ahora “ + ch);

}

Aquí se muestra la salida generada por este programa:

ch contiene X

ch es ahora Y

ch es ahora Z

En el programa, a ch se le da primero el valor X. Luego se aumenta ch. El resultado es que ahora contiene Y, el siguiente carácter en la secuencia ASCII (y Unicode). Aunque char no es un tipo entero, en algunos casos puede manejarse como si lo fuera. A continuación, se le asigna a ch el valor 90, que es el valor de ASCII (y Unicode) que corresponde a la letra Z. Debido a que el conjunto de caracteres de ASCII ocupa los primeros 127 valores en el conjunto de caracteres de Unicode, todos los “viejos trucos” que ha usado con caracteres en el pasado funcionarán también en Java.

Tipo de datos de punto flotante

2010-02-26T17:54:00.003-04:30

Los tipos de datos de punto flotante pueden representar números que tienen componentes fraccionarios. Hay dos tipos de punto flotante, float y double, que representan números de precisión sencilla y doble, respectivamente. El tipo float es e 32 bits y el tipo double es de 64 bits de ancho.

El rango de estos tipos de datos primitivos es el siguiente:

float -3,4 * 10 ³⁸ hasta 3,4 * 10 ³⁸

double -1,8 * 10 ³⁰⁸ hasta 1,8 * 10 ³⁰⁸

De los dos, double es el más usado porque todas las funciones matemáticas de la biblioteca de clases de Java usan valores double. Por ejemplo, el método sqrt(), (que se define con la clase Math estándar), devuelve un valor double que es la raíz cuadrada de su argumento double.

El siguiente código muestra la declaración de dos variables pertenecientes al tipo de datos de punto flotante.

float a = 1.1f;

double d = 1.1;

Las variables literales float deben terminar con f o F.

Aquí, sqrt() se usa para calcular la longitud de la hipotenusa, dadas las longitudes de los dos lados opuestos:

Use el teorema de Pitágoras para encontrar la longitud de la hipotenusa

dadas las longitudes de los dos lados opuestos.

class Hipot {

public static void main(String args[]) {

double x, y, z;

x = 3;

y = 4;

z = Math.sqrt(x*x + y*y);

System.out.println(“la hipotenusa es “ +z);

}

La salida del programa se muestra aquí:

La hipotenusa es 5.0

Como ya se mencionó, sqrt() es un miembro de la clase estándar Math.Observe cómo se llama a sqrt() (va precedida por el nombreMath). Es una manera similar a cómoSystem.outprecede aprintln(). Aunque no todos los métodos estándar son nombrados especificando primero el nombre de su clase, varios de ellos sí son nombrados de este modo.

Tipo de datos enteros

2010-02-22T17:59:00.003-04:30

Java define cuatro tipos de enteros: byte, short, intylong.

El rango de valores que estos tipos de datos primitivos pueden almacenar se muestra a continuación:

Tipo	Ancho en bits	Rango
byte	8	-128 a 127
short	16	-32,768 a 32,767
int	32	-2,147,483,648 a 2,147,483,647
long	64	-9,223,372,036,854,775,808 a 9,223,372,036,854,775,807

Las diferentes variables variables de los tipos de datos enteros se declaran como se muestra en el siguiente código:

byte b = 1;

short s = 1;

int i = 1;

long l = 1;

En las declaraciones anteriores,a todas las variables se les ha asignado el valor del litera entero 1. Los literales son valores constantes que son asignados a las variables.

El tipo de entero más usado es int. Las variables de tipo int suelen emplearse para bucles control, para indicar matrices y para realizar operaciones matemáticas de propósito general.

Cuando necesite un entero que tenga un rango mayor que int, use long. Por ejemplo, he aquí un programa que calcula el número de pulgadas cúbicas que contiene un cubo de una milla por lado.

Calcula el número de pulgadas cúbicas en una milla cúbica.

class Pulgadas {

public static void main(String args[]) {

long pc;

long pm;

pm = 5280 * 12;

pc = pm * pm * pm;

System.out.println(“Hay “ + pc +

“ pulgadas cúbicas en una milla cúbica.”);

}

He aquí la salida del programa:

Hay 254358061056000 pulgadas cúbicas en una milla cúbica.

Evidentemente, no hubiera sido posible conservar el resultado en una variable int.

El tipo de entero más pequeño es el byte. Las variables de tipo byte resultan especialmente útiles cuando se trabaja con datos binarios que tal vez no sean compatibles directamente con otros tipos integrados de Java.

El tipo short crea un entero corto que tiene primero su byte de orden mayor (al que se le llama big-endian).

Tipos de datos en Java

2010-02-22T17:44:00.003-04:30

Los tipos de datos son especialmente importantes en Java porque es un lenguaje que requiere mucha escritura. Esto significa que el compilador revisa la compatibilidad de los tipos de todas las operaciones. Las operaciones ilegales no se compilarán. Por consiguiente, una revisión detallada de los tipos contribuye a evitar errores y a mejorar la confiabilidad. Para permitir una revisión tal de los tipos, todas la variables, expresiones y valores tienen un tipo. Por ejemplo, no existe el concepto de variable “sin tipo”. Más aún el tipo de un valor determina las operaciones que se permiten en él. Una operación permitida en un tipo tal vez no esté permitida en otro.

Tipos Primitivos de Java

Los tipos de datos primitivos se usan para definir variables en Java. El tipo de dato especificado junto con un identificador en el momento de la declaración de la variable define el rango de valores que puede ser almacenado en esta variable. Java provee ocho tipos de datos primitivos. En la siguiente tabla se proporciona el nombre del tipo de dato primitivo y el tamaño ocupado por cada tipo de dato primitivo en memoria.

Tipo de dato primitivo	Tamaño ocupado en memoria	Significado
boolean	1 byte	Representan valores verdaderos y falsos
byte	1 byte	Entero de 8 bits
char	2 bytes	Carácter
short	2 bytes	Entero corto
int	4 bytes	Entero
Long	8 bytes	Entero largo
Float	4 bytes	Punto flotante de precisión sencilla
Double	8 bytes	Punto flotante de doble precisión

El término primitivo se usa aquí para indicar que estos tipos de no son objetos en el sentido de que están orientados a objetos, sino más bien valores binarios normales. Estos tipos primitivos no son objetos en cuanto a la eficiencia.

Java especifica estrictamente un rango y un comportamiento para cada tipo primitivo, lo cual todas las implementaciones de la máquina virtual de Java deben soportar. Por ejemplo, un int es lo mismo en todos los entornos de ejecución. Esto permite que los programas sean completamente portables. No es necesario reescribir un código para adecuarlo a una plataforma. Aunque la especificación estricta del tamaño de los tipos primitivos pueda causar una pequeña pérdida de desempeño en algunos entornos, resulta necesaria para lograr la portabilidad.

Poliformismo

2010-02-19T03:15:00.002-04:30

Poliformismo (del griego “muchas formas”) es la cualidad que permite que una interfaz acceda a una clase general de acciones. La acción especifica está determinada por la naturaleza exacta de la situación. El volante de un automóvil representa un ejemplo simple de poliformismo. El volante (es decir, la interfaz) es el mismo sin importar el tipo de mecanismo de conducción real que se emplee. En otras palabras, el volante funcionará de manera igual si su automóvil tiene dirección manual, dirección hidráulica o de engranes. Por lo tanto, una vez que sepa cómo operar el volante, podrá manejar cualquier tipo de automóvil.

El mismo principio se puede aplicar también a la programación. Por ejemplo, tome en consideración una pila (la cual es una lista del tipo primero en entrar y último en salir). Podrá tener un programa que requiera tres tipos diferentes de pilas: una pila se usa para valores enteros, otra para valores de punto flotante y otra más para caracteres. En este caso, el algoritmo que implemente cada pila será el mismo, aunque los datos que se almacenen sean diferentes. En un lenguaje orientado a objetos necesitaría crear tres conjuntos diferentes de rutinas de pila, y cada conjunto tendría que emplear nombres diferentes. Sin embargo, debido al poliformismo, en Java puede crear un conjunto general de rutinas de pilas que funcione para las tres situaciones específicas. De esta manera, una vez que usted sabe cómo usar una pila, podrá usarlas todas.

De manera más general, el concepto de poliformismo suele expresarse con la frase “una interfaz, varios métodos”. Esto significa que es posible diseñar una interfaz genérica para un grupo de actividades relacionadas. El poliformismo ayuda a reducir la complejidad al permitir que la misma interfaz sea usada para especificar una clase general de acción. Usted, el programador, no necesita llevar a cabo esta selección manualmente, sólo necesita recordar y utilizar la interfaz general.

Herencia

2010-02-18T20:15:00.003-04:30

Herencia es el proceso mediante el cual un objeto puede adquirir las propiedades de otro objeto . Esto resulta importante porque soporta el concepto de clasificación jerárquica. En este sentido, la mayor parte del conocimiento se puede manejar mediante clasificaciones jerárquicas (es decir, de arriba a abajo). Por ejemplo, una manzana roja es parte de la clasificación manzana, que a su vez es parte de la clase fruta, la cual se encuentra bajo la clase más grande de alimento. Es decir, la clase alimento posee ciertas cualidades (comestible, nutritiva, etc.) que también aplican, lógicamente, a la subclase fruta. Además de estas cualidades, la clase fruta tiene características específicas (jugosa, dulce, etc.) que la distinguen de otros alimentos. La clase manzana define las cualidades específicas de una manzana (crece en árboles, no es tropical, etc.). Así, una manzana roja heredaría a su vez todas las cualidades de todas las clases anteriores y solo definiría las cualidades que la hacen única.

Sin el uso de jerarquías, cada objeto tendría que definir explícitamente todas sus características. Si utiliza la herencia, un objeto sólo necesitará definir esas cualidades que lo hacen único dentro su clase. De esta forma, el objeto puede heredar sus atributos generales a partir de sus ascendiente y, por consiguiente, el mecanismo de la herencia hace posible que un objeto sea una instancia específica de un caso más general.

Encapsulamiento

2010-02-18T15:56:00.001-04:30

El encapsulamiento es un mecanismo de programación que une al código y a los datos que manipula y que los mantiene a salvo de interferencias y de un mal uso externo. En un lenguaje orientado a objetos, el código y los datos pueden unirse de tal manera que pueda crearse una caja negra de contenido independiente. Dentro de la caja están todos los datos y el código necesarios. Cuando el código y los datos están vinculados de esta manera, se crea un objeto. En otras palabras, un objeto es el dispositivo que soporta el encapsulamiento.

Dentro de un objeto, el código, los datos o ambos, pueden ser privados, o públicos, en relación con dicho objeto. El código o los datos privados son conocidos para la otra parte del objeto, y sólo ésta puede tener acceso a ellos. Es decir, una parte del programa que se encuentra fuera del objeto no puede acceder al código o los datos privados. Cuando el código o los datos son públicos, otras partes de su programa pueden acceder a ellos aunque estén definidos dentro el objeto. Por lo general, las partes públicas de un objeto se usan para proporcionar una interfaz controlada a los elementos privados de un objeto.

Orientación a Objetos en Java

2010-02-17T17:10:00.001-04:30

Se sabe que Java brinda soporte a la programación orientada a objetos. En la programación orientada a objetos, los programadores crean objetos de software, que son modelados como los objetos del mundo real. Se describen los objetos del mundo real usando sus atributos y comportamiento. Similarmente, se tiene un prototipo llamado clase, de la cual se pueden crear muchos objetos de software del mismo tipo. Java implementa la orientación a objetos a través de tres importantes propiedades, que son:

Encapsulamiento

Herencia

Poliformismo

Teclas de Método Abreviado para NetBeans IDE 6.x

2009-12-12T19:57:00.003-04:30

A continuación la combinación de teclas de método abreviado para NetBeans 6.x

Buscando, Encontrando y Reemplazando

Ctrl-F3	Buscar palabra
F3/Shift-F3	Encontrar próximo/anterior in archivo
Ctrl-F/H	Encontrar/Reemplazar in archivo
Alt-F7	Encontrar los usos
Ctrl-Shift-F/H	Encontrar/Reemplazar en proyectos
Alt-Shift-U	Encontrar resultados de los usos
Alt-Shift-H	Iluminar los resultados de la búsqueda
Ctrl-R	Renombrar
Ctrl-U, U	Convertir a mayúsculas la selección
Ctrl-U, L	Convertir a minúsculas la selección
Ctrl-U, S	Alternar selección
Ctrl-Shift-V	Formatear Pegado

Navegando a través del código fuente

Ctrl-O/Alt-Shift-O	Ir a tipo/archivo
Ctrl-Shift-T	Ir a prueba JUnit
Alt-O	Ir a fuente
Ctrl-B	Ir a declaración
Ctrl-G	Ir a línea
Ctrl-Shift-M	Alternar agregar/remover marca


Ctrl-Shift-1/2/3	Seleccionar Proyecto/Archivo/Favoritos
Ctrl-[	Mover carácter para ….
Ctrl-K/Ctrl-Shift-K	Próximo/Anterior palabra coincidente
Alt-Izq/Alt-Der/Ctrl-Q	Ir atrás/adelante última edición

Codificando en Java

Alt-Insert	Generar código
Ctrl-Shift-I	Arreglar todas las importaciones de clases
Alt-Shift-I	Arreglar la importación de clases seleccionada
Alt-Shift-F	Formatear selección
Alt-Shift-Izq/Der/Arr/Abj	Cambiar líneas izquierda/derecha/arriba/abajo
Ctrl-Shift-Arr/Abj	Copias líneas arriba/abajo
Ctrl/Alt-F12	Inspeccionar miembros/jerarquía
Ctrl-/	Agregar/Eliminar comentarios
Ctrl-E	Borrar línea de código

Plantillas de Código para el Editor de Java

Cuando tecleamos en el Editor de Fuentes, tu puedes generar el texto de la columna de la derecha del siguiente listado tecleando la abreviación que está listada en la columna de la izquierda y luego presionando la tecla TAB.

En	Enumeration
Ex	Exception
Ob	Object
Psf	public static final
Psfb	public static final boolean
Psfi	public static final int
Psfs	public static final String
St	String
ab	abstract
bo	boolean
br	break
ca	catch (
cl	class
cn	continue
df	default:
dowhile	do { } while (condition);
eq	equals
ex	extends
fa	false
fi	final
fl	float
forc	for (Iterator it=collection.iterator(); it.hasNext();){ Object elem=(Object) it.next(); }
fore	for(Object elem : iterable) { }
fori	for (int i=0; i< arr.length; i++){ }
fy	finally
ie	interface
ifelse	if(condition) {} else{ }
im	implements
iof	instanceof
ir	import
le	length
newo	Object name = new Object(args);
pe	protected
pr	private
psf	private static final
psfb	private static final boolean
psfi	private static final int
psfs	private static final String
pst	printfStackTrace();
psvm	Public static void main(String[] args){ }
pu	public
re	return
serr	System.err.println(“\|”);
sout	System.out.println(“\|”);
st	static
sw	switch (
sy	synchronized
tds	Thread.dumpStack();
th	throws
trycatch	try {} catch (Exception e) {}
tw	throw
twn	throw new
wh	while (
whileit	while (it.hasNext()) { Object elem=(Object) it.next(); }

Hay muchas más teclas de método abreviado, que varían del lenguaje de programación que esté usando en el NetBeans, para verlas y conocer más de ellas pinche aquí.

Cómo se crean los objetos

2009-12-11T15:38:00.001-04:30

En los programas anteriores se usó la siguiente línea para declarar un objeto de tipo Automotor:

Automotor minivan = new Automotor();

Esta declaración tiene dos funciones. En primer lugar, declara una variable llamada minivan del tipo de clase Automotor. Esta variable no define un objeto, sino que simplemente es una variable que puede hacer referencia a un objeto. Esto se hace al usar el operador new, el cual asigna de forma dinámica (es decir, en tiempo de ejecución) memoria para un objeto y devuelve una referencia a él. Esta referencia es, más o menos, la dirección en memoria del objeto asignado por new. Luego, esta referencia se almacena en una variable. Por lo tanto, en Java, todos los objetos de clase deben asignarse dinámicamente.

Los dos pasos combinados de la instrucción anterior pueden reescribirse de esta manera para mostrar cada paso individualmente.

Automor minivan; //declara referencia a un objeto

minivan = new Automotor(); //asigna un objeto de Automotor

La primera Línea declara minivan como referencia a un objeto de tipo Automotor. Por lo tanto, minivan es una variable que puede hacer referencia a un objeto, pero no es un objeto en sí. En este sentido, minivan contiene el valor null, que significa que no alude a un objeto. La siguiente línea crea un nuevo objeto de Automotor y asigna a minivan una referencia a él. Ahora, minivan está vinculado con un objeto.

Traducion No Oficial Guias Netbeans Parte 2

2009-10-20T22:13:00.001-04:30

Desarrollo e implementación de aplicaciones Java general

El siguiente tutorial corto le lleva a través de algunos de los pasos básicos de desarrollo de una aplicación Java SE en NetBeans IDE. Este tutorial se supone que ya tiene cierta familiaridad con los países en desarrollo de aplicaciones Java. A lo largo del camino, se verá algunas de las características IDE que simplifican el desarrollo de aplicaciones.
Creará una aplicación que convierte varias palabras en una sola palabra que contiene una letra de cada una de las palabras de otras. La palabra resultante se denomina un acróstico.
Este tutorial es de aproximadamente 30 minutos para completar. Si desea hacer un tutorial de "Hello World" más rápido, vea el NetBeans IDE Java Quick Start Tutorial.
Contenido

Para completar este tutorial, necesita el software y recursos listeds en la tabla siguiente.

Software o recursos	Versión requerida
NetBeans IDE	versión 6.7 o 6.5
Java Development Kit (JDK)	versión 6 o versión 5

Instalación de proyecto

La aplicación que crea contendrá dos proyectos:

Un proyecto de la biblioteca de clases de Java en el que se creará una clase de utilidad.
Un proyecto de aplicación de Java con una clase principal que implementa un método de clase de utilidad del proyecto de biblioteca.

Después de crear los proyectos, se agrega el proyecto de biblioteca a la ruta de clases del proyecto de aplicación. A continuación, le será codificar la aplicación. El proyecto de biblioteca contendrá una clase de utilidad con un acróstico método. La acróstico método toma una matriz de palabras como un parámetro y, a continuación, genera un acróstico basado en esas palabras. El proyecto MyApp contendrá una clase principal que llama a la acróstico método y pasadas las palabras que se especifican como argumentos cuando se ejecuta la aplicación.

Nota: Estrictamente hablando, dos proyectos no son necesarios para una sencilla aplicación. Este tutorial utiliza dos proyectos para demostrar las características que usted puede ser que necesite para una aplicación más compleja.

Crear un proyecto de biblioteca de clases de Java

Elija archivo > nuevo proyecto (Ctrl-Mayús-N). En categorías, seleccione Java. En proyectos, seleccione la biblioteca de clases de Java. Haga clic en siguiente.
En nombre de proyecto, escriba MyLib. Cambiar la ubicación del proyecto en cualquier directorio en el equipo. De ahora en adelante, este tutorial se refiere a este directorio como NetBeans_projects.
Nota: La ruta especificada anteriormente debe aparecer como sigue en el campo de la carpeta de proyecto del asistente: /NetBeans_projects/MyLib/
(Opcional) Seleccione la carpeta de dedicado de uso para las bibliotecas de almacenamiento de casilla de verificación y especifique la ubicación de la carpeta de bibliotecas. Vea Compartir bibliotecas de proyecto para obtener más información sobre esta opción.
Haga clic en Finalizar. El proyecto MyLib se abre en la ventana de proyectos y en la ventana de archivos.

Crear un proyecto de aplicación de Java

Elija archivo > nuevo proyecto. En categorías, seleccione Java. En proyectos, seleccione la aplicación de Java. Haga clic en siguiente.
En nombre de proyecto, escriba MyApp. Asegúrese de que la ubicación del proyecto se establece en NetBeans_projects.
(Opcional) Comprobar la carpeta de dedicado del uso de la casilla de verificación de bibliotecas de almacenamiento.
Introduzca acrostic.Main como la clase principal.
Asegúrese de que se comprueban el establecer como casillas de verificación principal proyecto y crear la clase de principal.
Haga clic en Finalizar. El proyecto MyApp se muestra en la ventana de proyecto y Main.Java se abre en el Editor de fuentes.

Configuración de la ruta de clases de compilación

Dado que se va a depender de una clase en MyLib MyApp, usted tiene que añadir MyLib a la ruta de clases de MyApp. Al hacerlo también asegura que las clases en el proyecto puede hacer referencia a las clases en el proyecto de MyLib sin causar errores de compilación de MyApp. Además, esto le permite utilizar terminación de código en el MyApp proyecto para rellenar en el código basado en el proyecto MyLib. En el IDE, la ruta de clases visualmente está representado por el nodo de bibliotecas.
Para agregar clases de utilidad de la biblioteca a la ruta de clases del proyecto:

En la ventana de proyectos, haga clic con el botón secundario del mouse en el nodo de bibliotecas para el proyecto de MyApp y elija Agregar proyecto tal como se muestra en la imagen siguiente.
Vaya a NetBeans_projects / y seleccione la MyLib carpeta del proyecto. El panel archivos JAR proyecto muestra los archivos JAR que se pueden agregar al proyecto. Observe que se muestra un archivo JAR para MyLib a pesar de que has no realmente construido el archivo JAR aún. Este archivo JAR obtener construirá al crear y ejecutar el proyecto de MyApp.
Haga clic en Agregar archivos JAR del proyecto.
Expanda el nodo de bibliotecas. El MyLib archivo del proyecto JAR se agrega a la ruta de clases del proyecto MyApp.

Creación y edición de código fuente de Java

Ahora necesita crear un paquete de Java y agregar el método que va a utilizar para construir el acróstico. Después de que es necesario aplicar la acróstico método en el Principal clase.

Creación de un paquete de Java y archivo de clase

Haga clic con el botón secundario del mouse en el nodo del proyecto MyLib y elija nuevo > clase Java. Tipo LibClass como el nombre de la nueva clase, escriba org.me.mylib en el campo Package y haga clic en Finalizar. LibClass.java se abre en el Editor de fuentes.
En LibClass.java, coloque el cursor en la línea después del (declaración de clasepublic class LibClass {.
Escriba o pegue en el siguiente código del método:

público acróstico estático de cadena (String [] args) {StringBuffer b = StringBuffer() nuevo; para (int I = 0; me <> me) {b.append(args[i].charAt(i));} else {b.append('?')};} volver b.toString();}

Si el código que pega en formato no es correctamente, presione Alt-Mayús-F para cambiar el formato de archivo completo.
Presione CTRL-S para guardar el archivo.

Editar un archivo Java

Ahora agregará algún código para Main.Java. Al hacerlo, verá la terminación de código del Editor de origen y características de la plantilla (abreviatura) de código.

Seleccione la Main.Java ficha en el Editor de fuentes. Si aún no está abierto, expanda MyApp > paquetes de origen > acrostic en la ventana de proyectos y haga doble clic en Main.Java.
Eliminar la / / TODO código aquí la lógica de la aplicación comentario en el principal método.
En lugar del comentario, escriba lo siguiente:
```
Resultado de la cadena = Li
```
Dejar el cursor inmediatamente después de Li. En el siguiente paso utilizará terminación de código para activar Li en LibClass.
Presione Ctrl-Space para abrir el cuadro de terminación de código.
Aparece una breve lista de posibles formas para completar la palabra. Sin embargo, la clase que desee, LibClass no podría estar allí.
Presione Ctrl-Space otra vez para ver una lista más larga de posibles coincidencias.
LibClass debe estar en esta lista.
Seleccione LibClass y pulse Intro. El IDE llena en el resto del nombre de clase y también automáticamente crea una instrucción de importación para la clase.
Nota: El IDE también abre un cuadro sobre el cuadro de terminación de código que muestra información Javadoc para la clase seleccionada o paquete. Ya no hay Javadoc información para este paquete, el cuadro muestra un mensaje "No se encuentra Javadoc".
En el método principal, escriba un punto (.) después de LibClass. Una vez más se abre el cuadro de terminación de código.
Seleccione la acrostic(String[]args) método y pulse Intro. El IDE rellena el acróstico método y los aspectos más destacados del args parámetro.
Pulse Intro para aceptar args como parámetro.
Escriba un punto y coma (;).
La línea final debe parecerse a la línea siguiente.
```
Resultado de la cadena = LibClass.acrostic(args);
```
Pulse Intro para iniciar una nueva línea. A continuación, escriba Sout y pulse la tecla TAB. La Sout abreviatura se expande a System.out.println(""); con el cursor situado entre comillas. Tipo Resultado = dentro de las comillas y + resultado Después de las comillas final.
La línea final debe parecerse a la línea siguiente.
```
System.out.println("Result =" + result);
```
Presione CTRL-S para guardar el archivo.

Nota: Sout es una de muchas plantillas de código que están disponibles en el Editor de fuentes. Usted puede encontrar una lista de plantillas de código en la tarjeta de métodos abreviados de teclado, que puede abrir seleccionando Ayuda > tarjeta de métodos abreviados de teclado.

Compilar y ejecutar la aplicación

Ahora necesita establecer los principales argumentos de clase y la ejecución para que se puede ejecutar el proyecto.

Nota: De forma predeterminada, los proyectos han creado con la compilación de guardar característica está habilitada, por lo que no es necesario compilar el código en primer lugar a fin de ejecutar la aplicación en el IDE. Para obtener más información sobre la compilación de guardar la característica, consulte la compilación de guardado de sección de la creación, importación y proyectos de Java de configuración de guía.

Configuración de la clase principal y los argumentos de ejecución

El resultado de este programa se basa en argumentos que usted proporciona al ejecutar el programa. Como argumentos, proporcionará cinco palabras, desde el que se generará el acróstico "Hola". Se monta el acróstico desde la primera letra de la primera palabra, la segunda carta de la segunda palabra, la tercera carta de la tercera palabra y así sucesivamente.
Para agregar los argumentos para el IDE a utilizar cuando se ejecuta la aplicación:

Haga clic con el botón secundario del mouse en el nodo del proyecto MyApp, elija Propiedades y seleccione el nodo de ejecutar en panel izquierdo del cuadro de diálogo.
La clase principal debe ser establecida ya en acrostic.Main.
Tipo Sin embargo todos sentimos celosos en el campo de argumentos y haga clic en Aceptar.

Ejecución de la aplicación

Ahora que ha creado la aplicación y proporcionado argumentos de tiempo de ejecución para la aplicación, puede probar a ejecutar la aplicación en el IDE.

Para ejecutar la aplicación en el IDE de:

Elija ejecutar > ejecutar el proyecto principal (F6).
En la ventana de resultados, debe ver la salida del programa, Resultado = Hola (el acróstico de la frase que se pasó al programa como argumento).

Probar y depurar la aplicación

Ahora creará y ejecutar una prueba para el proyecto utilizando JUnit y, a continuación, ejecute la aplicación en depurador del IDE para comprobar si hay errores. En la prueba de JUnit, probará la LibClass pasando una frase para la acróstico método y el uso de una aserción para indicar qué piensa que el resultado deben ser.

Creación de pruebas JUnit

Haga clic con el botón secundario del mouse en la LibClass.javanodo de la ventana de proyectos y elija Herramientas > Crear JUnit tests (Ctrl-Mayús-U).
Si esto es la primera vez que haya creado pruebas JUnit en el IDE, se le pedirá con el cuadro de diálogo Seleccionar JUnit versión. Pulse Intro para seleccionar JUnit 4.x y seguir el cuadro de diálogo crear pruebas.
En el cuadro de diálogo crear pruebas, haga clic en Aceptar para ejecutar el comando con las opciones predeterminadas. El IDE crea la org.me.mylib paquete y la LibClassTest.java archivo en una distinta prueba carpeta. Usted puede encontrar este archivo, expanda el nodo de paquetes de prueba y la org.me.mylib subnodo.
En LibClassTest.java, eliminar el cuerpo de la testAcrostic() anular pública método.

En lugar de las líneas eliminadas, escriba o pegue en la siguiente:

System.err.println ("Running testAcrostic..."); el resultado de la cadena = LibClass.acrostic(new String[] {"fnord", "polly", "tropism"}); assertEquals ("Valor correcto", "foo", resultado);

Guarde el archivo pulsando Ctrl-S.

Ejecución de pruebas JUnit

Seleccione el nodo del proyecto MyLib y elija Ejecutar > proyecto de prueba (MyLib) o presione Alt-F6. LaMyLib (prueba) ficha se abre en la ventana de resultados. Los casos de pruebas JUnit se compilan y ejecutar. El resultado de la prueba de JUnit muestra que pasa la prueba.
También puede ejecutar un archivo de prueba única, en lugar de pruebas de todo el proyecto. Seleccione la LibClass.javaficha en el Editor de fuentes y elija Ejecutar > archivo de prueba.

La documentación de la API de JUnit está disponible desde el IDE. Elija ayuda > Javadoc referencias > JUnit NúmeroDeVersión.
Puede aprender más acerca de JUnit visitando http://www.junit.org

Depurar la aplicación

En esta sección, utilizará al depurador paso a través de la aplicación y observar los valores de cambio de variables como el acróstico se monta.

Para ejecutar la aplicación en el depurador:

En LibClass.java archivo, vaya a la acróstico método y lugar de la inserción del punto en cualquier lugar dentro de b.Append(args[i].charAt(i));. A continuación, pulse Ctrl-F8 para establecer un punto de interrupción.
Elija Depurar > depuración principal proyecto (CTRL-F5). El IDE abre el depurador de ventanas y se ejecuta el proyecto en el depurador hasta que se alcanza el punto de interrupción.
Seleccione la ventana de variables locales en la parte inferior de la IDE y ampliar la args nodo. La matriz de cadenas contiene la frase introducida como los argumentos de comando.
Pulse F7 (o elija Depurar > paso a paso) al paso a través del programa y el reloj la b se construye cambio variable como el acróstico.
Cuando el programa llega al final, cierre las ventanas del depurador.

Para obtener más información, consulte la sección Writing JUnit pruebas en NetBeans IDE.

Creación e implementación de la aplicación

Una vez que esté satisfecho de que la aplicación funciona correctamente, puede preparar la solicitud de implementación fuera del IDE. En esta sección se cree el archivo de la aplicación JAR y, a continuación, ejecute el JAR de archivos desde la línea de comandos.

Creación de la aplicación

El comando de generación principal en el IDE es el comando limpiar y generar. El comando limpiar y generar elimina clases previamente compiladas y otros artefactos de generación y, a continuación, vuelve a generar todo el proyecto desde cero.

Notas: También hay un comando, que no se elimina la vieja artefactos de generación, pero este comando está desactivado por defecto. Consulte la compilación en Guardar la sección de la creación, importación y proyectos de Java de configuración de guía para obtener más información.

Para generar la aplicación:

Elija ejecutar > limpiar y generar proyecto principal (Mayús-F11).

Resultado de la secuencia de comandos de generación de Ant aparece en la ventana de resultados. Si no aparece la ventana de resultados, puede abrirlo manualmente, elija Ventana > Salida > salida.

Al limpiar y genere el proyecto, se producen las siguientes cosas:

Salida de las carpetas que se han generado por la generación anterior se eliminan las acciones ("limpiado"). (En la mayoría de los casos, estos son los construir y dist carpetas).
construir y dist las carpetas se agregan a la carpeta del proyecto (en adelante el PROJECT_HOME carpeta).
Todas las fuentes se compilan en .class archivos, que se colocan en la PROJECT_HOME / construir carpeta.
Se crea un archivo JAR que contiene el proyecto dentro de la PROJECT_HOME / dist carpeta.
Si ha especificado las bibliotecas para el proyecto (además del JDK), un lib se crea una carpeta en la dist carpeta. Las bibliotecas se copian en dist/lib..
El archivo de manifiesto en el JAR se actualiza para incluir las entradas que designar la clase principal y las bibliotecas que están en la ruta de clases del proyecto.

Nota: Puede ver el contenido del manifiesto en la ventana de archivos de la IDE. Después de que ha creado el proyecto, cambiar a la ventana de archivos y vaya a dist/MyApp.jar. Expanda el nodo para el archivo JAR, el META-INF carpeta y haga doble clic en MANIFEST.MF para mostrar el manifiesto en el Editor de fuentes.

Principal-Class: acrostic.Main clase-Path: lib/MyLib.jar

(Para más información sobre el archivos manifiesto, puede leer este capítulo desde el tutorial de Java.)

Ejecución de la aplicación de la IDE

Para ejecutar la aplicación fuera del IDE:

En su sistema, abra un símbolo del sistema o la ventana de terminal.
En el símbolo del sistema, cambie los directorios para la MyApp/dist directorio.

En la línea de comandos, escriba la siguiente declaración:

Java - jar MyApp.jar sin embargo todos sentimos celosos

A continuación, la aplicación se ejecuta y devuelve el siguiente resultado como se muestra en la imagen siguiente:

Resultado = Hola

Distribución de la aplicación a otros usuarios

Ahora que haya comprobado que la aplicación funciona fuera del IDE, está listo para distribuir la aplicación.
Para distribuir la aplicación:

En el sistema, cree un archivo zip que contiene el (de archivo JAR de aplicaciónMyApp.jar) y el acompañamiento lib carpeta que contiene MyLib.jar.
Enviar el archivo a las personas que utilizarán la aplicación. Dígales para descomprimir el archivo zip, asegurándose de que el MyApp.jar archivo y la lib carpeta están en la misma carpeta.
Indicar a los usuarios que siga los pasos de la ejecución de la aplicación fuera del IDE sección anterior.

Otras tareas comunes

Ahora ha completado la mayor parte del tutorial, pero hay todavía algunos las tareas que no han sido cubiertas básicas. Esta sección incluye algunas de esas tareas.

Poner a disposición en el IDE de Javadoc de la JDK

Para el comando Mostrar Javadoc trabajar en las clases JDK, es necesario asociar Javadoc del JDK el JDK que utiliza su proyecto.

A disposición Javadoc de la JDK para el comando Mostrar Javadoc:

Si ya tiene la documentación de la API de Java SE en su sistema, descargue la documentación de http://java.sun.com/javase/downloads/index.jsp.
Elija Herramientas > plataformas Java.
En la lista de plataformas, seleccione el JDK que utiliza su proyecto.
Haga clic en la ficha Javadoc.
Haga clic en el botón Agregar ZIP/carpeta y desplácese hasta el archivo zip o la carpeta que contiene el Javadoc JDK en su sistema. Seleccione el archivo zip o la carpeta y haga clic en el botón Agregar ZIP/carpeta.
Haga clic en Cerrar.

Generar Javadoc para un proyecto

Puede generar documentación de Javadoc compilado para el proyecto sobre la base de las observaciones de Javadoc que haya agregado a las clases.

Para generar documentación Javadoc para un proyecto:

Seleccione el proyecto MyLib.
Elija ejecutar > generar Javadoc para "MyLib" en menú principal del IDE.
El Javadoc generado se agrega a la dist carpeta del proyecto. Además, el IDE abre un navegador web que muestra la Javadoc.

Traducion No Oficial Guias Netbeans

2009-10-20T22:07:00.002-04:30

Tutorial de inicio rápido de Java NetBeans IDE

Bienvenido a NetBeans IDE!

Este tutorial ofrece una introducción muy sencilla y rápida al flujo de trabajo NetBeans IDE le a través de la creación de una simple aplicación de consola de Java "Hello World". Una vez que termine con este tutorial, tendrá un conocimiento general de cómo crear y ejecutar aplicaciones en el IDE.

Este tutorial tarda menos de 10 minutos para completar.

Una vez finalizado este tutorial, puede mover a las pistas de aprendizaje, que están vinculadas desde la página de Documentación, capacitación y asistencia técnica. Los senderos de aprendizaje ofrecen tutoriales integrales que destacan una gama más amplia de las funciones del IDE y técnicas de programación para una variedad de tipos de aplicaciones. Si no desea hacer una aplicación "Hello World", puede omitir este tutorial y saltar directamente a las pistas de aprendizaje.
Contenido

Para completar este tutorial, necesita el siguiente software y recursos.

Software o recursos	Versión requerida
NetBeans IDE	versión 6.7
Java Development Kit (JDK)	versión 6 o versión 5

Configurar el proyecto

Para crear un proyecto IDE:

Inicie NetBeans IDE.
En el IDE, elija archivo > nuevo proyecto (Ctrl-Mayús-N), como se muestra en la figura siguiente.
New Project menu item selected." class="margin-around">
En el Asistente para nuevo proyecto, expanda la categoría de Java y seleccione aplicaciones Java como se muestra en la figura siguiente. A continuación, haga clic en siguiente.
En la página del Asistente de nombre y ubicación, haga lo siguiente (como se muestra en la figura siguiente):
- En el campo nombre del proyecto, escriba HelloWorldApp.
- Deje la carpeta de uso dedicado para casilla de verificación de bibliotecas de almacenamiento no está seleccionada.
- En el campo de crear la clase de principal, escriba helloworldapp.HelloWorldApp.
- Deje el conjunto como principal proyecto casilla.
Haga clic en Finalizar.

El proyecto es creado y ha abierto en el IDE. Debería ver los siguientes componentes:

La ventana de proyectos, que contiene una vista de árbol de los componentes del proyecto, incluyendo archivos de origen, las bibliotecas que depende de su código y así sucesivamente.
La ventana del Editor de origen con un archivo llamado HelloWorldApp Abrir.
La ventana de navegador, que se puede utilizar para desplazarse rápidamente por los elementos dentro de la clase seleccionada.
La ventana de tareas, que enumera los errores de compilación así como otras tareas que se marcan con palabras clave como XXX y TODO.

Agregar código en el archivo de origen generado

Porque tienes la casilla de verificación de crear la clase de principal seleccionado en el Asistente para nuevo proyecto, el IDE ha creado una clase esquema para usted. Puede agregar el mensaje "¡ Hello World!" a la estructura de código mediante la sustitución de la línea:

/ / TODO código aquí la lógica de la aplicación

con la línea:

System.out.println ("¡ Hello World!");

Guardar el cambio seleccionando Archivo > Guardar.

El archivo debe ser similar en el siguiente ejemplo de código.

/ * * Para cambiar esta plantilla, elija Herramientas | Plantillas * y abra la plantilla en el editor.
* / paquete helloworldapp; / ** ** @ autor Patrick Keegan * / public clase HelloWorldApp {/ ** * @ param args los argumentos de la línea de comandos * / public static void main(String[] args) {System.out.println ("Hello World!");}}

Compilar y ejecutar el programa

Por compilación del IDE en Guardar característica, no es necesario que compilar manualmente su proyecto para poder ejecutar en el IDE. Al guardar un archivo de código fuente Java, el IDE automáticamente compila.
Para ejecutar el programa:

Elija ejecutar > ejecutar el proyecto principal (F6).

La siguiente figura muestra lo que ahora debe ver.

¡ Enhorabuena! El programa funciona!
Si hay errores de compilación, se marcan con pictogramas rojos en los márgenes izquierdos y derecho del Editor de código fuente. Los glifos en el margen izquierdo indican errores para las líneas correspondientes. Los glifos en el margen derecho mostrar todas las áreas del archivo que contengan errores, incluidos los errores en las líneas que no son visibles. Usted puede mouse sobre una marca de error para obtener una descripción del error. Puede hacer clic en un pictograma en el margen derecho a acudir a la línea con el error.

Creación e implementación de la aplicación

Una vez que ha escrito y probar a ejecutar la aplicación, puede utilizar el comando limpiar y generar para generar la aplicación para la implementación. Al utilizar la limpieza y generación de comando, el IDE ejecuta una secuencia de comandos de generación que realiza las siguientes tareas:

Elimina cualquier compilado previamente archivos y otras salidas de construir.
Recompila la aplicación y genera un archivo JAR que contiene los archivos compilados.

Para crear la aplicación:

Elija ejecutar > limpiar y generar proyecto principal (Mayús-F11).

Puede ver los resultados de generación, abra la ventana de archivos y expanda el nodo HelloWorldApp. El archivo bytecode compilado HelloWorldApp.class está dentro de la generación/clases/helloworldapp subnodo. Un archivo JAR desplegable que contiene la HelloWorldApp.class está dentro de la dist nodo.

Desarrollo de la clase Automotor

2009-10-16T12:16:00.003-04:30

En el tema anterior se desarrolló una clase llamada Automotor que encapsulaba información acerca de automotores. Esta clase almacenaba tres elementos de información acerca de un vehículo: el número de pasajeros que puede tener, la capacidad de del tanque de combustible y su consumo promedio de gasolina.

He aquí el código completo que usa la clase Automotor:

/* Programa que usa la clase Automotor.

Llame a este archivo AutomotorDemo.java

class AutomotorDemo {

public static void main(String args[]) {

Automotor minivan = new Automotor();

int rango;

//asigna valores a campos de minivan

minivan.pasajeros = 7;

minivan.tanquegas = 60;

minivan.kpl = 6;

//calcula el rango suponiendo un tanque lleno de combustible

rango = minivan.tanquegas * minivan.kpl;

system.out.println(“Una minivan puede transportar “ + minivan.pasajeros + “ pasajeros con un rango de “ + rango);

}

Debe llamar con el nombre de AutomotorDemo.java al archivo que contiene este programa porque el método main() está en la clase AutomotorDemo, no en la clase Automotor. Cuando compile este programa, encontrará que se han creado dos archivos .class, uno para Automotor y otro para AutomotorDemo. El compilador de Java coloca automáticamente cada clase en su propio archivo .class. No es necesario que ambas clases estén en el mismo archivo fuente. Puede poner cada clase en sus propios archivos, llamados Automotor.java y AutomotorDemo.java, respectivamente.

Para ejecutar este programa, debe ejecutar AutomotorDemo.class. Se despliega la siguiente salida:

Una minivan puede transportar 7 pasajeros con un rango de 360

Antes de seguir adelante, revisemos un principio fundamental: cada objeto tiene sus propias copias de las variables de instancia definidas para su clase. Por lo tanto, el contenido de las variables en un objeto puede diferir del contenido de las variables en otro. No existe una conexión entre los dos objetos excepto por el hecho de que ambos objetos son del mismo tipo. Por ejemplo, si tiene dos objetos Automotor, cada uno tiene sus propia copia de pasajeros, tanquegas y kpl, y el contenido de éstos puede diferir entre los dos objetos.

Definición de una clase

2009-10-15T16:56:00.001-04:30

Para ilustrar las clases, desarrollaremos una clase que encapsule información acerca de automotores como coches, camionetas y camiones. Esta clase será Automotor y almacenará tres elementos de información acerca de un vehículo: el número de pasajeros que puede tener, la capacidad del tanque de combustible y su consumo promedio de gasolina (en kilómetros por litro).

A continuación se presenta la primera versión de Automotor. Define tres variables de instancia: pasajeros, tanquegas y kpl. Observe que Automotor no contiene métodos, por lo tanto, se trata actualmente de una clase que sólo contiene datos.

Class Automotor {

int pasajeros; //número de pasajeros

int tanquegas; //capacidad del tanque en litro

int kpl; // consumo de gasolina en km por litro

}

Una definición de class crea un nuevo tipo de datos. En este caso, al nuevo tipo de datos se le llama Automotor. Usará este nombre para declarar objetos de tipo Automotor. Recuerde que una definición de class es solo una descripción de tipo, por lo que no crea un objeto real. Por consiguiente, el código anterior no hace ningún objeto de Automotor cobre vida.

Para crear realmente un objeto de Automotor, debe usar una instrucción como la siguiente:

Automotor minivan = new Automotor(); //crea un objeto de Automotor llamado minivan

Después de que esta instrucción se ejecuta, minivan será una instancia de Automotor y, por lo tanto, tendrá una realidad “física”.

Cada vez que cree la instancia de una clase, estará creando un objeto que contenga su propia copia de cada variable de instancia definida por la clase. En consecuencia, todos los objetos de Automotor contendrán sus propias copias de las variables de instancia pasajeros, tanquegas y kpl. Para acceder a estas variables, usará el operador de punto (.). El operador de punto vincula el nombre de un objeto con el de un miembro. Ésta es la forma general del operador de punto:

objeto.miembro

El objeto se especifica a la izquierda y el miembro a la derecha. Por ejemplo, para asignar a la variable tanquegas de minivan el valor 60, use la siguiente instrucción:

minivan.tanquegas = 60;

En general, puede usar el operador de punto para acceder a variables de instancia y métodos.

Clase

2009-10-14T20:57:00.003-04:30

Fundamentos de las clases

Una clase es una plantilla que define la forma de un objeto y especifica los datos y el código que operarán sobre esos datos. Java usa una especificación de clase para construir objetos. Los objetos son instancias de una clase. Por lo tanto, una clase es, en esencia, un conjunto de planos que especifican cómo construir un objeto. Es importante que el siguiente tema quede claro: una clase es una abstracción lógica. No es sino hasta que se crea un objeto de esa clase que una representación física de dicha clase llega a existir en la memoria.

Recuerde que los métodos y las variables que constituyen una clase se les denomina miembros de la clase. Los miembros de datos también son conocidos como variables de instancia.

La forma general de una clase

Cuando define una clase, declara su forma y su naturaleza exactas, lo cual lleva a cabo al especificar las variables de instancia que contiene y los métodos que operan sobre estas variables. Aunque es posible que las clases muy simples contengan solamente métodos o variables de instancia, casi todas las clases reales contienen ambos.

Una clase se crea empleando la palabra clave class. A continuación se muestra la forma general de una definición de clase:

class nombreclase {

//declare variables de instancia

tipo var1;

tipo var2;

//...

tipo varN;

//declare métodos

tipo método1(parámetros) {

//cuerpo del método

}

tipo método2(parámetros) {

//cuerpo del método

}

//...

tipo de métodoN(parámetros) {

//cuerpo del método

}

Aunque no hay reglas sintácticas que así lo dicten, una clase bien diseñada debe definir una y sólo una entidad lógica. Por ejemplo, una clase que almacena nombres y números de teléfono no almacenará información acerca de la bolsa de valores, el promedio de precipitación pluvial, los ciclos de las manchas solares u otra información no relacionada. Lo importante aquí es que una clase bien diseñada agrupa información conectada de manera lógica. Si coloca información no relacionada en la misma clase, ¡desestructurará rápidamente su código!

Un Primer Programa de Ejemplo

2009-10-13T21:35:00.001-04:30

Empecemos por escribir el programa corto de ejemplo que se muestra a continuación:

Este es un programa simple de Java.

Llame a este archivo Ejemplo.java

class Ejemplo{

// Un programa de Java empieza con una llamada a main().

public static void main(String args[]) {

System.out.println(“Java esta en la web.”);

}

En el caso de la mayor parte de los lenguajes de computación, el nombre del archivo que contiene el código fuente de un programa es arbitrario. Sin embargo, éste no es el caso de Java. Lo primero que debe aprender acerca de Java es que el nombre que asigne a un archivo fuente es muy importante. Para este ejemplo, el nombre del archivo fuente debe ser Ejemplo.java. Veamos por qué.

En Java a un archivo fuente se le llama oficialmente unidad de compilación. Éste es un archivo de texto que contiene una o más definiciones de clase. El compilador de Java requiere que un archivo fuente use la extensión de nombre de archivo .java.

Como verá al revisar el programa, el nombre de la clase definida por el programa también es Ejemplo. No se trata de una coincidencia. En Java, todo el código debe residir dentro de una clase. Por convención, el nombre de esa clase debe coincidir con el del archivo que contiene el programa. También debe asegurarse de que las mayúsculas y minúsculas del nombre del archivo coincidan con el nombre de la clase. La razón de ello es que Java es sensible a mayúsculas y minúsculas. En este punto, es posible que la convención de que los nombres de archivo correspondan con los nombres de clase parezca arbitraria. Sin embargo, esta convención hace más fácil el mantenimiento y la organización de sus programas.

El primer programa de ejemplo, línea por línea

Aunque Ejemplo.java es muy corto, incluye varias características clave que le son comunes a todos los programas de Java. Examinemos de cerca cada parte del programa.

Este es un programa simple de Java.

Llame a este archivo Ejemplo.java

Se trata de un comentario. Como casi todos los demás lenguajes de programación, Java le permite ingresar un comentario en el archivo fuente de un programa. El contenido de un comentario es ignorado por el compilador. En cambio, un comentario describe o explica la operación del programa a cualquier persona que esté leyendo su código fuente. En este caso, el comentario describe el programa y le recuerda que el archivo fuente debe llamarse Ejemplo.java. Por supuesto, en aplicaciones reales, los comentarios suelen explicar la manera en la que funciona alguna parte del programa, o bien, lo que una característica específica lleva a cabo.

La siguiente línea del código del programa se muestra a continuación:

class Ejemplo{

Esta línea usa la palabra clave class para declarar que se está definiendo una nueva clase. Ejemplo es el nombre de la clase. La definición de clase empieza con una llave de apertura ({) y termina con una cierre (}). Los elementos entre las dos llaves son miembros de la clase. Por el momento, no se preocupe demasiado por los detalles de una clase, pero tome en cuenta que en Java toda la actividad del programa ocurre dentro de una.

La siguiente línea del programa es el comentario de una sola línea, el cual se muestra aquí:

// Un programa de Java empieza con una llamada a main().

Éste es el segundo tipo de comentario soportado por Java. Un comentario de una sola línea comienza con // y termina al final de la línea. Como regla general, los programadores usan comentarios de varias líneas para comentarios más largos y de una sola línea para descripciones breves, línea por línea.

A continuación se muestra la siguiente línea del código:

public static void main(String args[]) {

Esta línea empieza el método main(). En Java, a una subrutina se la llama método. Como se sugiere en el comentario anterior, ésta es la línea en la que el programa empezará a ejecutarse. Todas las aplicaciones de Java empiezan la ejecución mediante una llamada a main().

La palabra clave public es un especificador de acceso. Un especificador de acceso determina la manera en la que otras partes de un programa pueden acceder a los miembros de la clase. Cuando un miembro de una clase está precedido por public, entonces es posible acceder a dicho miembro mediante un código que esté fuera de la clase en la que se encuentre declarado. (Lo opuesto de public es private, lo cual evita que un miembro sea utilizado por un código definido fuera de su clase.) En este caso, main() debe declararse como public porque debe ser llamado por el código fuera de su clase cuando el programa se inicie. La palabra clave static permite que main() sea llamado por el intérprete de Java antes de que se haga cualquier objeto. La palabra clave void simplemente le indica al compilador que main() no regresa un valor. Como se verá, los métodos también pueden regresar valores.

Como ya se estableció, main() es el método al cual se llama al iniciar una aplicación en Java. Cualquier información que necesite pasar a un método es recibida por variables especificadas dentro del conjunto de paréntesis que viene después del nombre del método. A estas variables se les denominan parámetros. Si no se requieren parámetros para un método determinado, necesitará incluir de cualquier modo los paréntesis vacíos. En main() sólo hay un parámetro, String args[], el cual declara un parámetro denominado args. Se trata de una matriz de objetos del tipo String. (Las matrices son colecciones de objetos similares.) Los objetos de tipo String almacenan secuencias de caracteres. En este caso, args recibe cualquier argumento de línea de comandos que esté presente al momento de ejecutar el programa. Este programa no usa esta información.

El último carácter de esta línea es la {. Esto señala el inicio del cuerpo de main(). Todo el código incluido en un método ocurrirá entre la llave de apertura del método y su llave de cierre.

A continuación se muestra la siguiente línea de código. Note que esto ocurre dentro de main()

System.out.println(“Java esta en la web.”);

Esta línea da salida a la cadena “Java esta en la web.” seguida por una nueva línea en la pantalla. En realidad la salida se logra mediante el método integrado println(). En este caso println() despliega la cadena que se le pasa. Como verá, println() puede usarse también para desplegar otros tipos de información. La línea empieza con System.out, System que es una clase predefinida que proporciona acceso al sistema y out es el flujo de salida que está conectado a la consola. Por consiguiente, System.out es un objeto que encapsula la salida de la consola.

Tome en cuenta que la instrucción println() termina con un punto y coma. En Java, todas las instrucciones terminan con un punto y coma. La razón de que otras líneas del programa no terminen con punto y coma es que no son instrucciones en un sentido técnico.

La primera } del programa termina main() y la última termina la definición de clase de Ejemplo.

Un último comentario: Java es sensible a las mayúsculas y minúsculas. Si lo olvida, se puede meter en problemas serios. Por ejemplo, si escribe por accidente Main en lugar de main, o PrintLn en lugar de println, el programa anterior será incorrecto. Más aún, si bien el compilador de Java compilará clases que no contengan un método main(), no tendrá manera de ejecutarlas. De este modo, si escribe main de manera incorrecta, el compilador compilará de cualquier modo su programa. Sin embargo, el intérprete de Java reportará un error porque no encontrará el método main().

Obtener el kit de desarrollo Java

2009-10-01T15:12:00.000-04:30

Es hora de empezar a escribir programas. Sin embargo antes que pueda compilar y ejecutar dichos programas, debe tener un sistema de desarrollo de Java instalado en su computadora. El que se empleará en adelante sera el JDK (Java Development Kit, Kit de Desarrollo de Java) estándar, el cual está disponible en Sun Microsystems. El JDK puede descargase gratuitamente desde la páginade Sun Microsystems, y además nos apoyaremos NetBeans para escribir, compilar y depurar nuestros programas, en conveniente decir que NetBeans también sirve para programar en otros lenguajes como C/C++, PHP, JavaScript, JavaFX, Python, y más. Depiendo de lo que quieras hacer con NetBeans podrás descargar distintas distintas versiones, hay tantas como lenguajes de programación soporta, y hay una ultima versión que incluye en un solo paquete soporte para todos los lenguajes y por supuesto ésta será mçás pesada a la hora de descargar (unos 302 MB), ahora los enlaces de descarga:

JDK
Java SE
JavaFX
Java
Ruby
C/C++
PHP
Todos los anteriores

Si te decides en alguno en particular podrás más adelante agregar o quitar complementos para que soporte el lenguajes que desees.

Impacto de Java en Internet

2009-05-07T23:32:00.001-04:30

Internet ayudó a catapultar a Java al primer plano de la programación, y Java, a su vez, ha tenido un profundo efecto en Internet. La razón es muy simple: Java expande el universo de los objetos que pueden desplazarse libremente por el ciberespacio. Aunque los programas en red son deseables y dinámicos, también presentan problemas serios en la áreas de seguridad y portabilidad.

Los usuarios de Internet hacen uso de varios tipos de máquinas, y tienen diferentes plataformas. Así que el problema clave es hacer que la información en la Internet sea compatible con todas las plataformas. Debido a que Java permite la protabilidad, se logra este punto . Usando las características de portabilidad, el mismo programa puede ser ejecutado en diferentes plataformas, con resultados predecibles. La información no necesita ser replicada para soportar diferentes plataformas.

El otro tema principal que los usuarios de Internet enfrentan es la seguridad. Debido a la amplia difusión de los virus y programas que pueden capturar información como palabras claves y detalles de las tarjetas de crédito del sistema de archivo local, los usuarios hasta hace poco, estaban temerosos de descargar cualquier programa ejecutable desde máquinas no confiables.

Los programas Java no tienen permiso de acceder a cualquier recurso fuera del alcance de la JVM. Por esto, la JVM controla los intentos de romper la seguridad a través de programas Java.

Java comenzó de una manera modesta al permitir que los programas se ejecutaran en la Internet usando los applets de Java. Sin embargo, esto ha crecido hasta alcanzar un mayor poder de funcionalidad. Existen varias tecnologías basadas en Java que se usan para obtener funcionalidades especializadas. Por ejemplo, tecnologías como los Java Servlets, Java Server Pages (JSP), Enterprise Java Beans (EJB), etc., han otorgado al programador mucho más poder para contruir aplicaciones robustas y escalables para internet.

La plataforma Java

2009-05-06T23:55:00.001-04:30

Una plataforma es el entorno sobre el cual se ejecutan los programas. Una plataforma puede ser una plataforma de software, una plataforma de hardware o una combinación de ambos. La plataforma Java es una plataforma de sólo software, la cual se puede ejecutar en varias plataformas de hardware así como en varios sistemas operativos. La plataforma Java esta conformada por dos componentes, llamados la JVM y el API de Java.

JVM

La JVM es una aplicación ejecutable que representa a un procesador genérico en el cual corren los bytecodes de Java. Una implementación particular de esta máquina virtual, que es escrita para operar en un entorno particular, aún brindará soporte al API general de Java. Esto es lo que hace a Java independiente de la plataforma.

La JVM consta de los siguientes tres aspectos:

Especificación abstracta.

Implementación concreta.

Instancia en tiempo de ejecución.

La especificación Java define la especificación abstracta de la JVM, que se necesita para permitir que los programas se ejecuten en ella. La implementación concreta de la JVM es la implementación actual de la especificación abstracta. La instancia de tiempo de ejecución soporta la ejecución de los programas Java. El código fuente de Java (archivo .java) es convertido en bytecodes (archivo .class) por el compilador Java. Estos bytecodes son luego convertidos a código de máquina nativo por alguna JVM que sea especifica a una plataforma en particular. De aquí que, los archivos .class son portables a cualquier implementación de la máquina virtual.

API de Java

El API (Application Programming Interface) de Java es una muy buena colección de componentes de software apropiadas para el desarrollo de programas Java. En Java hay diferentes tipos de programas tales como aplicaciones, applets y servlets. El API de Java ayuda al desarrollo y ejecución de estos diferentes tipos de programas mediante una amplia librería. El soporte de las diversas características de Java se realiza a través del API. Éstas son básicamente librerías o paquetes de componentes relacionados.

Características de Java

2009-05-05T23:53:00.002-04:30

Java puede usarse para desarrollar dos tipos de programas: aplicaciones y applets. Las aplicaciones son programas independientes que pueden correr en una computadora, usando la plataforma Java con el soporte del sistema operativo de la computadora y los applets son programas especiales Java, que pueden usarse para transmitir información en Internet.

Si bien las aplicaciones y applets de Java son emocionantes, solo serían ideas deseables si Java no atendiera problemas fundamentales asociados a ellos:

Simple de usar: Java tiene un conjunto conciso y cohesivo de funciones que facilitan su aprendizaje y uso. El estilo de programación en Java está basado en C++, y soporta la mayoría de las características ofrecidas por C++. un programador con un buen conocimiento de los conceptos de orientado a objetos pude sacar el máximo provecho a Java, ya que se implementan los conceptos en una forma mucho más sencilla que en C++.

Seguridad: Java proporciona un medio seguro de crear aplicaciones de Internet. Inicialmente, cuando comenzó Internet y Java no era tan conocido, los usuarios de Internet temían descargar programas ejecutables debido al daño alarmante causado por la difusión de virus. Java proporcionó un modelo de seguridad, que previene el acceso a los recursos del sistema, y así bloquear cualquier intento malicioso.

Portabilidad: Los programas de Java pueden ejecutarse en cualquier entorno para el cual haya un sistema de Java en tiempo de ejecución. Java solventa este inconveniente de portabilidad con el uso de bytecodes. El compilador Java primero convierte el código fuente a bytecodes que puede entender el sistema de tiempo de ejecución de Java o la Máquina Virtual de Java (Java Virtual Machine JVM); estos bytecodes son interpretados por el intérprete de Java, y convertidos a una forma ejecutable que la entiende la plataforma en la cual el sistema de tiempo de ejecución de Java se esté ejecutando.

Distribuido: Java fue diseñado tomando en consideración el entorno distribuido de Internet. La computación distribuida es muy útil en el ambiente de Internet, donde los módulos de los programas pueden estar presentes en diferentes computadoras alrededor del mundo. Java fue diseñado para brindar soporte TCP/IP. El soporte a redes de Java permite construir aplicaciones cliente/servidor.

Orientado a objetos: Java encarna la filosofía moderna de programación orientada a objetos. C++ tenía que mantener las características y ser compatible con C. Cuando Java estaba siendo diseñado, sus diseñadores y desarrolladores no quisieron que Java fuera compatible al nivel de código fuente con ningún otro lenguaje. Por lo anterior, tuvieron la opción de crear un lenguaje orientado a objetos que hace uso de un modelo de objetos simple, y usa tipos de datos simples, no objetos, asegurando un alto rendimiento.

Robusto: Java alienta una programación libre de errores, pues requiere una escritura estricta y realiza comprobaciones en tiempo de ejecución. El diseño de Java hace posible que los programadores identifiquen errores en la misma etapa de desarrollo. El código puede ser revisado para asegurar confiabilidad colocando restricciones en ciertas áreas claves de la programación y teniendo un diseño para evitar los errores más comunes de programación. Java está diseñado para ser u lenguaje estrictamente tipado. Por lo tanto, verifica errores de codificación tanto en tiempo de compilación como en tiempo de ejecución.

Dinámico: Los programas de Java incluyen importantes cantidades de información que son del tipo de tiempo de ejecución. Esta información se usa para verificar y resolver el acceso a objetos al momento de realizar la ejecución.

Fuertemente tipificado: Java es fuertemente tipificado. Java fue diseñado de forma que si se comete cualquier error en una invocación de método, se mostrará un mensaje de error al programador en tiempo de compilación. Por esta razón, los programadores no necesitan preocuparse de cometer errores no detectables en la invocaciones de métodos.

Interpretado: Java soporta un código de plataforma cruzada mediante el uso de un código de bytes (bytecodes). Los bytecodes de Java son interpretados por la JVM en el lenguaje nativo de la plataforma subyacente. Los lenguajes interpretados tienen limitaciones de rendimiento comparados con los lenguajes que son compilados. Java combina las ventajas de la compilación e interpretación. El compilador Java puede ayudar a superar las limitaciones de rendimiento asociadas a la JVM.

Arquitectura neutral: Java no está unido a una máquina o a una arquitectura específicas de sistema operativos. Al compilar un programa en Java, el código resultante es un tipo de código binario conocido como bytecode. Este código es interpretado por diferentes computadoras de igual manera, solamente hay que implementar un interprete para cada plataforma. De esa manera Java logra ser un lenguaje que no depende de una arquitectura computacional definida.

Ambiente multihilos: Java proporciona un soporte integrado para la programación de subprocesos múltiples. Java brinda soporte a la programación multihilos, que permite que un único programa lleve a cabo varias tareas concurrectemente. Los programadores pueden hacer uso de esto para crear aplicaciones de red interactivas. El sistema en tiempo de ejecución Java (JVM) se implementó de forma eficiente, para permitir la fácil sincronización de hilos, que a su vez facilitan la programación interactiva.

Relación y diferencias de Java con C y C++

2009-05-05T00:02:00.000-04:30

Relación:

Hereda la sintaxis de C y el modelo de objetos está basado a partir de C y C++. La relación de Java con C y C++ es importante ya que mucho programadores están familiarizados con la sintaxis de C, C++, o ambos. Este hecho le facilita a un programador de C o C+ aprender Java y, de igual manera, a un programador de Java aprender C o C++.

Una de las filosofías centrales de C y C++ en cuanto al diseño es que el programador es la persona que tiene el control. Java hereda también dicha filosofía. Con excepción de las restricciones impuestas por el entorno de Internet, Java le proporciona a usted, es decir, el programador, un control total. Si usted programa bien, su programas así lo reflejarán. Si programa de manera deficiente, sus programas igualmente lo reflejarán.

Debido a las similitudes entre Java y C++, sobre todo en el soporte que brindan a la programación orientada a objetos, resulta tentador pensar en Java como la simple “versión de C++ para Internet”. Sin embargo, ello sería un error pues Java tiene importantes diferencias prácticas y filosóficas. Aunque fue influido por C++, no es una versión mejorada de éste (no es compatible ni hacia arriba ni hacia abajo con C++). Por supuesto, las similitudes con C++ son significativas; por lo tanto, si usted es un programador de C++, se sentirá como en casa con Java. Otro punto: Java no fue diseñado para reemplazar a C++: fue diseñado para resolver un cierto conjunto de problemas, mientras que C++ fue diseñado para resolver otro conjunto diferente. Ambos coexistirán durante muchos años más.

Diferencias:

Existen algunas deficiencias en C++, por el hecho de que permite programación estructurada. Esto ha sido eliminado en Java, que es un lenguaje puramente orientado a objetos.
Las principales diferencias entre Java y C++ son:

Java	C++
Es tanto un lenguaje de programación como una plataforma de software.	Es sólo un lenguaje de programación.
Es un lenguaje puramente orientado a objetos.	Da soporte tanto a la programación estructurada como a la programación orientada a objetos.
Todas las declaraciones de variables y métodos deben estar dentro de la definición de la clase.	Las declaraciones de variables y funciones pueden estar presentes fuera de las definiciones de las clases. No es necesario para un programa en C++ tener una clase.
El lenguaje es independiente de la plataforma. El código Java, una vez escrito, puede ser ejecutado en cualquier plataforma.	El código C++, una vez escrito para una plataforma, necesita se compilado de nuevo, y el código objeto reenlazado para ser ejecutado en otra plataforma diferente.
Maneja la memoria automáticamente.	Los programadores tienen que hacerse cargo de liberar la memoria no utilizada.
No se soporta características como sobrecarga de operadores y conversiones automáticas en ambos sentidos.	Da soporte a características como sobrecarga de operadores y conversiones automáticas en ambos sentidos.
Una clase no puede heredar directamente de más de una clase. Se da soporte a la herencia múltiple usando interfaces.	Una clase puede heredar directamente de más de una clase.
Tiene rutinas de librerías extensibles.	Sus rutinas de librerías no son extensibles.
La programación de redes es más fácil. Los objetos pueden ser accedidos a través de la red usando URLs.	La programación para redes es compleja, a menos que se usen APIs de terceros. C++, es un lenguaje, que no brinda soporte incorporado para programación de redes.
Los programadores no pueden usar apuntadores. Los apuntadores se usan internamente.	Los programadores pueden usar apuntadores.
Implementa arreglos verdaderos.	Se implementan los arreglos con aritmética de apuntadores.

La Historia

2009-05-03T13:37:00.001-04:30

Antes de que Java existiera, C y C++ eran los lenguajes de programación más usados. C es un lenguaje de programación estructurada, mientras que C++ brinda soporte tanto a la programación estructurada como a la programación orientada a objetos. Estos dos lenguajes de programación son complejos y tienen algunas limitaciones inherentes. Aunque Java no fue diseñado como solución a los problemas encontrados en C o C++, algunas de sus características han solventado las limitaciones de estos dos lenguajes.

La innovación en los lenguajes computacionales está determinada por dos factores: mejoras en el arte de la programación y cambios en el entorno del cómputo. Java no es la excepción. Aprovechando la rica herencia de C y C++, Java ofrece un mayor refinamiento y funciones que reflejan el estado actual del arte de la programación. Respondiendo al surgimiento del entorno en línea, Java ofrece funciones que modernizan la programación con el fin de desarrollar una arquitectura altamente distribuida.

James Gosling, Patrick Naughton, Chris Warth, Ed Frank y Myke Sheridan concibieron Java en Su Micosystems en 1991. A este lenguaje se le llamó inicialmente “Oak” pero se le renombró “Java” en 1995. La motivación principal, fue la necesidad de un lenguaje que fuera independiente de la plataforma y que pudiera emplearse para crear un software que estuviera incrustado en varios dispositivos electrónicos para uso del consumidor, como tostadoras, hornos de microondas y controles remotos. Como probablemente ya adivinó, se usan muchos tipos diferentes de CPU como controladores. El problema es que la mayor parte de los lenguajes de cómputo están diseñados para compilarse con un destino específico. Pensemos, por ejemplo, en C++.

Aunque es posible compilar una página de C++ para cualquier tipo de CPU, para ello se requiere un compilador completo de C++ orientado a ese CPU. Sin embargo, el problema es que los compiladores son caros y su creación requiere mucho tiempo. En el intento de encontrar una mejor solución, Gosling y sus demás compañeros trabajaron en un lenguaje portable, de plataforma cruzada, que pudiera producir un código que se ejecutara en diversos CPU bajo entornos diferentes. Este esfuerzo culminó en la creación de Java.

Indice

2009-05-02T18:29:00.000-04:30