MongoDB con Java en Linux

Este tutorial es un poco mas avanzado,es de esos tutoriales sueltos que están dedicados a los usuarios con cierta experiencia en java,así que no es igual que los que hasta ahora hemos estado viendo.

Primero que nada yo les recomiendo que usen eclipse para un rápido trabajo,si no es así de todas formas se puede programar desde un editor común pero yo voy a usar Eclipse en este tipo de tutoriales.

Primero que nada descargamos el driver:

http://central.maven.org/maven2/org/mongodb/mongo-java-driver/2.9.3/

En este caso hoy por hoy esta el 2.9.3 así que pueden usar wget en la terminal,para descargar:

wget http://central.maven.org/maven2/org/mongodb/mongo-java-driver/2.9.3/mongo-java-driver-2.9.3.jar

Ahora creamos un proyecto en eclipse:

Nuevo Projecto Java-> Elegimos de nombre MonEjemplo // Por ejemplo

Le damos next y en Libraries le damos Add external Jars y elegimos el dirver .jar que descargamos:

Ahora pasamos a la pestaña Order and Export y palomeamos el driver:

Bien con esto listo vamos al src y creamos una nueva clase,yo la llame MainMongo y añadimos el static main:

Ahora si esta listo nuestra clase main,primero que nada importamos el driver:

import com.mongodb.*;

O podemos importar solo lo que usaremos como se ve mas abajo.

Primero que nada vamos a crear una conexión al localhost:

Primero añadimos una UnknownHostException al main,para poder usar la función,vamos a ver un esqueleto básico:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

