Herencia

Cuando hablamos de la programación orientada a objetos es inevitable tratar con el tema de la Herencia, ya que es una de la principales características de este enfoque. La herencia es una característica que nos permite la creación de clases (subclase) a partir de una clase ya creada (superclase); de modo que cuando estemos creando una clase y decidimos que va a heredar de otra clase ya existente, lo la clase que estamos creando podrá hacer uno de los métodos y atributos de la clase que ya existe (de la cual heredamos).

Ejemplo:

Creamos una clase Persona y una clase Estudiante, distintas una de la otra:

Bien estas son dos diferentes clases por separado, independientes.

Pero pensemos que un estudiante también tiene los mismos atributos y los mismos métodos que una persona, pero una persona no necesita los mismos atributos y métodos que un estudiante. Entonces pensemos en que la clase estudiante puede heredar los métodos y atributos de la clase Persona, de tal modo que podríamos visualizar algo más o menos así:

La clase Estudiante HEREDA de la clase Persona:

El ejemplo anterior es una analogía con personas (un caso cotidiano) para dejar en claro la esencia de la Herencia. Ahora procederé a mostrarles un código de como se maneja la herencia en Java:

Setters y Getters

Los setter y getters, son métodos de acceso en una clase, estos sirven para establecer y obtener datos de los atributos de nuestra clase, estos dos métodos deben ser públicos:

El método set (traducción al español: "establecer"): nos sirve para asignar un valor (inicializar) a un atributo de nuestra clase, esto se hace de manera directa con este método, como este método no retorna nada, el nombre de este debe ser precedido por void, y siempre debe recibir un parámetro de entrada.

El método get (traducción al español: "obtener"): este tipo de método accede a la clase para retornarnos el valor de algún atributo que queramos, y como ya mencioné, el método get si debe retornar un valor por lo cual el nombre de este método debe ser precedido por el tipo de valor que vamos a retornar con ese método.

A estos métodos se les suele hacer referencia en plural (como el titulo de este post) porque generalmente son más de un método set y get en una clase, y de este modo nos referimos a todo ese tipo de métodos de establecimiento y obtención de información. Bien, estos métodos se ven así en una clase:

Pilas (Stack)

Una pila o stack es una lista de elementos a la cual se le pueden insertar o extraer elementos solo por uno de sus extremos. Las pilas son estructuras de datos en las que la inserción de datos se hace por el frente y la eliminación de los datos de igual manera se hace por el frente, se elimina un dato por el mismo lado de donde se inserta; debido a esta característica de inserción y eliminación de datos también se le conoce como estructura LIFO (Last-In, First-Out: Ultimo en entrar, primero en salir).

Una representación analógica de una pila con objetos cotidianos, podría ser una pila de platos: En una mesa se colocan muchos platos uno encima del otro (una pila de platos), para colocar un nuevo plato en la pila se coloca el plato en la cima de la pila. Para sacar un plato de la pila es necesario sacar el plato que esta encima de la pila (el ultimo plato que fue colocado en la pila de platos).

(a) Una pila de libros. (b) Una pila de CD's. (c) Una pila de platos.

Al igual que en en la analogía de la pila de platos, en las pilas de datos la información se almacena de la misma manera y se inserta nueva información y se elimina un dato del mismo modo. Ahora, para comodidad del lector vamos a representar una pila de datos de la siguiente manera:

En la figura anterior podemos observar una pila de datos con 4 elementos apilados. Podrían ser 4 elementos de cualquier tipo, hablando de programación en Java podrían ser: int, string o incluso objetos.

Manejo De Imagenes

Para el manejo de imágenes en java, utilizamos dos clases de la librería swing, que seria JLabel y ImageIcon, con estas podemos realizar una clase con la cual iremos actualizando la imagen cada vez que queramos. Definimos nuestra clase de la siguiente manera:

import javax.swing.ImageIcon;
/**
 * Archivo: ManejoImagen.java
 * @author BelloCerecero
 * @since 6/09/2011
 */
public class ManejoImagen 
{
    private String nombreImagen;
    private ImageIcon imagen;
    
    public ManejoImagen(String nombreImagen)
    {
 this.nombreImagen = nombreImagen;
 imagen = new ImageIcon(nombreImagen + ".gif");
    }
    
    public ImageIcon getImagen()
    {
 return imagen;
    }
    
    public void setImagen(String nuevaImagen)
    {
 imagen = new ImageIcon(nuevaImagen + ".gif");
    }
    
    public String getNombreImagen()
    {
 return nombreImagen;
    }
    
