Tarea Academica de Taller de Programacion
Tarea Academica de Taller de Programacion
Tarea Academica de Taller de Programacion
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:
El Java Development Kit (JDK) es un software que se utiliza para desarrollar aplicaciones y
subprogramas Java.
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.
- 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.
- 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.
- 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:
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.
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