What should a Java Developer know?

 

There are seven things a Java developer should know. And these are:

1. Who a Java Developer?
2. What is our main work tool?
3. Documentation... Is it important or not?
4. Certifications... How much do they matter?
5. Frameworks... Are they really useful?
6. Other languages...what with them?
7. Always stay updated.

A Java Developer is an:

• Passionate about problem solving.
• Who likes to find anything to investigate. To know how it works.
• Who, neurotically, loves to complicate his life to improve the lives of others.
• In another case, those who like to get money. Java is one of the most used languages in the world. This is the reason why Java programmers are so in demand.

What is our main work tool?

It's our brain. How we think. That's why you should feed it with good things. Read books. Write. Think about how you can improve your world, your environment and your life. Use your words carefully. How you treat others, they will treat you. The computer and programming languages are a medium, not our main tools. This helps us create things that are in our minds. If it contains garbage, you will create garbage.

Documentation... Is it important or not?

In short, it is important. Why it is important? Because the documentation tells us what and how of things. Imagine, we have a problem with some requirement and we don't know what or how to do it. Then the documentation helps us know what and how we can solve it. In a time where there was no internet, the only help was official documentation. If you didn't read, you were lost.

Certifications... How much do they matter?

"He who talks too much falls very hard". Those who have many diplomas, titles or certificates are not always the ones who know the most. Experience is more important than a sheet of paper.

It's like school. If you complete your assignments and get a 10 on your grades, it's because you are dedicated. But that doesn't mean you're better than everyone else. Sometimes experience kills any certificate.

Frameworks... Are they really useful?

Yes. They are really useful. Whether we want it or not. Creating an application the old-fashioned way was not easy. A "hello world" could take us more time than necessary.

Other languages...what with them?

I mean other languages, not programming languages. Speaking in other languages is always important. At least if you want to be a programmer or work in something related to technology.

You will often have to talk to other people in a language other than your own. Seriously, you have to talk to other people whether you want to or not.

You will have to talk, either with the boss or with the users.

Always stay updated.

It is not necessary to talk about it. If you sleep, another one will climb the tree. Whoever believes themselves to be better than others will have the opportunity to prove it. Today's knowledge may be a thing of the past. There is always something new to learn.

Docker, Kubernetes and Cloud Native are things you will have to learn and when you think you know it all, other things will come along that will make you obsolete and you will have to learn again.

To end. You will have to learn new things, always.

50 Questions you need to answer before a Java Interview

Edgar Regalado nos comparte en su blog una serie de 50 preguntas y respuestas sobre Java. Preguntas como: ¿Qué es una clase?, ¿Qué es un objeto? y ¿Cuál es la diferencia entre estos dos?

Como él mismo dice, su mayor énfasis es poder compartir esta teoría, ya que muchas veces solo nos enfocamos en la parte práctica sin pensar que la teoría siempre es un complemento.

The reason for this was mainly due to my lack of theoretical knowledge. I was focusing too much on the practical side and forgot about the underlying theory. Therefore, in this article, I'll be sharing with you 50 real questions that I have been asked during interviews. Each question comes with an answer and some of them also have references to read more on the topic. Let's nail that job!

Desde preguntas básicas hasta otras más complejas. El cuestionario, dividido en dos partes, es bastante útil para desarrolladores principiantes como desarrolladores con experiencia.

Enlaces:

https://supernovaic.blogspot.com/2019/02/50-questions-you-need-to-answer-before.html
https://supernovaic.blogspot.com/2019/02/50-questions-you-need-to-answer-before_11.html

Arreglos, listas, funciones y clases en Kotlin

En casi cualquier lenguaje de programación debemos trabajar con estructuras de datos como listas, arreglos, mapas, etc. Kotlin no se queda atrás y nos permite definir estas estructuras con algunas peculiaridades.
Si queremos definir un array (no olvidar que debemos poner de qué tipo) :

var arreglo: Array<Double> = arrayOf<Double>(10.7,20.55,31.90,49.99,53.33,66.666,70.70);

Si queremos definir una lista, por ejemplo de un tipo específico (un tipo Clase) podríamos definir primero la clase:

data class Circulo(val radio:Double)

¿Sólo eso? Sí, sólo eso. Kotlin nos ahorra mucho trabajo.

Ahora definamos una lista de tipo Circulo:

val listaCirculo: List<Circulo> =listOf(Circulo(34.55), Circulo(7.8),Circulo(12.00));

 ¿Cómo los recorremos?

//for en arreglo
     for(arr:Double in arreglo){
       println("Hola ${arr}");
     }
println();
     //for en lista Circulo
     for(circulo:Circulo in listaCirculo){
       println(circulo);
       println("Radio = ${circulo.radio}")
     }

¿Y qué pasa con las funciones?
Aquí unos ejemplos:

//Una función sin parámetros de entrada y salida
fun nombreFuncion(){
  println("Hola, desde Kotlin!!!");

}

nombreFuncion();

//Una función con parámetros de entrada:
fun getValor(numero:Int): Int{
  return numero*2;
}

var valor = getValor(2);
println("Valor: ${valor}");

//Una función de tipo Boolean
fun String.esMayorACinco():Boolean{
    return this.length > 5;
}
 println("CINCO".esMayorACinco());//false

Post anterior: http://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html


Links:
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a

Programando en Java ... no. 6

Más ejemplos de programas en Java

1. Ejemplo de uso de clases Externas e Internas. Creamos un archivo llamado Persona.java

public class Persona{
  private String nombre;
  private int edad;
  private String apellidoPaterno;
  private String apellidoMaterno;

  public Persona(){}

  public Persona(String nombre,String apellidoPaterno,String apellidoMaterno,int edad){
    this.nombre=nombre;
    this.edad=edad;
    this.apellidoPaterno=apellidoPaterno;
    this.apellidoMaterno=apellidoMaterno;
  }

}

Definimos dos constructores, uno de ellos con parámetros. Ahora escribimos su getters y setters,  y el método toString() para mostrar los datos.

public class Persona{
  private String nombre;
  private int edad;
  private String apellidoPaterno;
  private String apellidoMaterno;

  public Persona(){}

  public Persona(String nombre,String apellidoPaterno,String apellidoMaterno,int edad){
    this.nombre=nombre;
    this.edad=edad;
    this.apellidoPaterno=apellidoPaterno;
    this.apellidoMaterno=apellidoMaterno;
  }

  public void setNombre(String nombre){
    this.nombre=nombre;
  }

  public void setEdad(int edad){
    this.edad=edad;
  }

  public void setApellidoPaterno(String apellidoPaterno){
    this.apellidoPaterno=apellidoPaterno;
  }

  public void setApellidoMaterno(String apellidoMaterno){
    this.apellidoMaterno=apellidoMaterno;
  }

  public String getNombre(){
    return nombre;
  }

  public int getEdad(){
    return edad;
  }

  public String getApellidoPaterno(){
    return apellidoPaterno;
  }

  public String getApellidoMaterno(){
    return apellidoMaterno;
  }

  public String toString(){
    return "nombre: "+nombre+"\napellido paterno: "+apellidoPaterno+"\napellido materno: "+apellidoMaterno+"\nedad: "+edad;
  }

}//fin clase Persona

Una vez hecho esto dentro de la clase Persona vamos a crear una "clase interna" llamada Alumno:

//clase Interna

  class Alumno extends Persona{

    private String ID;

    public Alumno(){}

    public Alumno(String ID){

      this.ID=ID;

    }

    public Alumno(String nombre,String apellidoPaterno,String apellidoMaterno,int edad,String ID){

      super(nombre,apellidoPaterno,apellidoMaterno,edad);

      this.ID=ID;

    }

    public void setID(String ID){

      this.ID=ID;

    }

    public String getID(){

      return ID;

    }

    @Override

    public String toString(){

      return super.toString()+"\nid: "+ID;

    }

  }//fin clase Alumno

Finalmente creamos una clase llamada TestPersona.java:

public class  TestPersona{

   public static void main(String[] args){

     System.out.println(new Persona("Andrea","Calamaro","Nava",31));

//nos imprime sus datos

//para hacer uso de la clase interna  "Alumno" hacemos esto:

    Persona persona=new Persona();

    Persona.Alumno andrea=persona.new Alumno("Andrea","Calamaro","Nava",31,"12-D2209");

    System.out.println("id: "+andrea.getID());

    System.out.println("\n"+andrea.toString());

}

}

Código Completo:

http://www.pasteall.org/46651/java

Programando en Java ... no. 5

"Mientras tanto el programador trata de entender el mundo a través de código, olvidando que puede hacerlo con un simple vistazo"

