Creación de un Fat Jar con Apache Maven

Hace un tiempo publiqué un post en este mismo blog en el que se explicaba como construir un Fat Jar con Apache Ant para empaquetar toda una aplicación, dependencias incluidas, dentro de un mismo fichero jar. El procedimiento para ello se basa en extraer los ficheros *.class compilados que se encuentran dentro de los jars de las dependencias incluirlo dentro del jar principal de la aplicación. En caso de utilizar Maven como herramienta de construcción en lugar de Ant, esta acción se puede realizar utilizando el plugin Shade. Para ello será necesario incluir su definición dentro del fichero pom.xml del proyecto y asociar la ejecución de su único goal shade a la ejecución de la fase de empaquetado package:

<build>
    <plugins>             
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>2.4.1</version>
            <executions>
                <!-- Ejecutar el goal "shade" en la fase de empaquetado "package" -->
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <transformers>
                            <!-- Se puede especificar la clase que contiene el método "main" para inluirlo en el Manifest 
                                 de la aplicación i así hacerla ejecutable
                            -->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>com.bitsmi.yggdrasil.launcher.MainProgram</mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>      
</build>

Esto hará posible su ejecución automática durante la construcción de la aplicación a través de los goals package, install o deploy de Maven.

Adicionalmente, es posible especificar en la configuraciones adicionales para la ejecución del plugin en la sección <configuration/>, como por ejemplo reglas de inclusión y exclusión de artefactos en el Fat Jar, renombrado de paquetes, o tratamiento de recursos ubicados en el directorio META-INF para evitar solapamiento (ficheros de licencia, definición de Services…). En la página del plugin hay multitud de ejemplos sobre cómo utilizar cada una de estas funcionalidades.

Enlaces de interés

• Creación de un Fat Jar con Apache Ant
• Apache Maven Shade Plugin

more…

Adaptación de librería java-json.jar a JAVA 1.4

Una de las limitaciones más comunes a la hora de programar es la versión del jdk que requiere nuestra aplicación. Cuando los requerimientos exigen una versión un tanto antigua (1.4 por ejemplo), encontramos problemas a la hora de usar tecnologías como AJAX, sobretodo si necesitamos utilizar respuestas de tipo JSON. Para ello existe una librería muy simple «java-json.jar» pero nos encontramos de que es incompatible con el jdk 1.4.

Aquí explicaré en pocos pasos como adaptar y recompilar esta librería para hacerla compatible y funcional para una aplicación que use un jdk 1.4. Necesitaremos descargar el código fuente de la librería y modificar unos pequeños detalles de las clases que contiene.

Se puede descargar el código fuente de aquí

more…

Función CONVERT en BBDD Oracle 10g

La función CONVERT permite convertir un carácter de un conjunto específico de caracteres a otro carácter de otro conjunto específico de caracteres.

En el caso concreto de la aplicación en la que se está trabajando se desea realizar una consulta sobre una tabla concreta para recuperar una descripción que contenga la palabra avión, como caso de ejemplo. Las descripciones a recuperar son las siguientes

Auxiliares de vuelo y camareros de avión, barco y tren
Mecánicos y ajustadores de motores de avión mediante la siguiente consulta

SELECT 
	des.des_dcol
FROM 
    TABLA_DESCRIPCIONES des
WHERE 
    UPPER(des.des_dcol) LIKE UPPER(‘%avión%’));

No encuentra ningún resultado dado que realiza la consulta estrictamente con acento y aunque existe en la tabla no lo retorna correctamente.

Aquí es dónde entra la utilización de la función CONVERT. La siguiente consulta busca las descripciones que contengan el valor %avión% mostrando el resultado correctamente.

SELECT 
    des.des_dcol
FROM 
    TABLA_DESCRIPCIONES des
WHERE 
    UPPER(CONVERT(des.des_dcol, ‘US7ASCII‘)) 
	LIKE UPPER(CONVERT(‘%avión%’, ‘US7ASCII‘));

Las descripciones recuperadas son las esperadas como se ha comentado con anterioridad.

• Auxiliares de vuelo y camareros de avión, barco y tren
• Mecánicos y ajustadores de motores de avión

La clave se encuentra en el parámetro que se le pasa, US7ASCII, correspondiente una de las codificaciones de caracteres comunes (ASCII US 7-bit) de las que puede gestionar la función..

