2 programación orientada_a_objetos

Lina Ernestina Arias Hernández Instituto Tecnológico de la Laguna 1
Maestría en Sistemas Computacionales
Materia
TECNOLOGÍAS DE PROGRAMACIÓN
Capítulo
2.Programación Orientada a Objetos
semestre agosto – diciembre 2012
Instituto Tecnológico de la Laguna
División de Estudios de Posgrado e Investigación

Objetivos:
Describir los conceptos que fundamentan
la POO.
Crear objetos que pertenecen a las
clases de la biblioteca de Java.
Describir clases propias.
2. Programación Orientada a objetos2. Programación Orientada a objetos.

2.1 Definición de objeto y descripción de
clases.
2.2 Arreglos.
2.3 Encapsulamiento y control de acceso.
2.4 Propiedades y métodos estáticos,
sobrecarga de métodos y alcance de
variables.
2.5 Paquetes.
2.6 Clases: java.lang, System, Object, String
StringBuffer y StringBuilder.
Contenido

Introducción
 Java está totalmente orientado a objetos.
 Una clase es la plantilla o plano a partir del
cual se crean realmente los objetos. Cuando
se construye un objeto de una clase, se dice
que se ha creado un ejemplar de la clase.
 La encapsulación es combinar los datos y el
comportamiento del objeto en un único
paquete, y ocultar la implementación de los
datos a los ojos del usuario del objeto.

 Características de los objetos:
 El comportamiento del objeto:¿qué se
puede hacer con este objeto, o qué
métodos se le pueden aplicar?
 El estado del objeto: ¿cómo reacciona el
objeto cuando se le aplican esos
métodos?
 La identidad del objeto: ¿cómo se
distingue el objeto de otros que tengan
el mismo comportamiento y estado?
2.1 Definición de objeto y descripción
de clases.

 En el análisis de un problema, para
identificar las clases se buscan los
sustantivos en la descripción del
problema.
 Los métodos corresponden a los
verbos.

Relaciones entre clases
 Las relaciones entre clases más comunes son:
 Dependencia (“utiliza-un”)
 Agregación (“tiene-un”)
 Herencia(“es-un”)
 Notación UML:
 Herencia
 Interfaz de herencia
 Dependencia
 Agregación
 Asociación
 Asociación directa

Definición de una clase
class Empleado{
private String nombre;
private double sueldo;
private Date fechaContrato;
// constructor
public void Empleado(String n, double s, int año, int mes, int dia) {
nombre = n;
sueldo = s;
GregorianCalendar calendario =
new GregorianCalendar(año, mes-1,dia);
fechaContrato = calendario.getTime();
}
public String getNombre() {
return nombre;
}
}
Datos
(campos
de
ejemplar)
Métodos

Objetos y variables de objetos
 Declarar un objeto es declarar una
referencia a un objeto.
 Los objetos se crean con el operador
new.
Empleado cajera = new
Empleado(“María”,12500.00,2007,10,21);

Objetos y variables de objetos
 Crear un objeto significa reservar espacio en
memoria para sus variables.
 new reserva memoria para un objeto y
devuelve una referencia al objeto.
Empleado
nombre
sueldo
fechaContrato
cajera =
María
12500.00
2007/10/21

 La sentencia:
Empleado vendedor;
 Define una variable objeto denominada
vendedor, que puede referirse a objetos
de tipo Empleado.
 La variable vendedor no es un objeto.
Los métodos de la clase Empleado no se
pueden emplear mediante vendedor.

 Para crear el objeto tenemos dos
alternativas:
 Asignar a la variable un objeto ya construido:
vendedor = new
Empleado(“Elias”,9000.00,2010,05,27);
 O hacer que la variable apunte a un objeto ya
existente:
vendedor = cajera;

Métodos deprecated
 Se dice que un método está desaprobado
(deprecated) cuando el diseñador de una
biblioteca se da cuenta de que el método no
debería existir.
 Es posible seguir usándolos en los
programas pero el compilador mostrará una
advertencia.
 El uso de los métodos desaprobados debe
