Tiempo de Tux: basicos

Mostrando las entradas con la etiqueta basicos. Mostrar todas las entradas

miércoles, 15 de enero de 2014

Tutorial Java en Linux Basico 6

En este tutorial veremos Objetos.

Un Objeto es una instancia de una clase,un Objeto se puede tratar separado de los demás teniendo sus propios métodos y variables,para crear un método de una clase se usa la sintaxis:

Clase objeto = new Clase();

Lo que se pasa entre paréntesis es lo que recibe como argumentos el constructor.

Vayamos por partes:

La clase mas simple y que siempre se usa es donde esta el main,por ejemplo nuestro programa HolaMundo.java tiene esto adentro:

class HolaMundo {
    public static void main(String [] args) {
        System.out.println("Hola Mundo");
    }
}

Como ven pueden pensar que el main es el constructor,pero primero hay que saber que es un constructor,en mis palabras un constructor es:

Una función que se ejecuta antes que ninguna para inicializar o ejecutar acciones especificas.

En java todas las clases publicas deben tener el nombre del archivo que las contiene,en este caso HolaMundo,porque el archivo es HolaMundo.java.

Como crear un constructor?

El constructor es una función sin retorno y sin modificadores,esta debe tener el mismo nombre de la clase,vamos a crear un constructor para ese código:

1
2
3

HolaMundo(int x) {
    System.out.println("Hola se a creado el objeto numero "+x);
}

Este constructor lo único que hace es mostrar el numero de veces que se ha creado el archivo,basado en el paso por argumentos,veamos el código completo:

class HolaMundo {
    HolaMundo(int x) { // Constructor
        System.out.println("Hola se a creado el objeto numero "+x);
    }
    public static void main(String [] args) {
        System.out.println("Hola Mundo");
        for (int i = 1;i < 11;i++) {
            HolaMundo objeto = new HolaMundo(i); // Creamos objetos basados en el bucle
        }
    }
}

Eso demuestra como se crean los constructores y como es que se ejecutan,no es el mejor ejemplo y de hecho veo mala practica al usar una variable renovada en cada iteracion del bucle,pero eso no es lo que importa,lo que importa es ver como se ejecuta lo que esta adentro del constructor.

Algunas cosas que debemos saber de un constructor es que:

1. Siempre hay un constructor aunque no creemos uno javac lo hace por nosotros.

2. Puede haber mas de un constructor (overloaded;lo veremos mas adelante).

3. Repito, un constructor no lleva ni modificador y modificador de acceso.

Ahora si podemos ver algo un poco mas bueno que la mala practica de arriba,por ejemplo si queremos ver cuantas veces se ha creado un objeto usamos una variable static,como dije en el primer tutorial una variable de modificador static solo se crea una vez,solo una vez.

Algunas cosas que hay que saber o recordar de static:

1. No se considera OOP.

2. Solo se crea una vez.

3. Solo se pueden usar metodos static en métodos del mismo tipo de modificador(static),pero no así a la inversa.

4. Los métodos static en una clase se consideran métodos de clase y no métodos de objeto.

Veamos un ejemplo:

class Ejemplo {
 private static int veces = 0;

 Ejemplo() {
  System.out.println("Hola se a creado el objeto numero " + veces);
  veces++;
 }

 public static void main(String[] args) {
  System.out.println("Hola Mundo");
  Ejemplo objeto = new Ejemplo();
  Ejemplo objeto1 = new Ejemplo();
  Ejemplo objeto2 = new Ejemplo();
 }
}

De ese modo podemos usar esa variable static para ver como cuantas veces se ejecuta,como dije los métodos static en una clase se llaman métodos de clase,para llamarlos no necesitamos crear un objeto,por ejemplo:

1
2
3

public static void getVeces() {
 System.out.println("Numero de objetos creados: "+veces);
}

Para usar este metodo no tenemos que instanciar un objeto y luego llamar el metodo:

Ejemplo objeto = new Ejemplo();

objeto.getVeces();

Aunque si funciona,lo que podemos hacer es:

Ejemplo.getVeces(); // Directamente

O mejor aun,las variables static se llaman variables de clase y podemos llamarlas asi:

Ejemplo.veces;

Código completo:

class Ejemplo {
 private static int veces = 0;

 Ejemplo() {
  System.out.println("Hola se a creado el objeto numero " + veces);
  veces++;
 }

 public static void main(String[] args) {
  System.out.println("Hola Mundo");
  Ejemplo objeto = new Ejemplo();
  Ejemplo objeto1 = new Ejemplo();
  Ejemplo objeto2 = new Ejemplo();
  Ejemplo.getVeces();
 }

 public static void getVeces() {
  System.out.println("Numero de objetos creados: "+veces);
 }
}

Como vemos estamos trabajando solo con la clase del main,pero como creamos nuevas,para crear otras clases podemos hacerlo de distintas maneras para distintas ocasiones,ya que podemos crear clases locales,anónimas,etc pero en este caso veremos clases normales,al gual que la que guarda el main.