1. Creando nuestras propias excepciones, creamos una clase llamada "MyNumberException" que extiende de la clase Exception, si el número es mayor a 500 o menor a 0 ocurrirá la excepción

public class Codemonkey{
   
     static void setValor(int x)throws MyNumberException{
         if(x>500 || x<0)
             throw new MyNumberException("debes introducir un valor menor a 500 y mayor a 0");
          // se ejecutará si el número es mayor a 500 o menor a 0
     }
    public static void main(String[] args)throws MyNumberException{
        System.out.println("    c0D3m0Nk3Y    ");
       try{
            setValor(501);
        }catch(MyNumberException me){
           System.err.println("Ha ocurrido un error: "+me.getMessage());//mostramos el mensaje
        }finally{
             System.out.println("finally: esto siempre se ejecutara");
        }
        System.out.println("esto esta fuera del try-catch-finally");
    }  
}

class MyNumberException  extends Exception{
    public  MyNumberException(String message){
         super(message);
    }
}
Para ejecutar es necesario habilitar las "assertions" en java con "-ea":
javac -g Codemokey.java
java -ea Codemonkey

2. En este ejemplo se usa la clase HashSet para insertar un valor de tipo "Persona", si el valor es un duplicado no se podrá insertar.

import java.util.HashSet;
import java.util.Objects;


public class Codemonkey {
    public static void main(String[] args){
     HashSet persons=new HashSet();
     persons.add(new Persona("Laura",31));
     persons.add(new Persona("Hortencia",21));
     persons.add(new Persona("Laura",31));//duplicado
     persons.ass(new Persona("Hortencia",39)); //este valor si se agrega
   
     for(Object p: persons){
         Persona per=(Persona)p;
      System.out.println(per.getNombre()+"  - "+per.getEdad());
     }
   
     System.out.println(persons.toString());
   
    }
}

//aquí creamos la clase Persona
class Persona{
    private String nombre;
    private int edad;

    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }

    public String getNombre() {
        return nombre;
    }

    public int getEdad() {
        return edad;
    }
   
    @Override
    public String toString(){
        return "nombre: "+nombre+"  edad: " +edad;
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 79 * hash + this.edad;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Persona other = (Persona) obj;
        if (!Objects.equals(this.nombre, other.nombre)) {
            return false;
        }
        if (this.edad != other.edad) {
            return false;
        }
        return true;
    }
}

3. Ejecutando un hilo en java swing
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;



public class Codemonkey{
    public static void main(String[] args) {
        SwingUtilities.invokeLater( new Runnable() {
            @Override
            public void run() {
                new Ventana();
            }
        });
    }
}

class Ventana extends JFrame{
    private JPanel panel;
    private JButton btnSalir,btnActiva;

    Ventana(){
        setTitle("Iniciando hilos");
        setSize(450,300);
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        add(getGUI());
    }

    public JPanel getGUI(){
        panel=new JPanel();
        panel.setVisible(true);
        panel.setSize(700,400);
        panel.setBackground(Color.black);
        panel.add(new JLabel("<html><h1><font color='white'>Ejecutando un hilo</font></h1></html>"));
        panel.add(getBtnActiva());
        panel.add(getBtnSalir());
        return panel;
    }


    public JButton getBtnActiva(){
        btnActiva=new JButton("<html><font color='white'>Iniciar hilo</font></html>",new ImageIcon("mono.jpg"));
        btnActiva.setToolTipText("quitar ventana ...");
        btnActiva.setBackground(Color.blue);
        btnActiva.addActionListener(new ActionListener(){
               public void actionPerformed(ActionEvent e){
                   
                    new Thread(new Runnable(){
                        public void run(){
                            int cont=0;
                            System.out.println("Inicia hilo");
                            while(cont<4){
                            try{
                                Thread.sleep(1000);
                               System.out.println("Hola no. "+(cont+1));
                            cont++;
                        }catch(InterruptedException ex){
                            System.err.println(ex.toString());
                        }
                        System.out.println("Termina hilo");

                           }
                        }
                    }).start();


           }
       });

        return btnActiva;
    }

    public JButton getBtnSalir(){
        btnSalir=new JButton("<html><font color='white'>Salir</font></html>",new ImageIcon("mono.jpg"));
        btnSalir.setToolTipText("quitar ventana ...");
        btnSalir.setBackground(Color.red);
        btnSalir.addActionListener(new ActionListener(){
               public void actionPerformed(ActionEvent e){
                    System.exit(0);
           }
       });

        return btnSalir;
    }
}