evitarse pues podrían ser eliminados en
versiones futuras de las bibliotecas.

Clase Date de la biblioteca de Java
 Clase Date: representa un instante de tiempo como
“December 31,1999, 23:59:59 GMT”.
 Constructor Date:
 Pasando el objeto a un método:
System.out.println(new Date());
 Aplicando un método al objeto que se crea:
String s = new Date().toString();
 Almacenando el (descriptor del) objeto en una variable:
Date onomastica = new Date();
onomastica =
Date

Clase Date de la biblioteca de Java
 Algunos de sus métodos son before,
after, toString y los métodos
desaprobados getDay, getMonth y
getYear.
 Ejemplo:
Date hoy = new Date();
if (hoy.before(onomastica))
System.out.println(“Queda tiempo para comprar un regalo”);

Clase GregorianCalendar de la
biblioteca de Java
 Clase GregorianCalendar: expresa las
fechas con la notación del calendario.
 Constructores:
new GregorianCalendar();
new GregorianCalendar(1999,11,31);
new GregorianCalendar(1999,Calendar.DECEMBER,31);
new GregorianCalendar(1999,Calendar.DECEMBER,31,23,59,59);
 La clase GregorianCalendar extiende la
clase Calendar que describe las
propiedades de los calendarios en general.

Métodos de Consulta
 Método get de la clase GregorianCalendar:
GregorianCalendar ahora = new GregorianCalendar();
int mes = ahora.get(Calendar.MONTH);
int diaSemana = ahora.get(Calendar.DAY_OF_WEEK);
 Métodos getTime de la clase
GregorianCalendar:
GregorianCalendar calendario = new GregorianCalendar();
Date laHora = calendario.getTime();

Métodos de modificación
 Método set de la clase GregorianCalendar:
GregorianCalendar fechaLimite = new GregorianCalendar();
fechalimite.set(Calendar.YEAR, 2000);
fechalimite.set(Calendar.MONTH, Calendar.MARCH);
fechalimite.set(Calendar.DAY_OF_MONTH, 20);
 Métodos setTime de la clase
GregorianCalendar:
GregorianCalendar calendario = new GregorianCalendar();
Date laHora = calendario.getTime();
calendario.setTime(laHora);

Java.util.GregorianCalendar 1.1.
 Construye un objeto de calendario que representa
la hora actual en la zona horaria predeterminada
con el país predeterminado.
GregorianCalendar()
 Construye un calendario gregoriano con la fecha
dada:
GregorianCalendar(int anio, int mes, int dia)
Donde:
anio: el año de la fecha.
mes: el mes de la fecha. Inicia en 0 (enero).
dia : día del mes.

 Construye un calendario gregoriano con la fecha y
hora dadas:
GregorianCalendar(int anio, int mes, int dia, int
hora, int minutos, int segundos)
Donde:
anio : el año de la fecha.
mes : el mes de la fecha. Inicia en 0 (enero).
dia : día del mes.
hora : la hora (entre 0 y 23).
minutos : los minutos (entre 0 y 59).
segundos: los segundos (entre 0 y 59).

 Proporciona el valor de un cierto campo
int get(int campo)
 Determina el valor de un cierto campo
int set(int campo, int valor)

 Donde campo es uno de estos valores:
 Y valor es el nuevo valor.
Calendar.ERA Calendar.YEAR
Calendar.MONTH Calendar.WEEK_OF_YEAR
Calendar.WEEK_OF_MONTH Calendar.DAY_OF_MONTH
Calendar.DAY_OF_YEAR Calendar.DAY_OF_WEEK
Calendar.DAY_OF_WEEK_IN_MONTH Calendar.AM_PM
Calendar.HOUR Calendar.HOUR_OF_DAY
Calendar.MINUTE Calendar.SECOND
Calendar.MILLISECOND Calendar.ZONE_OFFSET
Calendar.DST_OFFSET

 Método aritmético para las fechas. Añade la cantidad
de tiempo especificado al campo de fecha dado:
void add(int campo, int cantidad)
c.add(Calendar.DAY_OF_MONTH,7);
 Asigna a este calendario el instante de tiempo
