¿A que nos referimos cuando decimos Programación Orientada a

Ingeniería de Sistemas - UATF
1
Ing. Limber Ruíz Molina
Programación Orientada a Objetos
¿A que nos referimos cuando decimos Programación Orientada a Objetos?
La Programación Orientada a Objetos es una de las formas más populares de programar y
viene teniendo gran acogida en el desarrollo de proyectos de software desde los últimos años.
Esta acogida se debe a sus grandes capacidades y ventajas frente a las antiguas formas de
programar. Para tener una idea más amplia de la P.O.O vamos a revisar 4 conceptos básicos.
-
Objetos
Clases
Herencia
Envío de Mensajes.
Objetos.
Entender que es un objeto es la clave para entender cualquier lenguaje orientado a objetos.
Existen muchas definiciones que se le ha dado al Objeto. Empecemos entendiendo que es un
objeto del mundo real, un Objeto del mundo real es cualquier cosa que vemos a nuestro
alrededor, digamos que para leer un artículo en internet lo hacemos a través del monitor y una
computadora, ambos son objetos, al igual que nuestro teléfono, una mesa, un árbol, un
automóvil, etc.
Analicemos un poco más a un objeto del mundo real, como la computadora, no necesitamos ser
expertos en hardware para saber que una computadora está compuesta internamente por
varios componentes: la tarjeta madre, el procesador, el disco duro, las memorias, y otras partes
más. El trabajo en conjunto de todos estos componentes hace operar a una computadora.
Internamente, cada uno de estos componentes puede ser sumamente complicado y puede ser
fabricado por diversas compañías con diversos métodos de diseño. Pero nosotros no
necesitamos saber cómo trabajan cada uno de estos componentes, cada componente es una
unidad autónoma, y todo lo que necesitamos saber de adentro es cómo interactúan entre sí los
componentes, saber por ejemplo si el procesador y las memorias son compatibles con la tarjeta
madre, o conocer donde se coloca la tarjeta de video. Cuando conocemos como interaccionan
los componentes entre sí, podremos armar fácilmente una computadora.
¿Que tiene que ver esto con la programación? La programación orientada a objetos trabaja de
esta manera. Todo el programa está construido en base a diferentes componentes (Objetos),
cada uno tiene un rol específico en el programa y todos los componentes pueden comunicarse
entre ellos de formas predefinidas.
Todo objeto del mundo real tiene 2 componentes: características y comportamiento.
Por ejemplo, los automóviles tienen características (marca, modelo, color, velocidad máxima,
etc.) y comportamiento (frenar, acelerar, retroceder, llenar combustible, cambiar llantas, etc.).
Los Objetos de Software, al igual que los objetos del mundo real, también tienen características
y comportamientos. Un objeto de software mantiene sus características en una o más
Ingeniería de Sistemas - UATF
2
Ing. Limber Ruíz Molina
"variables", e implementa su comportamiento con "métodos". Un método es una función o
subrutina asociada a un objeto.
Para redondear estas ideas, imaginemos que tenemos estacionado en nuestra cochera un Ford
Focus color azul que corre hasta 260 km/h. Si pasamos ese objeto del mundo real al mundo del
software, tendremos un objeto Automóvil con sus características predeterminadas:
Marca = Ford
Modelo = Focus
Color = Azul
Velocidad Máxima = 260 km/h
Cuando a las características del objeto le ponemos valores decimos que el objeto tiene estados.
Las variables almacenan los estados de un objeto en un determinado momento.
Definición teórica: Un objeto es una unidad de código compuesto de variables y métodos
relacionados.
Clases
En el mundo real, normalmente tenemos muchos objetos del mismo tipo. Por ejemplo, nuestro
teléfono celular es sólo uno de los miles que hay en el mundo. Si hablamos en términos de la
programación orientada a objetos, podemos decir que nuestro objeto celular es una instancia
de una clase conocida como "celular". Los celulares tienen características (marca, modelo,
sistema operativo, pantalla, teclado, etc.) y comportamientos (hacer y recibir llamadas, enviar
mensajes multimedia, transmisión de datos, etc.). Cuando se fabrican los celulares, los
fabricantes aprovechan el hecho de que los celulares comparten esas características comunes
y construyen modelos o plantillas comunes, para que a partir de esas se puedan crear muchos
equipos celulares del mismo modelo. A ese modelo o plantilla le llamamos CLASE, y a los
equipos que sacamos a partir de ella la llamamos OBJETOS.
Ingeniería de Sistemas - UATF
3
Ing. Limber Ruíz Molina
Esto mismo se aplica a los objetos de software, se puede tener muchos objetos del mismo tipo
y mismas características.
Definición teórica: La clase es un modelo o prototipo que define las variables y métodos
comunes a todos los objetos de cierta clase. También se puede decir que una clase es una
plantilla genérica para un conjunto de objetos de similares características.
Por otro lado, una instancia de una clase es otra forma de llamar a un objeto. En realidad no
existe diferencia entre un objeto y una instancia. Sólo que el objeto es un término más general,
pero los objetos y las instancias son ambas representación de una clase.
Definición Teórica: Una instancia es un objeto de una clase en particular.
Herencia.
La herencia es uno de los conceptos más cruciales en la POO. La herencia básicamente
consiste en que una clase puede heredar sus variables y métodos a varias subclases (la clase
que hereda es llamada superclase o clase padre). Esto significa que una subclase, aparte de
los atributos y métodos propios, tiene incorporados los atributos y métodos heredados de la
superclase. De esta manera se crea una jerarquía de herencia.
Por ejemplo, imaginemos que estamos haciendo el análisis de un Sistema para una tienda que
vende y repara equipos celulares.
En el gráfico vemos 2 Clases más que posiblemente necesitemos para crear nuestro Sistema.
Esas 2 Clases nuevas se construirán a partir de la Clase Celular existente. De esa forma
utilizamos el comportamiento de la SuperClase.
En general, podemos tener una gran jerarquía de Clases tal y como vemos en el siguiente
gráfico:
Ingeniería de Sistemas - UATF
4
Ing. Limber Ruíz Molina
Envío de Mensajes
Un objeto es inútil si está aislado. El medio empleado para que un objeto interactúe con otro son
los mensajes. Hablando en términos un poco más técnicos, los mensajes son invocaciones a los
métodos de los objetos.
Lenguajes de Programación Orientada a Objetos
En 1985, E. Stroustrup extendió el lenguaje de programación C a C++, es decir C con conceptos
de clases y objetos.
En 1995 apareció el más reciente lenguaje OO, Java desarrollado por SUN, que hereda
conceptos de C++.
El lenguaje de desarrollo más extendido para aplicaciones Web, el PHP, trae todas las
características necesarias para desarrollar software orientado a objetos.
Además de otros lenguajes que fueron evolucionando, como el Pascal a Delphi.
Ingeniería de Sistemas - UATF
5
Ing. Limber Ruíz Molina
CLASES EN JAVA
Las clases son el núcleo de Java, definen la forma y naturaleza de un Objeto.
1. Concepto de Clase.
Clase es una representación de un objeto en particular, las clases se utilizan para crear objetos de ese tipo
de clase en particular.
PARTES DE UNA CLASE
Una clase está conformada básicamente por nombre, atributos (variables) y funciones (operaciones o
métodos).
-
Empleado
Nombre de la clase
Código
Nombre
Sueldo
Fecha_ingreso
Atributos de la clase
crearNuevo()
generarCodigo()
…….
Funciones de la clase
Declaración de clases en java
[public] class Nombre_de_Clase
{
// atributos
// funciones
}
Nota- Las clases que no tienen la función principal main(), no se pueden ejecutar, sólo deben
ser compiladas, y así generarán el archivo .class.
Por ejemplo una clase Rectangulo que tiene los atributos de base y altura y la función obtenerArea:
Rectangulo
-
int base
int altura
Nombre de la clase
Atributos de la clase
void setDatos(int b, int a)
int obtenerArea()
.
Funciones de la clase
Ingeniería de Sistemas - UATF
6
Ing. Limber Ruíz Molina
La declaración de esta clase en java seria:
class Rectangulo
{
int base;
int altura;
void setDatos(int b, int a)
{
base=b;
altura=a;
}
int obtenerArea()
{
return(base*altura);
}
}
2. Objetos
Un objeto (en ingles instance) es un ejemplar concreto de una clase. Las clases son como tipos de
variables, mientras que los objetos son como variables concretas de un tipo determinado.
Los objetos se crean a partir de clases con la sentencia
objeto)
new (se reserva espacio de memoria para el
Rectangulo objeto1=new Rectangulo();
CLASE
OBJETO
Por ejemplo a partir de la clase Rectangulo podemos crear más de un objeto de ese tipo de clase, como se
muestra a continuación crearemos 2 objetos a los cuales les llamaremos objeto1 y objeto2
class prueba
{
public static void main(String args[])
{
Rectangulo objeto1=new Rectangulo();
objeto1.setDatos(4,3); //enviamos base y altura a objeto1
System.out.println(objeto1.obtenerArea()); //visualizamos el área del objeto1
Rectangulo objeto2=new Rectangulo();
objeto2.setDatos(9,2); //enviamos base y altura a objeto2
System.out.println(objeto2.obtenerArea()); //visualizamos el área del objeto2
}
}
A continuación se muestran varios programas con enfoque orientado a objetos.
Ingeniería de Sistemas - UATF
7
Ing. Limber Ruíz Molina
1. Programa que suma dos números (Mediante la clase Suma)
Ejemplo:
Entrada
Salida
4 8
12
Suma
int A
int B
void setAB(int x,int y)
int getSuma()
Suma
setAB()
4
8
getSuma()
12
public class Suma {
int A; //A y B son atributos de la clase
int B;
void setAB(int x,int y){ //funcion que recibe dos enteros
A=x;
//x se asigna al atributo A
B=y;
//y se asigna al atributo B
}
int getSuma(){
//funcion que devuelve la suma de A y B
int c=A+B;
return c;
}
}
public class prueba {
public static void main(String[] args) {
Suma s=new Suma(); //s es un objeto de tipo Suma
s.setAB(4,8);
//setAB() recibe dos parámetros
System.out.print(s.getSuma());
//getSuma devuelve la suma
}
}
2. Programa que dado un número devuelve la cantidad de dígitos que tiene (Mediante la clase
Numero)
Ejemplo: Entrada
Salida
435
3
Numero
Numero
int valor
void setValor(int a)
int getDigitos()
public class Numero {
int valor;
void setValor(int a){
valor=a;
}
int getDigitos(){
int c=0;
int n=valor;
while(n>0){
c++;
n=n/10;
setValor()
getDigitos()
Ingeniería de Sistemas - UATF
8
Ing. Limber Ruíz Molina
}
return c;
}
}
import java.util.*;
public class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Numero n=new Numero(); //se crea n que es objeto de tipo Numero
n.setValor(en.nextInt()); //setValor recibe un entero por teclado
System.out.print(n.getDigitos()); // getDigitos() devuelve la
cantidad de digitos
}
}
3. Programa que dado el radio de un circulo devuelve el área del circulo (Mediante la clase
Circulo)  A=Pi*r2
Ejemplo: Entrada
Salida
3,7
43,0084
Circulo
float radio
void setRadio(float r)
int getArea()
public class Circulo {
float radio;
void setRadio(float r){
radio=r;
}
double getArea(){
double a=Math.PI*(radio*radio);
return a;
}
}
import java.util.*;
public class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Circulo c=new Circulo();
c.setRadio(en.nextFloat());
System.out.print(c.getArea());
}
}
Ingeniería de Sistemas - UATF
9
Ing. Limber Ruíz Molina
4. Programa que visualiza los primeros N números de la serie Fibonacci. (Mediante la clase
Fibonacci)
Ejemplo: Entrada
Salida
7
1 1 2 3 5 8 13
Fibonacci
int N
void setN(int x)
void mostrarNFibos()
public class Fibonacci {
int N;
void setN(int x){
N=x;
}
void mostrarNFibos(){
int a=1,b=0,c,con=1;
while(con<=N){
System.out.print(a+" ");
c=a;
a=a+b;
b=c;
con++;
}
}
}
import java.util.*;
public class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Fibonacci f=new Fibonacci();
f.setN(en.nextInt());
f.mostrarNFibos();
}
}
5. Programa que dado una cadena devuelva la misma cadena pero en forma invertida
(Mediante la clase Cadena)
Ejemplo:
Entrada
Salida
Lagarto
otragaL
Cadena
String valor
void setValor(String c)
String getInvertir()
Ingeniería de Sistemas - UATF
10
Ing. Limber Ruíz Molina
public class Cadena {
String valor;
void setValor(String c){
valor=c;
}
String getInvertir(){
String cad="";
int t=valor.length();
for(int i=t-1;i>=0;i--)
cad=cad+valor.charAt(i);
return cad;
}
}
import java.util.*;
public class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Cadena ca=new Cadena();
ca.setValor(en.next());
System.out.print(ca.getInvertir());
}
}
6. Programa que permite insertar N datos en un vector y visualiza los mismos en forma invertida
Vector
int A
int cant
void crear(int n)
void insertar(int x)
void mostrarInvertido()
public class Vector {
int A[]; //A es un vector de numeros enteros
int cant=0; // cant es la cantidad de datos que hay en el vector
void crear(int n){ //crear recibe un numero que sera el tamaño del vector
A=new int[n]; //se crea el vector de tamaño n
}
void insertar(int x){ //recibe un numero que es insertado el vector
A[cant]=x;
cant++;
}
void mostrarInvertido(){
for(int i=cant-1;i>=0;i--)
System.out.print(A[i]+" ");
}
}
import java.util.*;
public class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Vector v=new Vector();
int N=en.nextInt(); //se inserta el tamaño del vector por teclado
v.crear(N); //se envia el tamaño al vector
for(int i=0;i<N;i++)
Ingeniería de Sistemas - UATF
11
Ing. Limber Ruíz Molina
v.insertar(en.nextInt());
v.mostrarInvertido();
}
}
7. Programa que permite insertar N nombres en un vector y posteriormente visualiza los datos y la
cantidad de nombre que empiezan con la letra A. (Mediante la clase Lista)
Lista
String A
int cant
void crear(int x)
void insertar(String x)
void mostrar()
int getIniciaA()
public class Lista {
String A[];
int cant=0;
void crear(int x){
A=new String[x];
}
void insertar(String x){
A[cant]=x;
cant++;
}
void mostrar(){
for(int i=0;i<cant;i++)
System.out.print(A[i]+" ");
}
int getIniciaA(){
int c=0;
for(int i=0;i<cant;i++)
if(A[i].charAt(0)=='A')
c++;
return c;
}
}
import java.util.*;
public class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Lista l=new Lista();
int N=en.nextInt();
l.crear(N);
for(int i=0;i<N;i++)
l.insertar(en.next()); //inserta por teclado nombres
l.mostrar();
System.out.print(l.getIniciaA());
}
}
8. Crear una clase Mascota y una clase de prueba donde se cree un objeto de tipo Mascota.
Ingeniería de Sistemas - UATF
Mascota
nombre
especie
edad
propietario
12
Ing. Limber Ruíz Molina
class Mascota {
String nombre;
String especie;
int edad;
String propietario;
void setDatos(String n,String e,int ed,String p)
{
nombre=n;
especie=e;
edad=ed;
propietario=p;
}
void mostrar()
{
System.out.println("nombre: "+nombre);
System.out.println("especie: "+especie);
System.out.println("edad: "+edad);
System.out.println("propietario: "+propietario);
}
setDatos()
mostrar()
}
class prueba {
public static void main(String[] args) {
Mascota m=new Mascota();
m.registrar("firulais","perro",12,"Juan Perez");
m.mostrar();
}
}
Ingeniería de Sistemas - UATF
13
Ing. Limber Ruíz Molina
ENCAPSULAMIENTO DE DATOS
Una Clase es “una colección de atributos (variables) y métodos (funciones)” uno de los aspectos más
importantes de la Programación Orientada a Objetos es el ocultamiento de datos dentro de una clase, y
hacer que estén disponibles solamente a través de los métodos. Esta técnica es usualmente conocida a
menudo como ENCAPSULACIÓN por que este cierra herméticamente los datos de la clase dentro de
la capsula de seguridad.
Los miembros (atributos y funciones) de una clase pueden ser: publicos (public), privados (private), ó
protegidos (protected).
A los datos públicos se puede acceder desde cualquier clase externa, a los datos privados sólo se puede
acceder dentro del ámbito de la misma clase.
Los datos ó miembros protegidos significan que sólo se puede acceder a ellos por métodos miembros
dentro de la misma clase y por funciones miembro de clases derivadas de esta clase.
Un único objeto de por si no es demasiado útil, un objeto es un componente más de un programa o una
aplicación que contiene otros muchos objetos. Los objetos de un programa interactúan y se comunican
entre ellos por medio de mensajes.
Nota.- para asignar valores a los atributos de las clases utilizaremos la palabra set.
Y para obtener los valores de los atributos utilizaremos la palabra get
clase
set
atributos
get
Ejemplo
La clase Persona tiene dos variables: nombre y edad. La variable nombre es de tipo privado (private) y la
variable edad es de tipo publico (public).
class Persona
{
private String nombre;
int edad;
variable privada
variable por defecto publica
void setNombre(String N){
nombre=N;
}
void mostrarDatos(){
System.out.println(“nombre: ”+nombre);
System.out.println(“edad: ”+edad);
}
}
Ingeniería de Sistemas - UATF
14
Ing. Limber Ruíz Molina
En el siguiente programa se hace uso de la clase Persona, en el cual se muestra que a una variable privada
no se puede acceder directamente, al tratar de acceder directamente a ella produciría un error y la única
forma de acceder a ella es mediante una función de la clase.
class prueba
{
public static void main(String args[])
{
Persona p1=new Persona();
Se crea el objeto p1 de tipo
de clase Persona
p1.nombre="luis sanchez";
Se trata de acceder directamente a la variable
nombre, pero esto producirá un ERROR ya que
la variable nombre es variable privada (private)
Aquí si se puede acceder sin ningún
problema ya que la variable edad es publica
p1.edad=18;
p1.setNombre(“luis sanchez”);
p1.mostrarDatos();
La forma de poder acceder o manipular una
variable privada es mediante las funciones de
la misma clase.
}
}
Ejercicios.
Programa que visualiza el promedio de 3 números (Mediante la clase Promedio).
Promedio
int a,b,c
setDatos()
getPromedio()
class Promedio {
private int a,b,c;
void setDatos(int x,int y,int z)
{
a=x;
b=y;
c=z;
}
float getPromedio()
{
float x=(float)(a+b+c)/3;
return x;
}
class prueba {
public static void main(String args[])
{
Promedio p=new Promedio();
p.setDatos(3,4,6);
System.out.print(p.getPromedio());
}
}
Ingeniería de Sistemas - UATF
15
Ing. Limber Ruíz Molina
}
Realice la siguiente clase:
Alumno
Nombre
edad
?
class Alumno
{
private String Nombre;
private int edad;
void setNombre(String n){
Nombre=n;
}
void setEdad(int e) {
edad=e;
}
String getNombre() {
return Nombre;
}
int getEdad() {
return edad;
}
}
Posteriormente realice una clase de prueba donde realice las
siguientes acciones:
- Crear un Alumno a1 e inserte los datos de a1
- visualice todos los datos de a1.
- Modifique la edad de a1.
- Visualice la edad de a1.
class prueba {
public static void main(String[] args) {
Alumno a1=new Alumno();
a1.setNombre("Juan Perez");
a1.setEdad(22);
System.out.println("los datos de a1 son:");
System.out.println("Nombre: "+a1.getNombre());
System.out.println("Edad: "+a1.getEdad());
System.out.println("modificando la edad");
a1.setEdad(20);
System.out.println("Edad: "+a1.getEdad());
}
}
Realice la siguiente clase:
Profesor
Nombre
item
especialidad
?
Posteriormente realice una clase de prueba donde realice las
siguientes acciones:
- Crear un objeto prof1 de tipo Profesor e ingrese sus
datos
- Crear un objeto prof2 de tipo Profesor e ingrese sus
datos
- Visualice el ítem de prof1
- Visualice el nombre de prof2
- Modifique el ítem de prof2
- Modifique la especialidad de prof1
- Visualice todos los datos de prof2
Ingeniería de Sistemas - UATF
class
16
Ing. Limber Ruíz Molina
Profesor {
private String Nombre;
private int item;
private String especialidad;
void setDatos(String n,int i,String e){
Nombre=n;
item=i;
especialidad=e;
}
void mostrarDatos(){
System.out.print(Nombre+" "+item+" "+especialidad);
}
void setNombre(String n){
Nombre=n;
}
void setItem(int i){
item=i;
}
void setEspecialidad(String e){
especialidad=e;
}
String getNombre(){
return Nombre;
}
int getItem(){
return item;
}
String getEspecialidad(){
return especialidad;
}
}
import java.util.Scanner;
class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Profesor prof1=new Profesor(); //crear prof1
//insertar los datos de prof1 desde teclado
System.out.print("Inserte los datos de profesor 1:");
prof1.setDatos(en.next(),en.nextInt(),en.next());
Profesor prof2=new Profesor(); //crear prof2
//insertar los datos de prof2 desde teclado
System.out.print("Inserte los datos de profesor 2:");
prof2.setDatos(en.next(),en.nextInt(),en.next());
//mostrar el item de prof1
System.out.println("el item de profesor 1 es: "+ prof1.getItem());
//mostrar el nombre de prof2
System.out.print("el nombre de profesor 2 es");
System.out.println(prof2.getNombre());
//modificar el item de prof2
System.out.print("inserte nuevo item para profesor 2:");
prof2.setItem(en.nextInt());
//modificar la especialidad de prof1
System.out.print("inserte nueva especialidad para profesor 1");
prof1.setEspecialidad(en.next());
//mostrar todos los datos de prof2
System.out.print("los datos del profesor 2 son:");
prof2.mostrarDatos();
}
}
Ingeniería de Sistemas - UATF
17
Ing. Limber Ruíz Molina
CONSTRUCTORES
Un punto clave de la Programación Orientada a Objetos es el evitar información incorrecta por no haber
sido inicializadas correctamente los atributos. Java no permite que hayan atributos que no estén
inicializados.
Java inicializa siempre con valores por defecto las variables miembro de clases y objetos. El segundo paso
en la inicialización correcta de objetos es el uso de constructores.
Un constructor es un método que se llama automáticamente cada vez que se crea un objeto de una clase.
La principal misión del constructor es reservar memoria e inicializar las variables miembro (sus atributos)
de la clase.
Los constructores no tienen valor de retorno (tampoco son funciones void) y su nombre es el
mismo que el de la clase.
Ej. 1. La siguiente clase punto tiene dos variables miembro (x,y), y un constructor punto(), como se
puede observar el constructor inicializa los datos x=10 e y=10.
class Punto
{
int x,y;
Punto()
{
x=10;
y=10;
}
Un constructor es una función que
no retorna nada, tampoco es void.
Tiene el mismo nombre de la clase
}
Esta inicialización se realiza automáticamente al crear un objeto. (con la sentencia new)
class prueba_punto{
public static void main(String args[]){
Punto p1=new Punto(); // cuando se crea el objeto, automáticamente se ejecuta el
constructor
System.out.println(p1.x); // veremos que imprime 10
System.out.println(p1.y); // veremos que imprime 10
}
}
Ingeniería de Sistemas - UATF
18
Ing. Limber Ruíz Molina
Ej. 2. Los constructores también pueden recibir parámetros
class Punto
{
int x,y;
El constructor de la clase Punto
recibe 2 parámetros (a y b de tipo
Punto(int a,int b)
enteros)
{
Estos datos recibidos son asignados
x=a;
a las variables de la clase.
y=b;
}
}
class prueba_punto
{
public static void main(String args[])
{
Punto p1=new Punto(7,8);
Debido a que el constructor de la
clase Punto recibe dos parámetros,
a la hora de crear un objeto de la
clase Punto se debe enviar los dos
parámetros.
System.out.println(p1.x);
System.out.println(p1.y);
}
}
Ej. 3. Una clase también puede tener varios constructores al mimo tiempo.
class Punto
{
int x,y;
public Punto()
{
x=1;
y=1;
}
public Punto(int a,int b)
{
x=a;
y=b;
}
}
Constructor que no recibe ningún
parámetro
Constructor que recibe 2
parámetros
Ingeniería de Sistemas - UATF
19
Ing. Limber Ruíz Molina
Al momento de crear el objeto podremos utilizar el constructor que mejor nos convenga.
class prueba_punto
{
public static void main(String args[])
{
Punto p1=new Punto(); //usa el constructor sin parámetros
System.out.println(p1.x);
punto p2=new punto(7,8);
System.out.println(p2.x);
//usa el constructor con parámetros
}
}
Ej 4. Cree la clase Rectangulo
Rectangulo
-
base
altura
-
getArea()
?
Los atributos deben ser privados
Debe utilizar constructores
Posteriormente realice una clase de prueba donde realice las siguientes acciones:
- Crear un objeto R1 de tipo Rectangulo
- Mostrar todos los datos de R1
- Modificar la base de R1
- Mostrar la base de R1
- Mostrar el área de R1
- Crear un objeto R2 de tipo Rectangulo
- Modificar la altura de R2
- Mostrar todos los datos de R2
class Rectangulo {
private int base;
private int altura;
Rectangulo(int b,int a)
{
base=b;
altura=a;
}
int getArea()
{
return(base*altura);
}
int getBase()
{
return base;
}
int getAltura()
Ingeniería de Sistemas - UATF
20
Ing. Limber Ruíz Molina
{
return altura;
}
void setBase(int b)
{
base=b;
}
void setAltura(int a)
{
altura=a;
}
void mostrar()
{
System.out.println("Base: "+base);
System.out.println("Altura: "+altura);
}
}
import java.util.*;
class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
int b,h;
System.out.print("introduzca base y altura para R1");
b=en.nextInt();
h=en.nextInt();
//creamos R1 utilizando el constructor
Rectangulo R1=new Rectangulo(b,h);
R1.mostrar();
System.out.print("introduzca nueva base");
b=en.nextInt();
R1.setBase(b);
System.out.println("la base es: "+R1.getBase());
System.out.println("el area es: "+R1.getArea());
System.out.print("introduzca base y altura para R2");
//creamos R2 con el constructor
Rectangulo R2=new Rectangulo(en.nextInt(),en.nextInt());
System.out.print("introduzca nueva altura");
R2.setAltura(en.nextInt());
R2.mostrar();
}
}
Ingeniería de Sistemas - UATF
21
Ing. Limber Ruíz Molina
Ej. 5 Programa que permita insertar N Alumnos en una Lista de Alumnos (vector de Alumnos),
posteriormente visualice los alumnos que tienen nota mayor a 50 y la cantidad de alumnos que tienen nota
mayor a 50. (Utilice la clase Alumno y la clase Lista).
Alumno
String Nombre
int Nota
?
class
Lista
int cant
Alumno A[]
void insertarAlumno(Alumno x)
void mostrarLista()
int getCantidadMayor()
Alumno {
private String Nombre;
private int nota;
Alumno(String n,int nt) //constructor de la clase
{
Nombre=n;
nota=nt;
}
void mostrar()
{
System.out.println(Nombre+" "+nota);
}
String getNombre()
{
return Nombre;
}
int getNota()
{
return nota;
}
}
public class Lista {
private Alumno A[];
private int cant;
Lista(int N)//constructor recibe N
{
A=new Alumno[N]; //crea un vector de alumnos de tamaño N
cant=0; //cantidad de alumnos inicia en 0
}
void insertarAlumno(Alumno x)
{
A[cant]=x;
cant++;
}
void mostrarAlumnos()
{
for(int i=0;i<cant;i++)
A[i].mostrar();
}
Ingeniería de Sistemas - UATF
22
Ing. Limber Ruíz Molina
int getCantidadMayor()
{
int c=0;
for(int i=0;i<cant;i++)
if(A[i].getNota()>50)
c++;
return c;
}
}
import java.util.Scanner;
public class prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
System.out.println("inserte el tamaño del vector:");
int tam=en.nextInt(); //tamaño del vector por teclado
Lista l=new Lista(tam); //se crea la lista de tamaño N
Alumno a; //se declara una variable de tipo Alumno
for(int i=0;i<tam;i++)
{
System.out.println("inserte nombre y nota de un alumno:");
a=new Alumno(en.next(),en.nextInt()); //se crea un alumno con datos
por teclado
l.insertarAlumno(a); //se inserta el alumno a la lista
}
System.out.println("la lista de alumnos es:");
l.mostrarAlumnos(); //se muestra los datos de la lista
System.out.println("la cantidad de alumnos que tiene nota mayor a 50:");
System.out.println(l.getCantidadMayor());
}
}
Ingeniería de Sistemas - UATF
23
Ing. Limber Ruíz Molina
HERENCIA
La herencia permite que se puedan definir nuevas clases basadas en clases existentes, lo cual facilita reutilizar código previamente desarrollado. Si una clase deriva de otra (extends) hereda todos sus atributos y
funciones. La clase derivada puede añadir nuevos atributos y funciones.
En Java, a diferencia de otros lenguajes orientados a objetos, una clase sólo puede derivar de una única
clase, con lo cual no es posible realizar herencia múltiple en base a clases.
Ej. En el siguiente ejemplo tenemos 3 clases, una superclase (class Empleado) y dos subclases (class
Administrativo y class Docente). Que derivan de la superclase Empleado. Las clases derivadas pueden
tener otros atributos y funciones además de las que heredan como se muestra en el siguiente ejemplo
Empleado
Administrativo
1. Ejemplo
// SUPERCLASE Empleado
class Empleado
{
private String nombre;
private int edad;
private String direccion;
void setDatos(String n,int e,String d)
{
nombre=n;
edad=e;
direccion=d;
}
void mostrarDatos()
{
System.out.println("Nombre: "+nombre);
System.out.println("Edad: "+edad);
System.out.println("Direccion: "+direccion);
}
}
superclase
Docente
subclases
Ingeniería de Sistemas - UATF
24
Ing. Limber Ruíz Molina
// la CLASE EXTENDIDA Docente, hereda todos los atributos y funciones de la clase Empleado
class Docente extends Empleado
{
}
La clase Docente como hereda todo de la
clase Empleado, tiene todos los atributos y
funciones de la clase Empleado, sin
necesidad de declararlos nuevamente
//la CLASE EXTENDIDA Administrativo, hereda todas los atributos y funciones de la clase Empleado,
además //se le añade un nuevo atributo que es cargo
class Administrativo extends Empleado
{
private String cargo;
void setDatos(String n,int e,String d,String c)
{
super.setDatos(n,e,d);
cargo=c;
}
void mostrarDatos()
{
super.mostrarDatos();
System.out.println("cargo: "+cargo);
}
}
Además de heredar todas los atributos y
funciones de la clase Empleado, la clase
Administrativo tiene una nueva variable
cargo
La palabra super hace referencia a variables o
funciones de la superclase Empleado. En este caso
llama a la función setDatos de la clase Empleado
Llama a la función mostrarDatos de la superclase
Empleado, el cual imprime los atributos nombre
edad y dirección. Y luego imprime el atributo cargo
por separado ya que en la clase Empleado no
imprime este atributo
//CLASE DE PRUEBA QUE USA LAS CLASES Administrativo y Docente
class prueba
{
public static void main(String args[])
{
Docente doc=new Docente();
doc.setDatos("Carlos Sanchez",32,"Frias 34");
doc.mostrarDatos();
Como se ve el objeto doc tiene todas los
atributos y funciones de la clase heredada
Empleado
Administrativo admi=new Administrativo();
//admi, objeto de tipo Administrativo
admi.setDatos("Juan Perez",20,"bustillos","cajero");
admi.mostrarDatos();
}
}
Ingeniería de Sistemas - UATF
25
Ing. Limber Ruíz Molina
2. Utilizando constructores
// SUPERCLASE Empleado
class Empleado
{
private String nombre;
private int edad;
private String direccion;
Empleado(String n,int e,String d) {
//constructor que recibe 3 parámetros
nombre=n;
edad=e;
direccion=d;
}
void mostrarDatos(){
System.out.println("Nombre: "+nombre);
System.out.println("Edad: "+edad);
System.out.println("Direccion: "+direccion);
}
}
// CLASE EXTENDIDA Administrativo
class Administrativo extends Empleado {
private String cargo;
public Administrativo(String n,int e,String d,String c) //constructor que recibe 4 parámetros
{
super(n,e,d);
//con esta sentencia se ejecuta el constructor de la superclase
cargo=c;
}
void mostrarDatos()
{
super.mostrarDatos();
System.out.println("cargo: "+cargo);
}
}
//CLASE DE PRUEBA QUE USA LA CLASE Administrativo
class prueba {
public static void main(String args[])
{
Administrativo admi=new Administrativo("Juan Perez",20,"bustillos","cajero");
admi.mostrarDatos();
}
}
Ingeniería de Sistemas - UATF
26
Ing. Limber Ruíz Molina
CLASES ABSTRACTAS E INTERFACES EN JAVA
CLASES ABSTRACTAS
Una clase que declara la existencia de métodos pero no la implementación de dichos métodos (o sea, estos
métodos no hacen nada, solo son declarados), se considera una clase abstracta.
Una clase abstracta puede contener métodos no abstractos pero al menos uno de los métodos debe ser
abstracto.
Para declarar una clase o método como abstractos, se utiliza la palabra reservada abstract.
abstract class Dibujar
{
abstract void miMetodo(int var1, int var2);
String otroMetodo()
{
//instrucciones del metodo
}
}
Una clase abstracta no se puede instanciar (es decir no se pueden volver en objetos) pero si se puede
heredar y las clases hijas serán las encargadas de agregar la funcionalidad a los métodos abstractos.
Ejemplo:
Como ejemplo tomaremos dos figuras geométricas, el Rectángulo y el Triangulo rectángulo, para el
ejemplo sólo consideraremos dos características similares: el ancho y el alto, por lo que podemos crear
una super clase Figura geométrica con estas dos características y sus métodos correspondientes, además
del métodos getArea() que devolverá el área de la Figura. Pero, se presenta un problema, el cálculo del
área del Rectangulo es diferente al cálculo del área del Triangulo.
Area del Rectangulo = ancho X alto
Area del Triangulo = (ancho X alto)/2
Por lo tanto, el método getArea() deberá ser abstracto, por lo cual, la clase Figura también deberá ser
abstracta.
abstract class Figura {
protected int ancho,alto;
void setDatos(int x,int y)
{
ancho=x;
alto=y;
//método no abstracto
Ingeniería de Sistemas - UATF
27
}
void mostrarDatos()
//método no abstracto
{
System.out.println(ancho);
System.out.println(alto);
}
abstract float getArea();
//método abstracto
}
class Rectangulo extends Figura{
float getArea()
//implementación (desarrollo del método)
{
return (ancho*alto);
}
}
class Triangulo extends Figura{
float getArea()
//implementación (desarrollo del método)
{
return ((ancho*alto)/2);
}
}
public class prueba {
public static void main(String[] args) {
Rectangulo r=new Rectangulo();
r.setDatos(4,3);
System.out.println(r.getArea());
Triangulo t=new Triangulo();
t.setDatos(4,3);
Ing. Limber Ruíz Molina
Ingeniería de Sistemas - UATF
28
Ing. Limber Ruíz Molina
System.out.print(t.getArea());
}
}
Tipo de dato Protected
Este tipo de datos es privado para todas aquellas clases que no son derivadas, pero público para una
clase derivada de la clase en la que se ha definido la variable como protected.
INTERFACES
Una interface es una variante de una clase abstracta con la condición de que todos sus métodos deben ser
abstractos. Si la interface va a tener atributos, éstos deben llevar las palabras reservadas static final y con
un valor inicial ya que funcionan como constantes por lo que, por convención, su nombre va en
mayúsculas.
interface Nomina
{
public static final String EMPRESA = "Patito, S. A.";
public void detalleDeEmpleado(Nomina obj);
}
Una clase implementa una o más interfaces (separadas por comas) con la palabra reservada implements
con el uso de interfaces se puede “simular” la herencia múltiple que Java no soporta
class Empleado implements Nomina
{
...
}
Ejemplo:
En el siguiente ejemplo, tomaremos de ejemplo a los animales, se sabe que todos los animales hablan
(literalmente), por ejemplo el perro ladra, el gato maúlla, etc.
Entonces se puede crear una interfaz Animal con el método hablar().
interface Animal {
public void hablar();
}
Ahora crearemos una clase Perro que implemente la interfaz Animal, por lo que obligatoriamente
tendremos que implementar el método hablar().
public class Perro implements Animal{
public void hablar()
Ingeniería de Sistemas - UATF
29
Ing. Limber Ruíz Molina
{
System.out.print("guauuu");
}
}
Ahora crearemos una clase Gato que implemente la interfaz Animal, por lo que obligatoriamente
tendremos que implementar el método hablar().
public class Gato implements Animal{
public void hablar()
{
System.out.print("miauuu");
}
}
class prueba {
public static void main(String[] args) {
Perro p=new Perro();
p.hablar();
Gato g=new Gato();
g.hablar();
}
}
MÉTODOS Y ATRIBUTOS ESTÁTICOS (static)
La palabra static se utiliza para definir atributos (variables) y funciones (métodos) estáticos, la
particularidad de estos miembros estáticos es que se pueden acceder a ellos sin necesidad de instanciar
la clase (sin necesidad de crear un objeto de la clase), como ejemplo tenemos las funciones de la clase
Math (pow, sin, random, etc.)
j=Math.pow(2,3);
Como se puede observar se puede acceder a la función pow de la clase Math, y no fue necesario crear un
objeto de la clase Math para poder acceder a la función pow
Ejemplo de una FUNCIÓN ESTÁTICA
Ingeniería de Sistemas - UATF
30
Ing. Limber Ruíz Molina
La clase matematica tiene una función sumar que es estática
class Matematica
{
static int sumar(int a,int b)
{
return (a+b);
}
}
class Principal_matematica
{
public static void main(String args[])
{
int a=5;
int b=7;
int c=Matematica.sumar(a,b);
función estática
Se puede usar la función sumar de la clase
Matematica aunque no se haya creado un
objeto de la misma, debido a que esta
función es estática
System.out.println(c);
}
}
Nota. Un caso especial de función estática es la función main, se trata de una función estática
porque debe ser utilizada sin crear objetos de su clase.
VARIABLES ESTÁTICAS
Una variable estática no se asocia a un objeto, sino que se asocia a la clase misma; no hay copia del dato
para cada objeto sino una sola copia que es compartida por todos los objetos de la clase. A las variables
estáticas se les llama a veces “variables de clase”, por contraposición a las variables no estáticas que se les
llama “variables de objeto”.
Ejemplo
La clase punto contiene dos variables de tipo entero (x,y), y una variable también de tipo entero pero esta
variable es estática.
Ingeniería de Sistemas - UATF
31
class Punto
{
int x,y;
static int cant=0;
public punto(int a,int b)
{
x=a;
y=b;
cant++;
}
Ing. Limber Ruíz Molina
variable estática
Al momento de crear un objeto de la clase
Punto, el constructor aumenta la variable
estática cant en uno.
}
class Principal_punto
{
public static void main(String args[])
{
Al crear el objeto p1, la variable cant aumenta en uno; canr=1
Punto p1=new Punto(5,0);
Punto p2=new Punto(2,12);
Punto p3=new Punto(1,10);
System.out.println(p1.cant);
System.out.println(p2.cant);
System.out.println(punto.cant);
}
}
Al crear el objeto p2, la variable cant aumenta en uno; cant=2
Al crear el objeto p3, la variable cant aumenta en uno; cant =3
Imprime 3, porque cant es variable estática
Imprime 3, porque cant es variable estática
Imprime 3. Tambien se puede acceder a una variable
estática sin haber creado una instancia de clase.