Seguidores

MIS WEBS



martes, 4 de junio de 2019

PARADIGMA DE LA PROGRAMACIÓN GENÉRICA EN JAVA


¿Qué es la programación genérica?


La programación genérica surge a partir de la versión 5.0 de java en el año 2004. Es un paradigma informático que nos indica que tenemos que crear un código que podamos reutilizar para otros objetos de diverso tipo. Por ejemplo el objeto ArrayList lo podemos utilizar para manejar y reutilizar objetos de tipo String, coche, moto….
Le pasaríamos por parámetros entre corchetes angulares <> el objeto al objeto ArrayList. Así conseguimos reutilizar el objeto ArrayList con cualquier objeto. El objeto pasado al ArrayList entre corchetes angulares <> se llama parámetro de tipo.



paradigma de la programación generica en java
parámetros de tipo en programación genérica de java




Tenemos que tener en cuenta que no podemos pasar como parámetro tipo una clase primitiva(int, long, boolean,double…)



VENTAJA DE LA PROGRAMACIÓN GENÉRICA


Esto mismo lo podríamos realizar utilizando una propiedad de java que es la herencia pero tendríamos que realizar uso continuo del casting. Por otra parte cuando heredas un objeto y le haces un casting el fallo no saldría en tiempo de compilación si no en tiempo de ejecución y esto haría más complicado controlar los posibles errores. Todo esto hace mas complejo de nuestro código.

Utilizar la programación genérica:

·         Hace nuestro código más sencillo.
·         Podemos reutilizar código de una forma más rápida.
·         Los errores nos acontecerán en la compilación, el IDE (entorno desarrollo) nos avisará y podremos rectificar antes de programar más líneas de código.

·         Al pasar un parámetro tipo queda más claro en nuestro código que tipo de dato estamos manejando.




Como crear mi clase genérica



Crearremos una clase y le pasarémos por parámetro tipo nuestro objeto. Es una buena praxis el pasarle una letra mayúscula que suele ser T, U,K. Podemos utilizar cualquier otra y no afectará a nuestro código pero es aconsejable pasarle estas para que el resto de programadores identifiquen que son.
public class ClaseGenericaaaaaaa <Q>{
}

Creamos una variable de tipo de tipo Q y un constructor.

public class ClaseGenericaaaaaaa <Q>{
       private Q xxxx;
       public ClaseGenericaaaaaaa() {
             xxxx = null;
       }
}




Ahora creamos los MÉTODOS GETTER Y SETTER

public class ClaseGenericaaaaaaa <Q>{
       private Q xxxx;
       //**constructor**
       public ClaseGenericaaaaaaa() {
             xxxx = null;
       }//**setter
       public void setClaseGenericaaaaaaa (Q xxxx ) {
             this.xxxx = xxxx;         
       }//getter
       public Q   getClaseGenericaaaaaaa () {
             return xxxx;
       }
}







Nos iremos al método main crearemos un objeto de la clase ClaseGenericaaaaaaa al que le pasamos por parámetro de tipo un String.


public class eSTOva {
       public static void main(String[] args) {
//le decimos que Q será un String
ClaseGenericaaaaaaa <String> CrearString = new ClaseGenericaaaaaaa<String>();
             //establecemos dato guardado
             CrearString.setClaseGenericaaaaaaa("DDDDDDDDDDDDDDD");
             //lo recuperamos para imprimirlo
             System.out.println(CrearString.getClaseGenericaaaaaaa());
       }
}





Antes le pasamos un parámetro tipo de String, pero puede ser un File o cualquier otro que deseemos.

