En esta guía aprenderemos a obtener información de los recursos sistema en Java, usando la librería Sigar. Los datos que podremos extraer son los siguientes:

• Información de la CPU.
• Espacio en disco disponible.
• Cantidad de espacio que consume un directorio en específico.
• Cantidad de memoria RAM disponible y en uso.
• Información de red (dirección IP, nombre de la NIC, puertos abiertos, tablas de enrutamiento, etc.)
• Información de los procesos que se están ejecutando en el sistema.
• Asignación de variables de entorno.
• Uptime, o cantidad de tiempo que el equipo ha estado encendido.
• Nombre y versión del sistema operativo.
• Usuarios logueados actualmente.

Resaltadas en negrita está la información en la que nos concentraremos en el ejemplo. Pero antes aclaremos un poco que es Sigar: el API de Sigar nos proporciona una serie de métodos que nos permiten obtener información del sistema operativo; consta de una librería de Java (.jar) y otras librerías nativas específicas para cada sistema operativo soportado (libsigar-amd64-linux.so, para Linux de 64 bits o sigar-x86-winnt.dll para Windows de 32 bits, por poner un ejemplo).

Teniendo esto en cuenta, para hacer funcionar dicha API en una de nuestras aplicaciones, bastaría con tener el archivo .jar y la librería específica de nuestro sistema operativo. En el desarrollo del ejemplo se usará Eclipse y, aunque se explicará cómo añadir las librerías en el proyecto, se da por conocido el funcionamiento del flag --classpath de los comandos javac y java (obligatorio si no se usa ningún IDE).

El resultado…

Siempre pongo primero el resultado ya que nos aclara la visión de hacia donde vamos, y de paso saber si lo que está aquí es lo que buscamos. Esta es la salida del programa en mi Gentoo Linux:

====Informacion del sistema====
Descripcion del SO	Gentoo 2.1.6
Nombre del SO		Linux
Arquitectura del SO	x86_64
Version del SO		2.6.31-gentoo
Nivel de parches	unknown
Fabricante		Gentoo
Version SO		2.1.6
Encendido durante:	6:15

==== Informacion de la CPU ====
Fabricante:		Intel
Modelo			Core(TM)2 Duo CPU     T5750  @ 2.00GHz
Mhz			1994
Total CPUs		2
CPUs fisiscas		1
Nucleos por CPU		2
Tamanio cache		2048

Consumo de CPU 0	22.0%
Consumo de CPU 1	2.0%
Consumo total de CPU	6.0%

====Informacion del sistema de archivos====

dispos.|total|usado|disponible|%uso|dir|tipo

/dev/root|24042944|10698228|12123376|47%|/|ext4
/dev/sda1|175457764|155825380|10719932|94%|/home|ext3

====Informacion de la memoria====
Cantidad de memoria RAM: 3968MB
Total: 4056984
Usada: 2307076
Disponible: 1749908
Memoria SWAP total: 1052248
Memoria SWAP usada: 0
Memoria SWAP libre: 1052248

Descargar Sigar

Puedes descargar Sigar de la página oficial: http://support.hyperic.com/display/SIGAR/Home que incluye además ejemplos para Java, Perl, C, Python, Ruby, y más. Puedes además descargar el código fuente que se encuentra licenciado bajo la GPL2.

Creación del proyecto en Eclipse

Voy a usar este ejemplo para además enseñar a manipular librerías externas en Eclipse; si lo que te interesa es conocer el código, puedes saltarte a dicha sección directamente.

Creamos un proyecto en Eclipse llamado InfoSistema:

Ahora creamos una carpeta dentro del proyecto llamada lib, en donde guardaremos las librerías de Sigar (.jar, .so, .dll, etc.):

Ahora descomprimimos el archivo que descargamos de Sigar, y copiamos los archivos que se encuentran en la carpeta sigar-bin/lib a la carpeta lib de nuestro proyecto. En mi caso la copia la hice con este comando:

Cabe resaltar que bastaría con copiar el archivo llamado sigar.jar y la librería del sistema donde vamos a correr nuestro programa (libsigar-amd64-linux.so en mi caso).

Una vez hecha la copia, hacemos clic en la raiz del proyecto en Eclipse y presionamos F5 para actualizar el árbol de ficheros; de esta manera Eclipse sabrá de los nuevos archivos que hemos copiado. Y lo que haremos a continuación será enlazar la librería sigar.jar a nuestro proyecto, para lo cual hacemos clic derecho en el mismo, Build Path -> Configure Build Path…

En la ventana que aparece, seleccionaremos la pestaña Libraries y hacemos clic en el botón Add JARs… Seleccionamos el archivo sigar.jar y hacemos clic en OK:

Ahora que la librería se encuentra añadida, podemos utilizar el API que Sigar nos ofrece. ¡Pasemos entonces al código!

Información del sistema…

La siguiente clase nos permite obtener información del sistema operativo, como el nombre, la versión, la arquitectura, etc. Creamos una nueva clase llamada InfoSO con el siguiente código:

