viernes, 21 de marzo de 2014

Arquitectura Modelo Vista Controlador (Patron de Diseño)

La arquitectura modelo vista controlador , este patrón de diseño, se encarga de  separar la lógica de negocio (Modelo) de la interfaz de usuario que es la entrada del sistema (Vista), el que tiene la responsabilidad de gestionar los eventos y la comunicación, entre modelo y la vista es el Controlador.


 MODELO VISTA CONTROLADOR



DIAGRAMA DE CLASES DEL EJEMPLO







Estructura del Proyecto



Vídeo Demo MVC








Codigo Fuente del Proyecto MVC



Autor Carlos Caceres Ochoa

lunes, 17 de marzo de 2014

Componentes Personalizados Swing Netbeans








Codigo Fuente Componente Personalizado

EJemplo Formulario en Java (Utilizando interfaces)


DIAGRAMA DE CLASES



Codigo Fuente


Algoritmo en java que Imprime el Menor, el Mayor y el Promedio de 20 numeros digitados

import java.util.Scanner;


public class Respuesta {
public static void main(String args[])
{
Scanner entrada = new Scanner(System.in);

int num;
int mayor = 0;
int menor = 999999999;
int sum=0;
double prom=0;



for(int i = 1;i<=20;i++)
{

System.out.print("Digita el numero "+i+" entero: ");
num = entrada.nextInt();
sum=sum+num;
if(num>mayor)
mayor = num;

if(num<menor)
menor = num;
}
prom=sum/20;
System.out.println("El Mayor Numero digitado es: "+mayor);
System.out.println("El Menor Numero Digitado es: "+menor);
System.out.println("El Promedio es: "+prom);


}

}
     
       
     
       
           
     
       
     
     
       
       
       
   

domingo, 16 de marzo de 2014

CLASE ANONIMA


Las clases anónimas representan el caso de clases internas mas extraño que se puede presentar.

Una clase anónima es una clase sin nombre, definida en la misma línea de código donde se crea el objeto de la clase. Esta operación se lleva a cabo en el interior de un método de otra clase, por ello la clase anónima es considerada como una clase interna anidada.

DEFINICION DE UNA CLASE ANONIMA

Una clase anónima siempre debe ser una subclase de otra clase existente o bien de implementar alguna interfaz. La sintaxis para la definición de una clase de este tipo será:




Superclase var= new Superclase(){
//Definición de la clase anónima

}

Donde var será la variable que almacene la instancia de la clase anónima, que una subclase de Superclase.

Como se puede observar, la definición de la clase anónima y la creación de una instancia de la misma representa acciones inseparables que se realizan en la misma línea de código.

Ejemplo
Class Externa {




}

Ejemplo

public class Operaciones {
   
    public void imprimir(){
        System.out.println("imprimir original");
    }
}

public class Externa {
    Operaciones op = new Operaciones(){
        // definición de la clase anonima
      public void imprimir(){
         
          System.out.println("Imprimir anonimma");
      }
       
    };// creación del objeto termina con ;
   
    void proceso(){
       
        op.imprimir();

   
}


De este ejemplo se deducen dos cosas importantes: en primer lugar, la variable op contiene una instancia del objeto de la clase anónima, no de la clase Operaciones. En segundo lugar, dado que la definición de la clase anónima se lleva a cabo en una línea a código, esta debe terminar con ; .


Citado de el libro Programador Certificado de Java 2 Curso practico 2ª Edición.

Autor Antonio Martin Sierra

CLASES INTERNAS LOCALES A METODO

CLASES INTERNAS LOCALES A METODO

Esta situación se corresponde al caso de dos clases anidadas en donde la clase interna está definida en el interior de un método de la clase externa.

Class Externa{

Void método(){
Class interna{


}
}
}

 Ejemplo 

public class Externa {
   
    void proceso(){
        class Interna{
           
        void muestra(){
           
            System.out.println("Local a metodo");
           
        }   
        }
           
        // solo se puede instanciar en el interior de este proceso a partir de aqui   
        Interna in = new Interna();
        in.muestra();
       
       
       
    }
   
}// FIN DE LA CLASE EXTERNA

public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Externa ex = new Externa();
        ex.proceso();
    }
}

 Citado de el libro Programador Certificado de Java 2 Curso practico 2ª Edición.