    public void setNombreImagen(String nuevoNombre)
    {
 nombreImagen = nuevoNombre;
    }
}

En la linea uno importamos la clase ImagenIcon, ya dentro de la clase definimos nuestras variables privadas, en este caso sería el nombre de la imagen que es de tipo String y la imagen que es de tipo ImageIcon. El constructor recibirá de parámetro el nombre de la imagen para que así podamos pasársela de parámetro a nuestra imagen (linea 15). Ahora ya solo hacemos los getters y setters de nuestras variables de clase, que actualizaran la imagen y la retornaran. Esta es un simple prueba de como funciona la clase ManejoImagen:

Estructura básica de un programa orientado a objetos

Al utilizar POO hacemos que los problemas sean mas sencillos de resolver, ya que lo dividimos en partes. Ahora estas divisiones (por así llamarlos) son los objetos, pero no podemos utilizarlos sin antes haber creado la clase y así poder hacer la instancia de clase. Bien para aclarar esto haremos el muy utilizado ejemplo de una persona. Primero que nada debemos pensar el nombre que llevara la clase, en este caso no hay necesidad de tanto pensarle ya que "Persona" es mas que claro. Ahora tenemos que identificar todos los atributos de una persona, los cuales pueden ser: la edad, estatura y color de pelo.

Solo usaremos esas, bien ya que tenemos definidos los atributos de la clase tendremos que asignarle el tipo de dato mas conveniente, en el caso de la edad sería de tipo int, la estatura sería double y el color de pelo sería String.

Ya bien definidas nuestras variables de clase, continuamos a programar. El programa tendrá una estructura, que es la siguiente:

          1) Declaración de variables.
          2)Constructor.
          3) Métodos.

Entonces declaramos las variables de clase, dependiendo el caso pueden llevar la palabra reservada: public, protected o private.

private int edad;
private double estatura;
private String colorPelo;

El constructor recibirá de parámetros la edad, la estatura y el color de pelo. Y utilizando la palabra reservada "this" (para hacer referencia a la variable de clase) asignaremos a cada variable de clase el parámetro correspondiente.

Introducción a los métodos

¡Que tal amigos!, en esta ocasión les hablare acerca del uso de los métodos en java, pero de una forma muy simple, solo para que tengan la idea de como es que funcionan estos; Para ejemplificar esto, hice un programa que verifica si un numero es par o impar.

Para esto hice una clase llamada "NumeroPar.java" esta clase tiene un método llamado "esPar" este método recibe de parámetro un número que sera evaluado para verificar si es par o impar, y si este número mencionado antes es par el método retornara "true" y si el número es impar retornara "false", sin mas preámbulos aquí les dejo el código de la clase "NumeroPar.java" (la descripción del funcionamiento de la clase esta abajo de la misma).

/**
 * Archivo: NumeroPar.java
 * @author @BelloCerecero
 */
public class NumeroPar 
{
    //Constructor.
    public NumeroPar()
    {
    }
    
    public boolean esPar(int numero)
    {
 if((numero % 2) == 0)
     return true;
 
 return false;
    }
}

Comencemos con el análisis linea por linea.

Como se puede observar de la linea 1 a la linea 4 son comentarios que nos sirven solo como referencia, ahora nos ubicamos en la linea 7 (ya dentro de la clase) aquí es nuestro constructor que en esta ocación no tiene nada dentro de el, así quedara ya que a nosotros nos interesa por ahora es el método, muy bien ahora vamos a la linea 11 aquí se encuentra nuestro método.

El método esPar tiene las siguientes características:

es publico (public), retornara un "verdadero" (true) o un "falso" (false) y recibe como parámetro un número.

En la siguiente imagen se describe con mas detalles las partes que llevan los métodos:

Ahora, siguiendo con la clase. Nos  vamos a la linea 13 aquí es donde hacemos la operación para saber si el método es par, para esto utilizamos una condición (if) dentro de esta condición hacemos una operación por módulo, que como ya sabemos la operación por modulo lo que hace es una división pero solo retorna el residuo, y como sabemos una de las características de los números pares es que son múltiplos de 2. Así que por lógica al ser divididos entre dos el residuo debe de ser 0, por ende en otras palabras lo que estamos haciendo en la linea 13 es lo siguiente:

"Si residuo de la división de numero entre 2 es igual a cero entonces.... " 

En la linea 14 retornamos true si la condición se cumple y en la linea 16 si no se cumple la condición.

