Programación java

1. Lo básico: versión de JVM, modo de ejecución y tamaño de heap de Java 

2. Tuning del recolector de basura: hilos de ejecución

3. Tuning del recolector de basura: incrementando la generación joven

Clase Punto:

package clonico;

public class Punto implements Cloneable{
    private int x;
    private int y;
   public Punto(int x, int y) {
        this.x = x;
     this.y = y;
    }
    public Punto() {
        x=0;
        y=0;
    }
    public Object clone(){
        Object obj=null;
        try{
            obj=super.clone();
        }catch(CloneNotSupportedException ex){
            System.out.println(" no se puede duplicar");
        }
        return obj;
    }
    public void trasladar(int dx, int dy){
        x+=dx;
        y+=dy;
    }
    public String toString(){
        String texto="origen: ("+x+", "+y+")";
        return texto;
    }
}

package clonico;

public class Rectangulo implements Cloneable{
    private int ancho ;
    private int alto ;
    private Punto origen;

    public Rectangulo() {
     origen = new Punto(0, 0);
     ancho=0;
     alto=0;
    }
    public Rectangulo(Punto p) {
     this(p, 0, 0);
    }
    public Rectangulo(int w, int h) {
     this(new Punto(0, 0), w, h);
    }
    public Rectangulo(Punto p, int w, int h) {
     origen = p;
     ancho = w;
     alto = h;
    }
    public Object clone(){
        Rectangulo obj=null;
        try{
            obj=(Rectangulo)super.clone();
        }catch(CloneNotSupportedException ex){
            System.out.println(" no se puede duplicar");
        }
        obj.origen=(Punto)obj.origen.clone();
        return obj;
    }
    public void mover(int dx, int dy) {
     origen.trasladar(dx, dy);
    }
    public int area() {
     return ancho * alto;
    }
    public String toString(){
        String texto=origen+" ancho: "+ancho+" alto: "+alto;
        return texto;
    }
}

package clonico;

public class ClonicoApp {
    public static void main(String[] args) {
        Punto punto=new Punto(20, 30);
        Punto pCopia=(Punto)punto.clone();
        System.out.println("punto "+ punto);
        System.out.println("copia "+ pCopia);

        Rectangulo rect=new Rectangulo(new Punto(0, 0), 4, 5);
        Rectangulo rCopia=(Rectangulo)rect.clone();
        System.out.println("rectángulo "+ rect);
        System.out.println("copia "+ rCopia);

        try  {
//espera la pulsación de una tecla y luego RETORNO
            System.in.read();
        }catch (Exception e) {  }
    }
}

1. JavaMailutilizando TLS

package com.mkyong.common;
 
import java.util.Properties;
 
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
 public class SendMailTLS {
 
 public static void main(String[] args) {
   final String username = "user@gmail.com";
  final String password = "pass";
   Properties props = new Properties();
  props.put("mail.smtp.auth", "true");
  props.put("mail.smtp.starttls.enable", "true");
  props.put("mail.smtp.host", "smtp.gmail.com");
  props.put("mail.smtp.port", "587");
   Session session = Session.getInstance(props,
    new javax.mail.Authenticator() {
  protected PasswordAuthentication getPasswordAuthentication() {
   return new PasswordAuthentication(username, password);
   }
    });
   try {
   Message message = new MimeMessage(session);
  message.setFrom(new InternetAddress("from@gmail.com"));
  message.setRecipients(Message.RecipientType.TO,
    InternetAddress.parse("to@gmail.com"));
  message.setSubject("Subject");
  message.setText("email de prueba");
    Transport.send(message);
    System.out.println("Finalizado");
   } catch (MessagingException e) {
   throw new RuntimeException(e);
  }
 }
}

Casos de Uso (Use Case)

• Actor.
• Casos de Uso.
• Relaciones de Uso, Herencia y Comunicación.

• Actor:
  
  
  Una definición previa, es que un Actor es un rol que un usuario juega con respecto al sistema. Es importante destacar el uso de la palabra rol, pues con esto se especifica que un Actor no necesariamente representa a una persona en particular, sino más bien la labor que realiza frente al sistema.
  Como ejemplo a la definición anterior, tenemos el caso de un sistema de ventas en que el rol de Vendedor con respecto al sistema puede ser realizado por un Vendedor o bien por el Jefe de Local.
  
• Caso de Uso:
  
  
  Es una operación/tarea específica que se realiza tras una orden de algún agente externo, sea desde una petición de un actor o bien desde la invocación desde otro caso de uso.
