Java

TI-Basic Basic Fortran Pascal C Prolog Delphi Visual Basic

Construcciones comunes de Java

Método principal

public static void main(String[] args)

Clase simple

[acceso] [final] class Nombre
{
	miembros
}
Un miembro puede ser un constructor, un campo, un método o una clase interior. Una clase pública debe encontrarse en su propio archivo Nombre.java.

Método

[acceso] [static] [synchronized] ...	//Encabezado de método
	nombre tipovalor (tipo arg1, tipo arg2, ...)
		[throws Excepcion_1, ... , Excepcion_i]
{
	declaraciones e instrucciones	//Cuerpo de método
}

Instrucción for

for ( init;
	cont condición; actualiza)	//Control del ciclo
	instrucción			//Cuerpo del ciclo
La parte init puede ser una lista de expresiones sencilla o separada por comas, al igual que la parte actualiza.

Instrucción if

if ( condición )
	instrucción uno
else
	instrucción dos

Instrucción switch

switch ( int-expresión )
{
	case constante-exp1:
		instrucciones
	case constante-exp2:
		instrucciones
	.
	 .
	  .
	default:
		instrucciones
}
Las instrucciones suelen terminar con break para evitar la caída.

Instrucción label

nombre-etiqueta: instrucción

break nombre-etiqueta ó
continue nombre-etiqueta

Instrucción do-while

do
	cuerpo
while ( condición );

Acceso a miembro

Acceso a miembro de instancia:
	objeto.miembro
Acceso a miembro de caso heredado oculto:
	super.miembro (asigna-a-superclase)this.campo
Acceso a miembro estático:
	nombreClase.miembro objeto.miembro

Unión de cadenas

	a+b
donde por lo menos a o b es una cadena. Un operador que no es una cadena debe ser un tipo primitivo o un objeto con toString sobrecargado.

Control de excepciones

try { instrucciones
	}
	catch ( e-tipo, e )
	{ instrucciones }
	catch ( e-tipo, e )
	{ instrucciones }
	...
	finally
	{ instrucciones }

Asignación explícita de tipo

	( nombre-tipo ) expresión

Extensión de clase

[acceso] [final] class Nombre extends superclase
{
	cuerpo de clase extendido
}

Constructor de subclase

public ClassName(arg1, ...)
{	super(...);
	...
}

Definición e implantación de interfaces

public interface NombreInterfaz
{
	...
}
acceso class ClaseX extends ClaseY
	implements Interfaz_1, Interfaz_2, ...
{
	cuerpo de clase
}

Clase anónima

new nombreSuper()
{
	cuerpo de la clase
};

Applet

public AppletName extends Applet
{	public void init() { ... }
	public void start() { ... }
	public void stop() { ... }
	public void destroy() { ... }
	public void paint(Graphics g) { ... }
}

main de la aplicación del AWT

public static void main(String[] args)
{	//Proceso de argumentos de línea de comandos
	Frame win = new Frame ("PieChart");	//Ventana de nivel superior
	//Configura win con barra de menús, etc.

	//Establece otros componentes
	win.add(...);

	win.setSize(width, height);
	win.setVisible(true);
}

Lectura y escritura de texto

BufferedReader rdr = new BufferedReader
	(new InputStreamReader(in));
String line = rdr.readLine();
char c = rdr.read();

PrintWriter wtr = new PrintWriter(new BufferedWriter
	(new OutputStreamWriter(out)), true);
wrt.println(...);
wrt.print(...);

Sobreescritura de equals

