package net.josemanuel.prietopalacios.antipatrones

public class Calculadora {

	double operador1;
	double operador2;

	public Calculadora() {

	}

	public Calculadora operador1(double ope1) {
		this.operador1 = ope1;
		return this;
	}

	public Calculadora operador2(double ope2) {
		this.operador2 = ope2;
		return this;
	}

	public double operacion(String operacion) {
		if ("+".equals(operacion)) {
			return operador1 + operador2;
		} else if ("-".equals(operacion)) {
			return operador1 - operador2;
		} else if ("*".equals(operacion)) {
			return operador1 * operador2;
		} else if ("/".equals(operacion)) {
			return operador1 / operador2;
		}
		return 0;
	}

	public static void main(String[] args) {
		double d = new Calculadora()
					.operador1(1)
					.operador2(1)
					.operacion("+");
		System.out.println(d);
	}

}

Disponemos de dos módulos realizados con maven: modulo_mail y modulo_socket. Estos módulos tienen su interfaz, su código ya implementado, sus test unitarios y su pom (gestiona las dependencias, compila, genera las fuentes, el javadoc y ejecuta los test).

Ahora nos han indicado que tenemos que realizar un nuevo proyecto: tenemos que hacer un socket que escuche en un puerto, en el que lo que se le mande, lo envía por correo.

De acuerdo, manos a la obra. Tenemos prácticamente todo hecho. Tenemos quien nos construya el socket, y quien nos envie los emails, solo necesitamos algo que lo integre todo y realice la funcionalidad que nos han indicado.

Tenemos dos maneras de actuar:
a) tratando estos módulos como independientes. Es decir, añadirlos como una dependencia en el pom.
b) tratando los módulos como algo vivo de lo que queremos hacer. Es decir, queremos añadir una nueva funcionalidad al modulo_mail: envio de adjuntos, y otra al modulo_socket: conexión SSL.

Tenemos que tener en cuenta que si estos módulos son utilizados por otros proyectos, cualquier cambio que hagamos en ellos puede alterar estos otros proyectos. Aunque bueno, para eso están las versiones. Pero para ello habría que tener un buen control de qué contiene cada versión.

Pero bueno, supongamos que queremos la opción b), para hacer un desarrollo conjunto. Bueno, para que no se nos vaya de las manos, necesitamos la Integracion Continua. Necesitamos que algo vaya a nuestros repositorio de código y cada vez que subimos algo, lo compile, realice los test y lo integre con todos los demás proyectos. De esta manera ese algo nos facilita bastante el saber si cualquier cambio que realicemos afecta a otros proyectos o no.

No voy a explicar como hacer funcionar un servidor de integración continua. Pero si como vamos a hacer este nuevo proyecto. Sigamos integrando las partes.

Repasemos, tenemos dos módulos, con sus pom, sus test y su código. Necesitamos integrarlos, haciendo un nuevo modulo.

(Continuara… pendiente de revision, publicar imagenes y de que pongas algun comentario)

Si el log de una aplicación está desactivado por completo o solo para unos niveles (error, warn…), el coste de una solicitud de log consiste en: llamada (invocación) al método + una comparación de enteros. Supone un coste en nanosegundos, pequeño, pero si tenemos la aplicación llena de líneas de log que no llaman a info… granito a granito creamos una montaña.

Si se pone log.isDebugEnabled() en el peor de los casos se pierde tiempo en evaluar la condición, pero hablamos de un tiempo inapreciable, mucho menor que en el caso anterior.

Por eso siempre que no vayamos a poner el nivel info es mejor preguntar, si estamos en ese nivel.

if(logger.isDebugEnabled() {
logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));
}

Sacado del manual de log4j.

INCONVENIENTES:

1. - (otros lo consideran una ventaja) para ejecutar las afirmaciones, hay que poner -ea (enable assert) a la hora de ejecutar.
2. - La excepción que lanza es: AssertionError, que hereda de Error. Error es una excepción que esta al mismo nivel que la clase Exception, pero a diferencia de esta, suele indicar problemas muy graves, que no suelen ser recuperables y no deben ser capturados.