Muy bien ahora ya tenemos nuestra clase NumeroPar.java con un método llamado "esPar" el cual recibe de parámetro el cual es evaluado y retorna true si es par de lo contrario retorna false (que no es par). Ahora haremos una clase aparte para probar nuestra clase NumeroPar.java, esta clase de que llamaremos "PruebaNumeroPar.java" lo que  hará es pedirle al usuario un numero entero y mostrar un mensaje diciendo si es par o impar, La clase quedaría de la siguiente manera:

String y char, Un análisis detallado

Esta ocasión hablaremos de letras y números. Haremos un análisis detallado del comportamiento de las cadenas de caracteres String y los caracteres char. Como ya sabemos una cadena de caracteres String en java es manejado como un objeto, una cadena de caracteres va entre comillas dobles, como: "Buenas Intenciones", a diferencia de un char (que no es un objeto) es un tipo de dato primitivo y este va entre comillas simples, como 'B'.

Una cadena de caracteres al ser un objeto, tiene metodos que podemos invocar, por ejemplo en una instruccion para mostrar un mensaje en consola:

System.out.println("buenas intenciones".toUpperCase());

La cadena de caracteres "buenas intenciones" esta llamando a su método toUpperCase() que hace que el mensaje se muestre en mayúsculas.

Los char en cambio aunque se escriben literales, en realidad son valores numéricos enteros, basados en el código ASCII (pronunciado "Asqui"); Por ejemplo el char 'B' en realidad es el numero: 66 (Al final del post dejo la tabla del código ASCII para su apoyo). Entendiendo las diferencias entre String "A" y char 'A' podemos sacar provecho de esto y jugar con ambos... ¡Hagamos código!.

//Archivo: DemoCaracteres.java

public class DemoCaracteres {
    
    public static void main(String args[]){
        
        //Concatenando un int y un string
        System.out.println("Usando un String:");
        for(int contador=0; contador < 5; contador++)
            System.out.println(contador+"A");
        
        System.out.println("\nUsando un char:");
        //Otra prueba; Concatenando char y string
        for(int contador=0; contador < 5; contador++)
            System.out.println(contador+'A');
    }
}

En el programa anterior, hacemos dos experimentos, uno para ver el comportamiento de los String y el otro para mostrar como se comporta un char.

Manejo de Cadenas: Subcadenas con substring()

Otro método de la clase String es substring(), este método retorna una parte especifica de una cadena de caracteres. Es útil, si por ejemplo, en la cadena "Buenas Intenciones" queremos obtener solo una parte de esa cadena, como "Buenas" ó "Intenciones" ó "tencion", etc.

A este método podemos pasarle 2 parámetros de tipo entero, en estos 2 números enteros debemos especificar la posición de la letra donde queremos que comience la subcadena y la posición donde queremos que termine esta. También podemos ingresar solo un parámetro al método, cuando hagamos esto, el método tomará como referencia el único numero entero que hemos ingresado como posición inicial de la subcadena y como posición final tomará el ultimo caracter de la cadena.

//Archivo: ManejoDeCadenas4.java

public class ManejoDeCadenas4 {

    public static void main(String args[]){
        
        String cadena = "Java y tus Buenas Intenciones";
        
        String subCadena1 = cadena.substring(0,4);
        String subCadena2 = cadena.substring(5,10);
        String subCadena3 = cadena.substring(4);
        
        System.out.println(subCadena1);
        System.out.println(subCadena2);
        System.out.println(subCadena3);
    }
}

En la linea 7 declaramos una variable que contiene una cadena de caracteres. En la linea 9 declaramos otra variable tipo String donde almacenaremos una subcadena de la cadena original declarada en la linea 9, a String subCadena1 le asignamos lo que retorne el método cadena.substring, a la que le pasamos 2 parámetros: 0 y 4, el método substring() toma como indice inicial de la subcadena la posición 0 y como indice final la posición 4; los caracteres que se encuentren entre la posición 0 y 4 serán parte de esa subcadena y se almacenarán en String subCadena1.

La linea 10 hace una operación similar a la descrita para la linea 9. En esta linea toma como referencia la posición 5 y 10, así que los caracteres que se encuentren entre esos indices serán parte de una subcadena y se almacenarán en String subCadena2.

Manejo de Cadenas: Ocurrencias de Caracteres con indexOf y lastIndexOf

La clase String también cuenta con los métodos indexOf() y lastIndexOf(), estos métodos sirven para ubicar la posición de un caracter dentro de una cadena de caracteres. Nos sirven, si por ejemplo, queremos ubicar la posición de la letra "c" en la cadena "Buenas Intenciones".

