En un post anterior tratamos lo que son las clases internas y definimos el uso mas común que se le puede dar a una clase interna, en este post trataremos el uso de una clase interna dentro de una interfaz y como instan ciarla fuera de la clase contenedora y la herencia de la clase contenedora y se puede “sobrescribir” una clase interna.

Alcance de las InnerClass

Como ya hemos visto las clases internas poseen grandes ventajas, como hemos visto las clases internas pueden ser declaradas como privadas, protegidas y publicas, al igual que los métodos las clases privadas solo son accesibles dentro de la clase, las privadas. A manera de referencia si se declara una clase interna como privada esta no podrá ser instanciada fuera de la clase, si es declarada como protected solo es accesible dentro del package de la clase contenedora y permite ser rescrita si la clase contenedora se le extiende además de ser instanciable en los hijos que hereden de la clase contenedora, en caso de accesible en todo parte del programa; y puede ser instanciada fuera de la clase contenedora.

Instancias de una clase interna fuera de la clase contenedora

Primero que todo existen dos maneras para instanciar explícitamente una clase interna, cada una tiene una ventaja y desventaja que definiremos más adelante. Para ambas soluciones la clase interna no puede estar contenida dentro de un método (obviamente se darán cuenta que la vida util de la clase no permite realizar la instancia explicita) y segundo la clase interna tiene que ser declara como publica. El código quedaría algo como así

package innerclasstwo;
public class Main {
 
    public class InternalClass
    {
        private String label;
        public InternalClass(String label)
        {
            this.label=label;
        }
        public void printLabel()
        {
  Main.this.printLabel(label);
         }
 
    private void printLabel(String label)
    {
         System.out.println(label);
    }
 
    public static void main(String[] args) {
        Main test=new Main();
        Main.InternalClass internal=  test.new InternalClass("hola mundo!!!");
        internal.printLabel();
    }
}

Nótese la instrucción “test.new InternalClass(String label);” como ven el new queda detrás de un punto y la instancia de Main, cabe notar que la clase tiene que ser instancia da por medio de una instancia de la clase contenedora, la clase interna tiene acceso a los métodos de la clase contenedora, esta es la ventaja primordial de esta solución

La otra solución es definir la clase como estática esto permitirá instan ciarla sin la necesidad de una instancia de la clase contenedora, pero para esto la clase interna declarada como final no tiene acceso a los métodos de la clase contenedora, Un miembro estático no puede referenciar a un elemento no estático. Pero en cambio no necesitaremos de un objeto para construir la clase interna. Un ejemplo seria algo asi

package innerclasstwo;
public class Main {
    public  static  class InternalClassFinal
    {
        private String label;
        public InternalClassFinal(String label)
        {
            this.label=label;
        }
        public void printLabel()
        {
           System.out.println(this.label);
        }
 
    }
 
    private void printLabel(String label)
    {
         System.out.println(label);
    }
    public static void main(String[] args) {
                Main.InternalClassFinal internalTwo= new Main.InternalClassFinal("hola mundo");
         internalTwo.printLabel();
    }
}

El uso de new es similar al usado con los packages, en este punto es diferente con el ejemplo anterior.

La desventaja de declarar la clase como final es que no se pueden acceder a ninguna propiedad o método de la clase contenedora aunque también sea estática no puede ser accedida por la clase interna, pero es independiente y puede ser instanciada sin una instancia de la clase contenedora

El primer método (NombreDelaClase instancia= nombredelobjeto.new ClaseInterna ()) se debe tener una instancia de la clase contenedora para realizar la instancia de la clase interna aunque podríamos declarar un objeto anónimo y hacer una instancia como de la siguiente manera

Main.InternalClass testThree=new Main().new InternalClass(" Hola Mundo");

Nótese que podríamos anidar clases internas (clases internas dentro de clases internas) y esta forma se vuelve engorrosa de analizar en caso de error o de modificación de código

Clases Internas dentro de una Interfaz o/y Clase Abstractas

Como conocerán las interfaces solo contienen la declaración de métodos y no el cuerpo de ellos, en el caso de incluir clases internas podemos desarrollar el cuerpo de una clase. Esto nos dará tres nuevas oportunidades, una es crear instancias de la interfase haciendo responsable a la clase interna, que la clase interna implemente la interfaz contenedora, o que esta sea un elemento “heredado” de la clase interna a las clases que la implementen. Para el siguiente ejemplo vamos a hacer una interfaz que nos permita probar las tres alternativas planteadas

En el apartado anterior notamos como instanciar clases internas explícitamente, como ya se imaginaran es posible construir clases internas dentro de interfaces y clases abstractas, obligatoriamente estas clases internas para ser instancia das. Una clase interna dentro de una interfase no puede ser declarada como protected o prívate, ya que en concepto todos los elementos de una interfaz son publicas

El código de la interfase a probar seria algo así

public interface Interface {
    public void SayHello();
 