Para crear una clase creamos un archivo en el mismo PATH(directorio) donde esta el main,en su momento también hablaremos de paquetes,pero de momento creen una clase,llamada Animales.java:

Esta clase va ademas de la que contiene el main que se llama Ejemplo.java:

vim Animales.java

La clase debe ser publica y el nombre debe ser el mismo del archivo:

public class Animales {

}

Vamos a crear unas funciones y variables para definir un animal,las cuales deben ser private:

Las variables private solo son visibles para la misma clase,objeto instanciado no lo podra llamar,lo cual hace que sean ocultadas para todo lo que no sea la misma clase,a esto se le conoce en el OOP como encapsulamiento.

Vamos a crear las variables:

private String especie;
private String sexo;
private boolean hambre = true;

Luego vamos a crear un constructor que reciba como parámetros las mismas variables,pero estas seran para definir las variables miembro(las de arriba):

Animales (String e,String s) {
especie = e;
sexo = s;
}

Ahora debemos crear una funcion que nos muestre el nombre,el sexo y si tiene hambre,ademas de una funcion para dar de comer:

Primero las funciones para ver el sexo y la especie,como son variables privadas no las podemos ver,asi que vamos a retornarlas como String,para ello tenemos que usar el token this,ya que this hace referencia a la variable del objeto actual,asi:

public String getEspecie() {
return this.especie;
}

Código completo:

public class Animales {
 private String especie;
 private String sexo;
 private boolean hambre = true;
 public Animales(String e,String s) {
  especie = e;
  sexo = s;
 }
 public String getSexo() {
  return this.sexo;
 }
 public String getEspecie() {
  return this.especie;
 }
 public void tienesHambre() {
  if (hambre)
   System.out.println("Tengo hambre :(");
  else 
   System.out.println("No tengo hambre :D");
 }
 public void darDeComer() {
  this.hambre = false;
 }
}

Como ven uso this para retornar,pero tambien se puede usar para definir,por ejemplo que los parámetros tuvieran el mismo nombre,usariamos this para hacer referencia a la variable miembro:

public Animales(String especie,String sexo) {
 this.especie = especie;
 this.sexo = sexo;
}

Ahora en la clase Ejemplo podemos crear un animal:

class Ejemplo {
 public static void main(String[] args) {
  Animales Mono = new Animales("Primate", "Macho");
  System.out.println(Mono.getEspecie());
 }
}

De esa manera hemos usado una clase mas ademas de la que contiene el main,podemos crear tantos animales como queramos y nuevos métodos,pero eso no es lo importante ahora ya que por ejemplo,en este ejemplo a la hora de comer se define en true,pero como vuelve a false(darle hambre de nuevo),pues esto lo veremos cuando veamos Threads,y como poder definir un animal mas especifico,esto lo veremos en herencia,pero de momento solo vimos como crear un objeto de una clase ajena al main.

Al ejecutar veremos esto:

Bien,algo que falta explicar en este tutorial basico de creación de objetos es la sobrecarga de métodos en la cual también veremos la sobrecarga de constructores:

En una clase puede haber distintos metodos con el mismo nombre,pero como se diferencian?

Con el simple hecho del paso por parametros:

Podemos tener estas dos funciones en la misma clase:

public void verNumero() {
 System.out.println(veces);
}
public void verNumero(String x) {
 System.out.println(x+veces);
 
}

Esto hará que podamos usar en el objeto:

Objeto.verNumero();

Objeto.verNumero("Veces creado : ");

Como dije lo único que lo distingue son los parametros,podriamos decir que lo distinguen los retornos,pero no,ya que el compilador no puede reconocer esto:

public void verNumero() {
 System.out.println(veces);
}
public int verNumero() {
 return veces;
 
}

Bien,de igual manera pasa con los constructores,podemos definir dos constructores para los Animales,supongamos esto,podemos darle de comer antes de crearlo,asi que así seria el constructor:

public Animales(String e,String s,boolean x) {
 especie = e;
 sexo = s;
 hambre = x;
}

Esto aun teniendo el constructor pasado, de esta manera podemos usar dos constructores:

new Animales("Primate", "Hembra");

new Animales("Primate", "Hembra",false);

Aunque no se obstruye uno con otro es recomendable iniciar todos los constructores,para ello usamos this,pero ahora con parámetros:

Por ejemplo llamamos:

Animales mono = new Animales("Primate", "Hembra");

En el constructor usamos this antes que nada:

public Animales(String e,String s) {
 this(e,s,false);
 especie = e;
 sexo = s;
}

El this inicia el otro constructor.

Como dije al principio podemos si no usamos constructores el compilador creara uno,si existen variables miembro sin iniciar,las cuales iniciaremos en un método,las variables se inician al valor por defecto:

Por ejemplo int 0,String u Objeto null,etc:

public class Ejemplo2 {
 private int vint;
 private boolean vbool;
 private char vchar;
 private short vshort;
 private long vlong;
 private double vdouble;
 private String vString;
 