JSNI… JavaScript Native Interface (GWT)

JSNI es el mecanismo por el cual es posible invocar código javascript nativo (entre los comentarios /*-  -*/) desde código java.

Ejemplo  1. Ventana javascript dentro de código java (gwt).  

public static native void msg(String cad)/*-{

   $wnd.alert(‘Tu dices:  ’+cad);

}-*/;

Es necesario usar la palabra native y colocar las llaves dentro de comentarios para que el compilador java no lo considere un error.

//invoco el código javascript  dentro del código java

public void onModuleLoad(){

msg(“Es un buen día”);

}

Ejemplo 2. Manejar los mensajes tipo consola (firebug):

//defino los métodos  “logs”

public static native void info(Object obj)/*-{

   console.log(obj);

}-*/;

public static native void debug(Object obj)/*-{

   console.debug(obj);

}-*/;

public static native void warning(Object obj)/*-{

   console.warn(obj);

}-*/;

public static native void error(Object obj)/*-{

   console.error(obj);

}-*/;

Ahora invocarlos en código java

public void onModuleLoad(){

info(“iniciando aplicación web…”);

try{

debug(“se ha creado el objeto satisfactoriamente”);

warning(“esperando un error”);

}catch(Exception ex){

error(“error encontrado:  ”+ex+” causa: ”+ex.getCause());

}

}

Para poder ver los mensajes es necesario activar firebug dentro de firefox o chrome. Esto puede ser una buena práctica de testing.

Ejemplo 3. Contenido html

public static native void contenido()/*-{

document.write(“<h1>GWT ejemplos</h1>”);

}-*/;

//invocar el método

public void onModuleLoad(){

       contenido();

      RootPanel.get().add(new  Acceso.getVista());

}

 http://code.google.com/intl/es-419/webtoolkit/doc/latest/DevGuideCodingBasicsJSNI.html

Control de versiones… cuidado con el commit !!

Al iniciar un proyecto  en equipo  es importante  tener un control de quien realiza algún cambio, por qué lo hizo, la fecha y saber de qué trata.

Es común que siempre exista algún problema, al hacer una descarga del proyecto, un cambio (sin aviso), borrar archivos por “error”,  moverlos,  o peor enviar cambios que afectan todo el proyecto.  

Aunque por lo regular existen formas de evitar o revertir los cambios cuesta mucho trabajo y tiempo.  Un equipo de 3 o 4 personas no puede ser causar grandes problemas (en teoría), pero si el equipo lo integran más de 10 (o muchos más) entonces habrá un caos.

Para resolver estos problemas surgen las herramientas de control de versiones.

Algunos comandos comunes:

1.       Import: incorporar proyecto

2.       Checkout: descargar copia

3.       Update: descargar última versión

4.       Add, delete, copy, move: añadir, borrar, copiar o mover archivos

5.       Status, diff: ver el estado del proyecto

6.       Commit: enviar cambios

7.       Revert: revertir cambios

8.       Branch: crear líneas separadas del proyecto

9.       Merge: unir distintas líneas

10.   Export: distribuir una versión del proyecto

Software de control de versiones más popular:

1.       Git   http://git-scm.com/ 

2.       Subversion  http://subversion.tigris.org/

3.       Mercurial  http://mercurial.selenic.com/downloads/

Scala IDE

Scala IDE

Ahora que tuve un poco de tiempo de probar varios lenguajes como: Scala, Ceylon, Clojure, etc. encontré este sitio Scala IDE http://scala-ide.org/

Se trata de un IDE (plugin) para crear programas en Scala desde Eclipse.

En Eclipse basta poner este link:

http://download.scala-ide.org/releases-29/stable/site

Y la verdad no pude evitarlo, quise probarlo con un código que hice en Groovy haber como quedaba:

object Horoscopo{