    public static class FirstClass
    {
        public Interface getInstance()
        {
            return new Interface()
            {
                public void SayHello() {
                    System.out.println("hello i am a inner class");
                }
 
            };
        }
    }
    public static class SecondClass implements Interface
    {
        public void SayHello() {
           System.out.println ("Hello i am  another inner Class");
        }
    }
    public class ThirdClass
    {
 
        public void SayAnotherHello()
        {
            System.out.println("Hello i am  a simple inner class");
        }
    }
 
    public abstract class FourClass
    {
        public abstract void SayAnotherHello();
 
    }
}

FirstClass es una clase que retornara una instancia de Interface, SecondClass implementa la interfaz contenedora, ThirdClass es simplemente una clase publica y FourClass es una clase abstracta.

Ahora el main del ejemplo instanciando a FirstClass y SecondClass seria algo asi

public class Main
{
    public static void main(String[] args) {
        Interface inter=new Interface.FirstClass().getInstance();
        inter.SayHello();
        Interface interTwo= new  Interface.SecondClass();
        interTwo.SayHello();
 
    }
}

Claro esta si intentamos realizar una instancia de ThirdClass usando una instancia de FirstClass o SecondClass directamente, el codigo seria algo asi

Interface.ThirdClass innerClassFromInterface=new Interface.SecondClass().new ThirdClass() ;

Pero como Interface es una interfase y no un objecto el compilador nos dará el siguiente error

“source code - qualified new of static class”

Entonces acceder a una clase interna no estática de una interfaz no puede ser instanciada, se deberá usar una clase que implemente la internas para tener acceso a esta clase interna, inclusive la clase internas y estáticas declaradas dentro de la internas pueden hacer instancias de ThirdClass sin ningún problema, como ejemplo usaremos SecondClass y le incluiremos en método SayHello() una instancia de ThirdClass

  public static class SecondClass implements Interface
  {
        public void SayHello()
        {
           ThirdClass test=new ThirdClass();
           test.SayAnotherHello();
           System.out.println ("Hello i am  another inner Class");
        }
  }

Aun podemos hacer una prueba en una clase externa que implemente la clase abstracta (FourClass) y haga una instancia de ThirdClass

public class ClassAndInterface implements Interface {
 
    public void SayHello()
    {
        ThirdClass cla=new ThirdClass();
        cla.SayAnotherHello();
 
    }
 
    public void SaySecondHello()
    {
        new  FourClass()
        {
            @Override
            public void SayAnotherHello() {
               System.out.println("I am  a inner AbstractClass");
            }
 
        }.SayAnotherHello();
    }
 
    public FourClass getAbstractClass()
    {
        return new  FourClass()
        {
            @Override
            public void SayAnotherHello() {
               System.out.println("I am  a inner AbstractClass");
            }
 
        };
    }
 
}

Y a manera de prueba podemos incluir esta líneas en el main

        ClassAndInterface classAndInterface=new ClassAndInterface();
        classAndInterface.SayHello();
        Interface.FourClass abstractInnerClass =classAndInterface.getAbstractClass();
        abstractInnerClass.SayAnotherHello();

Las clases abstractas no se diferencian mucho a las interfaces, con respecto a lo que hemos estado hablando, pero la unica diferencia notable es que podemos hacer una instancia de una clase interna usando otra clase interna estática en otras palabras el compilador no nos dirá que es código incompilable, por ejemplo veamos esta clase abstracta usando el ejemplo anterior (SecondClass y ThirdClass)

public abstract class AbstractClass {
    public abstract void SayHello();
    public static class SecondClass extends AbstractClass
    {
        public void SayHello()
        {
           ThirdClass test=new ThirdClass();
           test.SayAnotherHello();
           System.out.println ("Hello i am  another abstract Class");
 
        }
    }
    public class ThirdClass
    {
 
