Angular - Ejecutar método cuando se pierde el foco de un componente

Fuente: http://stackoverflow.com/questions/19456397/angularjs-ngchange-trigger-onblur

<div ng-controller="MyCtrl">
    <input type='text' ng-blur='blurCount = blurCount + 1'/>

    <input type='text' ng-blur='blurCount = blurCount + 1' />

    blur count: {{blurCount}}
</div>

function MyCtrl($scope) {
    $scope.blurCount = 0;
    $scope.name = 'Superhero';
}

Java - Crear Singleton sin utilizar synchronized

Para poder realizar esto tenemos que definir el bean de esta manera:


public class SingletonSinSynchronized {

private SingletonSinSynchronized() {}

public static SingletonSinSynchronized getInstance() {
               return LazySingletonSinSynchronized.INSTANCE;
    }

    private static final class LazySingletonSinSynchronized {
        private static final SingletonSinSynchronized INSTANCE =  new SingletonSinSynchronized();
    }

}

De esta manera el primer objecto que llame al método getInstance va a inicializar previamente el atributo static de la clase interna LazySingletonSinSynchronized

Javascript - Herencia

Voy a mostrar una forma de crear objectos en Javascript y definir una herencia simple para poder heredar comportamiento en común entre distintos objectos. 

Supongamos que tenemos este objecto del cual necesitamos heredar: 

function AbstractObject(options) {
    //Declaramos un método publico.
    this.getUrl = function() {
        return options.url;
     };
} 

function MyObject() {
     //Se llama al constructor del padre.
     AbstractSearch.call(this, {
           url : "myImplementationUrl"
     };
}

Ahora definimos que nuestro MyObject sea del tipo AbstractObject

MyObject.prototype = Object.create(AbstractObject.prototype);

Luego ya podemos crear objectos MyObject y utilizar el método heredado. 

var myObject = new MyObject();
myObject.getUrl();

Y eso es todo!


 

Javascript - Métodos privados y publicos

En esta oportunidad voy a plantear un ejemplo de como crear un objecto en javascript y definir métodos privados y publicos.

El siguiente código muestra una clase persona con id, firsName y lastName:

function Person(options) {
    var id = options.id;
    var firstName = options.fistName;
    var lastName = options.lastName;
   
    //Private method
    var fullName = function () {
        return firstName + " " + lastName;
    }

    //Public method
    this.getId = function () {
        return id;
    }

    //Public method
    this.getFullName = function () {
        return fullName;
    }   
}

Donde tenemos fullName como método privado y getFullName y getId como métodos publicos.

Podemos observar que utilizando "this", en ese caso, se define como publicos a estos dos métodos. En el caso del otro (fullName) se define como variable-function privada.

Por ultimo para crear una instancia y utilizar esta clase, debemos realizar los siguiente:

var persona = new Persona({
            id: 1234,
            firstName: "Juan",
            lastName: "Perez"
     }
);
console.log(persona.getFullName());
console.log(persona.getId());


Este es un simple ejemplo de como crear un objecto en javascript y poder estructurar el código sin utilizar un framework particular.

Patrones de Diseño - Patrón Observer

Este patrón permite definir distintos observadores sobre un evento particular. Generalmente se utiliza para verificar y realizar acciones cuando un objecto cambia de estado.

El diagrama de este patrón es el siguiente: 

Para mas detalle consultar este link

Para poder implementar este patrón de manera sencilla, Java introduce dos clases (una interfaz y una clase) :

•     java.util.Observer -- cualquier objeto que necesité ser notificado cuando el estado de otro objeto cambia.
•     java.util.Observable -- cualquier objeto donde el cambio de su estado sea importante y otros puedan registrarse para rebicir la notificación de ese cambio de estado. 

Ahora podemos plantear un caso de ejemplo, supongamos que en un lugar de comida rápida dispone de una pizarra electrónica donde se notifica cuando un pedido esta completo. A su vez, existen compradores que están esperando que su pedido este listo y aparezca en dicha pizarra para poder retirarlos.

Para ello creamos una clase llamada OrderBoard para simular el funcionamiento de la pizarra cuando un pedido esta listo.

La clase puede definirse de esta manera:

import java.util.Observable;

class OrderBoard extends Observable {

  public void newOrderReady(final String orderNumber) {
    //it is necessary in order to hasChanged returns true.

    setChanged();
    //Notify all observers    notifyObservers(orderNumber);
  }
}

Es importante notar que esta clase va a ser observable por distintos observadores(Compradores) 

para saber cuando su pedido esta listo. Ahora definimos los distintos observadores en una clase 

llamada Buyer de la siguiente manera: 

import java.util.Observable;
import java.util.Observer;

final class Buyer implements Observer {

  private final String orderNumber;
  private final String name;

  public Buyer(final String orderNumber, final String name) {
    this.orderNumber = orderNumber;
    this.name = name;
  }

  public void update(final Observable observable, final Object arg) {
    if(arg != null && arg.equals(orderNumber)) {
      System.out.println(name + " says: " + " This is my order!!! - " + orderNumber);
    }
  }
}
 

Tener en cuenta que OrderBoard extiende de Observable y que Buyer implementa la interfaz 

Observer. Por último creamos una clase Main para unificar todo este comportamiento:

public class Main {

    public static void main(String[] args) throws InterruptedException {
        final OrderBoard board = new OrderBoard();
        final Buyer bob = new Buyer("A1", "bob");
        final Buyer joe = new Buyer("A2", "joe");
        final Buyer george = new Buyer("A4", "george");
        final Buyer john = new Buyer("A3", "john");
        
        //Adding all the observers        board.addObserver(bob);
        board.addObserver(joe);
        board.addObserver(george);
        board.addObserver(john);

        //We complete all the orders per each user.         

         board.newOrderReady("A1");
        board.newOrderReady("A4");
        board.newOrderReady("A3");
        board.newOrderReady("A2");
    }
}
 

La salida de la ejecución de este método es: 

bob says:  This is my order!!! - A1
george says:  This is my order!!! - A4
john says:  This is my order!!! - A3
joe says:  This is my order!!! - A2

El código se puede encontrar aquí 

Espero que sea de utilidad. 

Referencias:

http://www.javaworld.com/article/2077258/learn-java/observer-and-observable.html

http://migranitodejava.blogspot.com.ar/search/label/Observer

http://docs.oracle.com/javase/7/docs/api/java/util/Observer.html

http://docs.oracle.com/javase/7/docs/api/java/util/Observable.html

http://es.wikipedia.org/wiki/Observer_%28patr%C3%B3n_de_dise%C3%B1o%29