• Relaciones:
  
  • Asociación 
    Es el tipo de relación más básica que indica la invocación desde un actor o caso de uso a otra operación (caso de uso). Dicha relación se denota con una flecha simple.
  • Dependencia o Instanciación 
    Es una forma muy particular de relación entre clases, en la cual una clase depende de otra, es decir, se instancia (se crea). Dicha relación se denota con una flecha punteada.
  • Generalización 
    Este tipo de relación es uno de los más utilizados, cumple una doble función dependiendo de su estereotipo, que puede ser de Uso (<>) o de Herencia (<>).
    Este tipo de relación esta orientado exclusivamente para casos de uso (y no para actores).
    extends: Se recomienda utilizar cuando un caso de uso es similar a otro (características).
    uses: Se recomienda utilizar cuando se tiene un conjunto de características que son similares en más de un caso de uso y no se desea mantener copiada la descripción de la característica.
    De lo anterior cabe mencionar que tiene el mismo paradigma en diseño y modelamiento de clases, en donde esta la duda clásica de usar o heredar.

• Registrar el número de ítemes ingresados.
• Imprimir un recibo cuando el usuario lo solicita:
  1. Describe lo depositado
  2. El valor de cada item
  3. Total
• El usuario/cliente presiona el botón de comienzo
• Existe un operador que desea saber lo siguiente:
  1. Cuantos ítemes han sido retornados en el día.
  2. Al final de cada día el operador solicita un resumen de todo lo depositado en el día.
• El operador debe además poder cambiar:
  1. Información asociada a ítemes.
  2. Dar una alarma en el caso de que:
     1. Item se atora.
     2. No hay más papel.

HERENCIA EN JAVA

if ( error == true )

  return ERROR;

• Error: Excepciones que indican problemas muy graves, que suelen ser no recuperables y no deben casi nunca ser capturadas.


• Exception: Excepciones no definitivas, pero que se detectan fuera del tiempo de ejecución.


• RuntimeException: Excepciones que se dan durante la ejecución del programa.

• Trowable( String mensaje ); Constructor. La cadena es opcional


• Throwable fillInStackTrace(); Llena la pila de traza de ejecución.


• String getLocalizedMessage(); Crea una descripción local de este objeto.


• String getMessage(); Devuelve la cadena de error del objeto.


• void printStackTrace( PrintStream_o_PrintWriter s ); Imprime este objeto y su traza en el flujo del parámetro s, o en la salida estándar (por defecto).


• String toString; Devuelve una breve descripción del objeto.

• Definir qué partes de los programas crean una excepción y bajo qué condiciones. Para ello se utilizan las palabras reservadas throw y throws.


• Comprobar en ciertas partes de los programas si una excepción se ha producido, y actuar en consecuencia. Para ello se utilizan las palabras reservadas try, catch y finally.

try {

  // Código posiblemente problemático

}

try {

  // Código posiblemente problemático

} catch( tipo_de_excepcion e) {

  // Código para solucionar la excepción e

} catch( tipo_de_excepcion_mas_general e) {

  // Código para solucionar la excepción e

}

try {

} catch( Exception e ) {

} finally {

  // Se ejecutara tras try o catch

}

if ( condicion_de_excepcion == true )

  throw new miExcepcion();

tipo_devuelto miMetodoLanzador() throws miExcep1, miExcep2 {

  // Codigo capaz de lanzar excepciones miExcep1 y miExcep2

}

// Creo una excepción personalizada

class MiExcepcion extends Exception {

  MiExcepcion(){

    super(); // constructor por defecto de Exception

  }

  MiExcepcion( String cadena ){

    super( cadena ); // constructor param. de Exception

  }

}


// Esta clase lanzará la excepción

class Lanzadora {

  void lanzaSiNegativo( int param ) throws MiExcepcion {

    if ( param < 0 )

      throw new MiExcepcion( "Numero negativo" );

  }

}


class Excepciones {