Hasta aquí la prueba de concepto de esta función de Oracle. Para un mayor detalle de la misma se puede consultar en el siguiente enlace.

more…

Quick reference - Oracle DML and DDL statements

Just a quick reference of DML and DDL Oracle Statements and some links to visit.

DML Statements

Main Site: Oracle DML Statements

Insert

INSERT INTO table_name (list_of_columns)
VALUES (list_of_values);

Update

UPDATE table_name
SET column_name = value [, column_name = value]…
[ WHERE condition ];

Delete

DELETE FROM table_name
[ WHERE condition ];

DDL Statements

Main Site: DDL Oracle Statements

Create

CREATE TABLE table_name
(
column1 datatype [ NULL | NOT NULL ],
column2 datatype [ NULL | NOT NULL ],
…
column_n datatype [ NULL | NOT NULL ] );

Alter

ALTER TABLE table_name
ADD column_name column-definition;

Drop

DROP [schema_name].TABLE table_name
[ CASCADE CONSTRAINTS ] [ PURGE ];

Extra

Some sites which contains interesting information about the last topics:

• http://www.orafaq.com/faq/what_are_the_difference_between_ddl_dml_and_dcl_commands
• http://docs.oracle.com/cd/E11882_01/server.112/e41085/sqlqr01001.htm#SQLQR110
• http://www.techonthenet.com/oracle/index.php

more…

Hilite.me – decorador de código fuente para blogs y otras publicaciones

Página web que permite transformar secciones de código fuente en HTML para incrustarlo de forma legible y atractiva en publicaciones en Internet.

more…

Consultas SQL sobre las vistas del diccionario de Oracle

Se añaden consultas para recuperar información sobre el diccionario de Oracle. La mayoría han funcionado correctamente para la versión 10.1.0.2.0 de Oracle Database 10g release 1. Su documentación se puede encontrar en este enlace.

Consulta Oracle SQL sobre la vista que muestra el estado de la base de datos

SELECT * FROM v$instance;

Consulta Oracle SQL que muestra si la base de datos está abierta

SELECT status FROM v$instance;

Consulta Oracle SQL sobre la vista que muestra los parámetros generales de Oracle

SELECT * FROM v$system_parameter;

Consulta Oracle SQL para conocer la Versión de Oracle

SELECT value FROM v$system_parameter where name = ‘compatible’;

Consulta Oracle SQL para conocer la Ubicación y nombre del fichero spfile

SELECT value FROM v$system_parameter where name = ‘spfile’

Consulta Oracle SQL para conocer la Ubicación y número de ficheros de control

SELECT value FROM v$system_parameter where name = ‘control_files’;

Consulta Oracle SQL para conocer el Nombre de la base de datos

SELECT value FROM v$system_parameter where name = ‘db_name’;

Consulta Oracle SQL sobre la vista que muestra las conexiones actuales a Oracle. Para visualizarla es necesario entrar con privilegios de administrador

SELECT osuser, username, machine, program
FROM v$session
ORDER BY osuser;

Consulta Oracle SQL para matar una sesión Oracle

SELECT sid, serial# FROM v$session where username='<usuario>’;
ALTER SYSTEM kill session ‘<sid, serial>’;

Consulta Oracle SQL que muestra el número de conexiones actuales a Oracle agrupado por aplicación que realiza la conexión

SELECT program Aplicacion, count(program) Numero_Sesiones
FROM v$session
GROUP BY program
ORDER BY Numero_Sesiones desc;

Consulta Oracle SQL que muestra los usuarios de Oracle conectados y el número de sesiones por usuario

SELECT username Usuario_Oracle, count(username) Numero_Sesiones
FROM v$session
GROUP BY username
ORDER BY Numero_Sesiones desc;

Consulta Oracle SQL que muestra propietarios de objetos y número de objetos por propietario

SELECT owner, count(owner) Numero
FROM dba_objects
GROUP BY owner;

Consulta Oracle SQL sobre el Diccionario de datos (incluye todas las vistas y tablas de la Base de Datos)

SELECT * FROM dictionary;

Consulta Oracle SQL que muestra los datos de una tabla especificada

SELECT * FROM ALL_ALL_TABLES where upper(table_name) like ‘%<cadena_texto>%’;