        public void SayAnotherHello()
        {
            System.out.println("Hello i am  a simple abstract  class");
        }
    }
}

Podemos hacer una instancia de ThirdClass de forma reducida y explicita, en forma resumida será así la instancia:

AbstractClass.ThirdClass innerClassFromInterface=new AbstractClass.SecondClass().new ThirdClass() ;
 
innerClassFromInterface.SayAnotherHello();

En futuro y ultimo post trataremos Herencia de una clase contenedora

codigo de ejemplo

En este post trataremos estos temas
Clases Internas
Clases internas dentro de un método
Clases anónimas

Clases Internas

package innerclasstest;
public class Main {
	private class MyInnerClass
	{
		private String label;
 
		public MyInnerClass(String label)
		{
			this.label=label;
		}
		public MyInnerClass()
		{
			this.label="Soy un constructor sin parametros :(";
 
		}
 
		public void printLabel()
		{
			System.out.println(this.label);
		}
	}
	public Main()
	{
		MyInnerClass uno=new MyInnerClass("Soy un constructor con parametros");
		MyInnerClass dos=new MyInnerClass();
		uno.printLabel();
		dos.printLabel();
 
	}
	public static void main(String[] args) {
		Main test=new Main();
 
	}
}

En el ejemplo anterior notamos tres puntos importates.
La clase interna (MyInnerClass) se declara exactamente como cualquier otra clase
Se instancia como cualquier otra clase dentro de la clase contenedora.
Puede declararse como privada, publica o protegida.

Como se ha mencionado puede llamar a los elementos de la clase contenedora aunque sean declarados como privados, para hacer la llamada tenemos que hacerlo de la siguiente manera: NombredelaClaseContenedora.this.nombreMetodoOPropiedad.
Seria algo como asi,

package innerclasstest;
public class Main {
	/*Clase Interna*/
	private class MyInnerClass
	{
 
        		public void callToCall(String parametro)
        		{
           		          Main.this.call(parametro);/*OJO la llamada*/
            }
	}
	/*Fin de la clase Interna*/
 private void call(String parametro)
    	{
        		System.out.println(parametro);
}
 
	public Main()
	{
MyInnerClass test=new MyInnerClass();
            uno.callToCall("Estoy Llamando un metodo de la clase contenedora");
}
	public static void main(String[] args) {
		Main test=new Main();
 
	}
}

Como vemos call(String parametro) es privado pero es facilmente llamado por la clase interna

Clases internas dentro de un método

Como hemos visto una clase puede contener una clase, pero dentro de java podemos declarar una clase dentro de una método, en este ciclo de vida de la clase depende de la ejecución del método, o en todo caso dependerá de cuanto dure el bloque donde estara declarada la clase, antes o después del bloque la clase no existe por ende no puede ser instanciada, un ejemplo seria algo asi

package innerclasstest;
public class Main {
 
    public void ContrustruirUnaClase()
    {
        class Metodo
        {
            public void print(){System.out.println("hola mundo");};
        }
        new Metodo().print();
    }
 
	public Main()
	{
        this.ContrustruirUnaClase();
	}
	public static void main(String[] args) {
		Main test=new Main();
 
	}
}

Aunque seria un uso poco común el anterior ejemplo, y la verdad no tendría sentido, el uso mas común de contener una clase dentro de un método seria retornar una instancia de esta clase. Para esto necesitamos que nuestra clase interna herede una clase (ya sea abstracta o sencilla) o implemente una interfaz. El codigo de la interfaz y la clase abstracta seria algo como así.

abstract class  AbstractClass {
    protected int res=0;
 
    public  abstract void addToSum(int b);
 
    public int getRes() {
        return res;
    }
}

Y el de la interfaz

public interface IInterface {
 
    int Sum(int b,int c);
}

Ahora veamos como seria la implementación y una prueba, cabe destacar que este tipo de implementación facilita el patrón de fabrica abstracta

package innerclasstest;
public class Main {
 
    public IInterface getInstance()
    {
        class test implements IInterface
        {
            public int Sum(int b, int c) {
                return b+c;
            }
        }
        return new test();
    }
 
