Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 6

INDICE:

1. Introducción.........................................................................1
2. Arquitectura de JDK..............................................................1
3. Componentes de JDK............................................................1
4. Uso de JDK............................................................................1
5. Jerarquia de Paquetes...........................................................1
6. Importación de Paquetes.......................................................1
Introducción:
Java es un lenguaje de programación y una plataforma informática que fue lanzado por
primera vez en 1995 por Sun Microsystems. Hay muchas aplicaciones y sitios web que solo
funcionarán si tiene Java instalado y muchos se crean todos los días. Java es rápido, seguro y
fiable. Desde computadoras portátiles hasta centros de datos y desde consolas de juegos hasta
supercomputadoras y teléfonos móviles e Internet.

Arquitectura JDK:

¿Para que sirve?

El Java Development Kit (JDK) es un software que se utiliza para desarrollar aplicaciones y
subprogramas Java.

Componentes del JDK:

El JDK contiene varias herramientas de desarrollo como pueden ser:

- Java Runtime Environment (JRE):

Es una capa de software que se ejecuta sobre el software del sistema operativo y proporciona
las bibliotecas de clases y otros recursos necesarios para ejecutar un programa Java en
particular.

La sintaxis para su utilización es la siguiente: java [Opciones] ClaseAEjecutar [Argumentos]

- Compilador:

Compila archivos de código fuente Java (habitualmente *.java) en archivos de clase Java
ejecutables (*.class). Luego se crea un archivo de clase para cada clase definida en el archivo
de fuente.

Tal compilador se usa con la siguiente sintaxis: javac [Opciones] ArchivoACompilar

- Visualizador de Applets:

Es una herramienta que actúa como campo de pruebas de applets, visualizando cómo
aparecerá en el navegador, en lugar de tener que esperar. Cuando se activa desde la línea de
ordenes abre una ventana que muestra el contenido del applet.

Se activa con la sintaxis: appletviewer [Opciones] Applet

- Depurador:

Es una utilidad de línea de comandos que permite depurar aplicaciones Java. No es un entorno
de características visuales, pero permite encontrar y eliminar los errores de los programas Java
con mucha exactitud. Es parecido en su funcionamiento al depurador gdb que se incluye
con las distribuciones del compilador gcc/g++ para C/C++.
Se activa con la sintaxis: jdb [Opciones]

- Generador de documentación:

Es una herramienta útil para la generación de documentación API directamente desde


el código fuente Java. Genera páginas HTML basadas en las declaraciones y
comentarios javadoc , con el formato /** comentarios */ :
La sintaxis es la siguiente: javah [Opciones] NombreClase
Uso del JDK:
Hemos visto las diferentes partes que componen el JDK, pero para poder desarrollar
una aplicación Java final (ya sea una app o un applet), tenemos que utilizar las
diferentes herramientas que el JDK les proporciona. en un orden específico. En el
siguiente diagrama, podemos ver la secuencia de pasos para crear un programa Java
final
Jerarquía de Paquetes de JAVA
Creación de paquetes:
Un paquete de Java se crea simplemente al incluir la palabra clave package en la
parte superior de los modulos de código que definen las clases que formarán parte de
él. Cuando trabajemos en un proyecto con NetBean, comprobaremos que en la
ventana de Projects, los paquetes están representados por un icono específico y
actúan como nodos contenedores, alojando módulos .java con código fuente. El menú
contextual del proyecto nos da la opción New > Java Package, que será la opción que
vamos a utilizar por lo general, para crear un nuevo paquete:

Nota: Cada vez que se crea un nuevo proyecto con NetBeans se propone la definición
de un nuevo paquete, cuyo nombre sería el mismo del proyecto, donde se alojarían los
módulos de código. En proyectos complejos, no obstante, puede ser necesaria la
creación de paquetes adicionales.
Un paquete puede contener, además de definiciones de tipos como las clases e
interfaces, otros paquetes, dando lugar a estructuras jerárquicas de contenedores.
Importación de paquetes
Los paquetes Java son como cajas de herramientas, cada una de ellas con una
colección distinta de útiles instrumentos para nuestro trabajo, a las que podemos
necesitar acceder cada vez que abordamos el desarrollo de un nuevo proyecto. Es en
este contexto donde recurriremos a la cláusula import, a fin de importar en el ámbito
actual las definiciones de otro paquete y poder usarlas según el procedimiento
habitual, creando objetos, accediendo a los servicios de las clases, etc. La cláusula
import puede utilizarse para importar un elemento concreto de un paquete, facilitando
el nombre de este seguido de un punto y el identificador de dicho elemento. Por
ejemplo, para importar la clase Math del paquete java.lang, pudiendo así acceder a la
constante PI y las funciones matemáticas que aporta, bastaría con la siguiente línea:
♦ import java.lang.Math;

Por lo general, al importar un paquete, nos interesan varias clases definidas en él. En
este caso podemos importarlos individualmente, usando la fórmula anterior o podemos
usar el siguiente método alternativo .Esto nos permitiría usar la clase Math, así como
la clase System, la clase Thread y muchas otras definidas en el paquete java.lang:
♦ import java.lang.*;

En ocasiones, como ocurre con la clase Math, importamos una clase para acceder
directamente a sus miembros estáticos, constantes y métodos, no para crear
objetos a partir de ellas, lo que nos fuerza a utilizar constantemente la sintaxis
Clase.miembro, por ejemplo Math.PI o Math.sin(). Si tras importar la clase Math
intentamos referirnos a estos miembros simplemente por su nombre, como se hace en
la mitad superior de la siguiente imagen, obtendremos un error. En estos casos
podemos recurrir a la sintaxis import static paquete.clase.*, cuya finalidad es incluir
en el ámbito actual los miembros estáticos de la clase indicada. Es lo que se hace
en la mitad inferior de la siguiente imagen:
Ejemplo de import en Java Vamos a suponer que al interior de nuestro proyecto
hemos creado cuatro clases diferentes en paquetes diferentes, cada clase se llamará
"Clase_1", "Clase_2", "Clase_3" y "Clase_4" respectivamente.

La clase número uno fue declarada en el paquete "mis_clases.


clases_publicas.clase_1" por lo tanto quedará al interior de una carpeta llamada
"clase_1" la cual estará al interior de otra carpeta llamada "clases_publicas" y esta a
su vez estará dentro de la carpeta llamada "mis_clases". La clase número dos se le
declaró el paquete "mis_clases.clase_2" por lo tanto ha quedado al interior de una
carpeta llamada "clase_2" la cual a su vez está al interior de la carpeta "mis_clases". A
la clase número tres se le impuso el paquete "mis_clases", esto indica que esta estará
al interior de la carpeta "mis_clases". Por último, la clase número cuatro no tiene
declarado ningún paquete por lo tanto el paquete asignado será el paquete por
defecto, en otras palabras, esta clase se mantendrá siempre en la carpeta raíz del
proyecto (en netbeans y eclipse la carpeta raíz se llama src).

Los archivos Jars en Java:

Conclusiones:

Bibliografias:
 Java:
https://www.java.com/es/download/help/whatis_java.html
 Arquitectura del JDK:
https://www.usmp.edu.pe/publicaciones/boletin/fia/info49/too.html
 Paquetes en Java:
https://www.campusmvp.es/recursos/post/paquetes-en-java-que-son-para-
que-se-utilizan-y-como-se-usan.aspx
 Importar paquetes en Java:
https://www.programarya.com/Cursos/Java/Librerias

También podría gustarte