Tipo de datos de punto flotante

viernes, 26 de febrero de 2010 · 1 comentarios
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 38 hasta 3,4 * 10 38
double -1,8 * 10 308 hasta 1,8 * 10 308

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.

[ Seguir leyendo ]

Tipo de datos enteros

lunes, 22 de febrero de 2010 · 0 comentarios
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).
[ Seguir leyendo ]

Tipos de datos en Java

· 0 comentarios
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.

[ Seguir leyendo ]

Poliformismo

viernes, 19 de febrero de 2010 · 0 comentarios
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.
[ Seguir leyendo ]

Herencia

jueves, 18 de febrero de 2010 · 0 comentarios
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.
[ Seguir leyendo ]

Encapsulamiento

· 0 comentarios
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.
[ Seguir leyendo ]

Orientación a Objetos en Java

miércoles, 17 de febrero de 2010 · 0 comentarios
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
[ Seguir leyendo ]

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

sábado, 12 de diciembre de 2009 · 3 comentarios
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í.

[ Seguir leyendo ]

Cómo se crean los objetos

viernes, 11 de diciembre de 2009 · 0 comentarios
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.
[ Seguir leyendo ]

Traducion No Oficial Guias Netbeans Parte 2

martes, 20 de octubre de 2009 · 0 comentarios

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 recursosVersión requerida
NetBeans IDEversió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

  1. 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.
  2. 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/

  3. (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.
  4. 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

  1. Elija archivo > nuevo proyecto. En categorías, seleccione Java. En proyectos, seleccione la aplicación de Java. Haga clic en siguiente.
  2. En nombre de proyecto, escriba MyApp. Asegúrese de que la ubicación del proyecto se establece en NetBeans_projects.
  3. (Opcional) Comprobar la carpeta de dedicado del uso de la casilla de verificación de bibliotecas de almacenamiento.
  4. Introduzca acrostic.Main como la clase principal.
  5. Asegúrese de que se comprueban el establecer como casillas de verificación principal proyecto y crear la clase de principal.
  6. 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:
  1. 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.
    Image showing the Add Project command that is offered when you                         right-click a project's node.
  2. 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.
  3. Haga clic en Agregar archivos JAR del proyecto.
  4. 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

  1. 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.
  2. En LibClass.java, coloque el cursor en la línea después del (declaración de clasepublic class LibClass {.
  3. Escriba o pegue en el siguiente código del método:
  4. 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();}
  5. Si el código que pega en formato no es correctamente, presione Alt-Mayús-F para cambiar el formato de archivo completo.
  6. 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.
  1. 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.
  2. Eliminar la / / TODO código aquí la lógica de la aplicación comentario en el principal método.
  3. 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.
  4. 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í.
  5. Presione Ctrl-Space otra vez para ver una lista más larga de posibles coincidencias.
    LibClass debe estar en esta lista.
  6. 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".
  7. 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.
  8. 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.
  9. Pulse Intro para aceptar args como parámetro.
  10. Escriba un punto y coma (;).
    La línea final debe parecerse a la línea siguiente.
    Resultado de la cadena = LibClass.acrostic(args);

  11. 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);

  12. 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:
  1. 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.
  2. 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

  1. 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.
  2. 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.
  3. En LibClassTest.java, eliminar el cuerpo de la testAcrostic() anular pública método.
  4. 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);

  5. Guarde el archivo pulsando Ctrl-S.

Ejecución de pruebas JUnit

  1. 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.
  2. 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:
  1. 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.
  2. 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.
  3. 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.
  4. 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:
  1. En su sistema, abra un símbolo del sistema o la ventana de terminal.
  2. En el símbolo del sistema, cambie los directorios para la MyApp/dist directorio.
  3. 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
Command prompt showing the output from the running program.

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:
  1. 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.
  2. 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.
  3. 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:
  1. 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.
  2. Elija Herramientas > plataformas Java.
  3. En la lista de plataformas, seleccione el JDK que utiliza su proyecto.
  4. Haga clic en la ficha Javadoc.
  5. 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.
  6. 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:
  1. Seleccione el proyecto MyLib.
  2. 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.
[ Seguir leyendo ]
Entradas Recientes Entradas Antiguas data:homeMsg

CodigoByte

Codigo QR

Etiquetas

Blogumulus by Roy Tanck and Amanda Fazani

Twitter

Seguir codigobyte en Twitter

Twitter Actualizar

    sigueme en Twitter

    Participa

    Java Twitter

    ¿Cúal es la extensión usada para guardar los archivos fuente Java?

    Mangoos

    Mangoos
    http://mangoosbuscador.wordpress.com/

    Anunciantes

    Se escribe con...

    Se escribe con...