    public AbstractClass getInstanceAbstract()
    {
        class test extends AbstractClass
        {
 
            @Override
            public void addToSum(int b) {
                super.res+=b;
            }
 
        }
        return new test();
    }
 
	public static void main(String[] args) {
		Main test=new Main();
       		Interface test2=test.getInstance();
         	System.out.println(test2.Sum(3, 5));
        	AbstractClass test3=test.getInstanceAbstract();
            test3.addToSum(5);
            test3.addToSum(10);
            test3.addToSum(11);
            System.out.println(test3.getRes());
	}
}

Clases anónimas

Como hemos visto las clases internas tiene una utilidad bastante evidente, sobre todo en la capacidad que tienen de ocultar código, a las programadores que usan la herramienta NetBeans notaran que cuando este genera un JFrame genera un main y dentro del main incluye unas lineas parecidas a esta

  java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new NewJFrame().setVisible(true);
            }
        });

Como vemos este realiza un new Runnable(), pero Runnable es una interfaz y aparte de esto desarrolla un cuerpo e implementa el método run(), en java se permite este tipo de instrucciones lo cual esta clase que implementa Runnable se le conoce como una clase anónima, la cual no posee un nombre, pero se sabe que implementa o extiende de una interfaz o una clase, por lo cual se le puede hacer un upcasting. Ahora del ejemplo del subtema anterior usaremos la clase abstracta AbstractClass y la interfaz IInterface, Ahora retornaremos usando una clase anónima dentro de la estructura de los métodos

 package innerclasstest;
public class Main {
        public AbstractClass getInstanceAbstractTwo()
    {
        return new AbstractClass(){
 
            @Override
            public void addToSum(int b) {
               super.res+=b;
            }
        };
    }
 
    public IInterface getInstanceTwo()
    {
        return new IInterface()
        {
            public int Sum(int b, int c) {
                return b+c;
            }
        };
    }
 
	public static void main(String[] args) {
		Main test=new Main();
 
        AbstractClass test4=test.getInstanceAbstractTwo();
        test4.addToSum(10);
        test4.addToSum(11);
        test4.addToSum(12);
        System.out.println(test4.getRes());
 
        IInterface test5=test.getInstanceTwo();
        System.out.println(test5.Sum(10, 21));
	}
}

Como vemos es una manera abreviada de retornar una clase implementada en el cuerpo de un método. Una desventaja de este método es que al no tener una clase con un nombre el compilador no permitirá sobrecargar el constructor vacio, para esto deberemos declarar un bloque sin nombre y definir los parámetros en el metodo contenedor como final, ya que los parámetros tienen que existir para ser llamados en el bloque vació. Por inconveniente el constructor no puede ser sobrecargado y no puede existir más de un constructor. Un ejemplo seria esto.

package innerclasstest;
public class Main {
 
    public IInterface getInstanceTwo(final int b,final int c)
    {
        return new IInterface()
        {
            private int k;
            private int l;
            {
                this.k=b;
                this.l=c;
            }
 
            public int Sum(int b, int c) {
                return k+l+c+b;
            }
 
        };
    }
 
	public Main()
	public static void main(String[] args) {
Main test=new Main();
           IInterface test6=test.getInstanceTwo(10, 20);
           System.out.println(test6.Sum(10, 21));
	}
}

En un futuro post trataremos instanciar clases internas en otras clases y clases internas dentro de clases abstractas e interfaces.

codigo de ejemplo

En nuestras aplicaciones a veces necesitamos que al realizar una acción (sea un clic sobre un botón, o al cargar una pagina Web) se ejecute una parte del código de la aplicación de manera transparente. Este primer tutorial de eventos vamos a tratar el tema de Delegados en .net como parte del manejo de eventos.

En .net el manejo de eventos se realiza por medio de la definición de un tipo especial de subclase que se le conoce como delegado. Estas clases pueden contener referencias de uno o más métodos de tal manera que a través del objeto sea posible solicitar ejecución en cadena de todos ellos.

Delegados

Es un tipo especial de subclase (System.MulticastDelegate). Sin embargo, para definir estas clases no se puede utilizar el mecanismo de herencia normal, este tendrá una sintaxis especial. Estas clases especiales contienen métodos y propiedades de otros objetos, y permiten hacer colecciones de estos métodos.

<private/public/protected> delegate <tipoRetorno> <nombreDelegado> (<parámetros>);

