Bueno resulta que hace unos años escribí el mismo manual de introducción a la POO en distintos lenguajes. Los tengo en version C#, java, C++ y PHP..
Hoy traigo aquí el de java.
Programación Orientada a Objetos en Java (Introducción)
Cuando escribimos un programa en un lenguaje orientado a objetos, definimos clases, una clase describe las características y comportamientos de objetos similares.
Por ejemplo: la clase Automóvil lista las características comunes a todos los automóviles (atributos y comportamientos).
Atributos: Color, Nro de ruedas, potencia, cambios, etc
Comportamientos: Encender, Apagar, Marcha atrás, acelerar, etc
Así de forma abstracta listamos atributos y comportamientos que todos los autos pueden tener.
Luego los objetos son la forma concreta de esto mismo:
Tenemos el auto de Juan, con 4 puertas, 5 cambios, marca Mercedes Benz, color azul y el de Fernando con 2 puertas, 4 cambios, rojo, descapotable..
Resumiendo:
Una clase es una plantilla que describe a un conjunto de objetos con características y atributos similares.
Un objeto, o instancia de una clase, es la representación concreta y especifica de esta, que reside en la memoria (puede haber muchos objetos de una misma clase).
Ejemplo:
Automovil.java
package programandoobjetos;
//Por norma los nombres de las clases comienzan con mayúscula:
public class Automovil {
//Atributos:
String Color, Marca, Patente;
int Cambios, Puertas;
//Métodos:
void verDatos(){
System.out.println("Color: " + Color);
System.out.println("Marca: " + Marca);
System.out.println("Cambios: " + Cambios);
System.out.println("Puertas: " + Puertas);
if(Patente != null)
{
System.out.println("Patente: " + Patente);
}
System.out.println();
}
//Cuando un método de una clase se llama igual que la clase
//significa que es el constructor de la clase
//es decir la funcion a la que se llama al crear el objeto
//Y se determina sus parámetros
public Automovil(String color, String marca, int cambios,
int puertas){
this.Color = color;
this.Marca = marca;
this.Cambios = cambios;
this.Puertas = puertas;
}
//El polimorfismo o sobre carga de métodos
//Es que podamos tener funciones con el mismo nombre
//Y distitnos parámetros y acciones
//En este caso tendremos otro constructor
//que acepte como parámetro también la patente
public Automovil(String color, String marca, int cambios,
int puertas, String patente){
this.Color = color;
this.Marca = marca;
this.Cambios = cambios;
this.Puertas = puertas;
this.Patente = patente;
}
}ProgramandoObjetos.java
package programandoobjetos;
public class ProgramandoObjetos {
public static void main(String[] args) {
//Creamos un objeto del tipo automovil
//Le pasamos parametros a su constructor
Automovil Auto = new Automovil("Azul","Mercedes Benz", 5, 4);
//En este caso también le pasamos la patente
//Y automáticamente usa el otro constructor
Automovil Auto2 = new Automovil("Rojo","Ferrari", 4, 2, "HYO345");
Auto.verDatos();
Auto2.verDatos();
}
}
/* Imprime:
Color: Azul
Marca: Mercedes Benz
Cambios: 5
Puertas: 4
Color: Rojo
Marca: Ferrari
Cambios: 4
Puertas: 2
Patente: HYO345
*/Polimorfismo: Es la capacidad de un método para poder comportarse de diversas maneras y recibir distintos parámetros. Arriba puede verse un ejemplo.
También es conocido como polimorfismo el hecho de que un método que acepta un tipo de objeto como parámetro, acepte a su vez sin necesidad de ningún cambio a los objetos de sus clases hijas.
Herencia:La herencia es una relación entre las clases.
Todas las clases en Java existen dentro de una jerarquía. Cada clase tiene una (y solo una) clase por encima de ella (no como en C++ que puede haber herencia múltiple), denominada superclase, y cualquier número de clases (o ninguna) por debajo.
A estas últimas se las denomina subclases.
Una clase heredará los métodos y variables miembro de su superclase. Del mismo modo, sus subclases heredarán los métodos y variables de esa clase.
Ejemplo Herencia:
Persona.java
package herencia;
public class Persona {
int numeroDeDocumento;
String nombre, apellido, tipoDeDocumento;
void Persona(String nom, String ape)
{
this.nombre = nom;
this.apellido = ape;
}
void setDocumento(String tipo, int numero){
this.tipoDeDocumento = tipo;
this.numeroDeDocumento = numero;
}
void verDocumento(){
System.out.println("Tipo de documento: " + tipoDeDocumento
+ "\nNumero de documento: " + numeroDeDocumento);
}
void verNombre(){
System.out.println("nombre: " + nombre
+ " \nApellido: " + apellido);
}
}
Empleado.java
package herencia;
//La clase pública Empleado hereda de Persona
public class Empleado extends Persona {
int Sueldo;
String Cargo;
//El constructor mínimamente debe tener
//los parámetros del constructor de
//la clase Padre:
public Empleado(String nom, String ape,
int sueldo, String cargo){
this.Sueldo = sueldo;
this.Cargo = cargo;
//Nombre y apellido fueron algunos de los
//Atributos heredados:
this.nombre = nom;
this.apellido = ape;
}
void VerSueldo(){
System.out.println("Sueldo: " + Sueldo);
}
void verCargo(){
System.out.println("Cargo: " + Cargo);
}
}Herencia.java
package herencia;
public class Herencia {
public static void main(String[] args) {
//Creamos un objeto de la clase empleado
//Le pasamos los parametros a su constructor
Empleado NombreDelObjeto = new Empleado("Juan","Perez",
15000, "Software Developer");
//Como vemos, usamos las funciones de la clase padre
//Y sus atributos
NombreDelObjeto.setDocumento("DNI", 20202678);
NombreDelObjeto.verNombre();
NombreDelObjeto.verDocumento();
NombreDelObjeto.verCargo();
NombreDelObjeto.VerSueldo();
}
}
/*Print:
nombre: Juan
Apellido: Perez
Tipo de documento: DNI
Numero de documento: 20202678
Cargo: Software Developer
Sueldo: 15000
*/Encapsulación: La encapsulación es una técnica para empaquetar la información, envolviendo los atributos y métodos de los objetos en clases, de tal forma que se oculte lo que debe ocultarse y haga visible lo que está pensado para serlo. Tanto los métodos como los atributos pueden ser encapsulados. Para ello se utilizan las palabras: public; protected y private.
| MODIFICADOR | CLASE | PACKAGE | SUBCLASE | TODOS |
| Public | Si | Si | Si | Si |
| Protected | Si | Si | Si | No |
| No especificado | Si | Si | No | No |
| Private | Si | No | No | No |
Ejemplo:
Persona.java
package encapsulacion;
public class Persona {
private int numDoc;
public String ColorDePiel;
protected String nombre;
Persona(int doc, String color, String nomb){
this.numDoc = doc;
this.ColorDePiel = color;
this.nombre = nomb;
}
//Como numDoc no puede accederse desde otro lado
//Más que su propia clase, ya que es private
//Hacemos una función que lo muestre
void VerDoc()
{
System.out.println("Documento: " + this.numDoc);
}
}Encapsulacion.java
package encapsulacion;
public class Encapsulacion {
public static void main(String[] args) {
Persona Jorge = new Persona(32145672,"Blanco", "Jorge");
//Podemos acceder a sus atributos públicos
//y protected (ya que estamos en el mismo package)
//pero no a los private (Solo pueden accederse
//Desde su misma clase)
System.out.println("Color: " + Jorge.ColorDePiel);
System.out.println("Nombre: " + Jorge.nombre);
Jorge.VerDoc();
}
}Concepto de interface:
En java una interface es una clase abstracta pura, es decir una clase donde todos los métodos son abstractos(no se implementa ninguno). Una interface puede también contener datos miembro, pero estos son siempre static y final. Una interface sirve para establecer un “protocolo” entre clases.
Para crear una interface, se utiliza la palabra clave interface en lugar de Class. La interface puede defirnirse public o sin modificador de acceso, y tiene el mismo significado que para las clases. Todos los métodos que declara una interface son siempre public.
Para indicar que una clase implementa todos los métodos de una interface se utiliza la palabra clave implements. El compilador verificara que la clase efectivamente declare e implemente todos los métodos de la interface. Una clase puede implementar más de una interface.
Ejemplo:
interface InstrumentoMusical{
void tocar();
void Afinar();
}
class Flauta implements InstrumentoMusical {
@Override
public void tocar() {
//Acá la implementación
}
@Override
public void Afinar() {
//Acá la implementación
}
}Las interfaces pueden extender otras interfaces y, a diferencia de las clases, una interface puede extender más de una interface:
Interface SubInterface extends PadreUno, PadreDos
{
} Dado que todos los datos miembros de una interface son por definición static y final resultan una buena herramienta para declarar constantes.
Saludos,
This site uses cookies own and third. If you continue to browse consider to accept the use of cookies.