   def main(args: Array[String]){

      var resto=0;

      val anyos=List(1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012);

      var horos=""

      println("[Horoscopo chino en Scala]");

        for(val i <- anyos){

           resto=i%12

          

           if(resto==0){

              horos="mono"

            }

           if(resto==1){

              horos="gallo"

           }

          

           if(resto==2){

              horos="perro"

            }

           if(resto==3){

              horos="cerdo"

           }

           if(resto==4){

              horos="rata"

            }

           if(resto==5){

              horos="buey"

           }

          

           if(resto==6){

              horos="tigre"

            }

           if(resto==7){

              horos="conejo"

           }

           if(resto==8){

              horos="dragon"

           }

           if(resto==9){

              horos="serpiente"

            }

           if(resto==10){

              horos="caballo"

           }

          

           if(resto==11){

              horos="cabra"

            }

          

           println("si naciste en: "+i+" te corresponde el anyo del: "+horos)

          

         }

        

    }

}



Semejanzas con Groovy Python 

Horoscopo.groovy

def anyos=[1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012]
def resto=0
def horos=""
println "\t[Horoscopo chino en Groovy]\n"
for (int e:anyos){
  resto=e%12
  switch(resto){
  case 0:
                horos="mono"
                break
                case 1:
                horos="gallo"
                break
                case 2:
                horos="perro"
                break
                case 3:
                horos="cerdo"
                break
                case 4:
                horos="rata"
                break
                case 5:
                horos="buey"
                break
                case 6:
                horos="tigre"
                break
                case 7:
                horos="conejo"
                break
                case 8:
                horos="dragon"
                break
                case 9:
                horos="serpiente"
                break
                case 10:
                horos="caballo"
                break
                case 11:
                horos="cabra"
                break
  }



  println "Si nacistes en $e  te corresponde el signo: $horos "
}



Horoscopo.py

resto,i=0,0
horos=""
print "\t[Horoscopo chino en Python]\n"
for i in range(len(anyos)):
    resto=anyos[i]%12

    if resto==0:
        horos="mono"

    if resto==1:
        horos="gallo"

    if resto==2:
        horos="perro"

    if resto==3:
        horos="cerdo"

    if resto==4:
        horos="rata"

    if resto==5:
        horos="buey"


    if resto==6:
        horos="tigre"

    if resto==7:
        horos="conejo"

    if resto==8:
        horos="dragon"

    if resto==9:
        horos="serpiente"

    if resto==10:
        horos="caballo"

    if resto==11:
        horos="cabra"

    print "Si naciste en",anyos[i]," te corresponde el signo: ",horos

Frameworks… Spring Framework

Es un framework para desarrollo en Java. Su misión es  hacer de la programación Java algo más sencillo de realizar. Es un "contenedor de objetos" (beans) como alternativa a EJB; normalmente usa archivos xml para definir los beans.

Tipos de inyección de dependencias:

1. en las propiedades usando set
2. o directamente usando un constructor
3. en interfaces (no usado)

Además nos permite integrar otras tecnologías (GWT, Hibernate,JSF, etc.). Permite el testeo de las clases (pruebas unitarias, TDD,etc.) y otras cosas más.

1. Este es un ejercicio sencillo: el famoso Hola mundo !!


ServicioHola.java
package org.springpruebas.prueba01;

/**
 *
 * @author yo
 */
public interface ServicioHola {
   public abstract void decirHola();
}

ServicioHolaImpl.java

package org.springpruebas.prueba01;

/**

 *

 * @author yo

 */

public class ServicioHolaImpl implements ServicioHola {

  private String greeting;

  public  ServicioHolaImpl  () {}

  

  public  ServicioHolaImpl  (String saludo) {

    this.saludo = saludo;

  }

  public void decirHola() {

    System.out.println(saludo);

  }

  public void setSaludo(String saludo) {

    this.saludo = saludo;

  }

}

context.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

    "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

  <!-- para el ejemplo de HolaApp.java -->

  <bean id="holaServicio"

      class="org.springpruebas.prueba01.ServicioHolaImpl">

    <property name="saludo">

      <value>Hola mundo!!</value>

    </property>

  </bean>

  <!-- para el ejemplo de HolaApp.java -->

</beans>

HolaApp.java

package org.springpruebas.prueba01;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

 *

 * @author yo

 */

public class HolaApp {

   public static void main(String[] args) throws Exception {

 ApplicationContext  application= new ClassPathXmlApplicationContext("context.xml");

 ServicioHola holaServicio =(ServicioHola) application.getBean("holaServicio");

    holaServicio.decirHola();

  }

}

Salida (en Netbeans):

Hola mundo!!
BUILD SUCCESSFUL (total time: 0 seconds)

http://www.springsource.org/

Frameworks… Google Web Toolkit

Google Web Toolkit