indicado:
void setTime(Date laHora)
Donde: laHora es un instante de tiempo
 Proporciona el instante de tiempo que está siendo
representado por el valor actual de este objeto de
calendario:
Date getTime()

 Un arreglo:
 Es una estructura de datos que
contiene una colección de valores del
mismo tipo.
 Para acceder a cada valor se emplea
un entero como índice.
 Un arreglo puede ser un vector:
arreglo unidimensional.
 O una matriz: arreglo
multidimensional.
2.2 Arreglos.

 Declaración de un vector:
int[] a = new int[100];
 Las localidades del vector se numeran del 0 al 99.
 Se pueden almacenar datos en el vector
mediante un bucle:
for (int i =0;i<100;i++)
a[i] = i*2;
 Si se intenta acceder un elemento con cualquier
índice que esté fuera de rango el programa
concluirá con la excepción “array index out of
limits”.
2.2 Arreglos: vector (arreglo unidimensional)

 Para determinar el número de elementos que hay
en un vector:
nombreVector.lenght
 Una vez creado el arreglo no se puede modificar su
tamaño. Si se necesita incrementar frecuentemente
el tamaño de un arreglo mientras el programa se
está ejecutando puede utilizar una estructura de
datos denominada “lista de arreglos”.
 Para acceder a los elementos de un vector se puede
el bucle:
for (int i = 0; i < a.length; i++)
System.out.println(a[i]);
2.2 Arreglos: vector (arreglo unidimensional)

 Permite recorrer todos los elementos de un arreglo
(y de otras colecciones) sin tener que usar índices:
for (variable:colección)
sentencia;
Por ejemplo:
for (int elemento : a)
System.out.println(elemento);
Imprime cada elemento del vector en una línea diferente.
 Este bucle se lee “para cada elemento de a”.
2.2 Arreglos:bucle “for each”

 Cuando se emplea esta sintaxis no se
llama a new:
int[] primerosPrimos ={2, 3, 5, 7, 11, 13};
 Esta expresión reserva un vector nuevo y
lo rellena con los valores que van entre
llaves.
2.2 Arreglos: iniciación.

 Es posible darle valores iniciales a un
vector anónimo sin crear una nueva
variable:
primerosPrimos = new int [] {17,19,23,29,31,37};
 La expresión anterior es una forma
abreviada de:
int[] anonimo = {17,19,23,29,31,37};
primerosPrimos = anonimo;
2.2 Arreglos: anónimos.

 Las variables arreglos se pueden
copiar entre sí, en este caso ambas
variables se refieren al mismo
vector:
int[] numerosDeLaSuerte = primerosPrimos;
2.2 Arreglos: copiar.
2
3
5
7
11
12
primerosPrimos =
numerosDeLaSuerte=

 Para copiar los valores de un vector
en otro emplear el método
arraycopy:
System.arraycopy(origenCopia, desdeElIndice,
destinoCopia, aPartirDelIndice, contador);
2.2 Arreglos: copiar.

 Para ordenar los números de un
vector, se puede utilizar uno de los
métodos sort de la clase Arrays:
int[] i = new int[1000];
…
Array.sort(i);
2.2 Arreglos: ordenación.

Ejemplo: SorteoLoteria.java
 SorteoLoteria.java

2.2 Arreglos: matrices.
Las matrices son arreglos
multidimensionales y se
emplea más de un índice para
acceder a sus elementos.
Se utilizan para crear tablas o
distribuciones.

 Declaración de una matriz:
double[][] saldos;
saldos = new double[x][y];
double[][] saldos = new double[x][y];
int[][] cuadradoMagico =
{
{16,3,2,13}, {5,10,11,8}, {9,6,7,12}, {4,15,14,1}
};

 Los bucles “for each” no recorren
automáticamente todas las localidades
de una matriz, recorren las filas (arreglo
unidimensional). Para tener acceso a
todos los elementos de una matriz
bidimensional:
for (double[] fila: saldos)
for (double b: fila)
Hacer algo con b;