CONCLUSION:
Solo para entornos de desarrollo, no lo usaría en producción porque no se deben capturar las Excepciones que son de tipo Error. Y porque hay que saber que hay que poner -ea para que la VM no las ignore. Si bien es cierto que hay maneras de avisar de que es necesario activar las afirmaciones, pero es una cosa mas.
Si necesitas validar unos parámetros, harás un if o crearás una arquitectura que te lo permita, para que el sistema no se pare. Por que con los assert, el sistema se para.
Esta puede ser una de las razones por la cual no había oído antes nada sobre Assert en Java.

¿Necesitais unas capturas de pantalla?

public static final String VAR =  "var";

• Public, para que se pueda acceder desde cualquier clase, sin tener que instanciar dicha clase.
• Static para que sea común a todas las clases que hereden de esta clase.
• Final para expecificar que una vez que sea instanciada no puede modificarse.
• El tipo de dato que va a representar.
• La inicialización de la constante.

FINAL

private final String var;

INMUTABLE

Inmutable significa que el valor no cambia.

private String var = "perro";
private String var = "gato";

• final: decalaración de una constante.
• El método finalize(): Algunos lenguajes de programación orientados a objetos requieren que el programador destruya explícitamente los objetos cuando dejan de utilizarse. Sin embargo en java, la JVM se responsabiliza de reclamar la memoria reservada por los diferentes objetos estos quedan fuera de alcance (proceso denominado “garbage collection“, o de limpieza), por lo que se libera al programador de esta tarea. Hay dos importantes características del proceso de limpieza: 1) cuando un object sale de alcance, inmediatamente se le considero que pertenece a la “colección basura”. Pero no es del todo preciso. Al salir de alcance, lo que ocurre es que se le marca como candidato para la “colección basura”, y el proceso limpieza (que gestiona la colección) periódicamente va reclamando estos objetos en memoria fuera de alcance sin referenciar, de modo recursivo. Lo malo es que esto no ocurre en momentos predeterminados, pues no existe una especificación exacta en la JVM de cuando se ejecutará el proceso de limpieza.
  Si el proceso se ejecuta antes de que un objeto haya pasado a la colección-de-basura, el runtime de java invoca al método finalize() del objeto, permitiendo que este pueda realizar cualquiera las operaciones que liberen los recursos demandados al sistema tales como ficheros o sockets abiertos. Este método finalize() se declara como: protected void finalize() throws Throwable. El proceso de limpieza se ejecuta como un hilo demonio de bajo-nivel y, en general, para este tipo de hilos, no es esencial que el hilo se complete antes de que la aplicación termine.
  He aquí el problema, pues aunque pueda utilizarse el método finalize para realizar las operaciones de limpieza, el hilo recolector encargado de llamar al método finalize() de los objetos podría ejecutarse de un modo impredecible.

public class UseTwo<T, X> {
	T one;
	X two;

	UseTwo(T one, X two) {
		this.one = one;
		this.two = two;
	}

	T getT() {
		return one;
	}

	X getX() {
		return two;
	}

	// test it by creating it with <String, Integer>
	public static void main(String[] args) {
		UseTwo<String, Integer> twos = new UseTwo<String, Integer>("foo", 42);
		String theT = twos.getT(); // returns a String
		int theX = twos.getX(); // returns Integer, unboxes to int
	}
}

Métodos genéricos:

public class CreateAnArrayList {
	public <T> void makeArrayList(T t) { // take an object of an unknown type and use a
	                                     // "T" to represent the type
		List<T> list = new ArrayList<T>(); // now we can create the
		// list using "T"
		list.add(t);

		System.out.println(list.get(0).toString());
	}

	public static void main(String[] args) {
		CreateAnArrayList arr = new CreateAnArrayList();
		Horse h = new Horse(4, "eno");
		arr.makeArrayList(h);
	}
}

Ordenado (Ordered): Significa que la colección se puede iterar en un orden específico no aleatorio.

Clasificado (Sorted): el orden de la colección es determinado acorde a unas reglas, basadas en las propiedades de los objetos que la componen. La ordenación natural: alfabética o numérica.

Comparable vs Comparator (artículo)

A través de la Interfaz ‘Comparable’ que define como la instancia de una clase puede ser comparada con otra (la clase persona se ordena por el nombre).

java.util.Comparator

int objOne.compareTo(objTwo)

int compare(objOne, objTwo)

Same as Comparable

Only one sort sequence can be created

Many sort sequences can be created

String, Wrapper classes, Date, Calendar...