Es un framework que permite crear aplicaciones web similares a aplicaciones de escritorio; posee componentes (controles) muy parecidos a los que tiene Java Swing:

1.       TextBox

2.       ListBox

3.        Image

4.       Tree

5.        Grid

6.       Window

7.        Etc. 

GWT compila el código Java y lo traduce a Javascript y HTML (algo parecido a lo que hace la librería dwr.jar).  

GWT y los IDEs

Creo la mejor forma de usar este framework es con  ayuda de un IDE como NetBeans  y/o Eclipse,  existen plugins para ambos y según yo no son difíciles de configurar.

¿Qué necesito para empezar con GWT?

1.       El SDK GWT

2.       El plugin (para NetBeans o Eclipse)

3.       Librerías gwtext, mejora muchos de los controles de gwt

Ejemplo 1. Un botón que activa una ventana “alert”.

package org.gwtprueba.client;

import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.user.client.Window;

import com.gwtext.client.core.EventObject;

import com.gwtext.client.widgets.Button;

import com.gwtext.client.widgets.event.ButtonListenerAdapter;

/**

 * @author yo

 */

public class testGWTEntryPoint implements EntryPoint {

public void onModuleLoad() {

        Button btnActiva=new Button();

        btnActiva.setText("Activar mensaje");

        btnActiva.addListener(new ButtonListenerAdapter(){

        @Override

         public void onClick(Button btn, EventObject ev){

           Window.alert("Bienvenido usuario");

         }

        });

        RootPanel.get().add(btnActiva);

    }

}

Ejemplo 2. Crear un ejmeplo básico de GWT RPC

Automáticamente se generan  4 archivos java: GWTService.java, GWTServiceAsync.java, GWTServiceImpl.java y GWTServiceUsageExample.java (este es el archivo principal).

GWTService.java

package org.prueba.client;

import com.google.gwt.user.client.rpc.RemoteService;

public interface GWTService extends RemoteService{

    public String myMethod(String s,Integer e);

}

GWTServiceAsync.java

package org.prueba.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

public interface GWTServiceAsync {

    public void myMethod(String s,int e, AsyncCallback callback);

}

GWTServiceImpl.java

package org.prueba.server;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

import org.redalyc.client.GWTService;

public class GWTServiceImpl extends RemoteServiceServlet implements

        GWTService {

   

    public String myMethod(String s,int e) {

        // Do something interesting with 's' here on the server.

        return "Hola: " + s+"   tienes  "+e+"   años";

    }

}

GWTServiceUsageExample.java

package org.prueba.client;

import com.google.gwt.core.client.GWT;

import com.google.gwt.user.client.rpc.AsyncCallback;

import com.google.gwt.user.client.rpc.ServiceDefTarget;

import com.google.gwt.user.client.ui.Button;

import com.google.gwt.user.client.ui.ClickListener;

import com.google.gwt.user.client.ui.Label;

import com.google.gwt.user.client.ui.TextBox;

import com.google.gwt.user.client.ui.VerticalPanel;

import com.google.gwt.user.client.ui.Widget;

public class GWTServiceUsageExample extends VerticalPanel {

    private Label lblServerReply = new Label();

    private TextBox txtNombre= new TextBox();

private TextBox  txtEdad = new TextBox();

    private Button btnSend = new Button("Enviar al servidor");

   

    public GWTServiceUsageExample() {

        add(new Label("Introduce tu nombre: "));

        add(txtNombre);

        add(new Label("Introduce tu edad: "));

        add(txtEdad);

        add(btnSend);

        add(lblServerReply);

       

        // Create an asynchronous callback to handle the result.

        final AsyncCallback callback = new AsyncCallback() {

            public void onSuccess(Object result) {

                lblServerReply.setText((String)result);

            }

           

            public void onFailure(Throwable caught) {

                lblServerReply.setText("Communicación fallida");

            }

        };

       

        // Listen for the button clicks

        btnSend.addClickListener(new ClickListener(){

            public void onClick(Widget w) {

                // Make remote call. Control flow will continue immediately and later

                // 'callback' will be invoked when the RPC completes.

                getService().myMethod(txtNombre.getText(),Integer.parseInt(txtEdad.getText()), callback);

            }

        });

    }

   