import java.util.List; import java.net.UnknownHostException; import java.util.Set; import com.mongodb.BasicDBObject; import com.mongodb.DB; import com.mongodb.DBCollection; import com.mongodb.DBCursor; import com.mongodb.Mongo; public class MainMongo { // Variable miembro privadas private Mongo conexion; // Conexion private DB database; // Base de datos private DBCollection collection; // Colleciones /** * @param args * @throws UnknownHostException */ public static void main(String[] args) throws UnknownHostException { // TODO Auto-generated method stub MainMongo ObjetoMongo = new MainMongo(); ObjetoMongo.conexion("localhost"); // Creamos una conexion } private void conexion(String host) throws UnknownHostException { this.conexion = new Mongo(host); // Definimos la variable miembro List bases = conexion.getDatabaseNames(); // Usamos una lista para ver las bases de datos System.out.println("Bases de datos :"); for (String b : bases) { // Las recorremos System.out.println("Bases de datos : "+b); } /* Podemos agregar mas funciones,para emular una shell,pero este es un ejemplo basico */ System.out.println("Usando test"); this.database = this.conexion.getDB( "test" ); // Definimos la base de datos } }

Bien,ahora vamos a ver algunos ejemplos en funciones:

Como ver las colecciones y usar una:

1 2 3 4 5 6 7 8 9

private void colecciones() { Set colls = this.database.getCollectionNames(); // Esto nos devuelve Set con el nombre de las conexiones System.out.println("Colecciones de "+this.database.getName().toString()); for (String c : colls) { // Las mostramos System.out.println(c); } this.collection = this.database.getCollection("test"); // Definimos nuestra conexion con la coleccion System.out.println("Usando test"); // Esto no es real,ya que es un ejemplo,ya que si no tienes test no servira el ejemplo }

Ahora una funcion para mostrar los elementos de una coleccion:

1 2 3 4 5 6 7 8 9 10 11 12

private void mostrarelementos() { System.out.println("Todos los elementos :"); DBCursor cursor = this.collection.find(); // Buscamos todos los elementos en un cursor // Usamos un manejador de execepciones por si falla algo try { while(cursor.hasNext()) { // Miestras haya elementos nos movemos en el bucle System.out.println(cursor.next()); // Nos movemos al siguiente } } finally { cursor.close(); // Cerramos pase lo que pase } }

Insertar elementos,para insertar valores en una base de datos creamos un objeto BasicDBObject en mongo seria así:

x = {"Elemento":1}}

db.test.insert(x)

En java esto se ve así:

BasicDBObject x = new BasicDBObject("Elemento : ", 1);

this.collection.insert(x);

O usando una clase anónima:

this.collection.insert(new BasicDBObject("Elemento : ", 1));

Por ejemplo una función para añadir 100 elementos:

1 2 3 4 5 6

private void insertar() { System.err.println("Insertando elementos"); for (int i=0; i < 100; i++) { this.collection.insert(new BasicDBObject("Elemento : ", i)); } }

Si quisieramos hacer algo mas avanzado como en mongo esto:

x = {name:"atheyus",sitio:"itimetux.com"}

En java luce asi:

BasicDBObject x = new BasicDBObject("name", "atheyus").append("sitio", "itimetux.com");

O algo mas avanzado,en mongo:

x = {name:"atheyus",sitio : { dominio:"itimetux.com",nombre:"Tiempo de Tux"}}

En java:

BasicDBObject x = new BasicDBObject("name", "atheyus").append("sitio",new BasicDBObject("dominio", "itimetux.com").append("nombre", "Tiempo de Tux"));

Y asi lo podemos hacer en muchos niveles.

Ahora que entendemos como definir objetos basicos de la db,podemos usar eso mismo para hacer una consulta:

Si quisiera buscar todos los registros que tengan de name atheyus así lo haríamos en mongo:

db.test.find({"name":"atheyus"})

En java esto seria así:

1 2 3 4 5

BasicDBObject x = new BasicDBObject("name", "atheyus"); DBCursor cursor = this.collection.find(x); // Aqui usamos un bucle que recorra los valores

Para borrar una base de datos usamos:

conexion.dropDatabase("test"); // test es la base de datos

Eso es todo :D

Referencias: http://docs.mongodb.org/

Ver el codigo ya que no se ven bien las letras entre Paréntesis angulares (de List y Set)y puede dar serios errores.

Codigo completo : MainMongo.java

Leer más...

Tutorial Java en Linux Basico 3

Vectores y matrices

En java podemos definir arrays igual que en otros lenguajes de programación,los mas sencillos son los vectores,arrays unidimensionales. Un arreglo sea de una dimensión o de dos o mas es una agrupación de valores del el mismo tipo(en Java).

Un array lo usamos para agrupar datos relacionados,no necesariamente relacionados pero es para lo que se usaría comúnmente,un array se define como un tipo de dato solo que lo que lo diferencia es que lo definimos junto con una pareja de corchetes ,por ejemplo un array de strings de una dimensión(vector) con 6 elementos:

String [] arrayS;

o

String arrayS [];

Un vector se crea como un objeto,con la palabra new pero se le pasa el numero de elementos que vamos a crear dentro de otros corchetes por ejemplo, 5 palabras:

arrayS = new String[5];

 Luego podemos definir cada valor comenzando desde 0:

arrayS[0] = "Palabra1";arrayS[1] = "Palabra2";...

También podemos hacerlo mas sencillo:

String arrayS []  = new String[5];

Bueno eso es el estilo de definición solamente,pero también contamos con la definición al mismo tiempo,para hacer esto usamos una pareja de  ({}),y no necesitamos decir el numero de elementos,esto se hace automático por el sistema(compilador):

String [] arrayS = {"Palabra1","Palabra2","..."};

Como decía en el tutorial anterior los vectores se pasan por referencia,así que si le pasamos un valor a una función puede modificar el valor:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

/** * Archivo Ejemplo.java * Ejecuta : javac Ejemplo.java && java Ejemplo * @author Atheyus * */ public class Ejemplo { public static void main(String[] args) { String [] arrayS = {"Palabra1","Palabra2","..."}; System.out.println("Valor 1 antes de la funcion : "+arrayS[1]); // Vale 10 cambiar(arrayS); System.out.println("Valor 1 despues de la funcion : "+arrayS[1]); // Vale 10 } private static void cambiar(String [] x) { System.out.println("Valor 1 en la funcion antes del cambio : "+x[1]); // Vale 10 x[1] = "Cambio"; } }

Para los arrays tenemos varias funciones,algunas que se heredan de un nivel mas alto,la mas importante(que no es una funcion):

length

Que devuelve el numero de elementos del array:

Una función para recorrer los valores de un vector seria esta:

1 2 3 4 5 6

private static void recorre(String [] x) { for (int i = 0;i < (x.length);i++ ){ System.out.println("Numero "+i+" :"+x[i]); } System.out.println("Ultimo valor :"+x[x.length-1]); // Para obtener el ultimo valor se usa esta solucion }

Los vectores pueden ser de cualquier dato,siempre y cuando sea el mismo tipo.

Matrices

Una matriz es un array bidimensional,el cual se define igual que un vector pero con el doble de corchetes,podemos decir que es un vector de vectores:

Para no complicar mucho vamos a crear un valor de dos filas(primera dimension) y dos columnas
(segunda dimensión):

1 2 3 4 5

String[][] matrizS = new String[2][2]; matrizS[0][0] = "Palabra uno fila 1"; matrizS[0][1] = "Palabra dos fila 1"; matrizS[1][0] = "Palabra uno fila 2"; matrizS[1][1] = "Palabra dos fila 2";

Eso es todo,ahora podemos acceder a sus valores,solamente que hay que tratar la primera dimencion como un vector no como un valor en si:

Si quisiéramos saber el numero de elementos de la primera fila haríamos esto:

matrizS[0].length();

También podemos usar una definición,de una sola linea,solo que debemos subir un nivel en ({}):

1 2	String [][] matrizS = {{"Palabra uno fila 1","Palabra dos fila 1"}, {"Palabra uno fila 2","Palabra dos fila 2"}};

Como lo consultamos?

Fácil,el algoritmo que yo uso(que aprendí en C) lo usamos creando un bucle anidado en cada nivel es una dimensión,esto es bueno porque he visto arrays de mas de tres dimensiones:

Solución:

1 2 3 4 5 6 7 8 9 10

private static void recorre(String[][] x) { for (int i = 0; i < x.length; i++) { int columnas = x[i].length; System.out.println("Fila : "+(i+1)); for (int o = 0; o < columnas; o++) { System.out.println("Valor : "+x[i][o]); } } }

Bien,como dije arriba los arrays tienen funciones pero estas son inútiles a excepción de length que no es una función si no que es una variable,pero Java nos ofrece una biblioteca muy buena para usar algunas funciones sobre nuestros arrays de una dimensión:

Primero debemos importar:

import java.util.Arrays;

Para ordenar un vector alfabéticamente o en orden asendente(numeros):

Arrays.sort(vector);

Como dije los valores de los vectores se pasan por referencia,por lo que no hay porque hacer esto:

ejem = Arrays.sort(ejem); // no

sort también tiene constructores mas avanzados,los veremos en su momento.

Arrays.toString(vector)

Esa función devuelve una String que representa el vector.

Arrays.equals(vector1,vector2)

Esa función devuelve un boolean para saber si dos vectores son iguales.

 De momento es todo, existen algunas cosas un poco mas avanzadas y utiles como son los diccionarios y las listas ademas de las funciones avanzadas de la clase Arrays,pero lo veremos en su momento :D.

Codigo completo: Vectors y Matrices

Leer más...

Programacion Orientada a Objetos con Perl parte 1

La programación orientada a objetos en perl es un poco rara(para los que no conocen bien este lenguaje),he visto que dicen que no existe,la OOP(de ahora en adelante) en Perl es como en Lua,estamos usando tipos de datos de distintas formas en conjunto para crear un objeto,de hecho en Perl la OOP es lo mas básico que hay porque de no ser así no existirían tantos módulos de CPAN(pureperl) y vamos que CPAN es famoso por sus miles de módulos :D.

Bien,en Perl para definir una clase la podemos definir en un archivo .pm o en el mismo archivo .pl(u otra extensión),en este caso vamos a usar un archivo .pm.

Perl busca los módulos al igual que otros lenguajes,como Python,Ruby,etc primero en su PATH y luego en el directorio actual(cual sea el principio),para tener una clase que cree un objeto,vamos a crearlo en la misma carpeta:

En este caso vamos a usar dos,el principal:

vim principal.pl

Y una clase que se llame persona:

vim persona.pm

Si la clase persona.pm estuviera en un subdirectorio,por ejemplo que hiciéramos dos módulos uno para test y otro "oficial" seria así:

Bien en el modulo principal estas serian las lineas principales de siempre:

1 2 3 4

#!/usr/bin/env perl use strict; use warnings;

Y la clase lo añadimos asi:

use persona;

Si estuviera en test tendrías que usar cuatro puntos,ya que así es como perl ve los directorios:

use test::persona;

Bien,en la clase persona vamos a usar un constructor de clase llamado new,no necesariamente debe ser llamado new,puede ser otro nombre que no sea una palabra reservada del lenguaje,pero usare new ya que es lo que dice perldoc:

Primero que nada todo aquí son subrutinas,metodos,los cuales reciben parámetros que manipulamos con las variables especiales:

$_ y @_ o sus funciones shift,unshift

El argumento que recibiremos en la creacion de la clase sera la clase misma:

my $class = shift;

En este caso $class contendrá el nombre de persona,esto es para que sepa a que clase pertenece,ahora lo que tenemos que hacer es crear un hash para trabajar con los datos miembro:

my $self = {};

Luego debemos asociarlos de alguna manera,bless se encarga de eso:

bless $self,$class;

Ya lista la asociación devolvemos $self para que el objeto creado haga referencia a el:

return $self;

Así queda nuestro constructor:

1 2 3 4 5 6 7

sub new { my $class = shift; my $self = {}; bless $self,$class; return $self; }

Algo muy importante es que al crear una clase nueva siempre lo primero que deben escribir es :

1 2 3

package nombre; # Aqui toda la clase 1;

En package tenemos que poner el nombre de la clase o paquete,debe ser el mismo del archivo(respetando mayúsculas y minúsculas) solo que sin la extensión:

1;

Es un retorno a true,que necesitan los paquetes para que funcionen,vamos a ver un poco de lo que serian set y get:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

sub setName { my $self = shift; $self->{NOMBRE} = shift; } sub getName { my $self = shift; if ($self->{NOMBRE}) { return $self->{NOMBRE}; } else { return "Sin sombre"; } }

Cuando llamamos una función el parámetro que se nos pasa primero es el self,la referencia del hash que estamos usando,y lo demás puede ser cualquier cosa,por ejemplo en setName podemos hacer también esto:

1 2	my ($self,$n) = @_; $self->{NOMBRE} = $n;

Bien ahora en el archivo principal vamos a crear un objeto persona:

Asi queda todo el codigo de ejemplo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#!/usr/bin/env perl use warnings; use strict; use feature 'say'; use test::persona; # ./test/persona.pm my $atheyus_tux = persona->new(); say $atheyus_tux->getName(); $atheyus_tux->setName("Atheyus"); say $atheyus_tux->getName();

Bien como vemos es muy sencillo,ahora vamos a ver como usar metodos internos desde la misma clase:

Gracias a bless $self esta a referencia con $class que a la vez es un shift que contiene el nombre del paquete en el ejemplo mas sencillo,pues gracias a esto $self puede usar funciones internas simplemente con llamarlas:

Por ejemplo una función que no permite  mostrar el nombre:

1 2 3 4 5 6 7

sub borraNombre { my $self = shift; if ($self->{NOMBRE}) # Si existe el nombre { $self->{NOMBRE} = "Borre el nombre"; # Cambiamos el valor } }

Ahora lo podemos usar en la función getName:

1 2 3 4 5 6 7 8 9 10

sub getName { my $self = shift; $self->borraNombre(); # Lo llamamos if ($self->{NOMBRE}) { return $self->{NOMBRE}; } else { return "Sin sombre"; } }

Tambien podemos crear un destructor para que destrulla las variables asociaciadas al hash:

1 2 3 4 5

sub destruye { my $self=shift; #El primer parámetro de un metodo es la clase delete ($self->{NOMBRE}); }

Hasta aquí la primera parte en la siguiente hablaremos de herencia,pero de momento es todo,como vemos es un ejemplo sencillo pero no se trata de eso si no de que así como es de simple el ejemplo así de simple se entienda.


Codigo completo: principal.pl

Codigo completo: persona.pm

Leer más...

Tutorial Java en Linux Basico 2

Funciones

Antes de ver como crear objetos tenemos que saber como crear funciones desde nuestra clase principal,lo que serian metodos de la clase iniciadora(la que contiene el main),en esta ocasión veremos como crear funciones dentro de nuestra clase principal.

Una función es algo que nos ahorra escribir mucho código varias veces,en java una función no tiene palabra especial para iniciarla,lo que la diferencia de una variable son los paréntesis (),y el cuerpo de la función.

Para entender esto deben leer el primer tutorial.

Enlace

Una función se define así:

modificador retorno nombre(tipo parámetro) {
   // Cuerpo
}

Una función la podemos la podemos definir para que ejecute un código simplemente o para usarla como una solución que devuelva un valor,por ejemplo una función que solo se use para ejecutar su bloque podrir ser algo como imprimir en la pantalla:

1 2 3

public static void saluda(String n) { System.out.println("Hola"+" "+n); }

Bien aquí vamos a explicar un poco:

En java el símbolo de mas(+) junto con Strings se usa para concatenar,aquí estamos usando static porque vamos a llamar la función saluda desde el main,y el main es static:

Un método static solo puede llamar métodos static,ya que no existe o necesita referencia,y no en viceversa un método no static si puede llamar uno static.

Así seria el main:

1 2 3 4

public static void main (String [] args) { String nombre = "atheyus tux"; saluda(nombre); }

El ejemplo completo seria asi:

Creamos un archivo llamado funciones.java:

vim hola.java

Y este es código completo:

1 2 3 4 5 6 7 8 9

public class funciones { public static void main (String [] args) { String nombre = "tu nombre"; saluda(nombre); } public static void saluda(String name) { System.out.println("Hola"+" "+name); } }

Compilamos:

javac funciones.java

Ejecutamos:

java funciones

Y veremos algo como esto:

Antes de continuar debo explicar que en java los comentarios se definen asi:

Comentario de una sola linea:

// Un comentario de una sola linea

Y un comentario de varias lineas:

/*
   Comentario
   de varias lineas
   en Java
*/

Tambien tenemos la comentacion para documentacion que se define asi:

/**
   @author Atheyus
   Un comentario de documentacion
   @vesion 1.0
*/

Así que ya no voy a explica como compilar y el nombre del archivo,esto ira en el código java.

Bien esa función es una función vacía,ya que no devuelve nada,podemos usar:

return;

pero no es sumamente necesario,en otro caso podríamos usar una función por retorno,por ejemplo en vez de que trabaje la String que saluda,que devuelva una String para que nosotros hagamos lo que queramos con ella,en este caso no seria void si no String,porque devolvería un String:

1 2 3

public static String saluda(String name) { return "Hola"+" "+name; }

Esta función nos retorna una String,que podríamos almacenar en otra o usar directamente,por ejemplo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

/** Archivo : funciones.java Ejecuta : javac funciones.java && java funciones */ public class funciones { public static void main (String [] args) { String nombre = "atheyus tux"; String nombre_saludado = saluda(nombre); // Creamos una String a partir del retorno de nuestra funcion System.out.println(nombre_saludado); } public static String saluda(String name) { return "Hola"+" "+name; } }

Bien de igual manera como si de una String normal(que si es) se tratara,podemos usar los métodos de dicho objeto,porque como en java casi todo son objetos si una función devuelve un objeto,podemos usar funciones del mismo:

Por ejemplo:

String nombre_saludado = saluda(nombre).concat(" :D");

concat es una función de String que se usa para añadir texto al que ya tiene.

En este caso al ejecutar veríamos:

Hola tu nombre :D

Sin embargo si es un tipo primitivo no podemos hacer eso:

Por ejemplo tenemos una función que nos devuelve un booleano para hacer determinada cosa:

1 2 3 4 5 6 7

private static boolean checar(int i) { if (i == 1) { return false; } else { return true; } }

En el main tenemos:

1 2 3

public static void main(String[] args) { boolean ver = checar(1).aqui_no_hay_nada; }

En java no existe un paso por referencia siempre lo hacemos por valor,a menos que sea un vector o una matriz o un objeto especial que se extienda de Object y no sea inmutable:

Por ejemplo tenemos esta funcion:

1 2 3

private static void cambiar(int i/* esta es una copia */) { i = 10; }

Y en el main:

1 2 3 4 5

public static void main(String[] args) { int x = 1; // Valor 1 cambiar(x); // Valor 1 // Valor de x 1 }

Si queremos modificar un valor desde una función,podemos crear una variable de clase(miembro[privada]):

Antes de continuar hay que saber que en java en el método main no siempre es necesario usar metodos static,para usar métodos no static desde main debemos crear un objeto del mismo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/** * Archivo Ejemplo.java * Ejecuta : javac Ejemplo.java && java EJemplo * @author Atheyus * */ public class Ejemplo { private int x = 10; public static void main(String[] args) { Ejemplo e = new Ejemplo(); // Creamos un objeto de la propia clase,x vale 10 para e cambiar(e); // cambiar si es static porque lo llamamos desde main System.out.println(e.x); // x vale 20 } private static void cambiar(Ejemplo x/*Referencia a e*/) { x.x = 20; // Cambiamos el valor de x de e,usando x } }

Eso es un poco tonto y un poco de mala practica,podemos usar el método cambiar desde el objeto:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

/** * Archivo Ejemplo.java * Ejecuta : javac Ejemplo.java && java Ejemplo * @author Atheyus * */ public class Ejemplo { private int x = 10; // Creamos una variable miembro public static void main(String[] args) { Ejemplo e = new Ejemplo(); // Creamos un objeto Ejemplo e.cambiar(20); // Cambiamos el valor de x de e Ejemplo e2 = new Ejemplo(); // Creamos otro objeto de Ejemplo System.out.println(e.x); // Vale 20 System.out.println(e2.x); // Vale 10 } private void cambiar(int x) { this.x = x; } }

this es una palabra que apunta al objeto dueño del elemento,en el caso de arriba e.

Bien como vemos se puede cambiar el valor del objeto por referencia cuando se trate de un Objeto,en su momento veremos los arrays y matrices,pero de momento solo puedo decir que los valores que no se pueden cambiar por referencia son los primitivos directamente,ya que aquí cambiamos un primitivo pero haciendo referencia al objeto no al valor en si.

Leer más...

Tutorial Java en Linux Basico 1

Comenzamos con los tutoriales de Java,antes que nada una pequeña aclaración sobre estos tutoriales:

Java es un lenguaje mas avanzado que los que hemos visto hasta ahora ya que se compila,usa definición de tipos y muchas clases para trabajar distintas cosas,así que este lenguaje lo que voy a hacer es como lo hice con bash va a haber un nivel de dificultad para que se entienda o mejor dicho no se complique para los nuevos usuarios,ya que hasta en el programa mas básico que es el hola mundo si explicara todo lo que se usa ahí se complicaría un poco la explicación porque si son usuarios medios/avanzados y quisieran explicar bien como funciona el Hola Mundo en Java desde los modificadores que usa hasta los parámetros que se pasan al main y de ahí explican lo relacionado con eso y luego lo relacionado con eso,pueden explica java a un nivel avanzado,así que voy a dividir los tutoriales en cuatro niveles básico,medio,avanzado y otras cosas como bases de datos,GUI,etc.

En este caso veremos tipos de datos y modificadores:

Nota: Van a faltar algunos,los que considero algo mas avanzados y que veremos en su momento.

En Java para definir una variable tenemos que definir primero el tipo de dato que contiene,por ejemplo no podemos solamente escribir:

variable = 1

o

var = "hola mundo"

Necesitamos definir que tipo de dato contienen,para "ayudarle" a java a administrar la memoria,como en el caso de C.

En el caso anterior seria así:

int variable = 1;

String var = "hola mundo";

En java casi todo son objetos excepto los tipos primitivos,los objetos llamados asi son clases con metodos(funciones),asi que los tipos primitivos no tienen metodos,son solo la definición y el uso que les demos como tal:

Tipos primitivos:


Palabra Tipo                     En memoria

int     Entero                   4 byte

boolean true o false             1 byte

char    Caracter                 2 bytes

long    Entero                   8 bytes

float   Decimal de una precicion 4 bytes

void    Vacio


Cambien contamos con los tipos objeto,que para comenzar mencionaría los tipos envueltos, o wrapper(en ingles),los tipos wrapper son los tipos primitivos pero como Objetos(con Metodos),veamos su equivalentes:

Integer

Boolean

Character

Long

Float

^ Estos  datos son la equivalencia de los primitivos pero en Objetos,para una manipulación en conjunto con otros objetos mas sencilla.

También tenemos los tipos de Objetos de la librería estándar de Java que solo citare en este momento:

String  Cadena de texto

Para definir tipos sencillos de datos siempre es bueno usar los tipos primitivos,por ejemplo no es muy necesario usar:

Integer val = 10;

Vamos a ver los modificadores de acceso que usa Java,los modificadores de acceso lo usa para controlar el alcance de las variables,estos son los modificadores de acceso mas sencillos de java:

public

Este modificador permite acceder a dicho elemento desde cualquier clase o paquete.

private

Este modificador permite acceder a dicho elemento solo desde la clase que lo creo util para los parámetros.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class hola { private int x; hola(int x){ this.x = x; // this menciona x de la clase,x menciona x por parametro } int getX(){ return this.x; // Podemos usar x de la clase } }

final

Este modificador permite crear lo que serian constantes,ya que el valor que se les asigna no puede cambiar,por ejemplo es bueno para crear valores que no cambian,como nombres valores numéricos(como PI),etc.

Cabe mencionar que el valor de final no puede ser cambiado como en principio(su referencia) pero se puede modificar el valor que ya tiene(en objeto),un código explica mejor que yo:

1 2 3 4 5 6 7

final String n = "itimetux.com"; val = "Tiempo de Tux"; // No sirve final String n = "Tiempo de "; String s = n.concat("Tux");

static

El modificador static,este modificador es un poco mas avanzado y no quería mencionarlo pero lo incluye hasta el programa mas simple,ya que lo incluye el main de nuestro programa,así hay que mencionarlo.

El modificador static se usa para evitar hacer referencias de un objeto,por ejemplo tenemos el ejemplo de arriba(el que dice hola),para usar getX seria de esta manera:

hola var = new hola(1); // Primero creamos la referencia

Luego lo llamamos así:

var.getX();

Si fuera static no necesitamos referencias,esta seria la versión:

1 2 3 4 5 6 7 8 9 10 11

class hola { private static int x = 1; static int getX(){ return x; // Podemos usar x de la clase } }

Para llamar la función getX lo hacemos así:

hola.getX();

Aunque también podemos usarlos desde instancias de clases:

hola var = new hola();

var.getX();

Con el modificador static también contamos con una función estatica,o mejor dicho un bloque ya que solo lleva la palabra, static,este es un inicializador statico que se ejecuta una y solo una vez:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class hola { private int x = 10; static { // Inicio estatico System.out.println("Iniciada clase"); } int getX(){ return x; // Podemos usar x de la clase } }

Si en la clase principla usamos:

hola var = new hola();

hola var2 = new hola();

Solo veremos un mensaje.

abstract

Este modificador indica que no se van a implementar los métodos dentro de una clase si no que los implementaran desde clases que se extiendan de las mismas(Lo veremos en herencia).

Bien ahora si vamos a ver el Hola Mundo en Java:

Abrimos un archivo llamado hola.java,por ejemplo:

En terminal,con vim:

vim hola.java

Y en su interior:

1 2 3 4 5 6 7 8 9

public class hola { public static void main(String [] argumentos) { System.out.println("Hola mundo"); } }

Vamos a explicarlo :

1 2 3 4 5

public class hola // Clase publica debe llevar el mismo nombre que el archivo si es publica public static void main(String [] argumentos) // metodo publico,main es el primer metodo que ejecuta el programa,es estatico(static) para que no necesitemos referencia,es vacio(void) porque no tiene retorno,los agumentos pasados son indefinidos,podemos pasarlos desde la linea de comandos,por eso son recibidos en el constructor mediante un array de Strings. System.out.println("Hola mundo"); // Salida estandar,tambien tenemos print,printf,println agrega "\n" nueva linea

Bien como vemos no es muy complicado un poco mas largo que en los lenguajes como ruby,python,lua pero es sencillo si se comprende.

Para ejecutar debemos compilar:

javac hola.java

Luego ejecutamos así:

java hola

De hecho se nos crea un archivo hola.class,pero no es necesesario el .class al ejecutar.

Leer más...

Como instalar Java JDK en Ubuntu 13.10

Bien este es primer tutorial de Java para Linux,en este caso Ubuntu 13.10,lo primero que vamos a hacer es instalar las herramientas de desarrollo para Java(Java Development Kit) es muy sencillo solo basta con algunos comandos en la terminal asi que abrimos una:

Ctrl+Alt+T

Para instalar la version libre open-jdk hay que escribir :

sudo apt-get install icedtea6-plugin # No tan necesario,solo para applets

sudo apt-get install openjdk-7-jdk

Para instalar la version de Oracle

Añadimos su repositorio:

sudo add-apt-repository ppa:webupd8team/java 

Hacemos un update:

sudo aptitude update 

Y instalamos y iniciamos el instalador:

sudo apt-get install oracle-java7-installer  

Aceptamos la licencia y esperamos a que instale.

Y listo,podemos ver la versión de javac con:

javac -version 

Con esto podemos utilizar el compilador de java y java para los tutoriales que se realizaran en el sitio,también pueden usar como eclipse para un desarrollo rápido y sencillo.

Leer más...

Resultados Java vs Ruby vs PHP-CLI en itimetux

Bien como dije hace unos meses dos para ser exacto o yo diría uno,porque Tiempo de Tux estuvo caído 1 mes por algunas cuestiones,hice una pequeña prueba para ver que nuevo lenguaje de programación seria bueno para el sitio:

Si conocen el sitio desde hace como un año estoy escribiendo tutoriales de lenguajes de scripting,quería pasar a algo mas avanzado con C# pero no funciono,luego pensé en C pero aun me falta aprender para poder enseñar,los lenguajes del sitio son:

Bash

Perl

Python

Lua

Hice una entrada para cada lenguaje que conozco ademas de esos, de los cuales podría enseñar, los cuales fueron Ruby,Java y PHP desde terminal,el ganador fue Java,ya que en visitas gano,en comentarios gano,no son resultados muy grandes pero no hay que juzgar por las estadísticas de visitas si no por la diferencia entre las mismas poniéndolas en un grado de porcentaje.

Así que tendremos Java pronto en este sitio,sera desde el principio hasta donde se permita,por ejemplo:

Tipos de datos

Estructuras selectivas

Interfaces

Paquetes

Alcance de variables

Bases de datos

Scripting, por ejemplo Rhino

Librerias

Gtk

Y mas.

Leer más...

Decoración en las ventanas de Ubuntu 13.10 Unity como en KDE

A lo que me refiero con el titulo de esta entrada es tener un color azul en el contorno de nuestras ventanas en Unity,bueno no necesariamente es azul en KDE pero es el color por defecto ya que nosotros podemos cambiar eso,tampoco es azul por defecto en este ejemplo pero podemos ponerlo azul o del color que queramos:

Como ven yo elegí un color azul y cuando están en segundo plano un color rojo.

Tutorial

Primero que nada abrimos una terminal(ctrl+alt+t) y escribimos:

sudo apt-get install compizconfig-settings-manager

Con eso instalamos compiz config,luego lo buscamos en el Dash:

Lo abrimos y vamos a Decoración de ventanas:

Luego elegimos en Active Shadow el color para las ventanas en primer plano y en Inactive Shadow el color para las ventanas en segundo plano,también podemos elegir el tamaño y otras cosas,por ultimo activamos el plugin con el checkbox de la izquierda:

Eso es todo :D.

Leer más...

Tutorial python gtk3 Spinner y ProgressBar

En muchas ocasiones necesitamos mostrar una pequeña señal de que algo esta pasando,cuando estamos ejecutando una tarea y necesitamos que algo este respondiendo a dicha acción,por ejemplo cuando descargamos algo,cuando movemos archivos,cuando salvamos un documento,etc.

En muchos casos de muchos sistemas vemos los spinners,loc cuales son un widget que giran o se hacen presentes hasta que son necesarios,por ejemplo en windows cuando esta una tarea ocupada vemos que el cursor se convierte en un spinner,luego en otros casos cuando necesitamos un dialogo mas preciso nos encontramos con las barras de progreso o progressbar en ingles,los barras de progreso nos muestran una información mas exacta en casos en los cuales los spinners no son suficientes,en este caso veremos como funcionan ambos widgets en Gtk3 + Python.

Spinner:

Para crear un spinner se usa el constructor Gtk.Spinner(),al cual le podemos pasar el parámetro active para que le digamos al constructor si queremos que comience en movimiento:

self.spinner = Gtk.Spinner(active=True) # Comienza en movimiento

self.spinner = Gtk.Spinner() # Comienza quieto

Las únicas dos funciones que tenemos en este widget es start y stop una para iniciar y otro para comenzar,vamos a crear una ventana de ejemplo para ver como funciona:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class SpinnerEjemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Spinner") self.set_border_width(5) self.connect("delete-event", Gtk.main_quit) self.vbox = Gtk.Box(spacing=5) self.button = Gtk.ToggleButton("Girar") self.button.connect("toggled", self.on_start) # Este boton manipula el spinner self.button.set_active(False) self.vbox.pack_start(self.button,True,False,10) self.spinner = Gtk.Spinner() # Creamos un spinner self.vbox.pack_start(self.spinner,True,False,10) self.add(self.vbox) self.show_all() def on_start(self, widget): if widget.get_active(): # widget es el boton si esta activo self.spinner.start() # Iniciamos el widget self.button.set_label("Detener") else: # Si no self.spinner.stop() # Lo detenemos self.button.set_label("Girar") myspinner = SpinnerEjemplo() Gtk.main()

Como vemos es muy simple mostrar un  spinner,en el caso del progressbar es un poco mas complicado pero a la vez esto nos da mas posibilidades de personalización y una mayor descripción de la situación:

ProgresBar:

Para crear un ProgressBar se usa el constructor Gtk.ProgressBar(),primero que nada vamos a crear un ejemplo sencillo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class SpinnerEjemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Progressbar") self.set_border_width(5) self.connect("delete-event", Gtk.main_quit) self.vbox = Gtk.Box(spacing=5) self.button = Gtk.ToggleButton("Iniciar") self.button.connect("toggled", self.on_control) # Este boton manipula el spinner self.button.set_active(False) self.vbox.pack_start(self.button,True,False,10) self.progressbar = Gtk.ProgressBar() # Creamos un ProgressBar self.vbox.pack_start(self.progressbar,True,False,10) self.timeout_id = GObject.timeout_add(100, self.on_start, None) # Esta funcion es mantiene el ciclo de on_start # en milisegunos self.controller = False # Creamos un controlador self.add(self.vbox) self.show_all() def on_control(self,widget): self.controller = widget.get_active() # Cambiamos el valor del controlador al valor del boton if self.controller: self.button.set_label("Pausar") else: self.button.set_label("Continuar") def on_start(self, widget): # Esta funcion se ejecuta cada 100 milisegundos basado en el retorno de la misma if self.controller: # Si el controlador es True new_value = self.progressbar.get_fraction() + 0.01 # Añade una centecima if new_value > 1: # Si el valor es uno(completo) new_value = 0 # Reiniciamos a cero(vacio) self.progressbar.set_fraction(new_value) # Colocamos la fraccion return True myspinner = SpinnerEjemplo() Gtk.main()

Como vemos,he usado una función de la clase de ProgressBar,las cuales es:

set_fraction(new_value) # new_value es un entero a punto flotante 0,por ejemplo:

0.99,0.10,0.01,etc # 1 es lleno

También tenemos otras mas:

pulse() # Esta función hace que sea indefinida la barra de progreso,ya que solo va de un lado a otro.

set_inverted(bool) # Esta función invierte la forma que se llena el progressbar si el parámetro pasado es True.

set_orientation(orientacion) # Esta función cambia la forma de la orientación,por defecto es horizontal,pero podemos cambiarla a vertical pasandole como parámetro Gtk.Orientation.VERTICAL.

set_show_text("Porcentaje") # Muestra el progreso de la barra en porcentaje.

set_text("Texto") # Coloca texto a la barra.

De momento eso es todo,en otra ocasión veremos las labels,menus,etc.

Leer más...