public class Employee implements Comparable<Employee>
{
private String name;
private int age;

public Employee(String name, int age)
{
this.name = name;
this.age = age;
}

public int compareTo(Employee e)
{
//comparison strategy
}

public static void main(String[] args)
{
List<Employee> employeeList = new ArrayList<Employee>();
employeeList.add( new Employee("Tim", 10) );
employeeList.add( new Employee("Rolvin", 11) );
employeeList.add( new Employee("Gerald", 12) );

Collections.sort(employeeList);
}
}

A través de la interfaz ‘Comparator’: se pueden implementar otras clases que implementan otros tipos de ordenación (la clase persona se ordena por nombre, o por apellido o por edad).

public class SortByName implements Comparator<Employee>
{
public int compare(Employee e1, Employee e2)
{
//comparison strategy here
}
}

public class SortByAge implements Comparator<Employee>
{
public int compare(Employee e1, Employee e2)
{
//comparison strategy here
}
}

public static void main(String[] args)
{
List<Employee> employeeList = new ArrayList<Employee>();
employeeList.add( new Employee("Tim", 10) );
employeeList.add( new Employee("Rolvin", 11) );
employeeList.add( new Employee("Gerald", 12) );

Collections.sort(employeeList, new SortByName() );//sort by name;
Collections.sort(employeeList, new SortByAge() );//sort by age;

}

La interfaz List

Sus implementaciones son ordenadas por el index.

get(int index), indexOf(Object o), add(int index, Object obj)

ArrayList: es un array con la capacidad de crecer. Ofrece una rápida iteración y acceso. Ordered pero no Sorted.
Vector: lo mismo que ArrayList pero es Synchronized.
LinkedList: mantiene el orden de los objetos según su inserción. Más lento en la iteración que el ArrayList pero más rápido en la inserción y eliminación. Implementa la interfaz java.util.Queue, que proporciona los métodos:

java.util.Queue
peek(), poll(), and offer().

El método peek devuelve, pero no borra, la cabecera de la cola.
El método poll devuelve y borra la cabecera de la cola
El método add inserta un elemento a no ser que se supere la capacidad de la cola, en este caso se lanza una IllegalStateException.
El método offer es igual que add pero devuelve false si existe algun error en la insercción.

La interfaz Set

No permite duplicados.
HashSet: es ‘unsorted and unordered’ no se puede ni ordenar ni clasificar. Usa el hasCode() de los objetos para insertarlos. Para colecciones sin duplicados pero no importa el orden en que se recorran
LinkedHashSet: es una versión ordenada de HashSet. Ordena los elementos en función del orden de inserción.
TreeSet: usa la estructura de árbol Red-Black. Ordena los elementos según se insertan en orden ascendente. Implementa ‘NavigableSet’. Puedes personalizar la clasificación.

La interfaz Map

Tiene un único identificador para un valor. (key /value)
HashMap: es ‘unsorted and unordered’ no se puede ni ordenar ni clasificar. Permite la llave nula y múltiples valores nulos.
HashTable: similar a HashMap pero es Synchronized. Ningún elemento debe ser nulo. LinkedHashmap: mantiene el orden de inserción. TreeMap: Ordena los elementos según se insertan en orden ascendente. Implementa ‘NavigableSet’. Puedes personalizar la clasificación.

La interfaz Queue

Como una pila FIFO (First In – First Out).
PriorityQueue: es una lista de prioridades (Priority In – Priority Out). La prioridad viene determinada por la clasificación de los elementos.

CLASE

MAP

SET

LIST

ORDERED

SORTED

HashMap

X

NO

NO

HashTable

X

NO

NO

TreeMap

X

SORTED

LinkedHashMap

X

By insertion order or last access order

NO

HashSet

X

NO

NO

TreeSet

X

SORTED

custom comparison rules

LinkedHashSet

X

By insertion order

NO

ArrayList

X

BY INDEX

NO

Vecctor

X

BY INDEX

NO

LinkedList

X

BY INDEX

NO

PriorityQueue

SORTED

By TO-DO order

ArrayList

Ventaja sobre un array: a) crece dinámicamente, b)inserción y búsqueda mejoradas.
Cómo ordenar un ArrayList:

ArrayList<String> stuff = new ArrayList<String>();
stuff.add("Denver");
stuff.add("Boulder");
stuff.add("Vail");
stuff.add("Aspen");
stuff.add("Telluride");
System.out.println("unsorted " + stuff);
Collections.sort(stuff);
System.out.println("sorted " + stuff);

