How to store data in your web page

Posted on Actualizado enn

Hi everybody!!, I was here studying how to code an arduino board, but as you all know I love coding, and I stated to make a website as a simple exercise of entertaiment.

One of most used javascripts frameworks is AngularJs, and I started to learnt it. I made a post about these frameworks some months ago, if you want you can look it up in the “Publicaciones” tab.

I was doing this tutorial and I thought, how could I store data in the web page? And I started to investigate it, and I was very surprised when I read this web page, so it is possible, and now I am going to show you all how to do that:

Get Started

(1) You can install angular-local-storage using 3 different ways:
Git: clone & build this repository
Bower:

$ bower install angular-local-storage –save

npm:

$ npm install angular-local-storage

(2) Include angular-local-storage.js (or angular-local-storage.min.js) from the dist directory in your index.html, after including Angular itself.

(3) Add 'LocalStorageModule' to your main module’s list of dependencies.

When you’re done, your setup should look similar to the following:

<!doctype html>
<html ng-app=myApp>
<head>
 
</head>
<body>
    …
    <script src=//ajax.googleapis.com/ajax/libs/angularjs/1.1.5/angular.min.js></script> 
    <script src=bower_components/js/angular-local-storage.min.js></script> 
    …
    <script>
        var myApp = angular.module(myApp, [LocalStorageModule]);
 
    </script> 
    …
</body>
</html>

Configuration

setPrefix

You could set a prefix to avoid overwriting any local storage variables from the rest of your app
Default prefix: ls.<your-key>

myApp.config(function (localStorageServiceProvider) {
  localStorageServiceProvider
    .setPrefix(yourAppName);
});

setStorageType

You could change web storage type to localStorage or sessionStorage
Default storage: localStorage

myApp.config(function (localStorageServiceProvider) {
  localStorageServiceProvider
    .setStorageType(sessionStorage);
});

setDefaultToCookie

If localStorage is not supported, the library will default to cookies instead. This behavior can be disabled.
Default: true

myApp.config(function (localStorageServiceProvider) {
  localStorageServiceProvider
    .setDefaultToCookie(false);
});

setStorageCookie

Set cookie options (usually in case of fallback)
expiry: number of days before cookies expire (0 = session cookie). default: 30
path: the web path the cookie represents. default: '/'
secure: whether to store cookies as secure. default: false

myApp.config(function (localStorageServiceProvider) {
  localStorageServiceProvider
    .setStorageCookie(45, <path>, false);
});

setStorageCookieDomain

Set the cookie domain, since this runs inside a the config() block, only providers and constants can be injected. As a result, $location service can’t be used here, use a hardcoded string or window.location.
No default value

myApp.config(function (localStorageServiceProvider) {
  localStorageServiceProvider
    .setStorageCookieDomain(<domain>);
});

For local testing (when you are testing on localhost) set the domain to an empty string ”. Setting the domain to ‘localhost’ will not work on all browsers (eg. Chrome) since some browsers only allow you to set domain cookies for registry controlled domains, i.e. something ending in .com or so, but not IPs or intranet hostnames like localhost.

setNotify

Configure whether events should be broadcasted on $rootScope for each of the following actions:
setItem , default: true, event “LocalStorageModule.notification.setitem”
removeItem , default: false, event “LocalStorageModule.notification.removeitem”

myApp.config(function (localStorageServiceProvider) {
  localStorageServiceProvider
    .setNotify(true, true);
});

Configuration Example

Using all together

myApp.config(function (localStorageServiceProvider) {
  localStorageServiceProvider
    .setPrefix(myApp)
    .setStorageType(sessionStorage)
    .setNotify(true, true)
});

API Documentation

isSupported

Checks if the browser support the current storage type(e.g: localStorage, sessionStorage). Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  if(localStorageService.isSupported) {
    //… 
  }
  //… 
});

getStorageType

Returns: String

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  var storageType = localStorageService.getStorageType(); //e.g localStorage 
  //… 
});

You can also dynamically change storage type by passing the storage type as the last parameter for any of the API calls. For example: localStorageService.set(key, val, "sessionStorage"); ###set Directly adds a value to local storage.
If local storage is not supported, use cookies instead.
Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function submit(key, val) {
   return localStorageService.set(key, val);
  }
  //… 
});

get

Directly get a value from local storage.
If local storage is not supported, use cookies instead.
Returns: value from local storage

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function getItem(key) {
   return localStorageService.get(key);
  }
  //… 
});

keys

Return array of keys for local storage, ignore keys that not owned.
Returns: value from local storage

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  var lsKeys = localStorageService.keys();
  //… 
});

remove

Remove an item(s) from local storage by key.
If local storage is not supported, use cookies instead.
Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function removeItem(key) {
   return localStorageService.remove(key);
  }
  //… 
  function removeItems(key1, key2, key3) {
   return localStorageService.remove(key1, key2, key3);
  }
});

clearAll

Remove all data for this app from local storage.
If local storage is not supported, use cookies instead.
Note: Optionally takes a regular expression string and removes matching.
Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function clearNumbers(key) {
   return localStorageService.clearAll(/^\d+$/);
  }
  //… 
  function clearAll() {
   return localStorageService.clearAll();
  }
});