indexOf() es un método que retorna la posición de la primera ocurrencia de la letra que queramos ubicar en la cadena de caracteres. Por ejemplo: en la cadena "Buenas Intenciones", la letra "e" ocurre (se repite) varias veces, pero la primera ocurrencia de la letra "e" es la que esta resaltada en negritas y de un tamaño más grande; la letra "B" por ejemplo, solo tiene una ocurrencia en esa cadena. Si ocupamos el método indexOf() para ubicar la posición de la letra "e" en esa cadena, nos retornara un valor entero que indicara la posición de la primera ocurrencia de esta letra, en este caso, retornará: 2.

lastIndexOf(), este método nos retorna la posición de la ultima ocurrencia de la letra que queramos ubicar. Nuevamente un ejemplo: en la cadena de caracteres "Buenas intenciones", la ultima ocurrencia de la letra "e" es la que esta resaltada en negritas y un tamaño más grande. Si usamos lastIndexOf() para ubicar la posición de la letra "e" en esa cadena de caracteres, nos retornará: 16.

Si le pasamos de parámetro una letra que no existe en la cadena de caracteres a los métodos indexOf() y lastIndexOf(), nos retornará un valor negativo.

¡Hagamos código!

//Archivo: ManejoDeCadenas3.java

public class ManejoDeCadenas3{
    
    public static void main(String args[]){
        
        String cadena = "Buenas Intenciones";
        
        int posicion1 = cadena.indexOf('c');
        int posicion2 = cadena.indexOf('i');
        int posicion3 = cadena.indexOf('I');
        int posicion4 = cadena.indexOf('e');
        
        System.out.println("Usando indexOf:");
        System.out.println(posicion1);
        System.out.println(posicion2);
        System.out.println(posicion3);
        System.out.println(posicion4);
        
        int posicion5 = cadena.lastIndexOf('n');
        int posicion6 = cadena.lastIndexOf('e');
        
        System.out.println("Usando lastIndexOf:");
        System.out.println(posicion5);
        System.out.println(posicion6);
        
        int posicion7 = cadena.indexOf('x');
        System.out.println("Para caracteres que no existen en\n"
                + "la cadena de caracteres:");
        System.out.println(posicion7);
    }
}

Convertir a Mayúsculas y Minúsculas con toUpperCase y toLowerCase

toUpperCase() y toLowerCase() son métodos de la clase String, el primero es un método que permite convertir las letras a mayúsculas de una cadena de caracteres, el segundo es un método que convierte las letras a minúsculas de una cadena. Estos métodos son sencillos de implementar, veamos:

//Archivo: ManejoDeCadenas2.java

public class ManejoDeCadenas2 {
    
    public static void main(String args[]){
        
        String cadena = "Buenas Intenciones";
        String mayus = cadena.toUpperCase();
        String minus = cadena.toLowerCase();
        
        System.out.println("Texto inicial: "+cadena);
        System.out.println("Texto en Mayusculas: "+mayus);
        System.out.println("Texto en Minusculas: "+minus);
    }
}

En la linea 7 declaramos String cadena que contiene la cadena "Buenas Intenciones". En la linea 8 declaramos String mayus que se le asigna lo que retorne el método toUpperCase() que es mandado a traer por String cadena, este método retornara la cadena contenida en String cadena pero en mayúsculas. En la linea 9 declaramos String minus que se le asigna lo que retorne el método toLowerCase() que es llamado por String cadena, este método retornara la cadena contenida en String cadena pero en minúsculas.

Ya en las lineas 10 a la 13 imprimimos por separado lo que contiene las variables cadena, mayus y minus que son de tipo String, para comparar su comportamiento.

Manejo de Cadenas: charAt()

Como sabemos el tipo de dato String es para cadenas de caracteres, por tanto una variable de tipo String almacena una cadena. Estas cadena de caracteres puede ser de 0 caracteres (cadena en blanco) o más caracteres; Y los caracteres de una cadena tienen un indice, es decir, tienen un numero de orden. Los elementos (caracteres) de una cadena se enumeran de una forma muy parecida a la que se enumeran los elementos de un arreglo, desde la posición 0 hasta la posición "n".

Por ejemplo la cadena de caracteres: "Buenas intenciones" contiene 18 caracteres, y estos están enumerados del 0 al 17, es decir:

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
B	U	E	N	A	S		I	N	T	E	N	C	I	O	N	E	S

Cada caracter que compone esta cadena de caracteres se puede guardar en una variable de tipo char.