    public static GWTServiceAsync getService(){

        // Create the client proxy. Note that although you are creating the

        // service interface proper, you cast the result to the asynchronous

        // version of

        // the interface. The cast is always safe because the generated proxy

        // implements the asynchronous interface automatically.

        GWTServiceAsync service = (GWTServiceAsync) GWT.create(GWTService.class);

        // Specify the URL at which our service implementation is running.

        // Note that the target URL must reside on the same domain and port from

        // which the host page was served.

        //

        ServiceDefTarget endpoint = (ServiceDefTarget) service;

        String moduleRelativeURL = GWT.getModuleBaseURL() + "gwtservice";

        endpoint.setServiceEntryPoint(moduleRelativeURL);

        return service;

    }

}

Ahora falta crear la clase que lo muestre

package org.prueba.client;

import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.user.client.ui.RootPanel;

public class Prog01  implements EntryPoint {

    public void onModuleLoad() {

        RootPanel.get().add(new GWTServiceUsageExample());

    }

}

36 Guías GWT
http://pathfindersoftware.com/2007/07/36-gwt-tutorial/

Página oficial, plugin para Eclipse

http://code.google.com/intl/es-419/webtoolkit/download.html

Plugin para NetBeans

http://plugins.netbeans.org/plugin/716/gwt4nb

http://java.net/projects/gwt4nb/pages/Home

http://java.net/projects/gwt4nb/downloads

Blog oficial GWT

http://googlewebtoolkit.blogspot.com/

SmartGWT

http://code.google.com/p/smartgwt/

Demo GWT ext

http://www.gwt-ext.com/demo

Manual  GWT

http://google-web-toolkit.googlecode.com/svn/javadoc/1.6/com/google/gwt/user/client/ui/

http://google-web-toolkit.googlecode.com/svn/javadoc/1.6/com/google/

Manual GWT ext

http://gwt-ext.com/docs/2.0.4/com/gwtext/

http://www.java2s.com/Code/Java/GWT/CatalogGWT.htm

Libros

http://stackoverflow.com/questions/194812/list-of-freely-available-programming-books

http://blog-erone.blogspot.com/2009/07/montar-gwt-ext-en-netbeans.html

Blogs sobre GWT
http://desarrollo-web-gwt.blogspot.com/

http://unpocodejava.wordpress.com/2012/01/12/un-poco-de-gwt/
http://www.ajaxline.com/20-best-gwt-tutorials-and-articles

Wiki
http://wikis.uca.es/wikiii/index.php/Google_Web_Toolkit_(GWT)

Programando en Java... errores comunes

1. The Maven Integration requires that Eclipse be running in a JDK.

Muchas veces el al instalar el plugin de Maven para Eclipse sale una ventana con este mensaje y es bastante molesto.  Parece que Maven no reconoce la ruta del JDK y tendremos que agregarla manualmente.

Solución:

1. Abrir el archivo eclipse.ini
2. Agregar la siguiente línea (aqui pongo el ejemplo para Windows): 

-vm

C:\Java\jdk1.7.0\bin\javaw.exe

Listo, problema resuelto (curioso solo en Windows me ha pasado esto).

2. Error al colocar la ruta de instalación del jdk

Al instalar Java nos pide una ruta, la ruta adecuada para la instalación en Windows es en C:\
Ejemplo
JAVA_HOME, el nombre de la variable
C:\Java\jdkxx , que será el valor

Ahora agregarla al path del sistema %JAVA_HOME%\bin

Listo solo falta ir a la consola de comandos (MS-DOS) y teclear java -version y comprobar que funciona correctamente.

3. Tratar de compilar/ejecutar una clase sin el main

public class Datos{
  private int no_cta;
  private double saldo;


  public Datos(int no_cta,double saldo){
   this.no_cta=no_cta;
   this.saldo=saldo;
  }


 public int getSaldo(){return this.saldo;}
 public int getNo-cat(){return this.no_cta;}


}


Compilar:
javac -g Datos.java

Correcto no parece haber algún error, pero si se trata de ejecutar con: java Datos la línea de comandos tira un error, es porque no encuentra la función  main.

4. Crear un objeto  null 

Muchas veces creamos un objeto y se nos olvida instanciarlo, ejemplo:

private ClaseSecundaria objetoSecundario;


objetoSecundario.setNombre(txtNombre.getText());

Cuando lo correcto sería:

private ClaseSecundaria objetoSecundario;


//aqui coloco la instancia
objetoSecundario= new ClaseSecundaria();
objetoSecundario.setNombre(txtNombre.getText());