bind

Bind $scope key to localStorageService. Usage: localStorageService.bind(scope, property, value[optional], key[optional]) key: The corresponding key used in local storage Returns: deregistration function for this listener.

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  localStorageService.set(property, oldValue);
  $scope.unbind = localStorageService.bind($scope, property);
 
  //Test Changes 
  $scope.update = function(val) {
    $scope.property = val;
    $timeout(function() {
      alert(localStorage value:  + localStorageService.get(property));
    });
  }
  //… 
});
<div ng-controller=MainCtrl>
  <p>{{property}}</p>
  <input type=text ng-model=lsValue/>
  <button ng-click=update(lsValue)>update</button>
  <button ng-click=unbind()>unbind</button>
</div>

deriveKey

Return the derive key Returns String

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  localStorageService.set(property, oldValue);
  //Test Result 
  console.log(localStorageService.deriveKey(property)); // ls.property 
  //… 
});

length

Return localStorageService.length, ignore keys that not owned. Returns Number

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  var lsLength = localStorageService.length(); // e.g: 7 
  //… 
});

Cookie

Deal with browser’s cookies directly. ##cookie.isSupported Checks if cookies are enabled in the browser. Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  if(localStorageService.cookie.isSupported) {
    //… 
  }
  //… 
});

cookie.set

Directly adds a value to cookies.
Note: Typically used as a fallback if local storage is not supported.
Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function submit(key, val) {
   return localStorageService.cookie.set(key, val);
  }
  //… 
});

Cookie Expiry Pass a third argument to specify number of days to expiry

    localStorageService.cookie.set(key,val,10)

sets a cookie that expires in 10 days. Secure Cookie Pass a fourth argument to set the cookie as secure W3C

    localStorageService.cookie.set(key,val,null,false)

sets a cookie that is secure. ###cookie.get Directly get a value from a cookie.
Returns: value from local storage

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function getItem(key) {
   return localStorageService.cookie.get(key);
  }
  //… 
});

cookie.remove

Remove directly value from a cookie.
Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function removeItem(key) {
   return localStorageService.cookie.remove(key);
  }
  //… 
});

cookie.clearAll

Remove all data for this app from cookie.
Returns: Boolean

myApp.controller(MainCtrl, function($scope, localStorageService) {
  //… 
  function clearAll() {
   return localStorageService.cookie.clearAll();
  }
});

Check out the full demo at http://gregpike.net/demos/angular-local-storage/demo.html

Development:

  • Don’t forget about tests.
  • If you’re planning to add some feature please create an issue before.

Clone the project:

$ git clone https://github.com/<your-repo>/angular-local-storage.git
$ npm install
$ bower install

Run the tests:

$ grunt test

Deploy:
Run the build task, update version before(bower,package)

$ npm version patch|minor|major
$ grunt dist
$ git commit [message]
$ git push origin master –tags

Sincronizar hilos en Java

Posted on

Ahi vá si hace tiempo que no publico nada, pero no os engañéis sigo programando, jejejeje.

En este post voy a realizar una introducción a la sincronización ya que estoy realizando un curso de programación y como estoy en el tema de sincronización, me he animado. Así que os dejo un aporte, una de mis fuentes favoritas aquí. Es un blog que consulto muy a menudo y lo he traducido libremente.

En un lenguaje de programación como es Java, los bloques sincronizados y los métodos sincronizados son dos formar de utilizar la sincronización e implementar la exclusión mutua en secciones críticas de código, clásico de hilos que emplean métodos comunes.

Los lenguajes de programación de alto nivel se emplean, de forma habitual, en programas multi-hilo, los cuales presentan varios tipos de peligros como la seguridad del hilo, deadlocks y condiciones de carrera, que pueden aparecer en el código por un mal entendimiento del mecanismo de sincronización provisto por Java.

Aunque el lenguaje Java provee sincronización de fábrica, y variables volatiles para conseguir la sincronización. La principal diferencia entre métodos y bloques sincronizados reside en el lugar en el que la sección crítica está ubicada.

Los métodos sincronizados además dependen de si es un método estático o un método no estático, pudiendo ser el bloqueo a nivel de clase o el bloqueo a nivel de objeto. El bloqueo a nivel de clase es uno para cada clase y representando por el literal class, por ejemplo String.class. El bloqueo a nivel de objeto es provisto por un objeto concreto, por ejemplo la instancia this. No se deberían mezclar métodos sincronizados estáticos y no estáticos. Por otro lado, los bloques sincronizados proporcionan una expresión como parámetro al bloque sincronizado. A continuación se verá un ejemplo de ambas alternativas de sincronización para entender mejor las diferencias.

Diferencia entre método sincronizado y bloque sincronizado en Java