public boolean equals ( object y )			//Sobreescritura
{
	return ( y == this ||				//Misma referencia
		(this.getClass() == y.getClass())	//Misma clase
		&& num == ((Fraction(y).num
		&& denom == ((Fraction(y).denom )	//Compara miembros
		);
}

Estructura de Java

Un programa de Java contiene una o más clases. Éstas describen objetos. Los objetos modelan entidades reales o lógicas. Una clase es el plano de los objetos. Describe las estructuras de datos del objeto y sus operaciones asociadas.

Una clase contiene miembros que pueden ser campos y métodos. Un mensaje enviado a un objeto activa (o invoca) un método de ese objeto, le pasa argumentos y obtiene el valor que devuelve. Los objetos interactúan al enviar y recibir mensajes.

Las clases pueden estar organizadas en paquetes con un nombre.

Definición simple de clase

class Nombre	//Encabezado de clase
{
	miembros	//Cuerpo de la clase
}
Un miembro pude ser un campo (datos) o un método (instrucciones). Para declarar una clase como pública se le debe agregar el modificador public. Una clase solo puede ser vista desde dentro de su paquete, a menos que se haga pública.

Todas las partes de un programa que tienen acceso a la clase pueden acceder a los miembros de ésta que se hayan declarado como public.

El método main es público para que pueda ser invocado por el intérprete de Java. También es static. Un miembro es un miembro de instancia a menos que se haya declarado como static que lo convierte en un miembro de clase.

Métodos de definición

Cada método contiene instrucciones y variables, algunas variables pueden ser objetos. Un método toma argumentos como entrada, realiza una secuencia de pasos y devuelve un resultado del tipo declarado. Puede llamar a otros métodos.

Una definición de método contiene encabezado y un cuerpo. El encabezado define el nombre del método y el tipo del valor de regreso; también especifica variables conocidas como parámetros formales. El cuerpo incluye una secuencia de declaraciones e instrucciones encerrados entre llaves {}.

tipo-de-regreso nombre ( tipo arg1, tipo arg2, ... )	//Encabezado de método
{
	declaraciones e instrucciones	//Cuerpo del método
}
Si el control fluye fuera del final de un método o se devuelve a través de un return sin argumento, el valor de devolución queda sin definir y el tipo de regreso del método será void.

Antes de utilizar una variable, es necesario declararla. Una declaración simple consta de un nombre de tipo, seguido por una lista de nombres de variables separados por comas y terminados con punto y coma. A cada variable se le puede asignar un inicializador opcional después de un signo de igual (=).

El punto (.) es el operador de miembro-de y se aplica a objetos. Una función especial del operador (+) es que sirve para unir a una cadena otros tipos de datos de Java según convenga. Una constante de cadena se da como una secuencia de caracteres encerrados entre comillas dobles ("). Utilice \" para incluir un caracter de comillas dobles. Las cadenas son objetos de la clase integradora String.

Una expresión relacional arroja un valor de tipo boolean. Los operadores relacionales son:

	Operador	Significado

	   >		Mayor que
	   <		Menor que
	   ==		Igual a
	   !=		No es igual a
	   >=		Mayor o igual a
	   <=		Menor o igual a
Java tiene los operadores aritméticos usuales: +, -, * y /; además incluye el remanente entero %. No existen operadores para potencias o exponentes. El sobreflujo aritmético de enteros pasa sin ser detectado y da como resultado un módulo de respuesta del tamaño del tipo.

Instrucciones

El cuerpo de un método contiene instrucciones. Existen dos tipos de ellas:

Se suele hacer referencia a una instrucción compuesta como bloque. Es necesario asegurarse de usar el punto y coma cuando sea necesario:

Comentarios

Existen tres formas de comentarios:

El comentario de documentación describe el propósito y el uso de una clase, método o campo que se encuentra a continuación.

while

La instrucción while especifica la ejecución repetida de instrucciones que forman un ciclo. La condición (entre paréntesis) produce un valor de tipo boolean (true o false) y controla el número de veces que se ejecuta el ciclo while (encerrado entre llaves).

A la condición se le conoce como condición de continuación. La variable que cambia su valor tras cada repetición y determina cuándo se detiene el ciclo se conoce como variable de control de ciclo.

Instrucciones condicionales simples

La instrucción if...else proporciona ramificación condicional. Los paréntesis alrededor de la condición son obligatorios.

Como una instrucción puede ser simple o compuesta, entonces las instrucciones del if..else pueden ser compuestas, en la forma {st_1;...;st_n}. Puede omitirse la parte else.

Instrucción for

La instrucción for especifica un ciclo. El cuerpo del ciclo puede ser una instrucción simple o compuesta. Su control contiene una parte de inicialización, una condición de continuación y una parte de actualización, separadas por puntos y comas.

La parte init se ejecuta antes de que se inicie el ciclo for. La condición cont se prueba. Si es verdadera, la instrucción o cuerpo del ciclo for se ejecuta una vez. Entonces se ejecuta la parte actualizar; En seguida se revalúa la condición de continuación. Si es verdadera, el cuerpo se ejecuta una vez más. Si es falsa, se termina la instrucción.

Es posible que el cuerpo de for se omita sin ejecutarse. Es posible omitir una o más partes del control del ciclo for. Es incluso posible escribir un for con un cuerpo vacío o una instrucción nula:

for ( control ) {}	//Cuerpo de ciclo vacío
for ( control ) ;	//Cuerpo de ciclo con instrucción nula
Es una práctica común mover la instrucción de la declaración dentro de for, así la variable es local para el ciclo for y no puede utilizarse después de él.

Operadores de incremento y decremento

Los operadores ++ (incremento) y -- (decremento) se utilizan para aumentar o disminuir en 1 el valor de la variable entera. Es posible utilizar:

El uso de los operadores de incremento y decremento pueden dificultar la lectura del código.

La instrucción do-while

1