POO (Programacin Orientada a Objeto)

La programacin orientada a objetos se basa en la programacin de clases; a

diferencia de la programacin estructurada, que est centrada en las funciones.

Clase
Una clase es una plantilla (molde) donde se definen atributos (variables) y mtodos
(funciones), donde posteriormente se pueden crear mltiples objetos, con similares
caractersticas. Otra definicin podra ser que una Clase es la estructura de un objeto,
es decir, la definicin de todos los elementos de que est hecho un objeto.

La estructura de una clase es:

class [nombre de la clase] {

[atributos o variables de la clase]
[mtodos o funciones de la clase]
[main]
}

Objeto
Un objeto es el "resultado" de una clase. En realidad, un objeto es una instancia de
una clase, por lo que se pueden intercambiar los trminos objeto o instancia (o
incluso evento). Cada objeto est compuesto por un juego de datos (propiedades y/o
atributos) que son las variables que describen las caractersticas esenciales del objeto,
tambin consiste en un juego de mtodos (comportamientos) que describen como el
objeto se comporta.

Si tenemos una clase llamada auto, los objetos Peugeot y Renault sern
instancias de esa clase. Tambin puede haber otros objetos Peugeot 406,
diferenciados por su nmero de modelo. De igual manera, dos instancias
de una clase pueden tener los mismos atributos, pero considerarse objetos
distintos independientes. Tal es el caso de la Clase Felinos (dentro de la
clase Animal) que puede tener 2 objetos: 1 de tipo Gato y otro de tipo
Len.

Variables de instancia
Cuando se crea una instancia de un objeto se obtiene un juego nuevo de variables, sin
embargo, la implementacin de los mtodos es compartida entre los objetos de la
misma clase.

Variables estticas
Adicional a las variables de instancia, es posible definir variables de la clase, siendo
estas variables pertenecientes a la clase. Estas variables almacenan el mismo valor
para todos los objetos de la misma clase, incluso an cuando no existe ninguna
instancia de la clase. Estas variables son conocidas como Variables Estticas.

Instancia de una clase

Para crear un objeto o una instancia de una clase, utilizamos el operador new,
ejemplo, se escribe el siguiente cdigo si se desea crear una instancia de la clase
String.

String cadena = new String(Programacin II);

El operador new localiza memoria para el objeto y retorna una referencia a la posicin
de memoria.

Cuando se crea un objeto, se esta invocando al constructor. El Constructor es el

mtodo encargado de construir todas las instancias de la misma clase.

Ejemplo de la clase Persona

import java.util.Scanner;
public class Persona {
private Scanner teclado;
private String nombre;
private int edad;

public void inicializar() {

teclado=new Scanner(System.in);
System.out.print("Ingrese nombre:");
nombre=teclado.next();
System.out.print("Ingrese edad:");
edad=teclado.nextInt();
}

public void imprimir() {

System.out.println("Nombre:"+nombre);
System.out.println("Edad:"+edad);
}

public void esMayorEdad() {

if (edad>=18) {
System.out.print(nombre+" es mayor de edad.");
} else {
System.out.print(nombre+" no es mayor de edad.");
}
}

static void main(String[] args) {

Persona persona1;
persona1=new Persona();
persona1.inicializar();
persona1.imprimir();
persona1.esMayorEdad();
}
}
Constructores
Los constructores son mtodos especficos que llevan el mismo nombre de la clase.
Siempre que se cree un nuevo objeto se ejecutar un constructor incluso cuando no se
defina ningn constructor por parte del programador, Java ejecutar el constructor
automticamente (lo construir).

Caractersticas de los Constructores

1. Un constructor, tiene el mismo nombre de la clase a la cual pertenece.
2. No puede ser Heredado.
3. No retorna ningn valor (Ni void), por lo cual no debe especificarse ningn
tipo de dato.
4. Debe declararse como public, slo en casos realmente extraordinarios ser
de otro tipo.

Forma General
Constructor sin parmetros Constructor con parmetros
modificador class NombreClase modificador class NombreClase
{ {
//declaracin de atributos //declaracin de atributos
public NombreClase();// int var;
} public NombreClase (int param1)
{//Constructor con parmetros
this.var=param1;
}
}

Ejemplo (Constructor sin parmetros):

import java.util.*;
public class Numeros {
private int num1;
private int num2;
Scanner leer;
//Mtodo Constructor sin parmetros
public Numeros() {
this.num1=0; this.num2=0;
}
public static void main (String[] args) {
Numeros obj = new Numeros();
obj.leer = new Scanner(System.in);
System.out.print("Ingrese el nmero 1: ");
obj.num1=obj.leer.nextInt();
System.out.print("Ingrese el nmero 2: ");
obj.num2=obj.leer.nextInt();
System.out.println("");
System.out.println("El valor del nmero 1 es: "+obj.num1);
System.out.println("El valor del nmero 2 es: "+obj.num2);
}
}
Ejemplo (Constructor con parmetros):
import java.util.*;
//Clase para calcular el Area de un Rectangulo
public class AreaRectangulo {
private double base;
private double altura;
//Mtodo Constructor con parmetros
public AreaRectangulo(double base, double altura) {
this.base = base;
this.altura = altura;
}
public static void main (String[] args) {
double a,b;
Scanner capturar = new Scanner(System.in);
System.out.print("Ingrese la base: ");
a=capturar.nextDouble();
System.out.print("Ingrese la altura: ");
b=capturar.nextDouble();

AreaRectangulo objArea = new AreaRectangulo(a,b);

System.out.println("");
System.out.println("El valor del area del rectangulo es:
"+objArea.Calculo_Area(objArea.base,objArea.altura));
}
public double Calculo_Area(double base, double altura)
{
return base * altura;
}
}

Constructores y Mtodos Sobrecargados

Como el resto de los mtodos, los constructores pueden estar sobrecargados. Esto
significa que podemos definir distintos constructores cambiando el orden, la cantidad y
el tipo de parmetros que reciben. Luego dependiendo la manera en la que se cree el
objeto con new Java elegir el constructor adecuado basndose en la lista de
parmetros.

Ejemplo:
import java.util.*;
//Clase para calcular diversas Areas de Figuras Geomtricas
public class Areas {
private double base;
private double altura;
private double lado;
//Mtodo Constructor sin parmetros
public Areas() {
this.base=0;this.altura=0;this.lado=0;
}
//Mtodo Constructor para el Cuadrado
 public Areas(double lado) {
this.lado = lado;
}
//Mtodo Constructor para el Rectangulo
public Areas(double base, double altura) {
this.base = base;
this.altura = altura;
}
public static void main (String[] args) {
double a,b,l;
Scanner capturar = new Scanner(System.in);
System.out.print("Ingrese el lado: ");
l=capturar.nextDouble();
System.out.print("Ingrese la base: ");
a=capturar.nextDouble();
System.out.print("Ingrese la altura: ");
b=capturar.nextDouble();

Areas objCuadrado = new Areas(l);

Areas objRectangulo = new Areas(a,b);

System.out.println("");
System.out.println("El valor del area del Cuadrado es:
"+objCuadrado.Calculo_Area(objCuadrado.lado));
System.out.println("El valor del area del Rectangulo es:
"+objRectangulo.Calculo_Area(objRectangulo.base,objRectangulo.altura));
}
//Mtodo para el Cuadrado
public double Calculo_Area(double lado)
{
return lado * lado;
}
//Mtodo para el Rectangulo
public double Calculo_Area(double base, double altura)
{
return base * altura;
}
}