Consulta Oracle SQL que muestra las descripciones de los campos de una tabla especificada

SELECT * FROM ALL_COL_COMMENTS where upper(table_name) like ‘%<cadena_texto>%’;

Consulta Oracle SQL para conocer las tablas propiedad del usuario actual

SELECT * FROM user_tables;

Consulta Oracle SQL para conocer todos los objetos propiedad del usuario conectado a Oracle

SELECT * FROM user_catalog;

Consulta Oracle SQL para el DBA de Oracle que muestra los tablespaces, el espacio utilizado, el espacio libre y los ficheros de datos de los mismos

SELECT t.tablespace_name «Tablespace», t.status «Estado»,
ROUND(MAX(d.bytes)/1024/1024,2) «MB Tamaño»,
ROUND((MAX(d.bytes)/1024/1024) –
(SUM(decode(f.bytes, NULL,0, f.bytes))/1024/1024),2) «MB Usados»,
ROUND(SUM(decode(f.bytes, NULL,0, f.bytes))/1024/1024,2) «MB Libres»,
t.pct_increase «% incremento»,
SUBSTR(d.file_name,1,80) «Fichero de datos»
FROM DBA_FREE_SPACE f, DBA_DATA_FILES d, DBA_TABLESPACES t
WHERE t.tablespace_name = d.tablespace_name AND
f.tablespace_name(+) = d.tablespace_name
AND f.file_id(+) = d.file_id GROUP BY t.tablespace_name,
d.file_name, t.pct_increase, t.status
ORDER BY 1,3 DESC;

Consulta Oracle SQL para conocer los productos Oracle instalados y la versión

SELECT * FROM product_component_version;

Consulta Oracle SQL para conocer los roles y privilegios por roles

SELECT * FROM role_sys_privs;

Consulta Oracle SQL para conocer las reglas de integridad y columna a la que afectan

SELECT constraint_name, column_name FROM sys.all_cons_columns;

Consulta Oracle SQL para conocer las tablas de las que es propietario un usuario

SELECT table_owner, table_name FROM sys.all_synonyms where table_owner like ‘<usuario>’;

Variante: Consulta Oracle SQL más efectiva

SELECT DISTINCT TABLE_NAME
FROM ALL_ALL_TABLES
WHERE OWNER LIKE ‘HR’;

Parámetros de Oracle, valor actual y su descripción

SELECT v.name, v.value value, decode(ISSYS_MODIFIABLE, ‘DEFERRED’,
‘TRUE’, ‘FALSE’) ISSYS_MODIFIABLE, decode(v.isDefault, ‘TRUE’, ‘YES’,
‘FALSE’, ‘NO’) «DEFAULT», DECODE(ISSES_MODIFIABLE, ‘IMMEDIATE’,
‘YES’,’FALSE’, ‘NO’, ‘DEFERRED’, ‘NO’, ‘YES’) SES_MODIFIABLE,
DECODE(ISSYS_MODIFIABLE, ‘IMMEDIATE’, ‘YES’, ‘FALSE’, ‘NO’,
‘DEFERRED’, ‘YES’,’YES’) SYS_MODIFIABLE , v.description
FROM V$PARAMETER v
WHERE name not like ‘nls%’ 
ORDER BY 1;

Consulta Oracle SQL que muestra los usuarios de Oracle y datos suyos (fecha de creación, estado, id, nombre, tablespace temporal,…)

SELECT * FROM dba_users;

Consulta Oracle SQL para conocer tablespaces y propietarios de los mismos

SELECT owner, decode(partition_name, null, segment_name,
segment_name || ‘:’ || partition_name) name,
segment_type, tablespace_name,bytes,initial_extent,
next_extent, PCT_INCREASE, extents, max_extents
FROM dba_segments
Where 1=1 AND extents > 1 
ORDER BY 9 desc, 3;

Últimas consultas SQL ejecutadas en Oracle y usuario que las ejecutó

SELECT distinct 
vs.sql_text, vs.sharable_mem,
vs.persistent_mem, vs.runtime_mem, vs.sorts,
vs.executions, vs.parse_calls, vs.module,
vs.buffer_gets, vs.disk_reads, vs.version_count,
vs.users_opening, vs.loads,
to_char(to_date(
   vs.first_load_time, ‘YYYY-MM-DD/HH24:MI:SS’),’MM/DD HH24:MI:SS’) first_load_time,