 public void ver() {
  System.out.println(vint);
  System.out.println(vbool);
  System.out.println(vchar);
  System.out.println(vshort);
  System.out.println(vlong);
  System.out.println(vdouble);
  System.out.println(vString);
 }
}

En el main:

class Ejemplo {
   public static void main(String[] args) {
   Ejemplo2 ejemplo = new Ejemplo2();
   ejemplo.ver();
   }

}

Aqui terminal la sexta parte de los tutoriales de Java.

sábado, 28 de diciembre de 2013

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

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.

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:

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:

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:

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:

public class hola {

   public static void main(String [] argumentos) {

      System.out.println("Hola mundo");

   }

}

Vamos a explicarlo :

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.

martes, 6 de marzo de 2012

Comandos UNIX basicos para empezar

Existen muchísimos comandos para UNIX que podemos ejecutar desde linux,OS X,o otros tipos,pero en si, lo que podemos unificar son los comandos que introducimos en nuestra terminal los cuales son:

Estos son algunos

ls
muestra el contenido de un directorio

echo
hace eco en pantalla

Ejemplo:

$ echo hola mundo!

cat
muestra el contenido de un fichero

more
muestra el contenido de un fichero haciendo pausas entre pantallas si el
fichero es largo

man
muestra la página del manual de un comando

Ejemplo:

$ man ls

clear
borra la pantalla

cp
copia ficheros y directorios

Ejemplo:

$ cp fichero_original fichero_copia

mv
mueve ficheros

Ejemplo:

$ mv fichero fichero2

rm
borra ficheros

Ejemplo:

$ rm fichero

ln
enlazar (referenciar) ficheros

Ejemplo de enlace "duro" (hardlink):

$ ln fichero enlace

Ejemplo de enlace "suave" (softlink):

$ ln -s fichero enlace_simbólico

cd
cambia de directorio de trabajo si no se indica directorio,
nos traslada a $HOME

Ejemplo:

$ cd directorio

pwd
muestra el directorio de trabajo actual

mkdir
crea directorios

Ejemplo:

$ mkdir directorio

rmdir
borra directorios (vacíos)

Ejemplo:

$ rmdir directorio

env
muestra las variables de entorno del programa

head
muestra las n primeras lineas de un fichero (10 por defecto)

Ejemplo:

$ head fichero

tail
muestra las n últimas lineas de un fichero (10 por defecto)

Ejemplo:

$ tail fichero

grep
busca ocurrencias de una cadena en un fichero

Ejemplo:

$ grep cadena fichero

ps
muestra los procesos en el sistema

kill
Envía una señal a un proceso indicando su PID (Process IDentifier,
o número único que identifica a cada proceso)

Ejemplo:

$ kill 1002

export
Exporta una variable al entorno del programa

Ejemplo:

$ export VARIABLE=valor

read
Lee una linea de la entrada estándar y la almacena en una variable

Ejemplo:

$ read linea

$
Delante de una variable permite acceder a su contenido

Ejemplo:

$ echo $SHELL

;
Separa dos comandos en una misma linea

Ejemplo:

$ read linea ; echo se ha leído: $linea

file
indica de qué tipo es un fichero

cal
muestra el calendario del mes actual

wc
cuenta lineas, palabras o bytes en ficheros

Ejemplo:

$ echo hola que tal | wc

date
muestra hora y fecha actuales

Ejemplo:

$ date

Ejemplo de fecha en formato yyyy-mm-dd:

$ date "+%Y-%m-%d"

passwd
cambia la contraseña de un usuario

chmod
cambia los permisos de un fichero

chown
cambia el propietario de un fichero

chgrp
cambia el grupo propietario de un fichero

reset
restaura la terminal de texto

whereis
indica donde se puede encontrar un fuente, binario o manual

Ejemplo:

$ whereis ls

which
indica donde está un comando

Ejemplo:

$ which ls

locate
busca ficheros

find
búsqueda avanzada de ficheros

who
quién tiene sesión abierta en la máquina

tac
concatena ficheros y los muestra a la inversa

touch
actualiza la fecha y hora de un fichero, si no existe lo crea

Ejemplo:

$ touch fichero_inexistente

less
una versión más elaborada de more que permite
desplazarnos por el texto, hacer búsquedas, etc.

df
muestra el espacio libre y ocupados de los discos

du
calcula el espacio de disco usado

mail
programa simple para enviar y leer correo

tar
empaquetar ficheros

Ejemplo empaquetar:

$ tar cvf fichero.tar directorio

Ejemplo desempaquetar:

$ tar xvf fichero.tar

gzip
comprimir un fichero

gunzip
descomprimir un fichero comprimido con gzip

zcat
muestra el contenido de un fichero comprimido con gzip

ldd
muestra las librerías que usa un programa

halt
apaga la máquina

reboot
reinicia la máquina

Esta información fue vista en

blackshell.usebox.net

Visitenla para mas info:D