Seguidores

MIS WEBS



domingo, 31 de diciembre de 2017

CLASE INTERNA LOCAL java



Es una clase dentro de un método. Nos resultarán útiles cuando se instancien tan solo una vez. Se utilizarán para simplificar nuestro código.  El ámbito de esa clase quedará restringido al método al que pertenece, por lo que quedará encapsulada.

SINTAXIS

class Clase_1ª{
public void método() {
class clase_2º_local{//la clase dos no lleva modificador
Código clase 2ª…
}
Código clase método…
}
Código clase 1ª…
}


Ejemplo


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

public static void main(String[] args) {
//instanciamos la clase reloj
Reloj miReloj = new Reloj(5000,true);
miReloj.Arranca(); 
JOptionPane.showMessageDialog(null, "SI TOCAS ACCEPTAR PARARAS EL RELO");
}

class Reloj{//clase1ª
//Constructior de reloj pasando por parametros
public Reloj(int intervalo,boolean sonido) {
this.intervalo=intervalo;
this.sonido=sonido;
}
*************************************************
//metodo setter establecer con action listener imprencindible para aplicar la interface timer

public void Arranca() {
__________________________________________________
//clase interna
*******************************************************
class clase2 implements ActionListener{
public void actionPerformed(ActionEvent evento) {
Date HoraActual = new Date();
System.out.println("hora Actual: " + HoraActual);
// en un bolean no hace falta == ni poner las dos conciones se sobreentiende que si lo ponemos asi es verdadero y si no no hace nada
if (sonido) { Toolkit.getDefaultToolkit().beep();}
}
}
**************************************************
Código método
ActionListener oyente = new clase2();
Timer miTemporizador = new Timer(intervalo,oyente);
miTemporizador.start();
}
*******************************************************
Código clase_1
private int intervalo;
private boolean sonido;
}





Una clase interna nos permite acceder a las variables del método, esto nos permite pasarle por parámetros las variables y simplificar nuestro código. La variable que pasemos por parámetros a la clase interna y vallamos a utilizar tendremos que pasarla como final.