rawtohex(vs.address) address, vs.hash_value hash_value ,
rows_processed , vs.command_type, vs.parsing_user_id ,
OPTIMIZER_MODE , au.USERNAME parseuser
FROM v$sqlarea vs , all_users au
where (parsing_user_id != 0) AND
(au.user_id(+)=vs.parsing_user_id)
AND (executions >= 1) ORDER BY buffer_gets/executions desc;

Consulta Oracle SQL para conocer todos los tablespaces

SELECT * FROM V$TABLESPACE;

Consulta Oracle SQL para conocer la memoria Share_Pool libre y usada

SELECT name, to_number(value) bytes
FROM v$parameter where name =’shared_pool_size’
union all
SELECT name,bytes
FROM v$sgastat where pool = ‘shared pool’ AND name = ‘free memory’;

Cursores abiertos por usuario

SELECT b.sid, a.username, b.value Cursores_Abiertos
FROM v$session a,
v$sesstat b,
v$statname c
where c.name in (‘opened cursors current’)
AND b.statistic# = c.statistic#
AND a.sid = b.sid
AND a.username is not null
AND b.value >0
ORDER BY 3;

Consulta Oracle SQL para conocer los aciertos de la caché (no debería superar el 1 por ciento)

SELECT sum(pins) Ejecuciones, sum(reloads) Fallos_cache,
trunc(sum(reloads)/sum(pins)*100,2) Porcentaje_aciertos
FROM v$librarycache
where namespace in (‘TABLE/PROCEDURE’, ‘SQL AREA’, ‘BODY’, ‘TRIGGER’);

Sentencias SQL completas ejecutadas con un texto determinado en el SQL

SELECT c.sid, d.piece, c.serial#, c.username, d.sql_text
FROM v$session c, v$sqltext d
WHERE c.sql_hash_value = d.hash_value
AND upper(d.sql_text) like ‘%WHERE <nombre_campo> LIKE%’
ORDER BY c.sid, d.piece;

Una sentencia SQL concreta (filtrado por sid)

SELECT c.sid, d.piece, c.serial#, c.username, d.sql_text
FROM v$session c, v$sqltext d
WHERE c.sql_hash_value = d.hash_value
AND sid = 105
ORDER BY c.sid, d.piece;

Consulta Oracle SQL para conocer el tamaño ocupado por la base de datos

SELECT sum(BYTES)/1024/1024 MB FROM DBA_EXTENTS;

Consulta Oracle SQL para conocer el tamaño de los ficheros de datos de la base de datos

SELECT sum(bytes)/1024/1024 MB FROM dba_data_files;

Consulta Oracle SQL para conocer el tamaño ocupado por una tabla concreta sin incluir los índices de la misma

SELECT sum(bytes)/1024/1024 MB FROM user_segments
where segment_type=’TABLE’ AND segment_name='<nombre_tabla>’;

Consulta Oracle SQL para conocer el tamaño ocupado por una tabla concreta incluyendo los índices de la misma