charAt() es un método de la clase String que retorna el caracter (tipo char) que se encuentra en la posición indicada. El metodo length() de la clase String también, retorna la cantidad total de caracteres contenidos en la cadena.

Ahora se presenta el siguiente programa para entender mejor la teoría anterior:

//Archivo: ManejoDeCadenas.java

public class MenejoDeCadenas {
    
    public static void main(String args[]){
        
        String cadena = "Buenas Intenciones";
        
        System.out.println(cadena.charAt(0));
        System.out.println(cadena.charAt(7));
        System.out.println(cadena.charAt(cadena.length()-1));
        
        char letra;
        for(int cont=0; cont < cadena.length(); cont++){
            letra=cadena.charAt(cont);
            System.out.println(cont+" --> "+letra);
        }
    }
}

Mostrar Una Imagen

En esta ocasión veremos como visualizar una imagen en java, para ejemplificar realice una pequeña clase llamada "Imagen" y quedo de la siguiente manera:

/**
* Archivo: Imagen.java
* @author Bello Cerecero
* @version 1.00 2012/3/4
*/

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.ImageIcon;

public class Imagen
{
 private JFrame ventana;
 private JPanel contenedor;
 private JLabel etiqueta;
 
  public Imagen()
  {
   ventana = new JFrame("Mostrar una imagen");
   contenedor = new JPanel();
   etiqueta = new JLabel(new ImageIcon("homero.gif"));
  }

  public void mostrarVentana()
  {
   contenedor.add(etiqueta);
   ventana.getContentPane().add(contenedor);
   ventana.pack();
   ventana.setResizable(false);
   ventana.setVisible(true);
   ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }

  public static void main (String[] args)
  {
   Imagen mostrar = new Imagen();
   mostrar.mostrarVentana();
 }
}

Como se puede observar de la linea 1 a la 5 solo son comentarios, despues de los comentarios importamos lo que se va a ocupar (lineas 7 a la 10), ya dentro de la clase en las lineas 20,21 y 22 declaramos nuestras variables, un JFrame al que llamaremos "ventana", un JPanel que se llamara "contenedor" y un JLabel que se llamara "etiqueta".

En el constructor (linea 18), inicializamos nuestras variables, a la variable ventana le pasamos como parámetro una String, esta String aparecerá en la ventana de titulo(linea 20) observe la imagen para descripción gráfica.

En la linea 21 inicializamos un JPanel llamado contenedor, y como lo dice el nombre, va a contener, en la linea 22 inicalizamos un JLabel llamado etiqueta a la que le pasamos como parametro el nombre de la imagen que deseamos que se visualice en la ventana, esto es importante, como la imagen que utilice se encontraba en la carpeta en la que esta mi código no es necesario colocar la ruta completa solo con colocar el nombre de la imagen y el tipo es suficiente ("homero.gif"), pero si la imagen que quieren visualizar esta en otra carpeta tienen que espesificar la ruta por ejemplo: ("C:\\Users\\user\\Desktop\\Nueva carpeta (2)\\homero.gif").

Calculo de Áreas usando POO

Usando Programación Orientada a Objetos realizaremos 4 programas que realicen el calculo de área de 4 figuras geométricas, cada programa realizara el calculo de área de una figura diferente, cada programa constara de una clase con sus métodos para poder usarlos en el calculo del área, y un main.

La clase Cuadrado.

//Archivo: Cuadrado.java

public class Cuadrado{
    
    double lado;
    
    Cuadrado(){
        
    }
    
    public void setLado(double l){
        lado=l;
    }
    
    public double gedLado(){
        return lado;
    }
    
    public double calcularArea(){
        return l*l;
    }
}

En esta clase solo declaramos un atributo, porque es el unico que necesitamos para calcular el area de esta figura. Declaramos el constructor por deafult, de claramos el metodo setLado() para establecer la longitud del lado del cuadrado, getLado() lo establecemos para que nos retorne el valor del lado y calcularArea() es el metodo que realizara la operacion matematica para obtener el area del cuadrado con las medidas establecidas, y este método retornara el resultado del calculo al programa principal.

Main para la clase Cuadrado.

//Archivo: EjemploCuadrado.java

import javax.swing.JOptionPane;

public class EjemploCuadrado{
    