ejercicio 2.

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
public class claseInterna {
public static void main(String[] args) {
Reloj miReloj = new Reloj();
miReloj.Arranca(5000,true); 
JOptionPane.showMessageDialog(null, "SI TOCAS ACCEPTAR PARARAS EL RELO");
System.exit(0);
}
}
class Reloj{//clase1ª
public void Arranca(int intervalo, final boolean sonido) {
class clase2 implements ActionListener{
public void actionPerformed(ActionEvent evento) {
Date HoraActual = new Date();
System.out.println("hora Actual: " + HoraActual);
if (sonido) { Toolkit.getDefaultToolkit().beep();}
}

}

CLASE INTERNA O ANIDADA EN JAVA





¿Qué son?
Una clase interna es una clase dentro de otra. Fueron introducidas en la versión 1.1 y son conocidas en inglés como Inner Class (clase interna) o Nested Class (clase anidada).
Una clase interna conoce los detalles de la clase contenedora y puede comunicarse con ella. Además el tipo de código que puede escribirse con las clases internas es más elegante y claro.
Una clase anidada siempre la declararemos como private.

¿Para qué sirve?

Para acceder a los campos privados de una clase desde otra clase
Para ocultar una clase de otras pertenecientes al mismo paquete, con esto conseguiremos encapsular nuestra clase interna.
Para crear clases internas “anónimas”, nos pueden resultar útiles para gestionar eventos retro llamadas.
Cuando solo una clase debe acceder a los campos de ejemplar de otra clase.
Creando clases internas nos ahorramos generar métodos getters y setters.

EJERCICIO.

package poo; import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;import java.util.*;
import javax.swing.*;import javax.swing.Timer;
public class claseInterna {
     public static void main(String[] args) {
         //instanciamos la clase reloj
         Reloj miReloj = new Reloj(5000,true);
         miReloj.Arranca();         
JOptionPane.showMessageDialog(null, "SI TOCAS ACCEPTAR PARARAS EL RELO");
     }
}

class Reloj{//clase1ª
     //Constructior de reloj pasando por parametros
     public Reloj(int intervalo,boolean sonido) {  
         this.intervalo=intervalo;
         this.sonido=sonido;
     }   
     //metodo setter establecer con action listener imprencindible para aplicar la interface timer
     public void Arranca() {
ActionListener oyente = new clase2();
Timer miTemporizador = new Timer(intervalo,oyente);
         miTemporizador.start();
     }
     private int intervalo;
     private boolean sonido;
    
     private class clase2 implements ActionListener{
     public void actionPerformed(ActionEvent evento) {
              Date HoraActual = new Date();
             
     System.out.println("hora Actual: " + HoraActual);
              // en un bolean no hace falta == ni poner las dos conciones se sobreentiende que si lo ponemos asi es verdadero y si no no hace nada
     if (sonido) { Toolkit.getDefaultToolkit().beep();
}
         }
     }
}

CREAR NUESTRA INTERFAZ


¿Para qué lo hacemos?


Cuando realicemos un programa crearemos una clase padre y luego una serie de subclases a raíz de ella. Cuando en una de las clases deseemos que cualquiera que trabaje con ella la cree con una serie de métodos que nosotros consideremos indispensable realizaremos una interface. Es una forma determinada de trabajar con nuestra clase implementando como mínimo una serie de métodos predefinidos por nosotros.

SINTAXIS:

public interface MiInterface {
//obligamos a cualquiera que utilice nuestra interface a implementar en su clase el método 1,2 y3.
     public abstract String Metodo1();
public abstract String Metodo2();
public abstract String Metodo3();    
}

Ejercicio

//creamos la interface para que se implimente el método incremento_sueldo los años de trabajo y el incremento por años.
public interface MiInterface {
public abstract double incremento_sueldo(double incremento_sueldo_por_año,double años);}
public class CLASES_ABSTRACTAS {
_______________________________________________________
     public static void main(String[] args) {
         OPERARIOS operario[]= new OPERARIOS[3];
//tenemos 2 tipos de operarios unos que son médicos y otros administrativos cada uno de ellos tendrá un tipo de incremento sueldo    
operario[0]= new medicos("tra","lalala","e5558","cardio",20);
operario[1]= new administrativos("paco","perez lopez","w3334","cont",50);
operario[2]=new medicos("Pedro","perez Casa","q8888888","pediatra",60);

// com instamceof confirmamos que pertenece a la clase medicos
if (operario[0] instanceof medicos) {
System.out.println(operario[0].get_regresadatos()+ "\n");}
if (operario[1] instanceof Comparable) {
System.out.println("utiliza Comparable que si no deja de funcionar");}

//imprimimos en ventana de inmediato el método incremento_sueldo
System.out.println(operario[0].incremento_sueldo(100, 10));
System.out.println(operario[1].incremento_sueldo(50, 15));
System.out.println(operario[2].incremento_sueldo(100, 30));
        
         Arrays.sort(operario);
         for (OPERARIOS i:operario) {
         System.out.println(i.get_regresadatos()+" ");}
     }
}
______________________________________________________________
//clase abstracta // clase padre// implementamos la interfaze Comparable y nuestra interfaze MiInterfaze
_______________________________________________________
abstract class OPERARIOS implements Comparable,MiInterface{
    
     //CONSTRUCTOR
     public OPERARIOS(String nom,String apellidos, String Dni,int numero) {
         nombre=nom; this.apellidos=apellidos; this.Dni=Dni;this.numero=numero;
     }
    
     public final String nombre,apellidos, Dni;
     public final int numero;
    
     public abstract String get_regresadatos();
//utilizamos el método incremento_sueldo de nuestra interface Miinterface
     public double incremento_sueldo
     (double incremento_sueldo_por_año,double años) {
     double incremento=incremento_sueldo_por_año;  
     double años_trabajados= años;
         return   incremento*años_trabajados;
             
     }
     //utilizamos el método compareto de Comparable
     public int compareTo(Object Bob) {
         OPERARIOS op=(OPERARIOS) Bob;
         if (this.numero < op.numero) {return -1;}
         if (this.numero>op.numero) {return 1;}
         return 0;    
     }              }
class medicos extends OPERARIOS{
     public medicos(String nom,String Apellidos,String Dni, String departamento, int nuemro) {
         super(nom,Apellidos,Dni,nuemro);
     dep=departamento;
        
     }
     public final String dep;
     public String get_regresadatos()
                   {return      numero+ "     "+
                                 Dni"   " +
                                 nombre+"   " 
                                 +apellidos+"   " +
                                 dep ;}
}

class administrativos extends OPERARIOS{
    
     public administrativos(String nom,String Apellidos,String Dni, String departamento, int numero)
     { super(nom,Apellidos,Dni,numero);
     dep=departamento;
        
     }
     public final String dep;
     public String get_regresadatos()
                   {return numero + "     "+
                            Dni"   " +
                            nombre+"   " 
                            +apellidos+"   " +
                            dep ;}

}

Buscar este blog

Sandisk y Western Digital