public class eSTOva {
       public static void main(String[] args) {
ClaseGenericaaaaaaa <String> CrearString = new ClaseGenericaaaaaaa<String>();
ClaseGenericaaaaaaa <File> RutaAcceso = new ClaseGenericaaaaaaa<File>();

       CrearString.setClaseGenericaaaaaaa("DDDDDDDDDDDDDDD");
       RutaAcceso.setClaseGenericaaaaaaa(new File("C:"+File.separator+"Users"                                            +File.separator+"dagip"
                                        +File.separator+"Desktop"                                                       +File.separator+"BOGEER"                                                        +File.separator+"imagenes"
                                        +File.separator+"video"));

                    //nos regresa un String
             System.out.println(CrearString.getClaseGenericaaaaaaa());
                    //nos regresa un File
             System.out.println(RutaAcceso.getClaseGenericaaaaaaa());
       }
}





Al ser un objeto de tipo File podemos decir lo siguiente, porque posee métodos de la clase File. Tenemos las ventajas de la herencia sin tener los problemas del casting.


System.out.println(RutaAcceso.getClaseGenericaaaaaaa().getAbsolutePath());







CREAR UN MÉTODO GENÉRICO


Es un método que podemos utilizar con cualquier tipo de objeto, no es necesario que se generado dentro de una clase genérica, lo podremos construir en cualquier tipo de clase. Y se adptará al objeto que le pasemos por parámetro tipo. No se le puede pasar un tipo de dato primitivo.
Su sintaxis es similar a la utilizada en una clase genérerica.

public static <K> String getdato (K variable){
             return "Este es tu dato     " + variable;
       }



Si deseamos que nos regrese un dato sin especificar que sea igual al objeto que recibe
public static <K> K getdato (K variable){
             return "Este es tu dato     " + variable;
       }



Ahora lo utilizamos, nos imprimiría en la ventana de inmediato lo que tenemos en ambas variables a pesar que una es File y la otra String y sin hacer un casting:


System.out.println(eSTOva.getdato(CrearString));
System.out.println(eSTOva.getdato(RutaAcceso));





HERENCIA DE CLASES GENÉRICAS Y TIPOS COMODÍN



La herencia en las clases genéricas no es igual al que tiene en el resto de clases. Esta anomalía a la hora de heredar de una clase genérica nos obligar
Recordemos que en una clase normal existía el pricipio de sustitución


Principio de sustitución: Se puede utilizar un objeto de una sub clase siempre que el programa espere un objeto de la Superclase. Por lo que un objeto se puede comportar de diferente manera dependiendo del contexto. Podremos utilizarlo siempre que podamos decir ES UN. En el siguiente caso podemos decir cerdo es carne y pollo es carne.

             Carne [] Cerdo=new Carne[5];
                Carne [] Pollo =new Carne[6];
                Carne [] ArticulosCarne=new Carne[11];
for (int x=0;  x<5;  x++) {ArticulosCarne[x]= Cerdo[x];}
for (int y=5,x=0;y<11 && x<6;y++,x++){ArticulosCarne[y]=Pollo[x];}



En las clases genéricas no existe relación entre los objetos. La Clase <carner> es un objeto con unas propiedades y métodos, la Clase <cerdo> es otro objeto independiente con unas propiedades y métodos, pero no tienen ningún nexo en común.


Para tener una salida a esto tenemos la posibilidad de crear un método genérico en la clase padre y pasarle por parámetros la clase hija. Luego iremos al método main y llamaremos a ese método.

ClaseGenericaaaaaaa < ArticulosCarne []> CrearString = new ClaseGenericaaaaaaa< ArticulosCarne []>();
ClaseGenericaaaaaaa < Pollo []> CrearString = new ClaseGenericaaaaaaa< Pollo []>();
ClaseGenericaaaaaaa < Cerdo []> CrearString = new ClaseGenericaaaaaaa< Cerdo []>();

Creamos el método diciéndole que hereda de ArticulosCarne

public static void getid(ClaseGenericaaaaaaa <? extends ArticulosCarne > p ) {
              Pollo heredaCarne = p.getClaseGenericaaaaaaa();
             System.out.print(nod);
       }


Ahora podemos utilizar el getClaseGenericaaaaaaa() en el método main.


             NUMERO1.setClaseGenericaaaaaaa(Pollo ());

No hay comentarios:

Publicar un comentario

Buscar este blog

Sandisk y Western Digital