Seguidamente, se van a repasar algunas de las diferencias entre los métodos y bloques sincronizados en Java basados en la experiencia y las reglas sintácticas de la palabra reservada synchronized en Java. Aunque ambos pueden ser usados para proveer un alto grado de sincronización en Java, el uso del bloque sincronizado sobre el método es considerado en Java una mejor práctica de programación.

  1. Una diferencia significativa entre método y bloque sincronizado es que el bloque sincronizado generalmente limita el alcance del bloqueo. El alcance del bloqueo es inversamente proporcional al rendimiento, con lo que siempre es mejor bloquear únicamente la sección crítica que haya en el código. Uno de los mejores ejemplos de usar bloque sincronizado es la doble comprobación de bloqueo en patrón Singleton en lugar del bloqueo completo en métodos sincronizados con getInstance(), sólo bloqueamos la sección crítica de código en la cual se crear la instancia Singleton. Esto mejora el rendimiento considerablemente debido a que el bloqueo se requiere únicamente una o dos veces.
  2. El bloque sincronizado provee control granular sobre el bloqueo, con lo que se puede utilizar arbitrariamente cualquier bloqueo para conseguir exclusión mutua en una sección crítica de código. Por el otro lado, el método sincronizado siempre bloquea el objeto actual representado por su palabra reservada o bloqueo a nivel de clase, si el método sincronizado es estático.
  3. El bloque sincronizado puede lanzar una java.lang.NullPointerException si la expresión resultante al bloquear es null, al contrario del caso de los métodos sincronizados.
  4. En el caso de los métodos sincronizados, el bloqueo conseguido por el hilo cuando entra en el método y cuando se libera al salir del método, o sale normalmente o lanzando una Exception. Por el otro lado, en el caso de los bloques sincronizados, el hilo bloquea cuando entra en el bloque propiamente dicho, y libera cuando deja el bloque.

Ejemplo de método sincronizado vs bloque sincronizado en Java

A continuación un ejemplo de una clase que muestra método y bloque sincronizados:

/**
* Java class to demonstrate use of synchronization method and block in Java
*/
public class SycnronizationExample{

public synchronized void lockedByThis(){
System.out.println(” This synchronized method is locked by current” instance of object i.e. this”);
}

public static synchronized void lockedByClassLock(){
System.out.println(“This static synchronized method is locked by class level lock of this class i.e. SychronizationExample.class”);

}

public void lockedBySynchronizedBlock(){
System.err.println(“This line is executed without locking”);

Object obj = String.class//class level lock of Stirng class

synchronized(obj){
System.out.println(“synchronized block, locked by lock represented using obj variable”);
}
}

}

Estas son las diferencias entre método y bloque sincronizado en Java. Empleando el bloque sincronizado sobre el método es una de las mejores prácticas de programación en Java y reduce el alcance del bloqueo, además de mejorar el rendimiento. Por el otro lado, utilizar métodos sincronizados es fácil aunque también crea bugs al mezclar métodos estáticos y sincronizados sincronizados, debido a que ambos son bloqueados en diferentes controles, y se utilizan para sincronizar accesos de recursos compartidos, con lo que lo más común es que haya algún fallo.

Diagramas de clases. Relaciones

Posted on Actualizado enn

UML, Agregacion y Composicion
He visto demasiadas discusiones vicentinas sobre las diferencias entre la agregación y la composición en los diagramas de clases de UML. Es más, cada cierto tiempo, alguien surge y me pregunta cual es la diferencia en el código y me explica sus propias teorías sobre esta cuestión, este debate es casi tan extenso como el de los extends y los includes de los casos de uso.

UML: Diferencia Agregacion, Asociacion y Composición. Codigo
Empecemos, debemos recordar siempre que una de las mayores criticas que recibe UML, es que ha logrado salvar muchas ambigüedades… Pero no todas!!! aun quedan conceptos que se prestan a dobles interpretaciones, no se si este será uno de ellos, pero por lo discutido parece que sí. Por otro lado, podemos hacer un poco de historia, recordando que primero existió la asociación, después surge la Agregación para representar un relacion estructural contenedor/contenido y luego como una “extensión” de esta ultima nace la Composición.
Para explicar mi punto de vista voy a echar mano, al diagrama de clases que ya he utilizado en otro post y después voy a poner el código de la clase Persona, que es la que se lleva todala carga de la discusiónEl código hace referencia, solo a este modelo, y es bien detallado, hasta con cosas innecesarias, o meramente teóricas, pero lo que busco es fijar una posición, concreta y definitiva, en el tema de las relaciones.

Algo importante a tener en cuenta, es que un objeto existe (digamos que esta vivo, pero esto no es técnicamente correcto por que no es un hilo) mientras existe una variable de referencia que “apunte” (tampoco correcto, por que java no tiene punteros, je) a dicho objeto en memoria. Es decir que se convertirá en elegible para ser borrado por el garbage collector, cuando no exista una variable que “apunte” a dicho objeto.


import java.util.LinkedList;
import java.util.List;