unsorted [Denver, Boulder, Vail, Aspen, Telluride]
sorted [Aspen, Boulder, Denver, Telluride, Vail]

Utilizando la ordenación de los arrays.

Arrays.sort(arrayToSort)

Búsqueda en Arrays y Collection:
-   Utilizan el método BinarySearch(): Arrays.binarySearch(arrayList,”one”)
-   Las búsquedas satisfactorias devuelven un ‘int’ que representa el índice del elemento.
-   Las búsquedas no satisfactorias devuelven in ‘int’ que representa el punto de insercción.

Convertir Arrays en Listas

String[] sa = {"one", "two", "three", "four"};
List sList = Arrays.asList(sa);

Backed Collections

TreeMap<String, String> map = new TreeMap<String, String>();
map.put("a", "ant"); map.put("d", "dog"); map.put("h", "horse");
SortedMap<String, String> submap;
submap = map.subMap("b", "g"); // #1 create a backed collection
System.out.println(map + " " + submap); // #2 show contents
map.put("b", "bat"); // #3 add to original
submap.put("f", "fish"); // #4 add to copy
map.put("r", "raccoon"); // #5 add to original - out of range
// submap.put("p", "pig"); // #6 add to copy - out of range
System.out.println(map + " " + submap); // #7 show final contents

{a=ant, d=dog, h=horse} {d=dog}
{a=ant, b=bat, d=dog, f=fish, h=horse, r=raccoon} {b=bat, d=dog, f=fish}

TreeMap.subMap(desde el valor inicial, hasta el valor final);
La subcoleción registra las modificaciones realizadas en la colección a la que pertenece.
El dato insertado en la subcoleción también se registra en la colección.

headSet: Empieza al principio y termina en el dato pasado como parámetro.
TreeSet.headSet();                        TreeMap.headSet();

subSet: Indica cuando empieza y acaba con los parámetros.
TreeSet.subSet();                           TreeMap.subSet();

TailSet: desde el parámetro pasado como argumento hasta el final.
TreeSet.tailSet();                            TreeMap.tailSet();

Bibliografia:
- http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html
- Libro:  SCJP Sun Certified Programmer for Java 6 Exam 310-065

Las 19 siguientes conversiones de tipos primitivos son llamados ‘widening primitive conversions’:

byte to short, int, long, float, or double
short to int, long, float, or double
char to int, long, float, or double
int to long, float, or double
long to float or double
float to double

No pierden información

class Test {
   public static void main(String[] args) {
      int big = 1234567890;
      float approx = big;
      System.out.println(big - (int)approx);
   }
}

Consola:

-46

Indica la información que se ha perdido durante la conversión de tipos, pero porque el tipo float no es preciso con 9 digitos.

Narrowing

Las 23 siguientes conversiones de tipos primitivos son llamados ‘narrowing primitive conversions’:

byte to char
short to byte or char
char to byte or short
int to byte, short, or char
long to byte, short, char, or int
float to byte, short, char, int, or long
double to byte, short, char, int, long, or float

Se pierde valor o precision.

Autoboxing

Para insertar un int en una colección, lo que se hace automaticamente es:

1.- BOX guardar la variable en una clase que la envuelva(wrapper), en este caso Integer.
2.- se guarda en la collection.
3.- cuando quieras recoger el dato se hace UNBOX del Integer usando intValue(), te devuelve en int.

Varargs

Hay veces que necesitas enviar a un metodo, muchas instancias de un mismo objeto. Pero en tiempo de compilacion no sabes cuantas. En vez de enviar un array o una collection, puedes usar: ‘variable arity parameters’ ó como se les conoce formalmente: ‘varargs‘.

class VarGreeter {
   public static void printGreeting(String... names) {
      for (String n : names) {
        System.out.println("Hello " + n + ". ");
      }
   }

   public static void main(String[] args) {
      printGreeting("Paul", "Sue");
   }
}

Sobrecargando Widening, Boxing, Varargs

W -> B -> V
(WB: NO)
(BW: SI)
(VW, VB: SI)

1. Widening wins over boxing and Varargs
2. Boxing wins over Varargs
3. Widening of reference variable depends on inheritance(so, Integer cannot be widened to Long. But, Integer widened to Number).
4. Widen and boxing is not possible
5. Boxing and widening is possible
6. Varargs can be combined with either boxing or widening