Ejemplo: InteresCompuesto.java
 InteresCompuesto.java

2.3 Encapsulamiento y control de acceso
 Una forma simple de definir una clase
en Java es:
class NombreClase
{
campo1
campo2
…
constructor1
constructor2
…
método1
método2
}

Ejemplo: clases PruebaEmpleado y Empleado
import java.util.*;
public class PruebaEmpleado
{
public static void main(String[] args)
{
//se llena el vector de personal con tres objetos de tipo Empleado
Empleado[] personal = new Empleado[3];
personal[0] = new Empleado(“Diego Medina”, 75000,2000,03,20);
personal[1] = new Empleado(“Lila E. Martinez”, 50000,2002,01,16);
personal[3] = new Empleado(“Isaias Antunez”, 30000,2004,05,08);
// se aumenta a todos el sueldo un 5%
for (Empleado e: personal)
e.subirSueldo(5);

Ejemplo: clases PruebaEmpleado y Empleado
// Se imprime la información de todos los objetos empleado
for (Empleado e:personal)
System.out.println(“nombre= “+ e.getNombre() +
“,sueldo=” + e.getSueldo()
“,fechaContrato=” + e.getFechaContrato());
}
} // termina clase PruebaEmpleado

Ejemplo: clases Empleado y PruebaEmpleado
class Empleado{
private String nombre;
private double sueldo;
private Date fechaContrato;
// constructor
public void Empleado(String n, double s, int anio, int mes, int dia) {
nombre = n;
sueldo = s;
GregorianCalendar calendario = new GregorianCalendar(anio, mes -1,
dia);
fechaContrato = calendario.getTime();
}
public String getNombre() {
return nombre;
}
}

Ejemplo: clases Empleado y PruebaEmpleado
public String getSueldo() {
return sueldo;
}
public String getFechaContrato() {
return fechaContrato;
}
public void subirSueldo(double porcentaje) {
double aumento = sueldo * porcentaje / 100;
sueldo +=aumento;
}
}

Constructores
 El constructor tiene el mismo nombre
que la clase.
 Una clase puede tener más de un
constructor.
 Un constructor puede tener cero, uno
o más parámetros.
 Los constructores siempre se invocan
mediante el operador new.

Modificadores de acceso
Determinan desde qué
clases se puede acceder a
un determinado elemento.

 Los modificadores de acceso preceden
a la declaración de un elemento de la
clase (dato o método), de la siguiente
forma:
[modificador] tipo_variable nombre;
[modificador] tipo_devuelto nombreMetodo(lista_Argumentos)
{ …
Sentencias;
…
}

 Tipos: public, private, protected
y el tipo por defecto, que no tiene
ninguna palabra clave asociada,
pero se suele conocer como
default o package-private.

 Las clases en si mismas pueden
declararse:
 public - Todo el mundo puede usar la clase.
Se pueden crear instancias de esa clase,
siempre y cuando alguno de sus
constructores sea accesible.
 sin modificador (default) - La clase puede
ser usada e instanciada por clases dentro
del package donde se define.
 Las clases no pueden declararse ni
protected , ni private.

 public: todos pueden acceder al
elemento: si es un dato miembro todo
mundo lo puede ver o modificar, si es un
método, todo mundo lo puede invocar.
 private: sólo se puede acceder al
elemento desde métodos de la
clase, o sólo puede invocarse el
método desde otro método de la
clase.

 protected: una característica a la que
solo pueden acceder los métodos de
esta clase, los de sus descendientes y
los de otras clases de este mismo
paquete. Se emplea en la Herencia.
 Default: se puede acceder al
elemento desde cualquier clase del
package donde se define la clase.

Resumen de los modificadores
de acceso
private: Visible solo dentro de
la clase.
public: Visible para todo el
mundo.
protected: Visible para el
package y todas las sublcases.
default: Visible para el
package.

Parámetros implícitos y explicítos
Empleado numero007 = new
Empleado(“James Bond”,100000,1950,1,1);
Numero007.subirSueldo(5);
Parámetro implícito:
Objeto de tipo Empleado
Parámetro explícito

