El tutorial de dos partes "Introducción a la programación Java" tiene como objetivo conseguir que los desarrolladores de software que sean nuevos en la tecnología Java estén listos y en movimiento con la programación orientada a objetos (OOP) y el desarrollo de aplicaciones del mundo real usando el lenguaje y la plataforma Java.
La primera parte es una introducción paso a paso a la OOP con el uso del lenguaje Java. El tutorial comienza con una visión general de la plataforma y el lenguaje Java y le siguen las instrucciones para establecer un entorno de desarrollo que consiste en un Kit de desarrollo de Java (JDK) y el Eclipse IDE. Una vez que se le hayan presentado los componentes de su entorno de desarrollo, comenzará a aprender la sintaxis Java básica en un modo práctico.
La Parte 2 cubre funciones de lenguaje más avanzadas, que incluyen expresiones regulares, genéricos, E/S y serialización. Los ejemplos de programación en la Parte 2 se desarrollan en base al objeto Person
que usted comienza a desarrollar en la Parte 1.
Cuando haya terminado la Parte 1, estará familiarizado con la sintaxis del lenguaje Java básico y podrá escribir programas Java simples. Debería continuar con "Introducción a la programación Java, parte 2: construcciones para aplicaciones del mundo real" para desarrollarse sobre esta base.
Este tutorial es para desarrolladores de software que todavía no tienen experiencia con el código Java o la plataforma Java. El tutorial incluye una visión general de los conceptos de OOP.
Para completar los ejercicios de este tutorial, instale y establezca un entorno de desarrollo que consista en:
En el tutorial, se incluyen instrucciones de descarga e instalación para ambos.
La configuración recomendada del sistema es la siguiente:
La tecnología Java se usa para desarrollar aplicaciones para un amplio alcance de entornos, desde dispositivos del consumidor hasta sistemas empresariales heterogéneos. En esta sección, obtenga una vista de alto nivel de la plataforma Java y sus componentes. Vea Recursos para aprender más acerca de los componentes de la plataforma Java discutidos en esta sección.
Como cualquier lenguaje de programación, el lenguaje Java tiene su propia estructura, reglas de sintaxis y paradigma de programación. El paradigma de programación del lenguaje Java se basa en el concepto de programación orientada a objetos (OOP), que las funciones del lenguaje soportan.
El lenguaje Java es un derivado del lenguaje C, por lo que sus reglas de sintaxis se parecen mucho a C: por ejemplo, los bloques de códigos se modularizan en métodos y se delimitan con llaves ({
y }
) y las variables se declaran antes de que se usen.
Estructuralmente, el lenguaje Java comienza con paquetes. Un paquete es el mecanismo de espacio de nombres del lenguaje Java. Dentro de los paquetes se encuentran las clases y dentro de las clases se encuentran métodos, variables, constantes, entre otros. En este tutorial, aprenderá acerca de las partes del lenguaje Java.
Cuando usted programa para la plataforma Java, escribe el código de origen en archivos .java y luego los compila. El compilador verifica su código con las reglas de sintaxis del lenguaje, luego escribe los códigos byte en archivos .class. Los códigos byte son instrucciones estándar destinadas a ejecutarse en una Java Virtual Machine (JVM). Al agregar este nivel de abstracción, el compilador Java difiere de los otros compiladores de lenguaje, que escriben instrucciones apropiadas para el chipset de la CPU en el que el programa se ejecutará.
Al momento de la ejecución, la JVM lee e interpreta archivos .class y ejecuta las instrucciones del programa en la plataforma de hardware nativo para la que se escribió la JVM. La JVM interpreta los códigos byte del mismo modo en que una CPU interpretaría las instrucciones del lenguaje del conjunto. La diferencia es que la JVM es un software escrito específicamente para una plataforma particular. La JVM es el corazón del principio "escrito una vez, ejecutado en cualquier lugar" del lenguaje Java. Su código se puede ejecutar en cualquier chipset para el cual una implementación apropiada de la JVM está disponible. Las JVM están disponibles para plataformas principales como Linux y Windows y se han implementado subconjuntos del lenguaje Java en las JVM para teléfonos móviles y aficionados de chips.
En lugar de forzarlo a mantenerse a la par con la asignación de memoria (o usar una biblioteca de terceros para hacer esto), la plataforma Java proporciona una gestión de memoria lista para usar. Cuando su aplicación Java crea una instancia de objeto al momento de ejecución, la JVM asigna automáticamente espacio de memoria para ese objeto desde el almacenamiento dinámico, que es una agrupación de memoria reservada para que use su programa. El recolector de basura Java se ejecuta en segundo plano y realiza un seguimiento de cuáles son los objetos que la aplicación ya no necesita y recupera la memoria que ellos ocupan. Este abordaje al manejo de la memoria se llama gestión de la memoria implícita porque no le exige que escriba cualquier código de manejo de la memoria. La recogida de basura es una de las funciones esenciales del rendimiento de la plataforma Java.
Cuando usted descarga un kit de desarrollo de Java (JDK), obtiene, — además del compilador y otras herramientas, — una librería de clase completa de programas de utilidad preconstruidos que lo ayudan a cumplir cualquier tarea común al desarrollo de aplicaciones. El mejor modo para tener una idea del ámbito de los paquetes y bibliotecas JDK es verificar la documentación API JDK (vea Recursos).
El Java Runtime Environment (JRE, también conocido como el Java Runtime) incluye las bibliotecas de códigos de la JVM y los componentes que son necesarios para programas en ejecución escritos en el lenguaje Java. Está disponible para múltiples plataformas. Puede redistribuir libremente el JRE con sus aplicaciones, de acuerdo a los términos de la licencia del JRE, para darles a los usuarios de la aplicación una plataforma en la cual ejecutar su software. El JRE se incluye en el JDK.
En esta sección, tendrá instrucciones para descargar e instalar el JDK 6 y el lanzamiento actual de IDE Eclipse y para configurar su entorno de desarrollo de Eclipse.
Si usted ya ha instalado el JDK e IDE Eclipse, tal vez quiera saltar a la secciónGetting started with Eclipse o a la que le sigue, Object-oriented programming concepts.
El JDK incluye un conjunto de herramientas de línea de comandos para compilar y ejecutar su código Java, que incluye una copia completa del JRE. Aunque usted ciertamente puede usar estas herramientas para desarrollar sus aplicaciones, la mayoría de los desarrolladores valoran la funcionalidad adicional, la gestión de tareas y la interfaz visual de un IDE.
Eclipse es un IDE de código abierto popular para el desarrollo Java. Maneja las tareas básicas, tales como la compilación de códigos y la configuración de un entorno de depuración, para que pueda centrase en escribir y probar códigos. Además, puede usar Eclipse para organizar archivos de códigos de origen en proyectos, compilar y probar esos proyectos y almacenar archivos de proyectos en cualquier cantidad de repositorios de origen. Necesita tener instalado un JDK para usar Eclipse para el desarrollo Java.
Siga estos pasos para descargar e instalar JDK 6:
Ahora tiene un entorno Java en su máquina. A continuación, instalará el IDE Eclipse.
Para descargar e instalar Eclipse, siga estos pasos:
El IDE Eclipse se coloca encima del JDK como una extracción útil pero todavía necesita acceder al JDK y sus diversas herramientas. Antes de que pueda usar Eclipse para escribir el código Java, tiene que indicarle dónde está ubicado el JDK.
Para configurar su entorno de desarrollo Eclipse:
Conozca las API de Java
La mayoría de los desarrolladores Java hacen referencia constantemente a la documentación API de Java online oficial, — también llamada el Javadoc (vea Recursos). De forma predeterminada, usted ve tres marcos en el Javadoc. El marco superior izquierdo muestra todos los paquetes en la API y debajo están las clases en cada paquete. El marco principal (a la derecha) muestra detalles del paquete o de la clase seleccionada actualmente. Por ejemplo, si selecciona el paquete java.util
en el marco superior izquierdo y luego selecciona la clase ArrayList
que aparece debajo de él, en el marco derecho, verá detalles acerca del ArrayList
, que incluyen una descripción de lo que hace, cómo usarlo y sus métodos.
Ahora Eclipse está configurado y listo para que usted cree proyectos y compile y ejecute códigos Java. La siguiente sección lo familiarizará con Eclipse.
Eclipse no es solo un IDE, es todo un ecosistema de desarrollo. Esta sección es una breve introducción práctica para usar Eclipse para el desarrollo Java. VeaRecursos si quiere aprender más acerca de Eclipse.
El entorno de desarrollo de Eclipse tiene cuatro componentes principales:
La unidad primaria de organización en Eclipse es el espacio de trabajo. Un espacio de trabajo contiene todos sus proyectos. Una perspectiva es un modo de observar cada proyecto (de ahí el nombre) y dentro de una perspectiva hay una o más vistas.
La Ilustración 2 muestra la perspectiva Java, que es la perspectiva predeterminada para Eclipse. Debería ver esta perspectiva cuando inicie Eclipse.
Ilustración 2. Perspectiva Java de Eclipse
La perspectiva Java contiene las herramientas que necesita para comenzar a escribir las aplicaciones Java. Cada pestaña que se muestra en la Ilustración 2 es una vista para la perspectiva Java. Package Explorer y Outline son dos vistas particularmente útiles.
El entorno Eclipse tiene un alto grado de configuración. Cada vista es acoplable, por lo que puede desplazarla alrededor de la perspectiva Java y ubicarla donde quiera. Aunque por ahora, quédese con la configuración predeterminada de la perspectiva y de la vista.
Siga estos pasos para crear un proyecto Java nuevo:
Intro
como nombre del proyecto y haga clic en Finish.Ahora ha creado un nuevo proyecto Java de Eclipse y carpeta de origen. Su entorno de desarrollo está listo para actuar. Sin embargo, una comprensión del paradigma OOP, — que se cubre en las siguientes dos secciones de este tutorial, — es esencial. Si usted está familiarizado con los conceptos y principios de OOP, tal vez quiera saltar a Getting started with the Java language.
El lenguaje Java está (en su mayor parte) orientado a objetos. Si no ha utilizado un lenguaje orientado a objetos antes, sus conceptos pueden parecer extraños al principio. Esta sección es una breve introducción a los conceptos del lenguaje OOP, que utiliza programación estructurada como punto de contraste.
Los lenguajes de programación estructurada como C y COBOL siguen un paradigma de programación muy diferente de los orientados a objetos. El paradigma de programación estructurada está altamente orientado a datos, lo cual significa que usted tiene estructuras de datos por una parte y luego instrucciones del programa que actúan sobre esos datos. Los lenguajes orientados a objetos, como el lenguaje Java, combinan datos e instrucciones del programa en objetos.
Un objeto es una entidad independiente que contiene atributos y comportamientos y nada más. En lugar de tener una estructura de datos con campos (atributos) y pasar esa estructura a toda la lógica del programa que actúa sobre ella (comportamiento), en un lenguaje orientado a objetos, se combinan los datos y la lógica del programa. Esta combinación puede ocurrir en niveles completamente diferentes de granularidad, desde objetos específicos como un Number
hasta objetos de aplicación general como un servicio deFundsTransfer
en una gran aplicación bancaria.
Un objeto padre es aquel que sirve como la base estructural para derivar objetos hijos más complejos. Un objeto hijo se parece a su padre pero es más especializado. El paradigma orientado a objetos le permite reutilizar los atributos y comportamientos comunes del objeto padre y le agrega a sus objetos hijos atributos y comportamientos que difieren. (Usted aprenderá más sobreherencia en la siguiente sección de este tutorial).
Los objetos se comunican con otros objetos por medio del envío de mensajes (llamadas de método en el lenguaje Java). Además, en una aplicación orientada a objetos, el código del programa coordina las actividades entre objetos para realizar tareas dentro del contexto del dominio de aplicación dado. (En el paradigma Modelo-Vista-Controlador, este código de programa de coordinación es el Controlador. Vea Recursos para aprender más acerca de MVC).
Un objeto bien escrito:
Básicamente, un objeto es una entidad diferenciada que tiene solo las dependencias necesarias de otros objetos para realizar sus tareas.
Ahora verá cómo luce un objeto.
Comenzaré con un ejemplo que está basado en escenario común de desarrollo de aplicación: se representa a un individuo con un objeto Person
.
Volviendo a la definición de un objeto, usted sabe que un objeto tiene dos elementos primarios: atributos y comportamiento. Verá cómo estos se aplican al objeto Person
.
Atributos
¿Qué atributos puede tener una persona? Algunos atributos comunes incluyen:
Probablemente a usted se le pueden ocurrir más (y siempre puede agregar más atributos más tarde) pero esta lista es un buen comienzo.
Comportamiento
Una persona real puede hacer todo tipo de actividades pero los comportamientos de los objetos normalmente se relacionan con algún tipo de contexto de aplicación. En un contexto de aplicación de negocio, por ejemplo, puede querer preguntarle a su objeto Person
: "¿Qué edad tiene?" Como respuesta, Person
le diría el valor de su atributo de Edad
.
Una lógica más compleja podría estar oculta dentro del objeto Person
pero por ahora suponga que esa Person
tiene el comportamiento de responder estas preguntas:
El Estado es un concepto importante en OOP. El estado de un objeto se representa en cualquier momento por medio del valor de sus atributos.
En el caso de Person
, su estado se define por sus atributos, tales como nombre, edad, altura y peso. Si usted quisiera presentar una lista de varios de esos atributos, podría hacerlo utilizando una clase de String
, sobre la cual hablaré más en el tutorial posteriormente.
Juntos, los conceptos de estado y cadena le permiten decirle a Person
: cuénteme quién es usted dándome un listado (o una String
) de sus atributos.
Si usted viene de un ambiente de programación estructurada, la proposición de valores de OOP puede que no sea clara todavía. Después de todo, los atributos de una persona y cualquier lógica para recuperar (y convertir) sus valores pueden escribirse en C o COBOL. Esta sección clarifica los beneficios del paradigma OOP al explicar sus principios distintivos: encapsulamiento, herenciay polimorfismo.
Recuerde que un objeto es, sobre todo, diferenciado o independiente. Este es el principio de encapsulamiento en funcionamiento. Ocultación es otro término que a veces se usa para expresar la naturaleza independiente y protegida de los objetos.
Sin tener en cuenta la terminología, lo que es importante es que el objeto mantiene un límite entre su estado y comportamiento y el mundo exterior. Como los objetos del mundo real, los objetos usados en la programación de computadora tienen diversos tipos de relaciones con diferentes categorías de objetos en las aplicaciones que los utilizan.
En la plataforma Java, puede usar especificadores de acceso (los que presentaré más adelante en el tutorial) para variar la naturaleza de las relaciones de los objetos desde lo público a lo privado. El acceso público tiene una gran apertura, mientras que el acceso privado significa que los atributos del objeto son accesibles solo dentro del objeto mismo.
El límite entre lo público y lo privado hace cumplir el principio orientado a objetos de encapsulamiento. En la plataforma Java, usted puede variar la fortaleza de ese límite sobre una base de objeto a objeto, al depender de un sistema de confianza. El encapsulamiento es una potente función del lenguaje Java.
En la programación estructurada, es común copiar una estructura, darle un nombre nuevo y agregar o modificar los atributos que hacen que la nueva identidad (por ejemplo, un registro de Cuenta
) sea diferente de su fuente original. Con el tiempo, este abordaje genera una gran cantidad de códigos duplicados, que pueden crear problemas de mantenimiento.
OOP presenta el concepto de herencia, por el cual los objetos especializados, — sin ningún código adicional, — pueden "copiar" los atributos y el comportamiento de los objetos de origen en los que se especializan. Si alguno de esos atributos o comportamientos necesitan modificarse, entonces simplemente modifíquelos temporalmente. Solo modifique lo que necesite modificar para crear objetos especializados. Como ya sabe desde la sección Object-oriented programming concepts, el objeto origen se llama el padre y la especialización nueva se llama elhijo.
Herencia en funcionamiento
Suponga que está escribiendo una aplicación de recursos humanos y quiere usar el objeto Person
como base para un objeto nuevo llamado Employee
. Al ser el hijo de Person
, el Employee
tendría todos los atributos de un objeto Person
, junto con los adicionales, tales como:
La herencia hace que sea fácil crear la nueva clase de Employee
del objeto sin necesidad de copiar manualmente todo el código de Person
o mantenerlo.
Verá muchos ejemplos de herencia en la programación Java más adelante en el tutorial, especialmente en la Part 2.
El polimorfismo es un concepto más difícil de entender que el encapsulamiento o la herencia. Básicamente, significa que los objetos que pertenecen a la misma ramificación de una jerarquía, cuando se envía el mismo mensaje (es decir, cuando se le indica que realice lo mismo), pueden manifestar ese comportamiento de modo diferente.
Para entender cómo el polimorfismo se aplica a un contexto de aplicación de negocio, regrese al ejemplo de Person
. ¿Recuerda indicarle a Person
que formatee sus atributos en una String
? El polimorfismo hace que sea posible para Person
representar sus atributos en una variedad de formas, dependiendo del tipo de Person
que sea.
El polimorfismo es uno de los conceptos más complejos con los que se encontrará en OOP en la plataforma Java y no dentro del ámbito de un tutorial introductorio. Vea Recursos si quiere aprender más acerca del polimorfismo.
Sería imposible introducir toda la sintaxis del lenguaje Java en un solo tutorial. Lo que resta de la Parte 1 se centra en los conceptos básicos del lenguaje, por lo que le da suficiente conocimiento y práctica para escribir programas simples. OOP se trata por completo de los objetos, por lo cual esta sección comienza con dos temas relacionados específicamente con la forma en que el lenguaje Java los maneja: palabras reservadas y la estructura de un objeto Java.
Como cualquier lenguaje de programación, el lenguaje Java designa ciertas palabras que el compilador reconoce como especiales y, como tales, usted no tiene permitido usarlas para nombrar sus construcciones Java. La lista de palabras reservadas es sorprendentemente corta:
abstracto
afirmar
booleano
interrupción
byte
caso
capturar
caract.
clase
const.
continuar
predeterminado
hacer
doble
else
enumer.
extiende
final
finalmente
flotante
para
ir a
si
implementa
importar
instancia de
int
interfaz
largo
nativo
nuevo
paquete
privado
protegido
público
retorno
corto
estático
strictfp
súper
conmutador
sincronizado
esto
arrojar
arroja
transitorio
intentar
inválido
volátil
mientras
Observe que true
, false
y null
técnicamente no son palabras reservadas. Aunque son literales, las incluyo en esta lista porque no puede usarlas para nombrar construcciones Java.
Una ventaja de la programación con un IDE es que puede usar coloreado de sintaxis para palabras reservadas, como verá más adelante en este tutorial.
Recuerde que un objeto es una entidad diferenciada que contiene atributos y comportamiento. Eso significa que tiene un límite nítido y un estado y puede realizar actividades cuando se lo piden correctamente. Cada lenguaje de orientación a objetos tiene reglas sobre cómo definir un objeto.
En el lenguaje Java, los objetos se definen como se demuestra en el Listado 1
Listado 1. Definición de objeto
El lenguaje Java: no está puramente orientado a objetos
El lenguaje Java le permite crear objetos de primera clase pero notodo en el lenguaje es un objeto. Hay dos cualidades que diferencian el lenguaje Java de los lenguajes puramente orientados a objetos como Smalltalk. Primero, el lenguaje Java es una mezcla de objetos y tipos primitivos. Segundo, le permite escribir un código que exponga el funcionamiento interno de un objeto a cualquier otro objeto que lo utilice.
El lenguaje Java sí le da las herramientas necesarias para seguir principios OOP sólidos y producir un código sólido orientado a objetos. Debido a que Java no está puramente orientado a objetos, debe ejercitar alguna disciplina sobre cómo usted escribe un código. — El lenguaje no lo obliga a hacer lo correcto, por lo tanto debe hacerlo usted mismo. (Esta última sección del tutorial,Writing good Java code, proporciona consejos).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package packageName;
import ClassNameToImport;
accessSpecifier class ClassName {
accessSpecifier dataType variableName [= initialValue];
accessSpecifier ClassName([argumentList]) {
constructorStatement(s)
}
accessSpecifier returnType methodName([argumentList]) {
methodStatement(s)
}
// This is a comment
/* This is a comment too */
/* This is a
multiline
comment */
}
El Listado 1 contiene diversos tipos de construcciones, que he diferenciado con formato de fuente. Las construcciones que se muestran en negrita (que encontrará en la lista de palabras reservadas) son literales. En cualquier definición de objeto, deben ser exactamente lo que son aquí. Los nombres que le he dado a las otras construcciones describen los conceptos que representan. Explicaré todas las construcciones en detalle en el resto de esta sección.
Nota: En el Listado 1 y algunos otros ejemplos de códigos en esta sección, los corchetes indican que las construcciones dentro de ellos no se requieren. Los corchetes en sí (a diferencia de {
y }
) no son parte de la sintaxis Java.
Comentarios en el código
Observe que el Listado 1 también incluye algunas líneas de comentarios:
1
2
3
4
5
// Este es un comentario
/* Este también es un comentario */
/* Este es un
comentario
múltiple */
Casi todos los lenguajes de programación le permiten al programador agregar comentarios para ayudar a documentar el código. La sintaxis Java permite tanto comentarios de una sola línea como comentarios múltiples. Un comentario de una sola línea debe ocupar una línea, aunque puede usar comentarios de una sola línea adyacentes para formar un bloque. Un comentario de líneas múltiples comienza con /*
, debe terminar con */
y puede distribuirse en cualquier cantidad de líneas.
Aprenderá más sobre los comentarios cuando llegue a la sección Writing good Java code de este tutorial.
El lenguaje Java le permite elegir los nombres de sus objetos, tales comoAccount
, Person
o LizardMan
. En ocasiones, puede que termine usando el mismo nombre para expresar dos conceptos ligeramente diferentes. Esto se llama unacolisión de nombres y sucede con frecuencia. El lenguaje Java usa paquetes para resolver estos conflictos.
Un paquete Java es un mecanismo para proporcionar un espacio de nombres: un área encapsulada en donde los nombres son únicos pero, fuera de esa área, puede que no lo sean. Para identificar una construcción de manera única, debe calificarla totalmente al incluir su espacio de nombres.
Los paquetes también le dan una buena forma para construir aplicaciones más complejas en unidades diferenciadas de funcionalidad.
Definición de paquete
Para definir un paquete, use la palabra clave paquete
seguida por un nombre de paquete legal y termina con un punto y coma. A menudo, los nombres de los paquetes se separan con puntos y siguen este plan de facto:
Esta definición de paquete se divide de la siguiente manera:
orgType
es el tipo de organización, tales como com
, org
o net
.orgName
es el nombre del ámbito de la organización, tales comomakotogroup
, sun
o ibm
.appName
es el nombre de la aplicación, abreviado.compName
es el nombre del componente.El lenguaje Java no lo obliga a seguir este convenio de paquetes. De hecho, usted no necesita especificar ningún paquete, en cuyo caso todos sus objetos deben tener nombres de clases únicos y residirán en el paquete predeterminado. Como una práctica mejor, recomiendo que defina todas sus clases Java en paquetes. Usted seguirá ese convenio durante este tutorial.
A continuación en la definición de objeto (retomando el Listado 1) se encuentra la sentencia de importación. Una sentencia de importación le comunica al compilador Java dónde encontrar las clases a las que usted hace referencia dentro de su código. Cualquier objeto no trivial usa otros objetos para alguna funcionalidad y la sentencia de importación es cómo usted le comunica al compilador Java sobre ellos.
Una sentencia de importación normalmente luce así:
Especifique la palabra clave importación
seguida de la clase que quiere importar seguida de un punto y coma. El nombre de la clase debería estar completamente calificado, es decir, debería incluir su paquete.
Para importar todas las clases dentro de un paquete, puede poner .*
después del nombre del paquete. Por ejemplo, esta sentencia importa cada clase en el paquete com.makotogroup
:
Sin embargo, importar todo un paquete puede hacer que su código sea menos legible, por lo tanto recomiendo que importe solo las clases que necesite.
Eclipse simplifica las importaciones
Cuando escribe el código en el editor de Eclipse, puede escribir el nombre de una clase que usted quiera usar, seguido por Ctrl+Shift+O. Eclipse resuelve cuáles son las importaciones que usted necesita y las agrega automáticamente. Si Eclipse encuentra dos clases con el mismo nombre, visualiza un recuadro de diálogo que le pregunta para cuál de las clases quiere agregar importaciones.
Para definir un objeto en el lenguaje Java, debe declarar una clase. Considere a una clase como una plantilla para un objeto, como un molde de galletas. La clase define la estructura básica del objeto y, al momento de la ejecución, su aplicación crea una instancia del objeto. La palabra objeto a menudo se usa como sinónimo de la palabra clase. En sentido estricto, una clase define la estructura de algo de lo cual el objeto es una instancia.
El Listado 1 incluye esta declaración de clase:
1
1
1
1
2
3
4
5
6
7
8
9
package orgType.orgName.appName.compName;
import ClassNameToImport;
import com.makotogroup.*;
accessSpecifier class ClassName {
accessSpecifier dataType variableName [= initialValue];
accessSpecifier ClassName([argumentList]) {
constructorStatement(s)
}
accessSpecifier returnType methodName([argumentList]) {
methodStatement(s)
}
}
Un accessSpecifier
de una clase podría tener varios valores pero, por lo general, es público
. Observará otros valores de accessSpecifier
pronto.
Convenios de denominación de clases
Puede denominar a las clases prácticamente como quiera pero el convenio es usar bicapitalización: comenzar con una letra en mayúscula, usar mayúscula en la primera letra de cada palabra concatenada y dejar todas las otras letras en minúscula. Los nombres de las clases deberían contener solo letras y números. Adherirse a estas guías asegurará que su código sea más accesible para otros desarrolladores que siguen los mismos convenios.
Las clases pueden tener dos tipos de miembros: variables y métodos.
Los valores de las variables de una clase dada distinguen cada instancia de esa clase y define su estado. A estos valores a menudo se los denomina variables de instancia. Una variable tiene:
accessSpecifier
dataType
variableName
initialValue
Lo posibles valores de accessSpecifier
son:
público
: Cualquier objeto en cualquier paquete puede ver la variable. (Nunca use este valor).protegido
: Cualquier objeto definido en el mismo paquete, o una subclase (definida en cualquier paquete), puede ver la variable.privado
: Solo la clase que contiene la variable puede verlaEl dataType
de una variable depende de lo que la variable sea, — podría ser un tipo primitivo u otro tipo de clase (repito, profundizaremos sobre esto más adelante).
El variableName
depende de usted pero, por convenio, los nombres de las variables usan el convenio de bicapitalización que describí anteriormente, con la excepción de que comienzan con una letra minúscula. (A este estilo a veces se lo llama lowerCamelCase).
No se preocupe por el initialValue
por ahora; solo sepa que puede inicializar una variable de instancia cuando la declara. (De otro modo, el compilador genera una predeterminación por usted que se establecerá cuando se cree una instancia de la clase).
Antes de seguir con los métodos, aquí hay un ejemplo que resume lo que ha aprendido hasta ahora. El Listado 2 es una definición de clase de Person
:
Listado 2. Definición de clase básica de Person
Variables públicas
Nunca es una buena idea usar variables públicas pero, en casos extremadamente raros, podría ser necesario, así que existe la opción. La plataforma Java no restringe sus casos de uso. Por lo tanto, depende de usted ser disciplinado al usar buenos convenios de codificación, incluso si se siente tentado para hacer lo contrario.
1
2
3
4
5
6
7
8
9
10
package com.makotogroup.intro;
public class Person {
private String name;
private int age;
private int height;
private int weight;
private String eyeColor;
private String gender;
}
La definición de clase básica de Person
no es muy útil en este momento porque define solo sus atributos (y los privados).
Para ser más interesante, la clase de Person
necesita comportamiento, — y eso significa métodos.
Los métodos de una clase definen su comportamiento. A veces, este comportamiento no es nada más que devolver el valor actual de un atributo. Otras veces, el comportamiento puede ser bastante complejo.
Hay esencialmente dos categorías de métodos: constructores y todos los otros métodos, — de los cuales existen muchos tipos. Un método constructor se usa solo para crear una instancia de una clase. Otros tipos de métodos pueden usarse para prácticamente cualquier comportamiento de aplicación.
Al mirar hacia atrás al Listado 1, muestra el modo para definir la estructura de un método, que incluye aspectos como:
accessSpecifier
returnType
methodName
argumentList
La combinación de estos elementos estructurales en la definición de un método se llama su firma.
A continuación, verá en más detalle dos tipos de métodos, comenzando con los constructores.
Métodos constructores
Los constructores le permiten especificar cómo crear una instancia de una clase. El Listado 1 muestra la sintaxis de la declaración del constructor en una forma abstracta. Aquí está de nuevo en el Listado 3:
Listado 3. Sintaxis de la declaración del constructor
1
2
3
accessSpecifier ClassName([argumentList]) {
constructorStatement(s)
}
El accessSpecifier
de un constructor es el mismo que el de las variables. El nombre del constructor debe coincidir con el nombre de la clase. Por lo tanto, si llama a su clase Person
, entonces el nombre del constructor también debe ser Person
.
Para cualquier constructor que no sea el constructor predeterminado, usted pasa unaargumentList
, que es una o más de:
Los constructores son opcionales
Si usted no proporciona un constructor, el compilador proporcionará uno por usted, denominado el constructor predeterminado (o sin argumento). Si usted proporciona un constructor que no sea un constructor sin argumento (o no-arg), el compilador no generará uno por usted.
1
argumentType argumentName
Los argumentos en una argumentList
se separan con comas y dos argumentos no pueden tener el mismo nombre. El argumentType
es un tipo primitivo u otro tipo de clase (lo mismo que sucede con los tipos de variables).
Definición de clase con un constructor
Ahora verá lo que sucede cuando agrega la capacidad de crear un objeto Person
de dos modos: al usar un constructor sin argumento y al inicializar una lista parcial de atributos.
El Listado 4 muestra cómo crear constructores y también cómo usar laargumentList
:
Listado 4. Definición de clase de Person
con un constructor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.makotogroup.intro;
public class Person {
private String name;
private int age;
private int height;
private int weight;
private String eyeColor;
private String gender;
public Person() {
// Nothing to do...
}
public Person(String name, int age, int height, String eyeColor, String gender) {
this.name = name;
this.age = age;
this.height = height;
this.weight = weight;
this.eyeColor = eyeColor;
this.gender = gender;
}
}
Observe el uso de la palabra clave this
al hacer las asignaciones de variables en el Listado 4. Esto es una taquigrafía de Java para "this object" y debe usarse cuando se haga referencia a dos variables con el mismo nombre (como en este caso en el que la edad, por ejemplo, es tanto un parámetro constructor como una variable de clase) y le ayuda al compilador a desambiguar la referencia.
El objeto Person
se está haciendo más interesante pero necesita más comportamiento. Y para eso, usted necesita más métodos.
Otros métodos
Un constructor es un tipo particular de método con una función particular. De forma similar, muchos otros tipos de métodos desempeñan funciones particulares en los programas Java. La exploración de otros métodos comienza en esta sección y continúa durante todo el tutorial.
En el Listado 1, le mostré cómo declarar un método:
1
2
3
accessSpecifier returnType methodName([argumentList]) {
methodStatement(s)
}
Otros métodos se parecen bastante a los constructores, con un par de excepciones. En primer lugar, usted puede denominar a otros métodos cómo usted quiera (aunque, por supuesto, hay reglas). Recomiendo los siguientes convenios:
En segundo lugar, a diferencia de los constructores, otros métodos tienen un tipo de retorno opcional.
Otros métodos de Person
Con esta información básica de su lado, usted puede ver en el Listado 5 lo que sucede cuando agrega algunos métodos más al objeto Person
. (He omitido los constructores para ser breve).
Listado 5. Person
con algunos métodos nuevos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.makotogroup.intro;
public class Person {
private String name;
private int age;
private int height;
private int weight;
private String eyeColor;
private String gender;
public String getName() { return name; }
public void setName(String value) { name = value; }
// Other getter/setter combinations...
}
Observe el comentario en el Listado 5 sobre "combinaciones getter/setter". Usted trabajará más con getters y setters más adelante en el tutorial. Por ahora, todo lo que necesita saber es que un getter es un método para recuperar el valor de un atributo y un setter es un método para modificar ese valor. Solo le he mostrado una combinación getter/setter (para el atributo de Nombre
) pero usted podría definir más de manera similar.
Observe en el Listado 5 que si un método no devuelve un valor, debe comunicárselo al compilador especificando el tipo de devolución inválido
en su firma.
Métodos estáticos y de instancia
Hay generalmente dos tipos de métodos (no constructores): los métodos de instancia y los métodos estáticos. Los métodos de instancia dependen del estado de una instancia de objeto específico por sus comportamientos. Los métodos estáticos también se denominan a veces métodos de clase porque sus comportamientos no dependen del estado de ningún objeto en particular. El comportamiento de un método estático sucede al nivel de la clase.
Los métodos estáticos se usan en gran medida por utilidad; puede considerarlos como un modo de tener métodos globales (à la C) mientras mantiene el código mismo agrupado con la clase que lo necesita.
Por ejemplo, en todo este tutorial usará la clase de Logger
JDK para enviar información a la consola. Para crear una instancia de clase de Logger
, no cree una instancia de clase de Logger
; en cambio, invoque un método estático llamado getLogger()
.
La sintaxis para invocar un método estático es diferente de la sintaxis usada para invocar un método para una instancia de objeto. También use el nombre de la clase que contiene el método estático, como se muestra en esta invocación:
Por lo cual, para invocar un método estático, no necesita una instancia de objeto, solo el nombre de la clase.
Es tiempo de reunir lo que ha aprendido en las secciones previas y comenzar a escribir algunos códigos. Esta sección lo guía por la declaración de una clase y la adición de variables y métodos a ella para usar el Eclipse Package Explorer. Aprenderá cómo usar la clase de Logger
para mantener en vista al comportamiento de su aplicación y también cómo usar un método main()
como un banco de pruebas.
Si todavía no está allí, vaya a la perspectiva Package Explorer en Eclipse. Se lo va a preparar para crear su primera clase Java. El primer paso es crear un lugar para que la clase viva. Los paquetes son construcciones de espacio de nombres pero también se correlacionan convenientemente de forma directa con la estructura del directorio del sistema de archivos.
En lugar de usar el paquete predeterminado (casi siempre una mal idea), creará uno específicamente para el código que estará escribiendo. Haga clic en File > New > Package para acceder al asistente del Paquete Java, que se muestra en la Ilustración 4:
Ilustración 4. El asistente del Paquete Java de Eclipse
1
Logger l = Logger.getLogger("NewLogger");
Escriba com.makotogroup.intro
en el recuadro de texto del Nombre y haga clic en Finish. Verá el nuevo paquete creado en el Package Explorer.
Hay más de un modo para crear una clase desde el Package Explorer pero el modo más fácil es hacer clic derecho en el paquete que acaba de crear y elegirNew > Class.... Verá el recuadro de diálogo New Class (Clase nueva).
En el recuadro de texto de Name escriba Person
. Bajo ¿Qué resguardos de métodos le gustaría crear?, marque public static void main(String[] args)
. (Pronto verá por qué). Luego, haga clic en Finish.
La clase nueva aparece en su ventana de edición. Recomiendo cerrar algunas de las vistas de su aspecto predeterminado para que sea más fácil ver su código de origen, como se muestra en la Ilustración 5:
Ilustración 5. Un espacio de trabajo bien ordenado
Eclipse genera una clase de shell para usted e incluye la sentencia del paquete en la parte superior, junto con el método main()
que usted pidió y los comentarios que ve. Ahora, solo necesita precisar la clase. Puede configurar cómo Eclipse genera clases nuevas por medio de Window > Preferences > Java > Code Style > Code Templates. Para simplificar, usted optará por la generación de código simple de instalar de Eclipse.
En la Ilustración 5, observe el asterisco (*) junto al nuevo archivo de código de origen, que indica que he hecho una modificación. Y observe que el código no está guardado. Luego, observe que he cometido un error cuando declaré el atribut Name
: Declaré que el tipo de Name
era Strin
. El compilador no pudo encontrar una referencia para tal clase y la distinguió como un error de compilación (esa es la línea roja ondulada debajo de Strin
). Por supuesto, puedo corregir mi error al agregar una g
al final de Strin
. Esto es solo una pequeña demostración del poder de un IDE sobre el uso de herramientas de líneas de comandos para el desarrollo de software.
En el Listado 4, usted comienza a precisar la clase de Person
pero no expliqué mucho sobre la sintaxis. Ahora formalmente definiré cómo agregar variables de clases.
Recuerde que una variable tiene un accessSpecifier
, un dataType
, unvariableName
y, opcionalmente, un initialValue
. Anteriormente, observó brevemente cómo definir el accessSpecifier
y variableName
. Ahora verá eldataType
que una variable puede tener.
Un dataType
puede ser un tipo primitivo o una referencia a otro objeto. Por ejemplo, observe que Age
es un int
(un tipo primitivo) y Name
es una String
(un objeto). El JDK viene empaquetado lleno de clases útiles comojava.lang.String
y aquellos en el paquete java.lang
no necesitan ser importados (una cortesía taquigráfica del compilador Java). Pero ya sea que eldataType
sea una clase JDK como String
o una clase definida por el usuario, la sintaxis es esencialmente la misma.
La Tabla 1 muestra los ocho tipos de datos primitivos que es probable que usted vea regularmente, incluidos los valores predeterminados que los primitivos adquieren si usted no inicializa explícitamente el valor de una variable miembro:
Tabla 1. Tipos de datos primitivos
Antes de avanzar más en la codificación, necesita saber cómo sus programas le dicen lo que están haciendo.
La plataforma Java incluye el paquete java.util.logging
, un mecanismo de registro incorporado para juntar información de programa en una forma legible. Los registradores son entidades con nombres que usted crea por medio de una llamada de método estático a la clase Logger
, como la siguiente:
1
2
3
import java.util.logging.Logger;
//. . .
Logger l = Logger.getLogger(getClass().getName());
Cuando se llama al método getLogger()
, usted pase una String
. Por ahora, solo acostúmbrese a pasar al nombre de la clase el código en el que su escritura se encuentra. Desde cualquier método regular (es decir, no estático), el código anterior siempre hará referencia al nombre de la clase y lo pasará al Logger
.
Si usted está haciendo una llamada de Logger
dentro de un método estático, solo haga referencia al nombre de la clase en la que se encuentre:
En este ejemplo, el código en el que usted se encuentra es la clase de Person
, por lo tanto haga referencia a un literal especial denominado clase
que recupera el objeto Class
(profundizaremos sobre esto más adelante) y obtiene su atributo Name
.
La sección Writing good Java code de este tutorial incluye un consejo sobre cómono hacer un registro.
main()
es un método especial que usted puede incluir en cualquier clase para que el JRE pueda ejecutar su código. No se requiere que una clase tenga un método main()
, — de hecho, la mayoría nunca lo tendrá, — y una clase puede tener, como mucho, un método main()
.
main()
es un método práctico para tener porque le da un banco de pruebas rápido para la clase. En el desarrollo empresarial, usted usaría bibliotecas de pruebas pero, a los propósitos de este tutorial, usará main()
como su banco de pruebas.
Vaya al editor de código de origen de Eclipse para Person
y agregue un código para hacer que se parezca al Listado 4. Eclipse tiene un práctico generador de códigos para generar getters y setters (entre otros). Para probarlo, ponga el cursor del ratón en la definición de clase de Person
(es decir, en la palabraPerson
en la definición de clase) y vaya a Source > Generate Getters and Setters.... Cuando el recuadro de diálogo se abra, haga clic en Select All, como se muestra en la Ilustración 6:
Ilustración 6. Eclipse genera getters y setters
1
Logger l = Logger.getLogger(Person.class.getName());
Para el punto de inserción, elija Last member y haga clic en OK. Observe que los getters y setters aparecen luego del método main()
.
Hay más sobre main()
Ahora agregará algunos códigos a main()
para que le permita crear una instancia de una Person
, establecer algunos atributos y luego imprimirlos en la consola.
Comience agregando un constructor a Person
. Escriba el código en el Listado 6 en su ventana de origen debajo de la parte superior de la definición de clase (la línea inmediatamente debajo de public class Person ()
):
Listado 6. Constructor de Person
1
2
3
4
5
6
7
8
9
public Person(String name, int age, int height, int weight, String eyeColor,
String gender) {
this.name = name;
this.age = age;
this.height = height;
this.weight = weight;
this.eyeColor = eyeColor;
this.gender = gender;
}
Asegúrese de no tener líneas onduladas que indiquen errores de compilación.
Luego, vaya al método main()
y haga que se parezca al Listado 7:
Listado 7. El método main()
1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
Logger l = Logger.getLogger(Person.class.getName());
l.info("Name: " + p.getName());
l.info("Age:" + p.getAge());
l.info("Height (cm):" + p.getHeight());
l.info("Weight (kg):" + p.getWeight());
l.info("Eye Color:" + p.getEyeColor());
l.info("Gender:" + p.getGender());
}
No se preocupe por la clase de Logger
por ahora. Solo ingrese el código como lo ve en el Listado 7. Ahora está listo para ejecutar su primer programa Java.
Para ejecutar una aplicación Java desde dentro de Eclipse, seleccione la clase que quiere ejecutar, que debe tener un método main()
. Actualmente, usted tiene solo una clase, — y sí tiene un método main()
, — por lo tanto seleccionePerson
, luego haga clic en el icono Run (que es verde y tiene una pequeña flecha triangular que apunta a la derecha). Cuando se lo pida, seleccione ejecutarPerson
como una aplicación Java, luego siéntese y obsérvelo funcionar. Debería ver algo parecido a la captura de pantalla de la Ilustración 7:
Ilustración 7. Vea ejecución de Person
Observe que la vista de Consola se abre automáticamente y muestra la salida deLogger
. También he seleccionado la vista de Esquema en el panel izquierdo, que revela la estructura básica de la clase de Person
en una vista rápida.