SELECT sum(bytes)/1024/1024 Table_Allocation_MB FROM user_segments
where segment_type in (‘TABLE’,’INDEX’) AND
(segment_name='<nombre_tabla>’ OR segment_name in
(SELECT index_name FROM user_indexes where table_name='<nombre_tabla>’));

Consulta Oracle SQL para conocer el tamaño ocupado por una columna de una tabla

SELECT sum(vsize(‘<nombre_columna’))/1024/1024 MB 
FROM <nombre_tabla>;

Consulta Oracle SQL para conocer el espacio ocupado por usuario

SELECT owner, SUM(BYTES)/1024/1024 MB FROM DBA_EXTENTS
GROUP BY owner;

Consulta Oracle SQL para conocer el espacio ocupado por los diferentes segmentos (tablas, índices, undo, rollback, cluster, …)

SELECT SEGMENT_TYPE, SUM(BYTES)/1024/1024 MB FROM DBA_EXTENTS
GROUP BY SEGMENT_TYPE;

Consulta Oracle SQL para obtener todas las funciones de Oracle: NVL, ABS, LTRIM, …

SELECT distinct object_name
FROM all_arguments
WHERE package_name = ‘STANDARD’
ORDER BY object_name;

Consulta Oracle SQL para conocer el espacio ocupado por todos los objetos de la base de datos, muestra los objetos que más ocupan primero

SELECT SEGMENT_NAME, SUM(BYTES)/1024/1024 MB FROM DBA_EXTENTS
GROUP BY SEGMENT_NAME
ORDER BY 2 desc;

Consulta Oracle SQL para recuperar los indices de una tabla específica

SELECT  index_name, index_type, table_owner, table_name, table_type
FROM user_indexes
WHERE table_name = ‘<nom_taula>’;

Consulta Oracle SQL para obtener todas las tablas que utilizan un campo concreto

SELECT  table_name
FROM all_tab_columns
WHERE column_name = ‘<nom_columna>’;

Variante sobre la consulta incluyendo el propietario y un tipo de dato específico:

SELECT  table_name
FROM all_tab_columns
WHERE column_name = ‘<nom_columna>’ and
data_type = ‘NVARCHAR2’    and
owner = «<schema_owner>
ORDER BY table_name;

more…

Creación de un Fat Jar con Apache Ant

Normalmente para construir el distribuible de una aplicación Java se empaqueta el código principal de esta dentro de un fichero jar ejecutable, esto es, que contiene dentro de su fichero de definición MANIFEST.MF una entrada que especifica qué clase contiene el metodo main() y junto a este se crea una carpeta que contenga todas las dependéncias que este (habitualmente se llama a esta carpeta lib).

Esto hace que para especificar el classpath de la aplicación sea necesario:

Especificar directamente en el archivo MANIFEST.MF de forma individual todos las dependéncias que forman el classpath mediante la propiedad Class-Path de la siguiente manera Class-Path: lib/jar1.jar lib/jar2.jar lib/jar3.jar

Especificar en la orden de ejecución Java las dependéncias a través del parámetro cp

En Windows: java -cp "lib/jar1.jar;lib/jar2.jar;lib/jar3.jar" -jar jar_principal

En Unix: java -cp "lib/jar1.jar:lib/jar2.jar:lib/jar3.jar" -jar jar_principal

En Java 6 también es posible utilizar wildcards: java -cp "lib/*" -jar jar_principal

Este método hace tediosa la llamada a la máquina vitual y normalmente se tiende a crear un shell-script o cmd que haga la llamada por nosotros, con lo que se añade un fichero más al distribuible

En ciertas circumstancias muchas veces es preferible distribuir nuestra aplicación en un jar simple que facilite su distribución y ejecución, pero hay que incluir las dependencias de alguna manera. Aquí es donde entra la técnica de generar un fat jar, o dicho de otra manera, empaquetar toda la aplicación, dependéncias incluidas dentro de un mismo fichero jar. Para ello se suelen extraer los ficheros .class compilados que se encuentran dentro de los jars de las dependéncias y se incluyen dentro del jar principal de la aplicación. Cómo el package de las clases és único no se producen conflictos al incluirlos dentro de este. Un mecanismo sencillo de realizar esta tarea mediante un script de Apache Ant es la siguiente:

Incluir todas las clases de las dependencias en un mismo jar temporal que servirá como fuente en la creación del jar definitivo

<target name="main.dependencies.jar">       
    <jar jarfile="${dist.dir}/dependencies-all.jar">
        <zipgroupfileset dir="lib">
            <include name="**/*.jar" />
        </zipgroupfileset>
    </jar>        
</target>

Mediante el tag zipgroupfileset se incluyen en el jar de dependéncias todos los ficheros contenidos dentro de los jars de la carpeta lib.

Construir el jar principal, para ello se lanzan previamente las tareas de limpieza, compilado y generación del jar de dependencias. No se encuentran definidas en el ejemplo las 2 primeras tareas porque es bastante obvia su función. El siguiente código corresponde a la tarea de generación del jar principal

<target name="main.jar" depends="clean, main.compile, main.dependencies.jar">
        <mkdir dir="${dist.dir}"/>
        <jar destfile="${dist.dir}/${jar.name}.jar"
                basedir="${main.build.dir}"
                manifest="${main.resources.dir}/META-INF/MANIFEST.MF">
             
            <zipfileset src="${dist.dir}/dependencies-all.jar" 
                    excludes="META-INF/*.SF" />
        </jar>
</target>

Mediante el tag zipfileset se incluyen en el jar todos los ficheros contenidos en el jar de dependencias exceptuando el contenido del directorio META-INF que pueda sobreescribir el MANIFEST.MF de la aplicación principal

more…

Obtener la conexión a base de datos a través de Hibernate 4

Si estáis trabajando en una aplicación en la que la persistencia se hace a través de Hibernate 4, os habréis dado cuenta que ha desaparecido la posibilidad de obtener el objecto Connection a través de la Session de Hibernate. Esto sucede porque en el paso de Hibernate 3 a Hibernate 4 ha desaparecido el método connection() a través del que se podía obtener.

El problema viene en el momento en que se necesita acceder directamente a la conexión para, por ejemplo, utilizar librerías como Jasperreports que necesitan de ella para rellenar los datos del reporte cuando la fuente es la base de datos directamente. Con Hibernate 3 se hubiera podido acceder a ella directamente desde la Session, aunque en la versión 3.5 esta forma de obtenerla ya se encontraba deprecada, pero en Hibernate 4 es necesario utilizar la nueva API Work de la siguiente manera:

more…

Ejecución de Maven des de consola de comandos MS-DOS

echo =================================================
echo TODOS LOS MODULOS HA SIDO DESPLEGADOS CON EXITO
echo =================================================

ECHO __________>>resultado.txt.
echo Modulo ST >>resultado.txt.  (1)
time /t>>resultado.txt. (2)
ECHO __________>>resultado.txt.
call mvn package war:exploded -f<Ruta_ubicación_fichero_pom>pomITT.xml>>resultado.txt. (3)
if not %ERRORLEVEL% == 0 exit /b. (4)
time /t>>resultado.txt (5)

call mvn package war:exploded -f<Ruta_ubicación_fichero_pom>pomITT.xml>>resultado.txt

call mvn install -f%1<nombre_del proyecto>pom.xml>>resultado.txt

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-war-plugin</artifactId>
	<configuration>
		<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
		<attachClasses>true</attachClasses>
		<classesClassifier>classes</classesClassifier>
		<encoding>ISO-8859-1</encoding>
		<webappDirectory>C:/Weblogic_Despliegues/${project.artifactId}</webappDirectory>
	</configuration>
</plugin>

more…

OCP7 04 – Diseño avanzado de una clase Java

Classes

Las clases abstractas sirven para indicar el comportamiento general que deben tener sus subclases sin implementar algunos métodos. Dichas subclases son las que se encargan de implementar estos métodos.

abstract class FiguraGeometrica {
     abstract void dibujar();
}
 
class Circulo extends FiguraGeometrica {
    void dibujar() {
     // codigo para dibujar Circulo
   }
}

Una clase que tenga uno o más métodos abstractos se llama clase abstracta. Debe contener en su declaración el termino abstract. A su vez, esta clase puede también contener métodos que no sean abstractos. Un método abstracto contiene el termino abstract en su declaración y no dispone de ninguna implementación: abstract type nom_metodo(); Es obligatorio que todas las subclases que heredan de la clase abstracta realicen la implementación de todos los métodos abstractos de la superclase dentro de su especificidad.

Aunque una clase abstracta puede ser utilizada como tipo de referencia, ésta no puede ser instanciada ya que su implementación está completa y si se intenta se producirá un error de compilación.

Palabras Reservadas

Static

Es útil disponer de una variable compartida por todas las instancias de una clase mediante el modificador static. Los campos que tienen static en su declaración se llaman campos estáticos o variables de clase.

Si existen por ejemplo tres objetos definidos que tienen el campo definido como estático, todas sus instancias pueden modificar el valor de dicho campo dado que está compartido por todos los objetos de la misma clase.

Para referenciar el campo estático es suficiente utilizar el nombre de la clase para acceder al campo.

Un método estático también tiene el modificador static en su declaración. También puede ser invocado sólo con el nombre de clase sin necesidad de instanciar el tipo. Cualquier de acceso a campos o métodos no estáticos provocará un error de compilación. Una clase también puede contener bloques de código estáticos que no forman parte de los métodos normales. Estos bloques estáticos se encuentran encerrados entre llaves. El código dentro de los bloques estáticos sólo se ejecuta una única vez, cuándo la clase se carga por primera vez. Si aparecen varios bloques dentro de la clase, éstos se ejecutan por orden de aparición en la clase. Importaciones static: Pueden utilizarse cuándo queramos importar campos o métodos estáticos de una clase sin anteponer el nombre de la misma:

import static java.lang.Math.random

y al no ser necesario anteponer el nombre de la clase al utilizar la importación estática su implementación queda de la siguiente manera:

double d = random();
System.out.println(d);

Final

Las clases, los métodos y las variables pueden ser finales.

• En las clases. No se pueden generar subclases a partir de esta clase.
• En los métodos. No pueden ser sobrescritos.
• En las variables: campos, parámetros o variables locales.

Una variable de referencia como final no puede hacer referencia a otro objeto (aunque puede modificarse el estado del mismo) Un campo puede posponer su inicialización (inicializarse mediante un constructor de la clase) o inicializarse en su declaración. Una vez está inicializado no es posible modificar su valor. El intento de modificarlo provoca un error de compilación.

Si se marca una variable como local se le podrá asignar el valor en cualquier momento dentro del cuerpo del método pero sólo una vez.

Dentro de los parámetros formales de un método si marcamos uno de los parámetros como final, el valor recibido en el método no podrá ser modificado dentro del cuerpo del método dando un error de compilación si se intenta. Si se utilizan static y final conjuntamente como en el caso de ejemplo:

private static final int field;   

se puede considerar el campo como una constante. Las constantes no se pueden reasignar y se producirá un error de compilación si se intenta.

Enumeraciones

public enum Day {
	 SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
	 SATURDAY;
}

Un tipo enumerado es un tipo cuyos campos son un conjunto de constantes. Proporciona una comprobación de rango en tiempo de compilación. El compilador interpreta la Enum como una clase Java por lo que es posible declararla fuera de una clase o dentro de ella como una clase interna. Todas las enumeraciones extienden implícitamente de la clase Enum. Las enumeraciones pueden ser importadas estáticamente:

import static package.Day.*;

Esto permite no ser necesario que el nombre de la enumeración preceda la constante.

Una enumeración proporciona una comprobación de rango en tiempo de compilación. Si se intenta asignar un valor que no se encuentra en la enumeración se produce un error de compilación. Debido a que los tipos enumerados son como una clase Java además de declarar constantes, un tipo enumerado puede contener:

• campos
• métodos
• constructores privados. El constructor de una enumeración es privado por lo que no es posible crear instancias de una enumeración. Los argumentos del constructor se suministran después de cada valor declarado:

public enum Day {
 
    SUNDAY("Sunday"),
    MONDAY("Monday"),
    TUESDAY("Tuesday"),
    WEDNESDAY("Wednesday"),
    THURSDAY("Thursday"),
    FRIDAY("Friday"),
    SATURDAY("Saturday");
 
    private final String name;
 
    private Day(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }   
}

Cuándo hay campos, métodos o constructores, la lista de constantes de la enumeración debe terminar con un punto y coma.

Las enumeraciones pueden implementar interfaces pero no pueden extender otras enumeraciones. Una posible utilidad de esto es «esconder» la enumeración referenciando a la interfaz:

public enum Day implements IDayOfWeek
{
             SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
             SATURDAY;
}
 
...
 
IDayOfWeek dow = Day.SUNDAY;

Clases Anidadas

Es una clase declarada en el cuerpo de otra clase.

import java.util.ArrayList;
 
public class Coordenadas {
 
    private class Punto {
        private int x, y;
 
        public Punto(int x, int y) {
            fijarX(x);
            fijarY(y);
        }
 
        public void fijarX(int x) {
            this.x = x;
        }
 
        public void fijarY(int y) {
            this.y = y;
        }
 
        public int retornarCuadrante() {
            if (x > 0 && y > 0)
                return 1;
            else if (x < 0 && y > 0)
                return 2;
            else if (x < 0 && y < 0)
                return 3;
            else if (x > 0 && y < 0)
                return 4;
            else
                return -1;
        }
    }
 
    private ArrayList<Punto> puntos;
 
    public Coordenadas() {
        puntos = new ArrayList<Punto>();
    }
 
    public void agregarPunto(int x, int y) {
        puntos.add(new Punto(x, y));
    }
 
    public int cantidadPuntosCuadrante(int cuadrante) {
        int cant = 0;
        for (Punto pun : puntos)
            if (pun.retornarCuadrante() == cuadrante)
                cant++;
        return cant;
    }
 
}

Pueden dividirse en dos categorías:

Clases Internas.

• Clases miembro: Están declaradas dentro de una clase y fuera de cualquier método. Esta clase tiene acceso a los campos y a los métodos de la clase anterior, así como de los campos y los métodos de la superclase de la que herede.
  No es posible declarar ninguna clase miembro estático debido a que una clase miembro es cargada sólo dentro del contexto de una instancia de su clase exterior.

public class DataStructure {
     
    // Create an array
    private final static int SIZE = 15;
    private int[] arrayOfInts = new int[SIZE];
     
    public DataStructure() {
        // fill the array with ascending integer values
        for (int i = 0; i < SIZE; i++) {
            arrayOfInts[i] = i;
        }
    }
     
    public void printEven() {
         
        // Print out values of even indices of the array
        DataStructureIterator iterator = this.new EvenIterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
    }
     
    interface DataStructureIterator extends java.util.Iterator<Integer> { } 
 
    // Inner class implements the DataStructureIterator interface,
    // which extends the Iterator<Integer> interface
     
    private class EvenIterator implements DataStructureIterator {
         
        // Start stepping through the array from the beginning
        private int nextIndex = 0;
         
        public boolean hasNext() {
             
            // Check if the current element is the last in the array
            return (nextIndex <= SIZE - 1);
        }        
         
        public Integer next() {
             
            // Record a value of an even index of the array
            Integer retValue = Integer.valueOf(arrayOfInts[nextIndex]);
             
            // Get the next even element
            nextIndex += 2;
            return retValue;
        }
    }
     
    public static void main(String s[]) {
         
        // Fill the array with integer values and print out only
        // values of even indices
        DataStructure ds = new DataStructure();
        ds.printEven();
    }
}

• Clases locales: Declarada dentro de un bloque de código en el cuerpo de un método y sólo es visible dentro del bloque de código en el que se ha definido. En las clases internas locales primero se define la clase y luego se crean uno o más objetos según la necesidad.

public class LocalClassExample {
   
    static String regularExpression = "[^0-9]";
   
    public static void validatePhoneNumber(
        String phoneNumber1, String phoneNumber2) {
       
        final int numberLength = 10;
         
        // Valid in JDK 8 and later:
        
        // int numberLength = 10;
        
        class PhoneNumber {
             
            String formattedPhoneNumber = null;
 
            PhoneNumber(String phoneNumber){
                // numberLength = 7;
                String currentNumber = phoneNumber.replaceAll(
                  regularExpression, "");
                if (currentNumber.length() == numberLength)
                    formattedPhoneNumber = currentNumber;
                else
                    formattedPhoneNumber = null;
            }
 
            public String getNumber() {
                return formattedPhoneNumber;
            }
             
            // Valid in JDK 8 and later:
 
//            public void printOriginalNumbers() {
//                System.out.println("Original numbers are " + phoneNumber1 +
//                    " and " + phoneNumber2);
//            }
        }
 
        PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
        PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);
         
        // Valid in JDK 8 and later:
 
//        myNumber1.printOriginalNumbers();
 
        if (myNumber1.getNumber() == null) 
            System.out.println("First number is invalid");
        else
            System.out.println("First number is " + myNumber1.getNumber());
        if (myNumber2.getNumber() == null)
            System.out.println("Second number is invalid");
        else
            System.out.println("Second number is " + myNumber2.getNumber());
 
    }
 
    public static void main(String... args) {
        validatePhoneNumber("123-456-7890", "456-7890");
    }
}

• Clases anónimas: Se usan para definir clases sin nombre. Cómo la clase anónima no tiene nombre sólo se puede crear un único objeto ya que las clases anónimas no pueden definir constructores.

public class HelloWorldAnonymousClasses {
   
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }
   
    public void sayHello() {
         
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }
       
        HelloWorld englishGreeting = new EnglishGreeting();
         
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };
         
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };
        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }
 
    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp =
            new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }            
}

Clases anidadas estáticas.

Se definen mediante el modificador static y sólo pueden ser creadas dentro de otra clase al máximo nivel, es decir, directamente en el bloque de definición de la clase contenedora y no en un bloque más interno.

clase ClaseExterior
{ 
... 
    clase ClaseAnidada
    { 
        ... 
    } 
}

more…