public class Persona {
private String nombre;
private String apellido;
private List perfiles = new LinkedList();
private List lugaresFrecuentes = new LinkedList();

//Setters and Getters
public String getNombre() {return nombre;}
public void setNombre(String nombre) {this.nombre = nombre;}
public String getApellido() {return apellido;}
public void setApellido(String apellido) {this.apellido = apellido;}

// OJO no confundir estos son solo setters y getters de las propiedades
public List getPerfiles() {return perfiles;}
public void setPerfiles(List perfiles) {this.perfiles = perfiles;}
public List getLugaresFrecuentes() {return lugaresFrecuentes;}
public void setLugaresFrecuentes(List lugaresFrecuentes) {this.lugaresFrecuentes = lugaresFrecuentes;}

La clase comienza normalmente con la declaración de las variables de instancia. Donde perfiles y lugaresFrecuentes

son dos colecciones, pero tranquilamente podrían ser arrays. que se transformarán en contenedores de elementos. Al ser propiedades tienen getters y setters (accessors y mutators), que nada tienen que ver con la agregación y la composición.
Ahora veamos cuales son los métodos que caracterizan a la relación de AGREGACIÓN


public void agregarLugarFrecuenta(Lugar lugar){
if(!lugaresFrecuentes.contains(lugar)){
lugaresFrecuentes.add(lugar);
}
}
public void removerLugarFrecuenta(Lugar lugar){
if(lugaresFrecuentes.contains(lugar)){
lugaresFrecuentes.remove(lugar);
}
}

La primera característica es que la clase contiene dos métodos uno que agrega elementos a la coleccion y otro que los elimina de ella. He acá algo importante… los objetos son pasados por parametro, no han sido instanciados dentro del método, es decir no hemos realizado el new del objeto. Ha “nacido” en cualquier otra parte y se lo hemos pasado por parámetro al método para ser agregado a la lista lugaresFrecuentes. En otras palabras, el objeto Persona podria morir, y el objeto ahun podría mantener una referencia activa en alguna otra parte de nuestro codigo por lo tanto sus ciclos de vida no estrían atados. No nace ni muere, dentro de la Persona.

¿Cual es la Diferencia con la COMPOSICIÓN?


public void agregarPerfil(){
Perfil p = new Perfil();
perfiles.add(p);
}
//sobrecarga
public void agregarPerfil(String nombre){
Perfil p = new Perfil(nombre);
perfiles.add(p);
}
public void removerPerfil(int index){

perfiles.remove(index); // aca lo quitamos de la lista

}
Bueno… la composición también tiene los métodos para agregar y borrar. Pero…

“el new del objeto se realiza dentro del método agregar”

la instanciación del objeto p se realiza dentro del método agregar y la referencia no se devuelve (es void o boolean), la variable de referencia local va a dejar de existir una vez que el método se termine de ejecutar, y el ciclo de vida de esa instancia en particular va a quedar atada a la lista, y por ende a la Persona. Una vez que el objeto Persona no se referencie más, (o sea muera, aunque técnicamente esto no es así) el objeto lista, quedará sin referencia, y por lo tantos sus elementos también. Además como el método no es estático, se deberá crear primero una instancia de Persona, para después poder agregar un Perfil. Empezando así a “atar” el ciclo de vida de un Perfil, al de una Persona.
En cuanto al método remover, no existe nada de extraordinario, simplemente quitamos un elemento de la lista.

Volviéndonos Paranoicos de la Teoría

Profundizando la paranoia y jugando con la teoría; para que atemos definitivamente los ciclos de vida, la variable lugaresFrecuentes no debería ser una propiedad, y la clase Perfil debería ser una Inner Class.
En el caso de la Inner class, hacemos esto para que se tenga que utilizar una instancia de la clase “Outer” para luego obtener una instancia de la clase Inner. Por ejemplo si en nuestro codigo, la clase Perfil, fuera una Inner class de la clase publica Persona (Se entiende no?, es decir que esta dentro del archivo Persona.java), para obtener una instancia de Perfil fuera de la clase persona tendríamos que hacer:
Persona persona = new Persona();
Persona.Perfil perfil = persona.new Perfil();

Y la clase Perfil existiría mientras exista la instancia de persona. (ciclos de vida atados)
En el caso de que la variable de instancia lugaresFrecuentes no debería tener getters y setters públicos, esto se debe a que ningún otra clase, con excepción de la clase Persona, debería tener la oportunidad de mantener una referencia viva a un objeto del contenedor. Y mucho menos obtener toda la Lista desde afuera! Un objeto Perfil, vive y muere con la Persona!
También de esto se pueden desprender otros delirios, como cuestiones de herencia y cosas así.
Pero de nuevo, y no me voy a cansar de decirlo… esto es un extremo!!, es solo para conversar entre amigos, o vanagloriarse con algún profesor, no tiene nada de practico, ni de real, salvo para casos específicos.

Paranoia de la Paranoia

¿Creían que ya habíamos terminado? aun se puede ser más paranoico!!!! mucho se ha discutido sobre estos temas, y mucho fue paranoia teórica. Lo siguiente, es algo que les llevará a sus amigos o profesor a decir, “…bueno pero eso ya es una locura”:
Sobreescribiremos el método finalize() de la Clase Persona, que es un método que todas las clases heredan de Object, y que se invoca justo antes de que un objeto sea borrado de la memoria por el garbage collector de java.

public void finalize(){
for(Perfil p : perfiles){
p = null;
}
}

En el desreferenciamos cada uno de los elementos de la lista un segundo antes de que el objeto de tipo Persona desaparezca de la memoria, una milésima de segundo, o algo asi!!! atando definitivamente el nacimiento y muerte, el ciclo de vida, de un elemento contenido con su contenedor.
Pero de nuevo!!! LA PARANOIA EN EL CÓDIGO NO ES BUENA!!! solo sirve en aquellas noches de borrachera entre programadores, en las cuales el boliche cerró y pinta quedarse en casa con amigos.

Yo rescataría de todo este biri-biri aquello de “el new se realiza dentro del método” y nada más!!!

UML, Asociacion y Agregacion
El post de la Agregación y Composición despertó otra pregunta más (Como siempre suele suceder, ya dije que el debate siempre dá para algo más). La duda viene por el lado de la diferencia entre asociación y Agregación en código. Se sostiene que es algo conceptual, que no se representa en código. Mi respuesta es que esto es 50% correcto. Ya que, como mencione antes (la etiqueta Diseño tiene mas sobre esto), la Asociación surgió primero, y la Agregación vendría a ser un tipo particular de Asociación. Ergo …Agregacion “IS-A” Asociación ¡punto para ud! . Primero veamos el diagrama UML

composicionAhora veamos el codigo de la clase Persona (Nota: imagínense los generics por que blogspot los toma como tags, así que no aparecen)

import java.util.List;

public class Persona {

private String nombre;
private String apellido;

private Foto foto;
private List lugaresFrecuentes;
private List comunicaciones;

public String getNombre() {return nombre;}
public void setNombre(String nombre) {this.nombre = nombre;}
public String getApellido() {return apellido;}
public void setApellido(String apellido) {this.apellido = apellido;}

//Asociacion Foto
public Foto getFoto() {return foto;}
public void setFoto(Foto foto) {this.foto = foto;}

//public List getLugaresFrecuentes() {return lugaresFrecuentes;}
//public void setLugaresFrecuentes(List lugaresFrecuentes) {this.lugaresFrecuentes = lugaresFrecuentes;}

//Agregacion
public void agregarLugar(Lugar lugar){
lugaresFrecuentes.add(lugar);
}
public boolean quitarLugar(Lugar lugar){
return lugaresFrecuentes.remove(lugar);
}
//Asociación
public void setComunicaciones(List comunicaciones) {
this.comunicaciones = comunicaciones;
}
public List getComunicaciones() {
return comunicaciones;
}

}

Las diferencias principales son que:
¡La Agregación son siempre colecciones, o arrays! O algo que sirva de contenedor para “agregar” más de un objeto, aunque agreguemos uno solo. (si no sería settear y no agregar, add)La Agregación cuenta con dos métodos: uno para “agregar” un solo objeto a la lista, y el otro para quitarlo de la misma.La agregación puede, como no, tener los metodos setter y getter, mientras que la Asociación siempre los tiene, que ponen y obtienen una variable de referencia del mismo tipo de la variable de instancia o de clase, en este caso List.

 

Habilitar ver filas y columnas en el bloc de notas de Windows

Posted on

Una de las mejores herramientas de Windows 7 y XP es y será siempre el Bloc de Notas  para la edición de texto plano.

En esta herramienta la barra de estado viene deshabilitada por defecto y no es fácil activarla, pues si vas a la opción “Ver” de la barra de menú, verás que no puedes hacer clic sin más, pero con unos simples pasos puedes tener esta opción accesible.

Actualmente, mi Bloc de Notas no tiene la barra de estado, se muestra de la siguiente forma:

dibujo

PAra habilitarlo debes abrir el registro de Windows de la siguiente forma:

  1. Clic en el menú Inicio
  2. En caso de que tengas Windows 7, escribe “regedit” y dale a la tecla Intro; en caso de que tengas Windows XP, escoge la opción “Ejecutar” y luego escribe “regedit”

Una vez que estamos en el registro del sistema, nos dirigimos a la siguiente clave:

HKEY_CURRENT_USER\Software\Microsoft\Notepad

Notepad - Regedit

En la opción “StatusBar”, pulsamos clic derecho y seleccionamos la opción Modificar, y le cambiamos el número a 1, con lo que activaremos automáticamente la barra de estado. El resultado se puede ver en la siguiente imagen:

Barra de estado en Notepad

Así,  la barra de estado estará activada de manera automática. Siendo el comportamiento y aspecto de mi Bloc de notas con la barra de estado habilitada.

Bloc de notas con barra de estado

Esto es muy útil  en muchas ocasiones, por ejemplo cuando desarrollo algún código en PHP a mano, no podía ver la línea donde estaba el error; con esto ya podré hacerlo sin problema.

Un truco fácil de aplicar que te da mucha potencialidad.

(Fuente: Aquí)

 

Tipos de variables en Java

Posted on

Las variables son posiciones de memoria reservadas para almacenar valores. Esto significa que cuando se crea una variable para reservar algo se crea un espacio en la memoria.

Existen dos tipos de datos disponibles en Java:

  • Tipos de datos primitivos.
  • Tipos de datos de referencia.

Tipos de datos primitivos

Hay ocho tipos de datos primitivos soportados por Java. Los tipos de datos primitivos están predefinidos por el lenguaje y nombrados por una palabra clave. Veamos ahora en detalle acerca de los ocho tipos de datos primitivos.

Byte

  • Tipo de datos Byte es un entero de 8 bits.
  • El valor mínimo es -128 (-2 ^ 7).
  • El valor máximo es 127 (inclusive) (2 ^ 7 -1).
  • El valor por defecto es 0.
  • Tipo de datos Byte se utiliza para ahorrar espacio en grandes conjuntos, sobre todo en el lugar de los números enteros, ya que un byte es cuatro veces más pequeño que un int.
  • Ejemplo: byte a = 100, byte b = -50

Short

  • Tipo de datos Short es un entero de 16 bits.
  • El valor mínimo es -32,768 (-2 ^ 15).
  • El valor máximo es de 32.767 (inclusive) (2 ^ 15 -1).
  • Tipo de datos Short también se puede utilizar para ahorrar memoria como tipo de datos byte. Un tipo de dato short es 2 veces más pequeño que un int.
  • El valor por defecto es 0.
  • Ejemplo: short s = 10000, short r = -20000

Int

  • Tipo de datos int es un entero de 32 bits.
  • El valor mínimo es -2147483648 (-2 ^ 31).
  • El valor máximo es 2147483647 (inclusive)(2 ^ 31 -1).
  • Int. se utiliza generalmente como el tipo de datos predeterminado para los valores enteros a menos que exista una preocupación acerca de la memoria.
  • El valor por defecto es 0.
  • Ejemplo: int a = 100000, int b = -200000

Long

  • Tipo de datos Long es un entero de 64 bits.
  • El valor mínimo es -9223372036854775808 (-2 ^ 63).
  • El valor máximo es 9223372036854775807 (inclusive) (2 ^ 63 -1).
  • Este tipo se utiliza cuando se necesita una gama más amplia que int.
  • El valor por defecto es 0.
  • Ejemplo: long a = 100000, int b =-200000

Float

  • El Float es un dato de coma flotante de precisión simple de 32 bits.
  • Float se utiliza principalmente para ahorrar memoria en grandes arrays de números.
  • El valor por defecto es 0,0 f.
  • Ejemplo: float f1 = 234.5f

Double

  • El doble es un dato de coma flotante de doble precisión de 64 bits.
  • Este tipo de datos se utiliza generalmente como el tipo de datos predeterminado para valores decimales, en general, la opción por defecto.
  • El valor por defecto es 0.0 D.
  • Ejemplo: doble d1 = 123,4

Boolean

  • Boolean representa un bit de información.
  • Sólo hay dos posibles valores: true y false.
  • Este tipo de datos se utiliza para indicadores simples que hacen un seguimiento de condiciones.
  • El valor predeterminado es falso.
  • Ejemplo: boolean a = true

Char

  • Char es un carácter Unicode de 16 bits.
  • El valor mínimo es ‘\u0000’ (o 0).
  • El valor máximo es ‘\uffff’ (o 65.535 inclusive).
  • Tipo de datos char se utiliza para almacenar cualquier carácter.
  • Ejemplo: char letra = 'A'

Tipos de datos de referencia

  • Las variables de referencia se crean mediante constructores definidos de las clases. Se utilizan para acceder a los objetos. Estas variables se declaran de un tipo específico que no se puede cambiar.
  • Objetos de la Clase, y varios tipos de variables de array están bajo tipo de datos de referencia.
  • El valor predeterminado de cualquier variable de referencia es nulo.
  • Una variable de referencia se puede utilizar para referirse a cualquier objeto del tipo declarado o cualquier tipo compatible.
  • Ejemplo: Carro unCarro = new Carro ("Ford");

 

(Fuente: Aquí)

Debugando con el IDE Eclipse

Posted on Actualizado enn

Creamos un proyecto java en eclipse y ponemos un par de clases para empezar a jugar con el debugger. Una con el main puede ser PruebaDebugger y la otra, por aquello de tener varias, puede ser ClaseParaDepurar. El código en ellas cualquiera, por ejemplo, el siguiente

package com.control.ejemplos;

public class PruebaDebugger {
    public static void main(String[] args) {
        ClaseParaDepurar clase = new ClaseParaDepurar();
        double valor = clase.echaCuentas();
        System.out.println("Sale "+valor);
    }
}
package com.control.ejemplos;

import java.util.LinkedList;
import java.util.List;

public class ClaseParaDepurar {
    private double suma;
    private List<Double> lista;