    public static void main(String args[]){
        
        JOptionPane.showMessageDialog(null, "Bienbenido al calculador de\narea para un Cuadrado");
        
        double tamaño=Double.parseDouble(JOptionPane.showInputDialog("Tamaño del lado del cuadrado:"));
        
        Cuadrado cuadrado1 = new Cuadrado();
        cuadrado1.setLado(tamaño);
        
        System.out.println("Usted ha introducido: "+cuadrado1.gedLado()+"\ncomo tamaño del lado del cuadrado\n");
        
        System.out.println("El area del cuadrado es:\n"+cuadrado1.calcularArea());
    }
}

Pediremos la medida del lado del cuadrado y lo guardaremos en double tamaño. En la linea 13 creamos nuestro objeto cuadrado1 de la clase Cuadrado. En la linea 14 asignamos la longitud del lado del cuadrado para nuestra variable double lado en la clase Cuadrado, esto lo hacemos mediante el método setLado() que es invocado por nuestro objeto cuadrado1 y a este método se le pasa de parámetro la variable tamaño (que es de tipo double).

En la linea 16 se imprime en pantalla el mensaje "Usted ha introducido:" concatenado con lo que retorne el método getLado() (en este caso retornara el tamaño del lado que haya introducido el usuario). Y en la linea 18 se imprime el mensaje en pantalla: "El área del cuadrado es:" concatenado con lo que retorne el método calcularArea() (que retornara el resultado del calculo del área, dependiendo del tamaño del lado del cuadrado que haya introducido el usuario).

Clases, Métodos y Objetos: Un análisis mas detallado.

Clase.

Pensemos en una Película como una clase de objeto. Las películas tienen características tales como: titulo, director, duración, etc. También tiene funciones, cosas que puede realizar, como: reproducirse, eliminarse, saber sus datos, etc. A partir de esta analogía podemos crear una clase que lleve por nombre "Película", a la cual le implementaremos sus atributos basándonos en sus características, y métodos basándonos en las funciones que puede realizar esta película.

La clase Película:

//Archivo: Pelicula.java

public class Pelicula{
    
    //Declarando los atributos de la clase
    //(las caracteristicas de una pelicula)
    String titulo;
    String director;
    String duracion;
    
    //Creando los metodos de la clase Pelicula
    //(cosas que se pueden hacer con una pelicula)
    
    Pelicula(){ //Metodo constructor por default
        
    }
    
    //Metodo para establecer el titulo:
    public void setTitulo(String t){
        titulo=t;
    }
    
    //Metodo para establecer el director:
    public void setDirector(String dir){
        director=dir;
    }
    
    //Metodo para establecer la duracion:
    public void setDuracion(String dur){
        duracion=dur;
    }
    
    //Metodo para devolver el titulo:
    public String getTitulo(){
        return titulo;
    }
    
    //Metodo para devolver el director:
    public String getDirector(){
        return director;
    }
    
    //Metodo para devolver la duracion:
    public String getDuracion(){
        return duracion;
    }
    
    //Metodo para reproducir pelicula:
    public void reproducirPeli(){
        System.out.println("Reproduciendo");
    }
    
    //Metodo para eliminar pelicula:
    public void eliminarPeli(){
        System.out.println("Pelicula eliminada");
    }
}

Se creo esta clase con sus atributos y sus metodos, basandonos en sus caracteristicas y funciones.

Métodos.

Introducción a la Programación Orientada a Objetos en Java

La programación orientada a objetos (POO) es una innovadora forma de programar, que facilita las tareas a los programadores, ya que se trata de hacer código expresándolo de una manera mas parecida a la vida real. Algunas ventajas de la POO son que facilita la creación de software de calidad, potencia el mantenimiento y la extensión, y permite la reutilización de código. Dentro de este tipo de programación resuenan muchos conceptos, entre los mas populares son: clase, métodos, herencia, superclase y objetos, entre otros. Para entender mejor el panorama de la programación orientada a objetos, prestemos atención al siguiente ejemplo.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

EJEMPLO:

Estoy en mi oficina y envió chocolates a mi novia. Para esto tengo las siguientes alternativas:

1. Lo hago directamente enviando un mensaje a Roberto (el señor de la tienda de chocolates).
2. Usando un objeto intermedio; se pido a María la secretaria.

El objeto Roberto y el objeto María tienen métodos que entienden mi mensaje.

El objeto Roberto tiene métodos que le permiten realizar la acción que pido.

Si le pido a mi jefe Gabriel que mande los chocolates, seguramente no va a hacerlo porque no tiene el método.

Si hubiese ido a otra tienda de chocolates donde atienda la Sra. Alejandra habría sido el mismo resultado, porque Roberto y Alejandra pertenecen a la misma clase. A esta clase la podríamos llamar Chocolatero.