Un Ejemplo de esto seria

public delegate int randomNumber(int seed);

Las clases delegadas solo pueden contener métodos que cumplan con los mismos valores de retorno y parámetros que las clases delegadas. Un ejemplo de esto seria:

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
 
namespace PrimerEjemploDelegado
{
    public delegate void sayHello();
    public delegate String  getHelloWorld();
    public delegate void sayHelloMore();
 
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Type t = typeof(Program);
                MethodInfo m = t.GetMethod("sayHelloMethod");
                sayHello sayHello = (sayHello)Delegate.CreateDelegate(typeof(sayHello), m);
                sayHello.Invoke();
 
            }
            catch (Exception ex)
            {
                System.Console.WriteLine(ex.Message);
            }
            finally
            {
                System.Console.ReadKey();
            }
        }
 
        public static void sayHelloMethod()
        {
            System.Console.WriteLine("hola");
        }
        public static String getHello()
        {
            return "hola";
        }
        public static void sayHelloMore(String msj)
        {
            System.Console.WriteLine("hola "+msj);
        }
    }
}

Como vemos si cambiamos esta linea MethodInfo m = t.GetMethod(”sayHelloMethod”); por cualquier de los otros metodos el programa nos lanzara una excepcion ya que los otros metodos reciben parametros diferentes y retornan valores.

Otra forma de realizar una asignacion de un metodo delegado seria algo asi.

using System;
using System.Collections.Generic;
using System.Text;
 
namespace SegundoEjemploDelegado
{
 
    class Program
    {
 
        public delegate int Suma(int a, int b);
        private static Suma suma;
        public static Suma SumaObj
        {
            get
            {
               return suma;
            }
            set
            {
                suma = value;
            }
        }
 
        static void Main(string[] args)
        {
            ObjetoConUnMetodo b = new ObjetoConUnMetodo();
            System.Console.WriteLine(Program.SumaObj(5,10));
            Console.ReadKey();
        }
 
    }
 
    class ObjetoConUnMetodo
    {
        public ObjetoConUnMetodo()
        {
            Program.SumaObj = new Program.Suma(Suma);
        }
        private int Suma(int c, int b)
        {
            return c + b;
        }
    }
}