    public ClaseParaDepurar() {
        System.out.println("construyendo clase");
    }
    public double echaCuentas() {
        lista = new LinkedList<Double>();
        for (int i = 0; i<100;i++){
            lista.add((double)i);
        }
        suma = 0.0;
        for (Double valor : lista){
            suma +=valor;
        }
        return suma;
    }
}

Poner un Breakpoint

Un Breakpoint es un punto en nuestro código en el que al ejecutar con debugger, la ejecución se detendrá y podremos ver los valores que tienen las variables en ese momento, modificarlos, etc, etc. Poner un BreakPoint es sencillo, basta ir a nuestra clase y hacer doble click en el margen izquierdo del editor, justo en la línea donde queremos que la ejecución se detenga. En la figura vemos un circulito a la izquierda de la línea 19, ese es el breakpoink que acabamos de poner haciendo doble click justo ahí.

Eclipse-breakpoint.png

Si queremos quitarlo, nos basta con hacer doble click en él nuevamente.

Arrancar el programa en modo debugger

Para arrancar el programa en modo debugger, sacamos el menú con el botón derecho del ratón sobre la clase que tiene el main. Buscamos “debug as” -> “java application”

Eclipse-arrancar-debugger.png

Esto arrancará nuestro programa en modo debugger y se ejecutará de forma normal hasta que la ejecución pase por un Breakpoint, en ese momento se detendrá.

Este proceso del menú y “debug as” -> “Java application” sólo es necesario la primera vez. Las siguientes veces que queramos ejecutar, podemos usar el botón en la parte superior con el dibujo de una cucaracha (un “bug”)

Eclipse-cucaracha.png

La vista de debugger

Cuando arranca el programa en modo debug, eclipse posiblemente nos pregunte si queremos pasar a la vista de debug. Le indicamos que sí, marcando el check de “Remember my decision” si no queremos que nos lo pregunte cada vez que arranquemos el debugger sin estar en esa vista.

El programa se ejecuará de forma normal hasta llegar a un breakpoint. Es ese momento se parará y tendremos una serie de “cosas” útiles en la vista de debugger para poder ver variables, hacer que el programa se ejecute paso a paso, ver quién llama a quién, etc.

Botones para ir paso a paso

En la vista de debugger tenemos botones para ir ejecutando paso a paso a partir del breakpoint donde nos hemos parado. Están en la parte superior y son como unas flechitas variadas amarillas

Eclipse-botones-debug.png

El primer botón de la imagen, un breakpoint tachado, deshabilita temporalmente todos los breakpoints. Si hacemos que nuestro código corra, no se parará en ningún breakpoint.

El siguiente botón, una flecha verde parecido al “play” de cualquier reproductor de música/video, hace que continue la ejecución de nuestro programa hasta el siguiente Breakpoint.

El siguiente botón, parecido al botón de pausa de cualquier reproductor de música/video, suspende la ejecución del programa que está corriendo. Es una forma de parar “al vuelo” el programa, esté donde esté en ese momento, haya o no breakpoint.

El cuadrado rojo es el botón de stop, aborta la ejecución de nuestro programa.

El siguiente botón que apenas se ve y cuyo tooltip es “disconnect” no tiene mucha utilidad en nuestro caso. Eclipse ofrece la posibilidad de conectarse a un programa java que se está ejecutando fuera de eclipse para depurarlo. Este botón nos desconectaría de ese programa remoto que estamos depurando.

El siguiente botón, una flecha amarilla que se “mete” entre dos puntos negros, imagina que nuestro programa tiene el breakpoint en una línea en la que se hace una llamada a un método y se ha parado ahí. Pulsando este botón, el debugger se meterá dentro del método y se parará en la primera línea del mismo, de forma que podemos depurar dentro del método. Por ejemplo, si el breakpoint está donde se muestra en la siguiente figura

Eclipse-debugger-step-into.png

al pulsar el botón marcado en rojo, el debugger se meterá dentro del método echaCuentas() y se parará en la primera línea de ese método.

El siguiente botón, una flecha amarilla que salta sobre un punto negro, avanza un paso la ejecución del programa, pero sin meterse dentro del método que encuentre. Por ejemplo, en la figura anterior, si pulsáramos este botón, la ejecución pasaría a la línea System.out.println(), sin pararse dentro del método echaCuentas().

Finalmente, el último botón es una flecha saliendo de entre dos puntos negros, hace avanzar el programa hasta que nos salimos del método actual y vamos hasta el sitio donde ha sido llamado. Por ejemplo, si el debugger está parado donde la figura y pulsamos este botón

Eclipse-debugger-step-return.png

el debugger pasará justo al código dose se está llamando a este método, es decir, al echaCuentas() anterior.

La pila de llamadas

Tenemos una ventana, etiquetada “Debug” en la que aparece la pila de llamadas, como la de la siguiente figura

Eclipse.debugger-pila-de-llamadas.png

En ella podemos ver cada uno de los hilos en ejecución (Thread main en la figura, único hilo existente en esta mini aplicación) y debajo el fichero en el que ahora está la ejecución parada (marcada en azul en la figura), quién ha llamado a esa clase (línea justo debajo con el PruebaDebugger.main). Haciendo doble click en estas líneas, iremos al fichero justo al sitio donde se está ejecutando el código.

Visualizar y modificar variables

Tenemos una ventana etiquetada Variables. En ella podemos ver todas las variables definidas en el punto en el que está parado nuestro código. Es la de la siguiente figura

Eclipse-debugger-lista-variables.png

Vemos que en ese punto de ejecución nuestra lista ya tiene sus 100 elementos, pero suma todavía vale 0.0. La lista se ve un poco “rara” ya que estamos viendo todos los detalles internos de la clase LinkedList que hemos usado. Hay un botón que si lo pulsamos nos permite ver las colecciones de una forma más amigable, es el que se muestra en la siguiente figura

Eclipse-debugger-lista-variables-bonita.png

Vemos que ahora sólo se ven los elementos de la LinkedList, no sus “cosas” internas.

En esta ventana es fácil modificar el valor de una variable, basta con hacer click en el valor y cambiarlo. Por ejemplo, en la figura donde se ve suma=0.0, si hacemos click en el 0.0, podremos poner el valor que queramos. Esto valor se usará en los siguientes pasos de ejecución del debugger.

Otra forma de visualizar el valor de una variable consiste simplemente en poner el ratón sobre ella en el código. Aparecerá un tooltip con su contenido. En la siguiente figura hemos puesto el ratón sobre la variable lista señalada en rojo, aparece el tooltip con todos los valores.

Eclipse-debugger-ver-variable.png

Cuando se muestra el valor de una variable, se llama a su método toString(), por lo que a veces la variable nos puede quedar algo fea y veremos algo como lo de la siguiente figura para la variable “clase”. No es más que una llamada al método toString() de esa clase y lo que sale es lo que muestra

Eclipse-debugger-toString.png

Vemos que sale el nombre de la clase, seguido de una @ y un número. Esto no nos dice nada. Afortunamente, podemos decirle a eclipse cómo queremos que se visualice una clase. Vamos a la ventana donde tenemos las variables, sacamos el menú con el botón derecho del ratón sobre la variable que nos interese y elegimos “New detail formatter”

Eclipse-debugger-abrir-detail-formatter.png

Esto nos abrirá una ventana con una caja de texto donde podemos poner lo que queramos que se muestre para visualizar esa variable. Por ejemplo, en nuestra clase podemos querer que se vea el tamaño de la lista y el valor de la suma, así que nos basta con poner algo como lo de la siguiente figura

Eclipse-debugger-ventana-detail-formatter.png

Obviamente, si en el ejemplo lista es null, la llamada a lista.getSize() dará un NullPointerException, y eso es lo que veremos al visualizar la variable. Si no es null, veremos algo como esto

Eclipse-debugger-variable-con-detail-formatter.png

Breakpoints condicionales

Tenemos otra ventana más con todos los breakpoints. Ahí podemos habilitarlos o deshabilitarlos sin más que marcar/desmarcar el check.

Eclipse-debugger-breakpoints.png

Lo que es más interesante es lo que se ve en la parte de debajo la ventana y es que podemos hacer que el código se pare o no en el breakpoint según alguna condición. Por ejemplo, ponemos el breakpoint en medio de un bucle, por ejemplo en el bucle donde estamos llenando la lista. Podemos hacer que el código se pare, por ejemplo, cuando estemos en la iteración 50 del bucle (cuando i==50), de esta forma

Eclipse-debugger-breakpoint-condicional.png

Hemos marcado el “check” etiquetado “conditional” y el etiquetado “Suspend when true”. Debajo hemos puesto la condición “i==50” y hemos arrancado el debugger, cuando se ha detenido visualizamos el valor de la variable i, y efectivamente es 50.

(Fuente: aqui)

Cambiar fondo a oscuro en IDE Eclipse

Posted on

Para cambiar el fondo de pantalla de la IDE Eclipse se puede realizar mediante los siguientes pasos:

Primero tenemos la opción de hacerlo nosotros mismo dirigiéndonos a:

Windows > Preferences > General > Editors > Text Editors

Ahora, procedemos a configurar, pero como no tengo todo el tiempo del dia para dedicarme  a realizar estas modificaciones, voy a usar los Plugin’s de Eclipse, primero necesitamos instalar el plug-in, así que nos vamos a:

Help > Install New Softare

y agregamos :

http://eclipse-color-theme.github.com/update
Esperamos unos segundos a que se instale y listo, lo tendremos disponible en:

Window→Preferences→General→Appereance→Color Theme

Para poder instalar los nuevos estilos seleccionamos.

Color Theme Plugin

Seleccionamos un tema de nuestro agrado, por ejemplo, elijo sublime porque es el que más se acomoda a mi gusto.
Pero como me agrada mas estilos oscuros y aun mas que el background que sea negro porque me siento mas cómodo trabajando así para lograr esto esto nos dirigimos a Text Editor y seleccionamos Background y cambiamos por el color deseado.

Si lo que quieres es cambiar el color de los comentarios, variables, strings, declaracion de clases, etc… entonces nos vamos a Java > Editor > Syntax Coloring.

Y asi se ve con mi tema definido y listo para continuar con el trabajo, aún le falta algunos retoques pero lo principal que me sienta a gusto esta ;). Y listo para posteriormente comenzar a trabajar.