Probablemente Roberto me pedirá dinero y me entregara un ticket, porque ese método lo usan todos los comerciantes, osea que la clase Chocolatero pertenece a una clase mayor (superclase) llamada Comerciante. Y por esto la clase Chocolatero hereda los métodos de la clase Comerciante.

El hecho de que yo no conozca con exactitud los métodos que usara Roberto, se conoce como ocultamiento de la información.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

En general todas las propiedades y métodos de un objeto se conjuntan en una clase. La clase es un prototipo para crear un objeto (sin clase, no hay objeto), por ello se dice que un objeto es una instancia de clases.

Las partes básicas de un objeto son: el nombre del objeto, sus atributos y sus métodos. En la composición de un objeto el tiempo de vida es la duración de dicho objeto en el programa, el estado de un objeto esta definido por sus atributos y su comportamiento se define por sus métodos. Cuando se crea un objeto se ha de especificar de que clase es, para que el compilador comprenda sus características.

Scanner parte 2

Bueno después de leer el comentario, me di a la tarea de leer un poco y pues esto fue lo que me pareció los mas apegado a lo que pides, utilizando el método useDelimiter(), bueno chequen el código (explicación al final).

/**
* Archivo: CaracterPorCaracterScanner.java
* @author Bello Cerecero
* @version 1.0
* @since 24/01/2012
*/
import java.util.Scanner;
public class CaracterPorCaracterScanner
{
  public static void main(String[] args)
  {
    Scanner entrada = new Scanner(System.in);
    entrada.useDelimiter(",");
 
    System.out.println("Escribe un nombre");
    System.out.println(entrada.next());
  }
}

Empezamos en la linea 12 vemos que creamos un objeto de la clase Scanner, en la linea 13 utilizamos el método useDelimiter(), esto significa que al leer la entrada solo leerá hasta donde aparezca el delimitador en este caso es una ",".
la salida del programa es la siguiente:

Utilizar Scanner

En esta ocasión hablare sobre la utilización del Scanner, esto nos sirve para poder pedirle al usuario que introduzca datos que le pedimos pero estos serán introducidos por medio de la consola, para hacer un poco mas claro esto hice este pequeño programa que muestra como utilizar el Scanner, échenle un vistazo (al final esta la explicación del código).

/**
* Archivo: EntradaTeclado.java
* @author Bello Cerecero
* @version 1.0
* @since 23/01/2012
*/
import java.util.Scanner;
public class EntradaTeclado
{
  public static void main(String[] args)
  {
    Scanner entrada = new Scanner(System.in);
    String nombre;
    int numero;
    double numeroDecimal;

    System.out.println("Introduce un nombre: ");
    nombre = entrada.next();

    System.out.println("Introduce un numero entero: ");
    numero = entrada.nextInt();

    System.out.println("Introduce un numero decimal: ");
    numeroDecimal = entrada.nextDouble();

    System.out.println("El nombres es: " + nombre);
    System.out.println("El entero es: " + numero);
    System.out.println("El numero decimal es: " + numeroDecimal);
  }
}

Empecemos en la linea 7 aquí importamos la librería para poder utilizar el Sacnner, después en la linea 12 declaramos e inicializamos el objeto de tipo Sacnner al que llamaremos "entrada", de las lineas 13 a la 15 declaramos variables que utilizaremos para guardar los datos que sean introducidos por el usuario, como había dicho que el Scanner utiliza la consola para poder pedir datos al usuario debemos imprimir, para estos utilizaremos "System.out.println()" así el usuario podrá leer lo que le pedimos y ahí mismo el introducirá el dato requerido.

Entonces el la linea 17 utilizamos un "System.out.println()" donde pondremos lo que queremos que introduzca el usuario, en este caso yo puse que coloque un nombre, como un nombre es de tipo String vemos que en la linea 18 a la variable "nombre" (que es de tipo String) se le asigna lo que tenga "entrada.next()" ahora "entrada" es el objeto de tipo Scanner y "next()" es un método para leer datos tipo String. lo mismo pasa en la linea 20 y 21 solo que en la linea 20 imprimo en consola que introduzca un numero entero como pueden ver en la linea 21 pasa algo similar a lo que ocurre en la linea 18, solo que en la linea 21 utilizamos la variable "numero" (que es de tipo int) para asignarle lo que tenga "entrada.nextInt()" como pueden darse cuenta que para cada tipo de dato que se requiere el método "next()" se va modificando, en este caso para poder leer un numero entero es "nextInt()" para el caso siguiente en el que se desea leer un numero decimal (lineas 26 y 27) seria "nextDouble()".