  public static void main( String[] args ) {

    // Para leer un fichero

    Lanzadora lanza = new Lanzadora();

    FileInputStream entrada = null;

    int leo;

    try {

      entrada = new FileInputStream( "fich.txt" );

      while ( ( leo = entrada.read() ) != -1 )

        lanza.lanzaSiNegativo( leo );

      entrada.close();

      System.out.println( "Todo fue bien" );

    } catch ( MiExcepcion e ){ // Personalizada

      System.out.println( "Excepcion: " + e.getMessage() );

    } catch ( IOException e ){ // Estándar

      System.out.println( "Excepcion: " + e.getMessage() );

    } finally {

      if ( entrada != null )

        try {

          entrada.close(); // Siempre queda cerrado

        } catch ( Exception e ) {

        System.out.println( "Excepcion: " + e.getMessage() );

        }

      System.out.println( "Fichero cerrado." );

    }

  }

}


class Excepciones {

  public static void main( String[] args ) {

    // Para leer un fichero

    FileInputStream entrada = null;

    Lanzadora lanza = new Lanzadora();

    int leo;

    try {

      entrada = new FileInputStream("fich.txt");

      while ( ( leo = entrada.read() ) != -1 )

        lanza.lanzaSiNegativo( leo );

      System.out.println( "Todo fue bien" );

    } catch ( MiExcepcion e ){ // Personalizada

      System.out.println( "Excepcion: " + e.getMessage() );

    } catch ( IOException e ){ // Estándar

      System.out.println( "Excepcion: " + e.getMessage() );

    } finally {

      entrada.close(); // Así el fichero siempre queda cerrado

      System.out.println( "Fichero cerrado" );

    }

  }

}

• Una Clase no está en el directorio correcto
  Este error de sintaxis ocurre si el comando javac no puede encontrar un archivo .java en el directorio esperado. Si una Clase está en el paquete por defecto (no tiene la declaración del package en la primera línea), entonces esta Clase pertenece al directorio actual de trabajo o al directorio donde apunta el flag sourcepath del javac. Si una Clase está a un paquete, entonces pertenece a un subdirectorio debajo del directorio actual de trabajo o a un subdirectorio debajo del directorio donde apunta el flan sourcepath del javac. Por ejemplo, si existe una Clase llamada com.hello.HelloWorld entonces su nombre es HelloWorld y su paquete es com.hello. Si el flan sourcepath está configurada a c:src, entonces el archivo HelloWorld.java debe estar ubicado en el subdirectorio: c:srccomhello.
• El nombre de la Clase pública no coincide con el nombre del archivo
  Cada archivo .java puede contener sólo una Clase pública. El nombre de esa Clase pública debe coincidir exactamente con el nombre del archivo antes de la extensión .java, respetando incluso las mayúsculas y minúsculas. Por ejemplo, una Clase pública llamada MyClass debe estar en un archivo MyClass.java y no en myclass.java. Este es un error de sintaxis.


• Error en mayúsculas y minúsculas. Java es un lenguaje case sensitive, esto es que debemos respetar las mayúsculas y minúsculas. (miVar no es igual a mivar). Si hacemos referencia a un identificador que no está bien escrito entonces obtendremos un error de sintaxis.
• • 
    
• • Usando equals contra la asignacion
  • En Java este error puede ser incluso un error de lógica o sintaxis. Para comparar 2 referencias para igualarlas se usa el operador == (el operador de igualdad). Para asignar el valor de la derecha a la variable de la izquierda se usa el operador = (operador de asignación). Los programadores novatos a veces escriben: if (miValor = valorEsperado) Este código intenta evaluar el valor Esperado como un valor booleano en lugar de intentar la evaluación de igualdad entre mi Valor y valorEsperado. Si valorEsperado es del tipo booleano, entonces el código tendrá un error de lógica y probará si el valor Esperado es verdadero o falso. Si valorEsperado no es del tipo booleano, entonces el código lanzará un error de compilación debido a que la estructura if requiere un valor booleano que sea retornado de la comparación (miValor = valorEsperado), pero en Java el operador = siempre retorna el valor de la derecha.
• Olvidar que los índices en Java empiezan en 0.
  Los índices de los arreglos de Java y las listas empiezan en 0, myArray[0], o myList.get(0). Asegurarse que su loop for no cause errores por este motivo. Si hacemos más loops de los que son posibles, entonces obtendremos el error: ArrayIndexOutBounds exception. Si hacemos menos loops de los requeridos, entonces tendremos un error de lógica.


• NullPointerException
  El NullPointerException, la maldición de los programadores en Java. Los NullPointerExceptions son errores de lógica causados cuando un programa intenta acceder a métodos o atributos en una referencia que está nula. Si nuestro objeto no ha sido inicializado o ha sido establecido a null con el operador =, entonces la llamada el método o el acceso a uno de sus atributos no es válido.