Como vemos el objeto “ObjectoConUnMetodo” es el encargado de registrar la implementacion de sumar al objecto delegado. Ahora vamos a intentar que el objeto delegado reciba n metodos y los llame sin que este se de cuenta. El codigo seria asi:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace TercerEjemploDelegado
{
    class Program
    {
        public delegate void OperacionesBasicas(int a, int b);
        private static OperacionesBasicas operacion;
 
        public static OperacionesBasicas Operacion
        {
            get
            {
                return operacion;
            }
            set
            {
                operacion = value;
            }
        }
        static void Main(string[] args)
        {
            try
            {
                Implementacion a = new Implementacion();
                Program.Operacion(20,5);
                Console.ReadKey();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
 
    public class Implementacion
    {
        public Implementacion()
        {
            Program.Operacion += new Program.OperacionesBasicas(Suma);
            Program.Operacion += new Program.OperacionesBasicas(Resta);
            Program.Operacion += new Program.OperacionesBasicas(Multiplicacion);
            Program.Operacion += new Program.OperacionesBasicas(Division);
        }
 
        private void Suma(int a, int b)
        {
            System.Console.WriteLine("Yo estoy sumando {0} y {1} y el resultado es {2}", a, b, a + b);
        }
        private void Resta(int a, int b)
        {
            System.Console.WriteLine("Yo estoy restando {0} y {1} y el resultado es {2}", a, b, a - b);
        }
        private void Multiplicacion(int a, int b)
        {
            System.Console.WriteLine("Yo estoy multiplicacion {0} y {1} y el resultado es {2}", a, b, a * b);
        }
        private void Division(int a, int b)
        {
            System.Console.WriteLine("Yo estoy division {0} y {1} y el resultado es {2}", a, b, a / b);
        }
    }
}

Como vemos al usar el operador += podemos indicarle al metodo delegado que va a contener mas metodos y cuando este se le llame nuestro objeto delegado va a llamar a todos los metodos contenidos

]]> http://www.blog.qui-mera.net/?feed=rss2&p=42 http://www.blog.qui-mera.net/?p=50 http://www.blog.qui-mera.net/?p=50#comments Sat, 29 Nov 2008 01:13:11 +0000 admin http://www.blog.qui-mera.net/?p=50 Introduccion

En nuestras aplicaciones a veces ocupamos cambiar los valores de una propiedad desde otra clase, en c++ con el manejo engorroso de punteros se podian hacer marravillas delegando a otras clases o metodos, pero insisto a veces es dificil controlar el manejo de punteros dentro de una clase

En .net el manejo de punteros se considera como codigo inseguro, por lo cual no lo recomiendan, pero para esto definieron  una forma de pasar valores por referencia a los metodos, ya que por defecto los valores se pasan por valor y no por referencia.

Existen dos formas de pasar por referencia como parametro, se utilizan la instruccion out y la instruccion ref de la siguiente manera.

valorderetorno nombreDelMetodo(ref tipo nombreparametro)

o

valorderetorno nombreDelMetodo(out tipo nombreparametro)

como ejemplo seria algo asi

 public void setValue(ref String id)
 {
  .......
 }
 public void setValue(out String id)
 {
  ......
 }

El compilador no va a identificar si es ref o out, este no conoce la diferencia pero para nosotros cuando usemos ref la variable tiene que estar inicializada y out no lo necesita.

un ejemplo de esto seria

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Referencias
{
    class ChangeValues
    {
        public void changeWithRef(ref int b, int c)
        {
            b = c;
        }
 
        public void changeWithOut(out  int b, int c)
        {
            b = c;
        }
 
    }
}

y el metodo main seria algo asi

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Referencias
{
    class Program
    {
        static void Main(string[] args)
        {
            int a=10;
            int b;
            System.Console.WriteLine("El valor de a es {0}", a);
            ChangeValues change = new ChangeValues();
            change.changeWithRef(ref a,15);
            change.changeWithOut(out b, 10);
            System.Console.WriteLine("Ahora el valor de a es {0}",a);
            System.Console.WriteLine("El valor de b es {0}", b);
            Console.ReadKey();
 
        }
    }
}

como vemos cuando la clase va a llamar a los metodos tenemos tambien que indicarle que los parametros van a pasar por referencia, sino el compilador nos mandara la exception.

codigo de ejemplo

A veces necesitamos ejecutar tareas secundarias dentro de una aplicación que no interfieran con las tareas principales, Java da la oportunidad de realizar estas tareas en forma independiente, esto se le conoce como hilos. Nuestra aplicación corre sobre un hilo principal al cual podemos integrarle mas hilos que corren detrás de la aplicación

Cada hilo se programa como si ejecutara solo; como si la CPU fuera una sola. Algún mecanismo del sistema operativo esta dividiendo el tiempo de la CPU para la aplicación, esto que hace la programación de múltiples hilos una tarea mucho mas fácil.

Un proceso son instrucciones al CPU que se ejecuta en su propio espacio. Un sistema operativo multitarea es capas de ejecutar mas de un proceso a la vez, haciendo que parezca que cada uno esta por su cuenta, proporcionando periódicamente ciclos de CPU para cada proceso. Un hilo es un solo flujo de control dentro de un proceso. Un solo proceso puede tener múltiples hilos ejecutándose al mismo tiempo. En resumen un proceso puede contener múltiples hilos

Hay muchos usos posibles para la multitarea, pero en general, se tendrá una parte de un programa colgado por un evento en particular o recurso, y no se quiere colgar el resto del programa a causa de esto. Así es que se crea un hilo asociado con ese evento o recurso y se deja correr independientemente del programa principal. Un buen ejemplo es un botón de “salida” -no se quiere estar forzado a sondear el botón de salida en cada parte de código que se escribe y de la misma forma se quiere que tenga una buena respuesta, como si fuera verificado regularmente. De hecho, uno de las razones convincentes de forma inmediata para la multitarea es producir una interfase de buena respuesta.

Hilos en Java

Existen dos formas de implementar un hilo en java, una de ellas es heredar de java.lang.Thread, al hacer esto debemos sobrescribir el método run(), dentro de este método debemos escribir el código que queremos que se ejecute en “background”

Por ejemplo este seria el código de una clase llamada hilo en el package “Thread”:

package Thread;
 
  public class hiloThread extends Thread
  {
 
    public void run()
    {
        for(int i=0;i<15;i++)
        {
           try
           {
                this.sleep(100);
                System.out.println(”Yo soy “+this.getName());
           }
           catch(InterruptedException e)
           {
                  System.out.println(”el hilo se cayo intentando dormir”);
           }
        }
     }
 
   }

Notaran que se llama a una función llamada sleep(long args0) (hay que mencionar que sleep(long args0) puede causar una excepción InterruptedException ), esta función detiene el hilo, en este caso 100 milisegundos y también llamamos a una función getName() que devuelve obviamente el nombre del hilo.

Ahora este es el código del main para probar nuestro hilo

package principal;
 
import Thread.hilo;
 
  public class main
  {
 
     public static void main(String[] args)
     {
           hiloThread hil=new hiloThread ();
           hiloThread hi2=new hiloThread ();
           hiloThread hi3=new hiloThread ();
           hil.setName(”hilo 1″);
           hi2.setName(”hilo 2″);
           hi3.setName(”hilo 3″);
           hil.start();
           hi2.start();
           hi3.start();
     }
 
  }

Como notamos para iniciar el hilo no debemos llamar al método run que implementamos en nuestra clase sino vamos a llamar a un método start().Como ya he mencionado heredar de Thread convierte a la clase en un hilo, la otra forma que tiene java para implementar hilos es tener una clase con hilos adentro, para esto debemos implementar la interfaz java.lang.Runnable. Ahora intentaremos hacer un ejemplo parecido, este seria el código:

package Thread;
 
public class hiloRunnable implements Runnable
{
   Thread hilo;
   public hiloRunnable(String name)
   {
         hilo=new Thread(hiloRunnable.this);
         hilo.setName(name);
   }
   @Override
   public void run()
   {
     for(int i=0;i<15;i++)
     {
       try
       {
         hilo.sleep(100);
         System.out.println("Yo soy "+hilo.getName());
       }
       catch(InterruptedException e)
       {
          System.out.println("el hilo se cayo intentando dormir");
       }
     }
 
   }
 
   public void start()
   {
      this.hilo.start();
 
   }
 
}

Como vemos hemos construido un objeto de tipo Thread que el constructor recibe como parámetro una clase que implemente java.lang.Runnable, aparte hemos construido un metodo start() que llame al método this.hilo.start(); este seria el codigo del main

package principal;
 
import Thread.hiloRunnable;
 
       public class main
       {
 
           public static void main(String[] args )
           {
            System.out.println("Implementando Runnable");
            hiloRunnable hil =new hiloRunnable("hilo 1");
            hiloRunnable hi2 =new hiloRunnable("hilo 2");
            hiloRunnable hi3 =new hiloRunnable("hilo 3");
            hil.start();
            hi2.start();
            hi3.start();
           }
        }

En un futuro post intentaremos trabajar con varios hilos al mismo tiempo, y resolver varios problemas como concurrencia y sincronización de hilos, aparte de hilos en .Net

codigo de ejemplo

presentacion y ejemplo

el jueves 3 a las 6 de la tarde estare dando una conferencia de aplicaciones distribuidas

programa latin tic latin fest 2008

El problema es que no es nada alejado de la realidad

Uno de los Frameworks que han tenido una gran popularidad entre los desarrolladores y programadores de javascript. JQuery es una “librería JavaScript muy rápida y muy ligera que simplifica el desarrollo de la parte de cliente de las aplicaciones web”. En otras palabras, jQuery incluye muchas utilidades para crear fácilmente las páginas web de las aplicaciones dinámicas complejas.

Este post pretende ser una introducción a los métodos más básicos de jquery, en un futuro se trataran los plugins y/o añadidos a este framework.

Jquery se distribuye en dos versiones, la versión descomprimida un poco pesada y es la mejor opción para desarrollar aplicaciones. La versión comprimida la cual es la opción ideal en el servidor de producción, para minimizar el tiempo de carga de la aplicación.

Caracteristicas

* DOM interactividad y modificaciones, (incluyendo soporte para CSS 1-3 y un Plugin Básico de XPath)
* Manejo de Eventos
* Efectos y Animaciones
* Ajax y JSon
* Extensibilidad (es extendible por medio plugins)
* Plugins Javascript

Instalacion

Simplemente incluiremos esta etiqueta dentro del head de nuestro documento html

<script type=”text/javascript” src=”jquery.js”></script>

El corazon de Jquery

El corazon de jquery es la funcion $, la funcion recibe como parametro un string y devuelve un objeto sea un array objetos html o un objecto html segun el query que se envie por parametro, la forma de utilizarlo es de la siguiente manera.

$(elemento).evento_o_metodo(funcion-o-parametro);

Selectores Simples

La forma de elegir los elementos DOM de una pagina jquery propone usar la funcion $ de la
siguiente manera

$(elemento) para propias html
$(#elemento) para identificadores, (id=””) de etiquetas html
$(.elemento) para atributos(class) CSS.

Selectores avanzados

Jquery permite no solo seleccionar un solo elemento o un conjunto de elementos con una misma
caracteristica ademas incluye la seleccion de varios elementos con diferentes atributos de
de la siguiente manera

$(”div,span,p.myClass”)

como ven la sintaxis para realizar esta seleccion es incluir comas entre los elementos
Efectos

Jquery incluye diferentes efectos que se detallaran

Show (Mostrar)
Modifica los atributos alto, ancho y transparencia partiendo de 0.

$(objeto).show(”velocidad”)
Velocidad: Determina el tiempo en el que se realizará el efecto. Puede ser “slow” (lento), “normal”, o “fast” (rápido).

$(objeto).hide(”velocidad”)
Modifica los atributos alto, ancho y transparencia, partiendo de los valores actuales hasta llegar a 0.

$(objeto).slideDown(”velocidad”)
Modifica los atributos alto y transparencia, partiendo de 0. Es similar a “show”, salvo que no modifica el ancho, creando un efecto de “cortinilla”.

$(objeto).slideUp(”velocidad”)
Modifica los atributos alto y transparencia, partiendo de los actuales, hasta llegar a 0. Es similar a “show”, salvo que no modifica el ancho, creando un efecto de “cortinilla”.

$(objeto).fadeIn(”velocidad”)
Modifica el atributo transparencia desde 0.

$(objeto).fadeOut(”velocidad”)
Modifica el atributo transparencia desde el valor actual, hasta llegar a 0.

$(objeto).center(”velocidad”);
Centra un elemento con respecto a su “parent”.

$(objeto).fadeTo(”velocidad”, transparencia)
Modifica el atributo transparencia a un valor especifico.

$(objeto).animate(”propiedades”,”velocidad”);
Velocidad: Determina el tiempo en el que se realizará el efecto. Puede ser “slow” (lento), “normal”, o “fast” (rápido).
Transparencia: Un numero de 0 a 100 que indica que tan visible es el elemento.

$(objeto).animate({width:20,height:200}, “slow”)
Velocidad: Determina el tiempo en el que se realizará el efecto. Puede ser “slow” (lento), “normal”, o “fast” (rápido).
Propiedades: Una o más propiedades con valor numérico en CSS, por ejemplo width y height.

tomado de http://www.cristalab.com/tutoriales/214/tutorial-de-jquery.html

Eventos

Jquery permite un manejo facil de eventos como por ejemplo el evento que muchos conoceran (window.onload = funcion) se hara de la siguiente manera

$(document).ready(function(){

});

Como vemos para controlar un evento en jquery usamos la siguiente sintaxis

$(”selector”).nombredelevento(funcion)

los eventos en jquery mas comunes son los siguietes:

blur( )

blur( fn )

change( )

change( fn ).

click( )

click( fn )

dblclick( )

dblclick( fn )

error( )

error( fn )

focus( )

keydown( )

keydown( fn )

keypress( )

keypress( fn )

keyup( )

keyup( fn )

load( fn )

mousedown( fn )

mousemove( fn )

mouseout( fn )

mouseover( fn )

resize( fn )

scroll( fn )

select( )

submit( )

submit( fn )

unload( fn )

Links de interes y bibliografia

http://docs.jquery.com/Main_Page

http://visualjquery.com/

http://www.cristalab.com/tutoriales/214/tutorial-de-jquery.html

http://es.wikipedia.org/wiki/JQuery

http://www.javascriptya.com.ar/jquery/

Bueno nuevamente me e sentado a intentar hacer un blog… en intentos anteriores no he podido formalizar un blog……

asi q en este intento de blog intentaremos cubrir diferentes tegnologias tanto de java a .net pasando por otras de mi interes