En la siguiente figura se muestra como queda en consola después de haber ejecutado el programa (lo que se encuentra en tono verde, son los datos que el usuario introdujo).

Calificaciones de Alumnos, usando Arreglos

¡Hola! Ya hace mucho que no se ve actividad por aquí, así que decidí postear un programa algo interesante sobre lo que se puede hacer teniendo dos arreglos -uno de números y otro de letras-; Ahora vamos a jugar con los arreglos, vamos a tratar de manejarlos con más precisión; Anteriormente creábamos nuestro arreglos y nosotros mismos como programadores especificábamos el tamaño del arreglo, sin darle oportunidad al usuario de que el diera el tamaño de este, en este programa le preguntaremos al usuario de que tamaño desea su arreglo y crearemos el arreglo del tamo indicado. El programa almacenara el nombre de n cantidad de Alumnos y sus calificaciones y posteriormente los imprimirá en pantalla; para esto usaremos 2 arreglos: uno de tipo String que almacenara los nombres y otro de tipo int o double que guardara las calificaciones, habiendo explicado esto ¡Hagamos código!.

//Archivo: ArregloNombres.java

import javax.swing.JOptionPane;

public class ArregloNombres {

   public static void main(String args[]){
        
      //Pedir tamaño del Arreglo al usuario:
      int tamaño=Integer.parseInt(JOptionPane.showInputDialog
                ("¿De que tamaño desea su Arreglo?"));
        
      //Crear y establecer tamaño de los Arreglos:
      String nombres[] = new String[tamaño];
      int calific[] = new int[tamaño];
        
      //Insertar nombres de alumnos al Arreglo String:
      for(int contador=0; contador < nombres.length; contador++)
            nombres[contador]=JOptionPane.showInputDialog
                    ("Nombre?");
        
      //Insertar calificaciones de cada alumno al Arreglo int:
      for(int contador=0; contador < calific.length; contador++)
            calific[contador]=Integer.parseInt
                    (JOptionPane.showInputDialog
                    ("Cual es la calificacione de "
                    +nombres[contador]+"?"));
        
      //Mostrar alumno y su calificacion en pantalla:
      System.out.println("Nombre\tCalificacion");
      for(int contador=0; contador < nombres.length; contador++)
            System.out.println(nombres[contador]+"\t"
                    +calific[contador]);
    }
}

Analicemos el código. Declaramos int tamaño en la linea 10 para que ahí se guarde el tamaño que especifique el usuario cuando mediante una ventana de JOptionPane le preguntemos "¿De que tamaño desea su Arreglo?", cuando el usuario introduzca un numero para indicar el tamaño del arreglo, en realidad estará especificando cuantos alumnos desea almacenar (por por consecuencia, también cuantas calificaciones). Suponga que el usuario introdujo el numero 3.

Arreglos, una perspectiva Orientada a Objetos

Ahora estudiemos los Arreglos en Java con una visión más orientada a objetos, los arreglos son objetos, por lo que se consideran como tipos de referencia. Para declarar y crear un  objeto arreglo, y asignarle valores se hace de la siguiente manera:

int numeros[];

numeros = new int[5];

o en una sola linea:

int numeros[] = new int[5];

donde int numeros es el tipo de datos y el nombre del arreglo, la asiganacion new int nos indica que se esta creando un objeto arreglo de tipo int de tamaño 5 (para 5 elementos). Una vez creado nuestro objeto arreglo solo hace falta asignarle valores a sus indices, cuando los indices tengan valores ya podremos realizar operaciones con el arreglo de igual manera como lo hemos hecho en post anteriores.

//Archivo: OArreglos.java

public class OArreglos{
 
 public static void main(String args[]){
  
  //CREACION DEL ARREGLO
  int numeros[] = new int[5];
  
  //INSERTAR DATOS AL ARREGLO
  numeros[0]=10;
  numeros[1]=20;
  numeros[2]=30;
  numeros[3]=40;
  numeros[4]=50;
  
  //IMPRIMIR ELEMENTOS DEL ARREGLO
  System.out.println("Indice\tValor");
  for(int contador=0; contador < numeros.length; contador++)
   System.out.println(contador+"\t"+numeros[contador]);
  
  //SUMAR ELEMENTOS DEL ARREGLO
  System.out.println();
  int suma;
  suma=numeros[0]+numeros[1]+numeros[2]+numeros[3]+numeros[4];
  System.out.println("La suma del arreglo es: "+suma);
 }
}