Parámetros implícitos y explicítos
 En todos los métodos, la palabra
reservada this se refiere al parámetro
implícito.
public void subirSueldo(double porcentaje)
{
double aumento = this.sueldo * porcentaje / 100;
this.sueldo +=aumento;
}
 Este estilo es utilizado para distinguir a
los datos miembros de las variables
locales.

public void setNombre(String nombre)
{ this.nombre = nombre;
}

Beneficios de la encapsulación
 Es necesario obtener y modificar el
valor de un campo de dato, entonces
hay que proporcionar tres cosas:
 un campo de datos privado;
 un método de acceso público al campo,
generalmente inicia el nombre del
método con la palabra get; y
 un método de modificación público del
campo, generalmente inicia el nombre
del método con la palabra set.

1. Se puede modificar la implementación
interna sin afectar a ningún código,
salvo el de los métodos de la clase.
Supongamos que el nombre completo se almacena en:
String nombreDePila;
String apellidos;
entonces el método getNombre se puede modificar para que
proporcione:
nombreDePila + “ ” + apellidos

2. Los métodos de modificación pueden
efectuar una comprobación de
errores.
Por ejemplo, un método llamado
setSueldo podría no comprobar el
sueldo siempre que sea menor que 0.

2.4 Propiedades y métodos estáticos,
sobrecarga de métodos y alcance
de variables.

Privilegio de acceso basado en clases
 Un método puede acceder a los datos
privados del objeto al cual se aplique.
 Un método puede acceder a los datos
privados de todos los objetos de su
clase.
class Empleado
{ …
boolean equals(Empleado otro)
{
return nombre.equals(otro.nombre);
}
} Una llamada típica:
if (harry.equals(jefe))…

Métodos privados (private)
 Los métodos privados solo se pueden
invocar dentro de la misma clase.
 Esto es útil ya que si es eliminado
solo afecta a las operaciones de esa
clase.

Campos finales
 Los campos datos se pueden definir como
final.
 Estos campos deben recibir un valor inicial
cuando se construye el objeto.
 Después de construir el objeto, los campos de
datos ya no pueden ser modificados.
 El modificador final es útil para los campos
cuyo tipo sea primitivo o una clase inmutable.
Una clase es inmutable si ninguno de sus
métodos puede modificar sus objetos (por
ejemplo la clase String).

Campos estáticos: variables
 Si se define un campo como static,
entonces solo hay uno de estos campos
por clase.
Ejemplo: se desea asignar un número de
identificación exclusivo a cada empleado.
class Empleado
{ . . .
private int id;
private static int idSiguiente = 1;
}

Todo objeto de tipo Empleado posee su
propio campo id, pero sólo hay un
campo idSiguiente que se comparte
entre todos los ejemplares de la clase.
Esto es, si hay 1000 objetos de la clase
Empleado, entonces hay 1000 campos
de ejemplar id, uno para cada objeto.
Pero solo hay un campo static
idSiguiente.

Aun cuando no hubiera objetos de tipo
Empleado, el campo idSiguiente estaría
presente. Pertenece a la clase, y no a
ningún objeto individual.
Por ejemplo, el siguiente
método:
public void setId()
{
id = idSiguiente;
idSiguiente++;
}
Estableciendo el número de id
para Harry:
harry.setId();
El campo id de Harry queda fijado
y el valor del campo static
idSiguiente se incrementa.

Campos estáticos: constantes
 Por ejemplo, la clase Math define una
constante static:
public class Math
{
. . .
public static final double PI = 3.14159265358979323846;
. . .
}
Esto implica que no necesita un objeto de la
clase Math para acceder al campo PI. Se puede
acceder a esta constante de la forma Math.PI.

Métodos estáticos
 No operan sobre objetos.
 Por ejemplo el método pow de la
clase Math es un método estático:
Math.pow(x, a);
calcula la potencia xa
. No se necesita
ningún objeto Math para llevar a cabo
esta tarea, esto es, carece de
parámetro implícito.
 No tienen el parámetro this.