Autor Antonio Martin Sierra


CLASES INTERNAS ESTANDARES

CLASES INTERNAS ESTANDARES

Esta situación se da cuando tenemos una clase no estatica definida en el interior de otra clase, como un miembro de la misma:

Class Externa{
   Class Interna{
}
.
.
.
}

Instanciación de la clase interna

Cuando se presenta un caso como este, la instaciacíón de la clase externa se realiza de la forma estándar. Sin embargo, para crear una instancia de la clase interna, dado que esta es un miembro no estatico de la externa, será necesario disponer previamente de una instanci a de la clase interna seguirá la siguiente sintaxis.

Externa .Interna  in  = ex.new  Interna

Clase Interna tiene acceso al reto de los miembros de la clase externa.



Utilización de this

Dentro de la clase, la palabra this hace referencia a la instancia en ejecución de la clase interna
Si desde el interior de la clase interna quiere hacerse referencia a la instancia de la clase externa deberá utilizarse la expresión:

Clase_externa .this


Ejemplo:


public class Externa {
   
    public void mostrarExterno(){
        System.out.println("objeto externo ");
       
    }
    class Interna{
       
        public void muestraInterno(){
               System.out.println("objeto interno ");
   
           
        }
       
        public void imprimir(){
            this.muestraInterno();
            Externa.this.mostrarExterno();
        }
       
    }
   
}// fin de la clase externa


public class Principal {
   
    public static void main(String[] args){
        Externa ex = new Externa();
        Externa.Interna in = ex.new Interna();
        in.imprimir();
    }
   
}

Modificadores para una Clase Interna

Una clase interna es un miembro mas de la clase, por tanto, en su definición se puede utilizar los siguientes modificadores:

Final, abstract, static, prívate, protected y public

Citado de el libro Programador Certificado de Java 2 Curso practico 2ª Edición.
Autor Antonio Martin Sierra






sábado, 15 de marzo de 2014

Patron de diseño Singleton Conexion Base de datos mysql

Codigo Fuente Calcular la Edad en Java


import java.util.Calendar;
import java.util.GregorianCalendar;


public class Fecha {

    public static void main(String[] args) {
        // TODO code application logic here
        Calendar c1 = GregorianCalendar.getInstance();
        int anActual=Integer.valueOf(c1.getTime().toLocaleString().substring(7,11));
        String fechaNac="28/08/1979";
        int anNacimiento=Integer.valueOf(fechaNac.substring(6));
        int edad=anActual-anNacimiento;
        System.out.println(edad);
       
       
    }
}

jueves, 13 de marzo de 2014

Clase Abstracta en Java

CLASE ABSTRACTA EN JAVA

Una clase abstracta es una clase en la que alguno de sus métodos esta declarado pero no esta definido, es decir, se especifica su nombre, parámetros y tipo de devolución pero no incluye código, A este tipo de métodos se les conoce como método abstractos.
Un método se define como abstracto porque en ese momento no se conoce como ha de ser su implementación;  serán las subclases de la clase abstracta responsables de darle “cuerpo” mediante la sobre escritura del mismo.
Sintaxis de la Clase Abstractactan                

Public abstract class nombre_clase
{
Public abtract tipo nombre_metodo(argumentos);
// otros métodos
}

Citado de el libro Programador Certificado de Java 2 Curso practico 2ª Edición.
Autor Antonio Martin Sierra

Diagrama de Clase Abstracta (Ejemplo Figura Geométricas)




Código Fuente Java


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Figura.Java (Clase Abstracta)

public abstract class Figura {
    
    double area;
    
    abstract public double CalcularArea();
    
    
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Circulo.java (Heredan de la Clase abstacta)

ublic class Circulo extends Figura{
    
    final double pi=3.1416;
    private double radio;

    @Override
    public double CalcularArea() {
        
        return this.area=pi*radio*radio;
     }

    public double getRadio() {
        return radio;
    }

    public void setRadio(double radio) {
        this.radio = radio;
    }
}



///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Triangulo.java (Heredan de la Clase abstacta)

public class Triangulo extends Figura{
    
    private double base;
    private double altura;

    @Override
    public double CalcularArea() {
        
        return this.area=(base*altura)/2;
     }

    public double getBase() {
        return base;
    }

    public void setBase(double base) {
        this.base = base;
    }