import org.hyperic.sigar.OperatingSystem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoSO {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() {
		OperatingSystem sys = OperatingSystem.getInstance();
		System.out.println("Descripcion del SO\t" + sys.getDescription());
		System.out.println("Nombre del SO\t\t" + sys.getName());
		System.out.println("Arquitectura del SO\t" + sys.getArch());
		System.out.println("Version del SO\t\t" + sys.getVersion());
		System.out.println("Nivel de parches\t" + sys.getPatchLevel());
		System.out.println("Fabricante\t\t" + sys.getVendor());
		System.out.println("Version SO\t\t" + sys.getVendorVersion());
		try {
			imprimirUptime();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
	public void imprimirUptime() throws SigarException {
		double uptime = sigar.getUptime().getUptime();
		String resultado = "";
		int dias = (int) uptime / (60 * 60 * 24);
		int minutos, horas;
		if (dias != 0)
			resultado += dias + " " + ((dias > 1) ? "dias" : "dia") + ", ";
		minutos = (int) uptime / 60;
		horas = minutos / 60;
		horas %= 24;
		minutos %= 60;
		if (horas != 0)
			resultado += horas + ":" + (minutos < 10 ? "0" + minutos : minutos);
		else
			resultado += minutos + " min";
		System.out.println("Encendido durante:\t" + resultado);
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para recuperar información del sistema operativo es OperatingSystem.
• Con los métodos getName y getDescription obtenemos el nombre del sistema operativo y descripción (por ejemplo: nombre = Linux; descripción = Gentoo 2.1.6).
• El método getUptime de la clase Sigar nos permite conocer cuanto tiempo ha estado prendido el equipo analizado.

Información de la CPU…

La siguiente clase nos permitirá conocer el modelo del procesador, sus capacidades, la cantidad de núcleos y el uso de los mismos, etc. Creamos una nueva clase llamada InfoCPU con el siguiente código:

import org.hyperic.sigar.CpuInfo;
import org.hyperic.sigar.CpuPerc;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoCPU {
	private Sigar sigar;

	public void imprimirInfoCPU() {
		sigar = new Sigar();
		CpuInfo[] infos = null;
		CpuPerc[] cpus = null;
		try {
			infos = sigar.getCpuInfoList();
			cpus = sigar.getCpuPercList();
		} catch (SigarException e) {
			e.printStackTrace();
		}

		CpuInfo info = infos[0];
		long tamanioCache = info.getCacheSize();
		System.out.println("Fabricante:\t\t" + info.getVendor());
		System.out.println("Modelo\t\t\t" + info.getModel());
		System.out.println("Mhz\t\t\t" + info.getMhz());
		System.out.println("Total CPUs\t\t" + info.getTotalCores());
		if ((info.getTotalCores() != info.getTotalSockets())
				|| (info.getCoresPerSocket() > info.getTotalCores())) {
			System.out.println("CPUs fisiscas\t\t" + info.getTotalSockets());
			System.out
					.println("Nucleos por CPU\t\t" + info.getCoresPerSocket());
		}

		if (tamanioCache != Sigar.FIELD_NOTIMPL)
			System.out.println("Tamanio cache\t\t" + tamanioCache);
		System.out.println("");

		for (int i = 0; i < cpus.length; i++)
			System.out.println("Consumo de CPU " + i + "\t"
					+ CpuPerc.format(cpus[i].getUser()));

		try {
			System.out.println("Consumo total de CPU\t"
					+ CpuPerc.format(sigar.getCpuPerc().getUser()));
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Aspectos importantes:

• Se deben usar objetos de CpuInfo y CpuPerc que proporcionan los métodos para recuperar información del procesador. Dichos objetos se crean a partir de un objeto principal de tipo Sigar.
• Para extraer información acerca del procesador usamos los métodos de la clase CpuInfo (por ejemplo getVendor o getModel).
• Los datos específicos de cada núcleo de nuestro procesador se extraen con los métodos de la clase CpuPerc (getUser para obtener el uso de un núcleo, por ejemplo).

Información del sistema de archivos…

La siguiente clase nos permite obtener información del sistema de archivos: unidades montadas, espacio en disco, tipo de sistema de archivos, etc. Creamos una nueva clase llamada InfoSistemaArchivos con el siguiente código:

import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;
import org.hyperic.sigar.FileSystem;
import org.hyperic.sigar.FileSystemUsage;
import org.hyperic.sigar.NfsFileSystem;
import org.hyperic.sigar.SigarProxy;
import org.hyperic.sigar.SigarProxyCache;

public class InfoSistemaArchivos {
	private SigarProxy proxy;
	private Sigar sigar;

	public InfoSistemaArchivos() {
		sigar = new Sigar();
		proxy = SigarProxyCache.newInstance(sigar);
	}

	public void imprimirInfo() throws SigarException {
		FileSystem[] listaSistemaArchivos = proxy.getFileSystemList();
		System.out.println("\ndispos.|total|usado|disponible|%uso|dir|tipo\n");
		for (int i = 0; i < listaSistemaArchivos.length; i++)
			imprimirSistemaArchivos(listaSistemaArchivos[i]);
	}

	public void imprimirSistemaArchivos(FileSystem sistemaArchivos)
			throws SigarException {
		long usado, disponible, total, porcentaje;

		try {
			FileSystemUsage uso;
			if (sistemaArchivos instanceof NfsFileSystem) {
				NfsFileSystem nfs = (NfsFileSystem) sistemaArchivos;
				if (!nfs.ping()) {
					System.out.println(nfs.getUnreachableMessage());
					return;
				}
			}
			uso = sigar.getFileSystemUsage(sistemaArchivos.getDirName());

			usado = uso.getTotal() - uso.getFree();
			disponible = uso.getAvail();
			total = uso.getTotal();

			porcentaje = (long) (uso.getUsePercent() * 100);
		} catch (SigarException e) {
			// por ejemplo, si en al procesar D:\ en windows falla
			// con "Device not ready"
			usado = disponible = total = porcentaje = 0;
		}

		String porcentajeUso;
		if (porcentaje == 0)
			porcentajeUso = "-";
		else
			porcentajeUso = porcentaje + "%";

		System.out.print(sistemaArchivos.getDevName());
		System.out.print("|" + total);
		System.out.print("|" + usado);
		System.out.print("|" + disponible);
		System.out.print("|" + porcentajeUso);
		System.out.print("|" + sistemaArchivos.getDirName());
		System.out.println("|" + sistemaArchivos.getSysTypeName());
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para obtener información de una unidad en específico es FileSystem.
• El método getDevName nos devuelve el nombre del dispositivo referenciado por el objeto de la clase FileSystem.
• Los métodos getTotal y getAvail devuelven un long que representa el espacio total del dispositivo y espacio disponible, respectivamente.
• Para conocer el tipo de sistema de archivos (ext4, ntfs, fat, btrfs, etc.) utilizamos el método getSysTypeName.

Información de la memoria…

La siguiente clase nos permite conocer la cantidad de memoria RAM que tiene el equipo, así como la que se está usando actualmente (tanto memoria física como virtual, aka, swap). Creamos una nueva clase llamada InfoMemoria con el siguiente código:

import org.hyperic.sigar.Mem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.Swap;
import org.hyperic.sigar.SigarException;

public class InfoMemoria {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() throws SigarException {
		Mem memoria = sigar.getMem();
		Swap intercambio = sigar.getSwap();

		System.out.println("Cantidad de memoria RAM: "+ memoria.getRam() + "MB");

		System.out.println("Total: "+enBytes(memoria.getTotal()));
		System.out.println("Usada: "+enBytes(memoria.getUsed()));
		System.out.println("Disponible: "+enBytes(memoria.getFree()));

		System.out.println("Memoria SWAP total: "+enBytes(intercambio.getTotal()));
		System.out.println("Memoria SWAP usada: "+enBytes(intercambio.getUsed()));
		System.out.println("Memoria SWAP libre: "+enBytes(intercambio.getFree()));

	}
	private Long enBytes(long valor) {
		return new Long(valor / 1024);
	}
}

Aspectos importantes:

• La clase Mem nos proporciona métodos para obtener información de la memoria del sistema.
• La clase Swap hace lo mismo que Mem, pero para la memoria virtual.
• Los métodos getTotal y getUsed nos devuelven un long que representa (en bits) la cantidad de memoria del equipo y lo que está usando, respectivamente.

La clase main…

El main de nuestro proyecto estará contenido en la clase InfoSistema:

import org.hyperic.sigar.SigarException;
public class InfoSistema {
	public static void main(String[] args) {
		try {
			System.out.println("====Informacion del sistema====");
			new InfoSO().imprimirInfo();
			System.out.println("\n==== Informacion de la CPU ====");
			new InfoCPU().imprimirInfoCPU();
			System.out.println("\n====Informacion del sistema de archivos====");
			new InfoSistemaArchivos().imprimirInfo();
			System.out.println("\n====Informacion de la memoria====");
			new InfoMemoria().imprimirInfo();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Eso es todo, solo nos queda ejecutar el proyecto y, opcionalmente, crear un archivo .jar para ejecutar en cualquier lado.

Descargas…

• Descarga del código fuente usado en esta entrada
• Descargar librerías de Sigar de SourceForge

Este es un tip bastante útil que nos permitirá poner las ventanas de nuestras aplicaciones en Fullscreen (pantalla completa), y de paso aprenderemos a crear ventanas sin bordes (lo cual es útil si queremos hacer algún splash de inicio para nuestra aplicación).

En el siguiente ejemplo usaremos básicamente los siguientes métodos y clases:

• Método setUndecorated de la clase JFrame, el cual recibe un parámetro boolean. Si le enviamos true, quitará los bordes de la ventana.
• La clase GraphicsDevice nos permite manejar objetos que representan dispositivos gráficos, como la pantalla del computador. En este caso creamos el  objeto con la instrucción GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); que nos devuelve un objeto que representa la pantalla en donde se está mostrando nuestro programa.
• El método setFullScreenWindow, de la clase GraphicsDevice, nos permite poner nuestro programa en pantalla completa. Además, aunque no lo usemos en el ejemplo, contamos con el método isFullScreenSupported que nos permite saber si es posible poner la ventana en modo fullscreen o no.

Código fuente del ejemplo…

import javax.swing.*;
import java.awt.GraphicsEnvironment;
import java.awt.GraphicsDevice;
import java.awt.event.*;

public class EjemploFullscreen extends JFrame implements ActionListener{
        private JButton boton;
        private boolean estaFull = false;
        static GraphicsDevice grafica=
                GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
        public EjemploFullscreen() {
                super("Ejemplo pantalla completa en Java");

                boton = new JButton("Presioname");
                boton.addActionListener(this);
                getContentPane().add(boton);

                setSize(640, 400);
                setUndecorated(true);
                setVisible(true);
        }

        public static void main(String[] args) {
                new EjemploFullscreen();
        }

        public void actionPerformed(ActionEvent e) {
                if(!estaFull)
                        grafica.setFullScreenWindow(this);
                else
                        grafica.setFullScreenWindow(null);
                estaFull = !estaFull;
        }
}

Descargar código fuente

Existen dos maneras de definir constantes en C Sharp: usando const o readonly. Cuando se usa const, es posible acceder a la variable directamente desde la clase (sin instanciar un objeto), como si se tratase de un atributo estático; mientras que con readonly, es un tipo de constantes que funciona como un atributo normal, y que una vez inicializada no se le puede cambiar el valor.

Veamos un ejemplo sencillo para aclararnos:

using System;
public class Constantes {
  // crear constante PI
  public const double PI = 3.14159;
  // radio es una constante esta sin iniciar
  public readonly int radio;
  public Constantes( int radioValue ) {
     radio = radioValue;
  }
}
// Clase UsarConstantes
public class UsarConstantes {
  // metodo Main crea un objeto de tipo 'Constantes'
  // y muestra los valores
  static void Main( string[] args ) {
     Random random = new Random();
     Constantes valoresConstantes =
        new Constantes( random.Next( 1, 20 ) );
     Console.WriteLine( "Radio = " + valoresConstantes.radio +
        "\nCircunferencia = " +
        2 * Constantes.PI * valoresConstantes.radio);
  }
}

Resultado…

Descargar código fuente

Las variables estáticas son atributos de una clase que están disponibles para todas las instancias de dicha clase, y a los cuales puedes acceder directamente (sin instanciar un objeto) de la forma Clase.Variable.

Los destructores son métodos que se ejecutan cuando se elimina un objeto; son especialmente útiles si deseamos hacer algo en particular, antes de eliminar la referencia al objeto. A continuación un sencillo ejercicio, en donde se ejemplifica el uso de las variables estáticas y de los destructores en C Sharp:

using System;
namespace Estatico{
   public class Clase {
      //un atributo normal
      private string variable;
      //esta variable esta disponible para todas
      //las instancias de esta clase
      private static int contador;
      //constructor
      public Clase(string x) {
         variable = x;
         //aumentar valor de la variable estatica
         ++contador;
         Console.WriteLine("Constructor de "+variable);
      }
      ~Clase(){
         --contador;
         Console.WriteLine("Se destruyo una de las instancias ("+variable+")"+contador);
      }
      public static int Contador{
         get{
            return contador;
         }
      }
   }
}

Clase que utiliza los valores estáticos de la clase anterior:

using System;
namespace Estatico{
   public class Principal{
      static void Main(string[] args){
         Console.WriteLine("Contador antes de crear objetos: "+Clase.Contador);
         //crear 2 instancias de la clase
         Clase objeto1 = new Clase("primero");
         Clase objeto2 = new Clase("segundo");
         Console.WriteLine("Contador despues de crear objetos: "+Clase.Contador);
         //eliminar referencias a los objetos
         objeto1 = null;
         objeto2 = null;
         //forzar al recolector de basura a ejecutarse
         System.GC.Collect();
         //esperar hasta que el recolector de basura termine su trabajo
         System.GC.WaitForPendingFinalizers();
         //despues de la recolecta de basura...
         Console.WriteLine("Despues de la recolecta de basura, contador: "+Clase.Contador);
      }
   }
}

Descargar código fuente

Al momento de acceder a los atributos de una clase, podemos usar métodos para asignar y obtener dichos datos (normalmente llamados getters y setters). En C Sharp podemos usar una caracterí­stica llamada ‘propiedades’, por medio de la cual declaramos un alias de acceso público para los atributos de acceso privado.

Me explico. Cuando declaramos atributos en una clase, lo más aconsejable es crearlos con el modificador de acceso private. Por tal motivo no es posible acceder a dichos atributos directamente desde el objeto (de la manera: objeto.atributo), porque como vimos en esta entrada nos arrojará errores de compilación.

Aquí­ es cuando las ‘propiedades’ son especialmente útiles. Una propiedad es como un alias que nos permite acceder a los atributos de manera segura, y con la que nos ahorramos tiempo y espacio en nuestro código. Vamos directamente con un ejemplo, y posteriormente una breve explicación del mismo.

Clase de ejemplo, que implementa una ‘propiedad’ para acceder al atributo:

public class Clase {
	//atributo
	private int variable;
	//constructor
	public Clase(int variable) {
		this.variable = variable;
	}
	//declaracion de la propiedad
	public int atributo{
		//get sirve para devolver el valor del atributo
		get{
			return variable;
		}
		//set sirve para cambiar el valor del atributo
		set{
			variable = value;
		}
	}
}

En la lí­nea 9 tenemos la declaración de la propiedad; en dicha declaración debemos especificar un nombre (diferente al del atributo al que vamos a acceder), y un tipo (en este caso int, entero). Dentro de la propiedad tenemos dos bloques: get y set. Dentro de get debemos poner los valores a retornar cuando se acceda a la propiedad; mientras que en set podemos usar la palabra clave value para asignar un valor al atributo.

En la siguiente clase se utiliza la propiedad de la clase anterior, para obtener y modificar los valores del atributo:

using System;
public class Propiedades {
	public Propiedades() {
		//declaracion del objeto
		Clase objeto = new Clase(5);
		//obteniendo el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa el bloque get)
		Console.WriteLine("El atributo del objeto es "+ objeto.atributo);
		Console.WriteLine("Cambiando el valor usando la propiedad 'atributo'...");
		//cambiando el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa get)
		objeto.atributo = 10;
		Console.WriteLine("Ahora el atributo del objeto es "+ objeto.atributo);
	}
	static void Main(string[] args){
		new Propiedades();
	}
}

Como puedes observar, es posible obtener y modificar los datos de un atributo privado usando una ‘propiedad’ pública, y todo de una manera totalmente segura, puesto que dentro de la ‘propiedad’ podemos verificar la consistencia de los datos.

El resultado…

Descargar código fuente

Tal como veí­amos en el ejemplo anterior, en donde explicabamos las nociones básicas de la programación orientada a objetos en C Sharp, los objetos pueden tener uno o más constructores. El siguiente ejemplo es una modificación del anterior ejercicio, en donde declaramos y usamos varios constructores.

El código…

La clase Tiempo2 que declara 5 constructores; el primero de ellos (lí­nea 9) no recibe argumentos e inicia las variables a cero; el segundo recibe solo parámetro e inica solo una de los atributos de la clase; mientras que el quinto constructor (lí­nea 32) recibe como parámetro un objeto del mismo tipo de la clase, y usando los atributos de dicho objeto inicia los atributos propios:

using System;
public class Tiempo2
{
  private int hora;    // 0 -23
  private int minuto;  // 0-59
  private int segundo;  // 0-59
  // Constructor de la clase Tiempo que inicialize
  //las variables a cero para poner la hora en media noche
  public Tiempo2()
  {
     cambiarHora( 0, 0, 0 );
  }
  // Contructor que recibe unicamente la
  // hora, y lo demas lo inicia a 0
  public Tiempo2( int hora )
  {
     cambiarHora( hora, 0, 0 );
  }
  // Contructor que recibe la hora y el
  // minuto, y lo demas lo inicia a 0
  public Tiempo2( int hora, int minuto )
  {
     cambiarHora( hora, minuto, 0 );
  }
  // Contructor que recibe los tres atributos
  public Tiempo2( int hora, int minuto, int segundo )
  {
     cambiarHora( hora, minuto, segundo );
  }
  // Constructor que utiliza los datos de otro
  //metodo de tipo Tiempo2 para inciar los datos
  public Tiempo2( Tiempo2 hora )
  {
     cambiarHora( hora.hora, hora.minuto, hora.segundo );
  }
  // este metodo asigna una nueva hora en formato 24-horas.
  public void cambiarHora(
     int valorHora, int valorMinuto, int valorSegundo )
  {
     hora = ( valorHora >= 0 &amp;amp;&amp;amp; valorHora < 24 ) ?
        valorHora : 0;
     minuto = ( valorMinuto >= 0 &amp;amp;&amp;amp; valorMinuto < 60 ) ?
        valorMinuto : 0;
     segundo = ( valorSegundo >= 0 &amp;amp;&amp;amp; valorSegundo < 60 ) ?
        valorSegundo : 0;
  }
  // convertir a hora universal con el metodo format
  public string horaUniversal()
  {
     return String.Format(
        "{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo );
  }
  // convertir a tiempo estandar (12 horas) usando el metodo format
  public string horaEstandar()
  {
     return String.Format( "{0}:{1:D2}:{2:D2} {3}",
        ( ( hora == 12 || hora == 0 ) ? 12 : hora % 12 ),
        minuto, segundo, ( hora < 12 ? "AM" : "PM" ) );
  }
}

Clase en donde se utilizan los diferentes tipos de constructores:

using System;
class PruebaTiempo2 {
  static void Main( string[] args ) {
     Tiempo2 hora1, hora2, hora3, hora4, hora5, hora6;
     hora1 = new Tiempo2();               // 00:00:00
     hora2 = new Tiempo2( 2 );            // 02:00:00
     hora3 = new Tiempo2( 21, 34 );       // 21:34:00
     hora4 = new Tiempo2( 12, 25, 42 );   // 12:25:42
     hora5 = new Tiempo2( 27, 74, 99 );   // 00:00:00
     hora6 = new Tiempo2( hora4 );        // 12:25:42
     String salida = "Construido con: " +
        "\nhora1: todos los argumentos por defecto" +
        "\n\t" + hora1.horaUniversal() +
        "\n\t" + hora1.horaEstandar();
     salida += "\nhora2: hora especifica; minuto y segundo por defecto" +
        "\n\t" + hora2.horaUniversal() +
        "\n\t" + hora2.horaEstandar();
     salida += "\nhora3: hora y minuto especifico; segundo por defecto" +
        "\n\t" + hora3.horaUniversal() +
        "\n\t" + hora3.horaEstandar();
     salida += "\nhora4: los tres argumentos especificamente" +
        "\n\t" + hora4.horaUniversal() +
        "\n\t" + hora4.horaEstandar();
     salida += "\nhora5: los tres argumentos especificamente" +
        "\n\t" + hora5.horaUniversal() +
        "\n\t" + hora5.horaEstandar();
     salida += "\nhora6: otro objeto de tipo Tiempo2 (hora4)" +
        "\n\t" + hora6.horaUniversal() +
        "\n\t" + hora6.horaEstandar();
     Console.WriteLine( salida );
  }
}

El resultado del programa es el siguiente:

Descargar código fuente

La POO es un paradigma de programación que intenta abstraer los módulos de cada programa en objetos. Los objetos son instancias de clases, en las que se declaran/especifican al menos dos cosas: los atributos, los métodos y opcionalmente los constructores.

Los atributos son las variables que posee el objeto, mientras que los métodos son las funciones o procedimientos que podemos invocar para realizar operaciones especí­ficas sobre los atributos.

Como en Java, en C Sharp utilizamos siempre clases y objetos, aún cuando no tengamos claro el concepto. Por ejemplo, el simple hola mundo:

using System;
class Hola{
   static void Main(string[] args){
      Console.WriteLine("Hola parce!");
   }
}

En cada lí­nea de código estamos usando la programación orientada a objetos: lí­nea 1, creamos una clase (llamada Hola); lí­nea 2, declaramos un método (función) para nuestra clase; lí­nea 3, usando la clase Console invocamos el método WriteLine. Todo, programación orientada a objetos.

Ejemplo de POO en C Sharp

En el siguiente ejemplo tomado del libro Cómo programar en C Sharp de Deitel, se utiliza una clase llamada tiempo. Dicha clase posee tres atributos (hora, minuto, segundo; todos variables enteras), y tres métodos. Vamos con el código, y mí¡s abajo una explicación:

using System;
public class Tiempo
{
  private int hora;    // 0 -23
  private int minuto;  // 0-59
  private int segundo;  // 0-59
  // Constructor de la clase Tiempo que inicialize
  //las variables a cero para poner la hora en media noche
  public Tiempo()
  {
     cambiarHora( 0, 0, 0 );
  }
  // este metodo asigna una nueva hora en formato 24-horas.
  public void cambiarHora(
     int valorHora, int valorMinuto, int valorSegundo )
  {
     hora = ( valorHora >= 0 && valorHora < 24 ) ?
        valorHora : 0;
     minuto = ( valorMinuto >= 0 && valorMinuto < 60 ) ?
        valorMinuto : 0;
     segundo = ( valorSegundo >= 0 && valorSegundo < 60 ) ?
        valorSegundo : 0;
  }
  // convertir a hora universal con el metodo format
  public string horaUniversal()
  {
     return String.Format(
        "{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo );
  }
  // convertir a tiempo estandar (12 horas) usando el metodo format
  public string horaEstandar()
  {
     return String.Format( "{0}:{1:D2}:{2:D2} {3}",
        ( ( hora == 12 || hora == 0 ) ? 12 : hora % 12 ),
        minuto, segundo, ( hora < 12 ? "AM" : "PM" ) );
  }
}

• En la segunda lí­nea vemos la instrucción public class Tiempo; esto no es mí¡s que la declaración de nuestra clase. Las clases por lo general son de tipo public, aunque si usamos clases internas anónimas es recomendable que sean private, aunque eso es otro tema… sigamos.
• En las lí­neas 4, 5 y 6 tenemos la declaración de los atributos de nuestra clase. Fí­jate como todos ellos son private; es un buen tip de programación que los atributos de nuestras clases sean privados, lo que significa que sólamente serí¡n accesibles desde los métodos de la clase.
• En la lí­nea 9 tenemos la declaración de un constructor. Los constructores son los métodos invocados en el momento de crear objetos; su función es la darle valores a los atributos del objeto. Podemos tener cuantos constructores necesitemos, por supuesto con diferente tipo de argumentos. Ademí¡s, es necesario tener en cuenta que los constructores son métodos que NO tienen ningún valor de retorno, y que deben llevar el mismo nombre de la clase.
• En las lí­neas 14, 25 y 31 estí¡n declarados los métodos o funciones, que permiten realizar operaciones sobre nuestro objeto. Por ejemplo, el método cambiarHora recibe tres argumentos, con los cuales modifica los atributos. Por lo general, los métodos de las clases son de tipo public, lo que permite invocarlos directamente a través de una instancia de la clase (es decir, un objeto).

Con el siguiente código, utilizamos la clase Tiempo:

using System;
class PruebaTiempo {
  static void Main( string[] args ) {
     Tiempo tiempo = new Tiempo();  // llamada al constructor de Tiempo
     string salida;
     // mostrar datos iniciales
     salida = "Hora universal inicial es: " +
        tiempo.horaUniversal() +
        "\nHora estandar inicial es: " +
        tiempo.horaEstandar();
     // cambiar hora (valida)
     tiempo.cambiarHora( 13, 27, 6 );
     // aniadir nueva hora a la salida
     salida += "\n\nHora universal despues de cambiada: " +
        tiempo.horaUniversal() +
        "\nHora estandar despues de cambiada: " +
        tiempo.horaEstandar();
     // cambiar hora (invalida)
     tiempo.cambiarHora( 99, 99, 99 );
     salida += "\n\nDespues de poner valores invalidos: " +
        "\nHora universal: " + tiempo.horaUniversal() +
        "\nHora estandar: " + tiempo.horaEstandar();
     Console.WriteLine( salida );
  }
}

• En la lí­nea 3 creamos un objeto de tipo tiempo. Por lo general la sintaxis para crear objetos es la siguiente: Clase objeto = new Clase(). Es decir, el nombre de la clase, el nombre del objeto, y posteriormente se incia el objeto haciendo una invocación al constructor de la clase (anteponiendo la instrucción new).
• En la lí­nea 8, invocamos uno de los métodos de la clase (horaUniversal). La sintaxis para la invocación de los métodos es: objeto.nombreMetodo(arg1, arg2, ...). Así­, en la lí­nea 12 podemos ver otro ejemplo de invocación, en la que pasamos algunos argumentos al método.

El resultado del programa es el siguiente:

Descargar código fuente

Acceso a los atributos de un objeto

Si al momento de declarar los atributos de una clase utilizamos el modificador de acceso public, es posible acceder a dichos atributos directamente de la siguiente manera: objeto.variable; ó objeto.variable = unValor;. Esto por supuesto NO es recomendable, es decir, los atributos de una clase deberí­an ser SIEMPRE privados.

De igual forma, si hemos declarado atributos con el modificador de acceso private, NO es posible acceder directamente a ellos. Así­ que para modificarlos, debemos crear métodos de acceso público, algo por supuesto mí¡s seguro. Si intentamos acceder directamente a atributos que se han declarado como privados, obtendremos errores de compilación.

En el post anterior decíamos que cuando pasamos un arreglo a un método, ’se pasa la referencia al arreglo por valor’. En este post veremos entonces cual es la diferencia entre pasar la “referencia de un arreglo por valor” y “referencia de un arreglo por referencia”.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
public class EjemploArregloReferencia : Form
{
  private Label labelSalida;
  private Button botonMostrarSalida;
  public EjemploArregloReferencia()
  {
     InitializeComponent();
  }

  private void InitializeComponent()
  {
     this.labelSalida = new Label();
     this.botonMostrarSalida = new Button();
     this.SuspendLayout();
     //
     // labelSalida
     //
     this.labelSalida.Location = new System.Drawing.Point(10, 40);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(272, 280);
     this.labelSalida.TabIndex = 0;
     //
     // botonMostrarSalida
     //
     this.botonMostrarSalida.Location = new System.Drawing.Point(101, 8);
     this.botonMostrarSalida.Name = "botonMostrarSalida";
     this.botonMostrarSalida.Size = new System.Drawing.Size(91, 23);
     this.botonMostrarSalida.TabIndex = 1;
     this.botonMostrarSalida.Text = "Mostrar salida";
     this.botonMostrarSalida.Click += new System.EventHandler(this.botonMostrarSalida_Click);
     //
     // EjemploArregloReferencia
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(292, 325);
     this.Controls.AddRange(new Control[] {
                                                                  this.botonMostrarSalida,
                                                                  this.labelSalida});
     this.Name = "EjemploArregloReferencia";
     this.Text = "EjemploArregloReferencia";
     this.ResumeLayout(false);

  }
  static void Main()
  {
     Application.Run( new EjemploArregloReferencia() );
  }

  private void botonMostrarSalida_Click( object sender,
     System.EventArgs e )
  {
     // crear e iniciar primerArreglo
     int[] primerArreglo = { 1, 2, 3 };

     // copiar primerArreglo en otro arreglo
     int[] copiaPrimerArreglo = primerArreglo;

     labelSalida.Text =
        "Ejemplo pasar la referencia de primerArreglo por valor";

     labelSalida.Text += "\n\nContenido de primerArreglo " +
        "antes de llamar el metodo primerDoblar:\n\t";

     // imprimir el contenido del arreglo primerArreglo
     for ( int i = 0; i < primerArreglo.Length; i++ )
        labelSalida.Text += primerArreglo[ i ] + " ";

     // pasar referencia de primerArreglo por valor a primerDoblar
     primerDoblar( primerArreglo );

     labelSalida.Text += "\n\nContenido de primerArreglo despues " +
        "de llamar el metodo primerDoblar\n\t";

     // imprimir contenido de primerArreglo
     for ( int i = 0; i < primerArreglo.Length; i++ )
        labelSalida.Text += primerArreglo[ i ] + " ";

     // probar si la copia cambio
     if ( primerArreglo == copiaPrimerArreglo )
        labelSalida.Text +=
           "\n\nLa copia fue modificada tambien (porque tiene la referencia a dicho arreglo)\n";
     else
        labelSalida.Text +=
           "\n\nLa copia no fue modificada\n";

     // crear e inciar segundoArreglo
     int[] segundoArreglo = { 1, 2, 3 };

     // crear una copia de segundoArreglo
     int[] copiaSegundoArreglo = segundoArreglo;

     labelSalida.Text += "\nEjemplo, pasar referencia de segundoArreglo " +
        "por referencia";

     labelSalida.Text += "\n\nContenido de segundoArreglo " +
        "antes de llamar el metodo segundoDoblar:\n\t";

     // imprime el contenido de segundoArreglo antes de llamar al metodo
     for ( int i = 0; i < segundoArreglo.Length; i++ )
        labelSalida.Text += segundoArreglo[ i ] + " ";

     segundoDoblar( ref segundoArreglo );

     labelSalida.Text += "\n\nContenido de segundoArreglo " +
        "despues de llamar el metodo segundoDoblar:\n\t";

     // imprimir el contenido de segundoArreglo despues de llamar al metodo
     for ( int i = 0; i < segundoArreglo.Length; i++ )
        labelSalida.Text += segundoArreglo[ i ] + " ";

     // verificar si la copia ha cambiado
     if ( segundoArreglo == copiaSegundoArreglo )
        labelSalida.Text +=
           "\n\nLa copia ha cambiado\n";
     else
        labelSalida.Text +=
           "\n\nLa referencia y el arreglo original son distintos (porque el original cambio de referencia)\n";

  } // fin del metodo botonMostrarSalida_Click

  // modifica elementos del arreglo e intentar modificar la referencia
  void primerDoblar( int[] array )
  {
     // doblar cada elemento del arreglo
     for ( int i = 0; i < array.Length; i++ )
        array[ i ] *= 2;

     // crear una nueva referencia y asignarla al arreglo
     array = new int[] { 11, 12, 13 };
  }

  // modifica elementos del arreglo e intentar modificar la referencia
  void segundoDoblar( ref int[] array )
  {
     // doblar cada elemento del arreglo
     for ( int i = 0; i < array.Length; i++ )
        array[ i ] *= 2;

     // crear una nueva referencia y asignarla al arreglo
     array = new int[] { 11, 12, 13 };
  }
}

Descargar código fuente

Cuando estamos trabajando con arreglos en C#, debemos tener en cuenta algo importante: si pasamos un arreglo entero, éste será pasado por referencia ; mientras que si pasamos uno de los elementos del arreglo, éste es pasado por valor.

¿Qué quiere decir esto exactamente? Pues bien, cuando pasamos un arreglo completo a un método, TODAS las modificaciones que hagamos sobre el arreglo en dicho método se verán reflejadas en el arreglo original. Por otro lado, cuando lo que pasamos es un elemento de un arreglo, las modificaciones que hagamos sobre el elemento serán accesibles únicamente desde dicho método, por lo tanto el valor original del elemento no es modificado.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
public class PasarArreglo : Form
{
  private Button botonMostrarSalida;
  private Label labelSalida;
  public PasarArreglo()
  {
     InitializeComponent();
  }
  private void InitializeComponent()
  {
     this.botonMostrarSalida = new Button();
     this.labelSalida = new Label();
     this.SuspendLayout();
     //
     // botonMostrarSalida
     //
     this.botonMostrarSalida.Location = new System.Drawing.Point(106, 8);
     this.botonMostrarSalida.Name = "botonMostrarSalida";
     this.botonMostrarSalida.Size = new System.Drawing.Size(80, 23);
     this.botonMostrarSalida.TabIndex = 0;
     this.botonMostrarSalida.Text = "Mostrar salida";
     this.botonMostrarSalida.Click += new System.EventHandler(this.botonMostrarSalida_Click);
     //
     // labelSalida
     //
     this.labelSalida.Location = new System.Drawing.Point(8, 48);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(280, 184);
     this.labelSalida.TabIndex = 1;
     //
     // PasarArreglo
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(292, 237);
     this.Controls.AddRange(new Control[] {
          this.labelSalida,
          this.botonMostrarSalida});
     this.Name = "PasarArreglo";
     this.Text = "Pasar Arreglo por valor y referencia";
     this.ResumeLayout(false);

  }
  static void Main()
  {
     Application.Run( new PasarArreglo() );
  }

  private void botonMostrarSalida_Click( object sender,
     System.EventArgs e )
  {
     int[] a = { 1, 2, 3, 4, 5 };

     labelSalida.Text = "Resultado de pasar un arreglo " +
        "por referencia...\n\nLos valores del arreglo original son:\n\t";

     for ( int i = 0; i < a.Length; i++ )
        labelSalida.Text += "   " + a[ i ];

     ModificarArreglo( a );   // el array es pasado por referencia

     labelSalida.Text +=
        "\n\nEl valor de los datos modificados del arreglo son:\n\t";

     // mostrar elementos del array a
     for ( int i = 0; i < a.Length; i++ )
        labelSalida.Text += "   " + a[ i ];

     labelSalida.Text += "\n\nResultado de pasar un elemento del array por valor..." +
        "\n\nvalor de a[ 3 ] (antes de ser pasado a ModificarElemento()) " + a[ 3 ];

     // elemento del array pasado por valor
     ModificarElemento( a[ 3 ] );

     labelSalida.Text +=
        "\na[ 3 ] (despues de ser pasado a ModificarElemento()): " + a[ 3 ];
  }

  // metodo que modifica el arreglo que recibe
  // (el original será modificado)
  public void ModificarArreglo( int[] b )
  {
     for ( int j = 0; j < b.Length; j++ )
        b[ j ] *= 2;
  }

  // metodo que modifica el entero recibido
  // (el original no será modificado)
  public void ModificarElemento( int e )
  {
     labelSalida.Text +=
        "\nvalor recibido por el metodo: " + e;
     e *= 2;
     labelSalida.Text +=
        "\nvalor modificado dentro del metodo: " + e;
  }
}

Descargar código fuente