Métodos estáticos
 Como no operan sobre objetos, no
pueden acceder a campos de
ejemplar desde los métodos static.
 Los métodos static pueden acceder a
los campos static de su clase.
Por ejemplo:
public static int getIdSiguiente()
{
return idSiguiente;
}
Para invocar a este método;
int n = Empleado.getIdSiguiente();
Note que se proporciona el nombre
de la clase

Métodos estáticos
Los métodos static se utilizan en dos
situaciones:
1.Cuando un método no necesita acceder
al estado del objeto porque todos los
parámetros necesarios se proporcionan
como parámetros explícitos. Por ejemplo:
Math.pow.
2.Cuando un método solo necesita acceder
a campos static de la clase. Por ejemplo:
Empleado.getIdSiguiente

Métodos Factoría
 Los métodos de factoría son
funciones de creación en vez de
constructores => cambiar el tipo de
lo que se crea mediante redefinición.
 Por ejemplo, la clase NumberFormat
emplea métodos de factoría que
producen objetos generadores de
formato para distintos estilos.

Métodos Factoría
NumberFormat formatoMonetario =
NumberFormat.getCurrencyInstance();
NumberFormat formatoPorcentual =
NumberFormat.getPercentInstance();
double x = 0.1;
System.out.println(formatoMonetario.form
at(x)); // imprime $0.10
System.out.println(formatoPorcentual.form
at(x)); // imprime 10%

El método main
 Los métodos estáticos se pueden
invocar sin tener objeto alguno.
 El método main es un método
estático y por ende no actúa sobre
objetos.
 Se ejecuta el método estático main, y
éste construye los objetos que
necesita el programa.

Parámetros de los métodos
 Formas de pasarle parámetros a un
método (o a una función):
 Parámetros por valor: significa que el
método obtiene solamente el valor que
proporciona quien hace la llamada.
 Parámetro por referencia: significa que el
método recibe la ubicación de la variable
que proporciona quien hace la llamada. De
modo que puede modificar el valor
almacenado de una variable que se le pase
por referencia.

 Existen dos tipos de parámetros:
 Tipos primitivos (números, valores boolean).
 Referencias de objetos.
 Un método no puede modificar un
parámetro de tipo primitivo.

 Parámetros por valor: suponga que un
método debe triplicar el valor del
parámetro,
public static void triplicarValor(double x)
{
x=3*x;
}
La llamada e este método:
double porcentaje = 10;
triplicarValor(porcentaje);
No funciona: Después de
la llamada al método, el
valor de porcentaje sigue
siendo 10:
1.X recibe como valor
una copia del valor de
porcentaje (10).
2.X se triplica, ahora vale
30, pero porcentaje sigue
siendo 10.
3.El método concluye y
la variable parámetro x
ya no se utiliza.

 Parámetros por referencia
public static void triplicarSueldo(Empleado x)
{
x.subirSueldo(200);
}
La llamada e este método:
leo = new Empleado(…);
triplicarSueldo(leo);
1. X recibe como valor
inicial una copia del
valor de leo (la
referencia de un
objeto).
2. Se aplica el método
subirSueldo a esa
referencia de objeto.
3. El método concluye y
la variable parámetro
x ya no se usa.

 En resumen:
 Los métodos no pueden modificar
parámetros primitivos (números o
valores de tipo boolean).
 Los métodos pueden cambiar el estado
de los parámetros tipo objeto.
 Los métodos no pueden hacer que un
parámetro de tipo objeto pase a referirse
a un nuevo objeto.
 Ejemplo: PruebaParametros.java

Fuente de información
 Core JAVA Volumen I. Fundamentos
Cay S. Horstmann, Gary Cornell
Pearson Educación, 2006

2 programación orientada_a_objetos

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (6)

Similar a 2 programación orientada_a_objetos

Similar a 2 programación orientada_a_objetos (20)

Más de Jesus Alberto Iribe Gonzalez

Más de Jesus Alberto Iribe Gonzalez (20)

2 programación orientada_a_objetos