    public double getAltura() {
        return altura;
    }

    public void setAltura(double altura) {
        this.altura = altura;
    }
   
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Rectangulo.java (Heredan de la Clase abstacta)

public class Rectangulo extends Figura{
    
    private double base;
    private double altura;

    @Override
    public double CalcularArea() {
        
        return this.area=(base*altura);
     }

    public double getBase() {
        return base;
    }

    public void setBase(double base) {
        this.base = base;
    }

    public double getAltura() {
        return altura;
    }

    public void setAltura(double altura) {
        this.altura = altura;
    }
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Main.java (Creación de los objetos)

import clases.Circulo;
import clases.Figura;
import clases.Rectangulo;
import clases.Triangulo;

public class Main {

    public static void main(String[] args) {
        // TODO code application logic here
        
        Circulo circulo = new Circulo();
        
        
        System.out.println("Area del circulo "+calcularArea(circulo));
      
        
        Rectangulo rectangulo = new Rectangulo();
        Triangulo triangulo = new Triangulo();
        circulo.setRadio(44.55);
        System.out.println("Area del circulo "+calcularArea(circulo));
         rectangulo.setBase(30);
        rectangulo.setAltura(40);
        System.out.println("Area del rectangulo "+calcularArea(rectangulo));
        triangulo.setBase(50);
        triangulo.setAltura(60);
        System.out.println("Area del Triangulo "+calcularArea(triangulo));
       }
    
    public static double calcularArea(Figura f){ // polimorfismo
        
        return f.CalcularArea();
    }
}





Manual de Java P.O.O

Descarga Manual y Codigo Fuente P.O.O


Codigo Calculadora en Android Eclipe ADT

Codigo Fuente Calculadora en Android 




Video de WebService IDE NetBeans




martes, 11 de marzo de 2014

Eventos del Mouse Archivos Fuentes

Evento del Mouse en Primer Plano
Codigo Fuente

Evento del Mouse en Segundo Plano
Codigo Fuente

Codigo Fuente Herencia en Java

Ciudadano.java

public class Ciudadano extends Persona{
   
    private String cedula;
    private String dirección;
   
    public Ciudadano(){
       
        super();
       
    }

    public String getCedula() {
        return cedula;
    }

    public void setCedula(String cedula) {
        this.cedula = cedula;
    }

    public String getDirección() {
        return dirección;
    }

    public void setDirección(String dirección) {
        this.dirección = dirección;
    }
   
}



Main.java


package prueba;

import java.util.Scanner;
import modelo.Persona;

/**
 *
 * @author CARLOS
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        
        Persona objeto1 = new Persona();
        Scanner teclado = new Scanner(System.in);
        System.out.println("digite el nombre");
        objeto1.setNombre(teclado.next());
        System.out.println("Digite el apellido");
        objeto1.setApellido(teclado.next());
        System.out.println("Digite la Edad");
        objeto1.setEdad(teclado.nextInt());
        System.out.println("Digite la Estatura");
        objeto1.setEstatura(teclado.nextDouble());
        System.out.println("Digite el Sexo");
        objeto1.setSexo(teclado.next());
        System.out.println("Digite el tipo de Sangre");
        objeto1.setTipoSangre(teclado.next());
        
        System.out.println("Salida por pantalla");
        System.out.println("Nombre: "+objeto1.getNombre());
        System.out.println("Apellido: "+objeto1.getApellido());
        System.out.println("Edad: "+objeto1.getEdad());
        System.out.println("Estatura: "+objeto1.getEstatura());
        System.out.println("Sexo: "+objeto1.getSexo());
        System.out.println("Tipo de Sangre: "+objeto1.getTipoSangre());
        
        
        
        
        
        
        
    }
}



lunes, 10 de marzo de 2014

Matriz en Java

MATRIZ

Una matriz es un arreglo, de tipo de dato estructurado, es bidimensional porque está conformado por filas y columnas. Para poder acceder a los elementos de la matriz, es por medio de dos índices uno de las filas y otro índice de las columnas. En cada elemento se almacena un dato. La matriz es finita porque conocemos el número de elementos que la conforman, es homogéneo porque el arreglo tiene un mismo tipo de datos y es ordenado porque tiene una secuencia de elementos consecutivos.
     



 

5.6.1 Ejercicios


Ejercicio 1
Desarrolle un programa en java, que de una matriz de 3x3 llenarlo e imprimirlo.
import java.util.Scanner;
public class Matriz1 {
    public static void main(String[] args) {
         int i,j;
        int a[][] = new int[3][3];
        Scanner sc = new Scanner(System.in);
            System.out.println("***llena vector***");  
      
        for(i=0;i<3;i++){
            for(j=0;j<3;j++){
             System.out.print("digite elemento a["+i+"]["+j+"]=");  
            a[i][j]=sc.nextInt();   
            }
        }
              System.out.println("***imprime vector***");  
      
          for(i=0;i<3;i++){
            for(j=0;j<3;j++){
             System.out.println("elemento a["+i+"]["+j+"]="+a[i][j]);  
          
            }
           }

            }
           }

         Ejercicio 2
Desarrolle un programa en java, de una Matriz de 2x2 , al digitar elemento del vector solo puede ser llenado por el numero 1.

import java.util.Scanner;

public class Matriz2 {

     
    public static void main(String[] args) {
        // TODO code application logic
        int i,j;
        int n;
        int cont;
        int a[][] = new int[3][3];
        Scanner sc = new Scanner(System.in);
        n=0;
        i=0;
        j=0;
        cont=0;
       
       
        do{
          System.out.println("digite el numero");
          n=sc.nextInt();
          if(n==1){
            
                     
          for(i=0;i<2;i++){
             
              for(j=0;j<2;j++){
                 
                  a[i][j]=n;
              }
          }
                   
              
          }
        }while(n!=-1);
         
       
        for(i=0;i<2;i++){
             for(j=0;j<2;j++){
            System.out.println("a["+i+"]["+j+"]="+a[i][j]);
             }       
        }
       
        }

        }

Vector en Java

Vector

EL vector es un arreglo, de tipo de dato estructurado, es unidimensional porque solo cuenta con un solo índice que accede a los elementos del arreglo, en el  podemos almacenar uno o más datos, el vector es finito porque conocemos el número de elementos que la conforman, es homogéneo porque el arreglo tiene un mismo tipo de datos y es ordenado porque tiene un secuencia de elementos consecutivos.



VECTOR Tipo entero de 10 Elementos
int a[] = new int[9];

           




           

Ejercicio 1
Desarrolle un programa en java que Llene el vector de 10 elementos y luego lo imprima por pantalla.

import java.util.Scanner;
public class Vector1 {
    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
      
        int a[] = new int[10];
        int i;
       
        for(i=0;i<10;i++){
            System.out.print("digite el elemento a["+i+"]=");
        }
       
        for(i=0;i<10;i++){
             System.out.println("a["+i+"]="+a[i]);
        }
       
    }
}
Ejercicio 2
Desarrolle un programa en java, de un vector de 5 elementos, al digitar elemento del vector solo puede ser llenado por la letra r.

import java.util.Scanner;
public class Vector2 {
    public static void main(String[] args) {
        // TODO code application logic here
        String a[] = new String[5];
        Scanner sc = new Scanner(System.in);
        int i;
        String n;
        n="";
        i=0;
        do{
          System.out.println("digite la letra");
          n=sc.nextLine();
          if(n.equals("r")==true){
            if(i==5){
               
                System.out.println("vector lleno");
                n="-1";
            }
            else{
              a[i]=n;
              i++;
            }
          }
         }while(!n.equals("-1"));
        for(i=0;i<5;i++){
            System.out.println("n["+i+"]="+a[i]);
        }
            }
}

Ejercicio 3

Desarrolle un programa de java, que al llenar el vector a y b, sus elementos lo sume en un vector suma.

import java.util.Scanner;

public class Vector {

    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner(System.in);
        int a[] = new int[5];
        int b[] = new int[5];
        int suma[] = new int[5];
        int i;
          for(i=0;i<5;i++){
            System.out.print("digite el elemento a["+i+"]=");
            a[i]=sc.nextInt();
        }
            for(i=0;i<5;i++){
            System.out.print("digite el elemento b["+i+"]=");
            b[i]=sc.nextInt();
        }
       
            for(i=0;i<5;i++){
           suma[i]=a[i]+b[i];
        }
        for(i=0;i<5;i++){
         System.out.println("suma["+i+"]="+suma[i]);
        }
       
        }

        }