LENGUAJE DE PROGRAMACION

ORIENTADO A OBJETOS

TRABAJANDO CON CLASES

Universidad Nacional de Ingeniería

Facultad de Ingeniería Industrial y de Sistemas

Angel Chata Tintaya (angel.chata@gmail.com)

http://aulaportal.googlepages.com

1
 Definiciones iniciales
1. El encapsulamiento se basa en los métodos de instancia.
2. La sobrecarga de métodos nos brinda una interfase mas legible.
3. Los constructores aseguran una consistente creación de objetos
4. El Garbage Collector libera espacio en memoria.

2
 Implementando clases
1. Las clases se agrupan en paquetes
• Un paquete contiene una colección de clases relacionadas
lógicamente

2. Los archivos con código fuente tiene la extensión .java

• Hay una clase publica por archivo .java

3. Una clase es como una plantilla

• Usualmente necesitaremos crear objetos o instancias de la
clase.

3
 Mensajes
1. Los mensajes invocan el comportamiento de un objeto a traves
de un método.

BankAccount cuenta = new BankAccount();

cuenta.setPropietario("Smith");
cuenta.acreditar(1000.0);
cuenta.debitar(50.5);
...

cuenta.debitar(50.5)

receptor parametros

mensaje

4
 Metodos
1. Los métodos determinan como los objetos responden a los
mensajes (la conducta de la clase).

tipo de nombre del

modificador retorno metodo lista de parametros
de acceso

public void debitar(double cantidad) {

// Cuerpo del metodo

// Codigo Java que implementa conducta del
metodo

5
 Firma del método
1. Una clase puede tener muchos métodos con el mismo nombre
(sobrecarga), pero deben tener una firma diferente.
2. La firma del método consiste de:
• El nombre del método
• Los tipos y cantidad de argumentos

tipo de
nombre argumento
metodo

public void acreditar (double cantidad)

{
...
}
firma
6
 Sobrecarga de métodos
1. Algunos métodos en una clase pueden tener el mismo nombre.
2. Estos métodos deben contar con diferentes argumentos.
3. El compilador decide que método invocar comparando los
argumentos.
4. Se generara un error si los métodos solo varían en el tipo de
retorno.
5. Las firmas permiten que el mismo nombre sea utilizado para
muchos diferentes metodos (overloading).

public class Pelicula {

private float precio;
public void setPrecio() {
precio = 3.50;
}
public void setPrecio(float nuevoPrecio) {
precio = nuevoPrecio;
} 7
}
 Clases
1. Las clases encapsulan atributos métodos. Los atributos y
métodos son miembros de la clase.
2. Los miembros pueden pertenecer a:
• Toda la clase (la clase y sus objetos). Son métodos y
atributos de clase, indicados por el calificador static
• Un objeto. Son métodos y atributos de instancia
3. Las clases pueden ser
• Independientes una de otra
• Relacionadas por herencia (superclase / subclase)
• Relacionadas por el tipo (interfase)

8
Iniciación de atributos de instancia
1. Las variables de instancia se pueden iniciar en la declaración.
2. Esta iniciación ocurre cuando se crea un objeto.
3. Los atributos de instancia conservan sus propios valores en
cada objeto.

public class Pelicula {

private String titulo; // implicito

private String tipo = "Drama"; // explicito
private int numeroDeOscares; // implicito

9
 Inicialización de atributos
1. Los atributos se inician implícitamente como:

char '0'
byte, short, int, long 0
boolean false
float, double 0.0
Referencia a Objeto null

2. En forma explicita se puede indicar un valor inicial.

private String tipo = "Drama";

 
3. Un constructor provee una inicialización de atributos de
instancia mas compleja.

10
 Pelicula.java
public class Pelicula {
private String titulo;
private String tipo = "Drama"; 

public Pelicula() {
titulo = "Pelicula sin definir.";
}
public Pelicula(String nuevoTitulo) {
titulo = nuevoTitulo;
}
public Pelicula(String nuevoTitulo, String nuevoTipo) {
titulo = nuevoTitulo;
tipo = nuevoTipo;
}
...
}

11
 Constructores
1. Para una adecuada iniciación de variables de instancia, la clase
debe tener un constructor.
2. Un constructor se invoca automáticamente cuando se crea un
objeto.
3. Se declaran de forma pública.
4. Tiene el mismo nombre que la clase.
5. Si no se codifica un constructor, el compilador crea uno por
defecto sin argumentos que inicializa las variables de instancia
en forma explicita o implicita.

Definicion del
public BankAccount(String nombre) { Constructor
setPropietario(nombre);
}
Uso del Constructor

BankAccount cuenta = new BankAccount(“Jorge Basadre"); 12

 Constructores
1. Es un método que crea una nueva instancia de una clase. Las
clases contienen al menos un constructor.
2. Se usa el comando new con un constructor para crear una
instancia de una clase.
3. No retorna ningún valor. Con el operador new retorna una
referencia al nuevo objeto.
4. Al definir un constructor, también se proporciona el constructor
por defecto.
5. Los constructores se sobrecargan para permitir diferentes
formas de creación de objetos.

BankAccount cuenta = new BankAccount();

BankAccount cuentaNumerada = new BankAccount(numero);

BankAccount cuentaNombrada = new BankAccount(“Caiman”);

13
 Pelicula.java
public class Pelicula {
private String titulo;
private String tipo = "Drama"; 

public Pelicula() {
titulo = "Pelicula sin definir.";
}
public Pelicula(String nuevoTitulo) {
titulo = nuevoTitulo;
}
public Pelicula(String nuevoTitulo, String nuevoTipo) {
titulo = nuevoTitulo;
tipo = nuevoTipo;
}
public String getTitulo() {
return titulo;
}
public String getTipo() {
return tipo;
}
} Cuantos constructores encuentra en Pelicula.Java?
14
 public class Pelicula {
private String titulo;
private String tipo = "Drama"; 
public Pelicula() {
titulo = "Pelicula sin definir.";
}
public Pelicula(String nuevoTitulo) {

TestConstructores.java }
titulo = nuevoTitulo;

public Pelicula(String nuevoTitulo,

String nuevoTipo) {
titulo = nuevoTitulo;
tipo = nuevoTipo;
}
public String getTitulo() {
return titulo;
}
public String getTipo() {
return tipo;
}
public class TestConstructores { }

public static void main (String[] args) {

Pelicula pelicula1 = new Pelicula();

Pelicula pelicula2 = new Pelicula("La lista de Schindler.");
Pelicula pelicula3 = new Pelicula("El dormilon.","Comedia");
System.out.println(pelicula1.getTitulo()+pelicula1.getTipo());
System.out.println(pelicula2.getTitulo()+pelicula2.getTipo());
System.out.println(pelicula3.getTitulo()+pelicula3.getTipo());

}
Que muestra el programa?
15
 La referencia this
1. Los métodos de instancia reciben el argumento this
implícitamente que se refiere al mismo objeto.

public class Pelicula {

private String titulo;

public void setTitulo(String titulo) {

this.titulo = titulo;
}

Que diferencia existe entre this.titulo y titulo en el metodo?

16
 La referencia this
1. En un constructor, el comando this es usado para referirse a otros
constructores en la misma clase.
...

public BankAccount(String name) {

super();
owner = name;
}

public BankAccount() {
this("TestName");
}

public BankAccount(String name, double initialBalance)

{
this(name);
setBalance(initialBalance);
}
... 17
 La referencia this
Pelicula.java 1. Se puede compartir
public class Pelicula {
private String titulo;
código entre constructores
private String tipo;  usando la referencia this.
public Pelicula() { Un constructor invoca a
this("Pelicula sin definir"); otro pasándole los
}
public Pelicula (String titulo) {
argumento que requiere.
this.titulo = titulo;
}
public String getTitulo() {
return titulo;
}
}
TestThis.java
public class TestThis {
public static void main (String[] args) {
Pelicula pelicula1 = new Pelicula();
Pelicula pelicula2 = new Pelicula(“Kramer vs Kramer");
System.out.println(pelicula1.getTitulo());
System.out.println(pelicula2.getTitulo());
}
} 18
Que muestra el siguiente codigo?
 Destructores?
1. Java no tiene el concepto de destructores para los objetos que no
se estan usando.
2. La des-asignación es realizada automaticamente por el Java
Virtual Machine (JVM)
3. El recolector de basura (Garbage Collector) libera la memoria de
objetos no referenciados.
4. Desligar una referencia (variable) de un objeto (memoria) se
realiza asignando otro valor a la referencia del objeto:
1. referenciaObjeto = null;
2. referenciaObjeto = otroObjeto;
5. Un objeto sin referencias es un candidato a la des-asignación
durante la recolección de basura.

19
 Atributos de clase
1. Los atributos de clase comparte un único valor entre todos las
instancias de la clase.
2. Se declaran con el calificador static.
3. Todos los objetos creados a partir de la clase obtienen el mismo
dato de un atributo estático.

public Class Pelicula {

// iniciación por defecto

private static double precioMinimo;
private String titulo, tipo;

20
 Atributos de clase
Pelicula.java 1. Los atributos de clase se
pueden iniciar en la
import java.util.*; declaración.
public class Pelicula {
// iniciación explicita 2. La iniciación ocurre
private static int numeroDias = 3; cuando se carga la clase
// iniciación compleja
en memoria.
private static double precioMinimo;
static { 3. Para una iniciación
Date hoy = new Date();
compleja se usara un
// si es Domingo
if (hoy.getDay() == 0) bloque static
precioMinimo = 5.10;
else
precioMinimo = 3.29;
}
public int getNumeroDias() {
return numeroDias;
}
public double getPrecioMinimo() {
return precioMinimo;
}
21
}
 Métodos de clase
1. Estos métodos son compartidos por todas las instancias.
2. Se usan estos métodos principalmente para manipular variables
de instancia.
3. Se les declara con el calificador static
4. Se invoca a este método de clase con el nombre de la clase o
con el nombre de una instancia.
5. No es necesario crear un objeto para utilizar un metodo de
clase, basta con referenciar a la clase.

22
Pelicula.java
public class Pelicula {
private static float precio = 3.50f;
private String titulo;
public Pelicula(String titulo) { this.titulo = titulo; }
public String getTitulo() { return titulo; }
public static void setPrecio(float nuevoPrecio) {
precio = nuevoPrecio;
}
public static float getPrecio() {
return precio;
}
}

TestStatic2.java
public class TestStatic2 {
public static void main (String[] args) {
Pelicula.setPrecio(3.98f);
Pelicula oscar = new Pelicula("Ben Hur");
Pelicula video = new Pelicula(“Aeropuerto”);
System.out.println(oscar.getPrecio());
oscar.setPrecio(4.98f);
Pelicula camara = new Pelicula(“Odisea 2001”);
System.out.println(video.getPrecio());
System.out.println(camara.getPrecio());
System.out.println(Pelicula.getPrecio());
} 23
} Que resultados se obtienen?
 Métodos main
1. Una aplicacion no puede ejecutarse a menos que una clase
presente un metodo main
2. La JVM carga la clase e inicia la ejecucion al llamar al metodo
main(String[] args)
• public: puede ser llamado por cualquier objeto
• static: no necesita crearse un objeto previamente
• void: no retornara ningún valor

public static void main(String[] args) {

BankAccount cuenta = new BankAccount();
account.setPropietario(args[0]);
account.credit(Integer.parseInt(args[1]));
System.out.println(cuenta.getBalance());
System.out.println(cuenta.getPropietario());
}
24
 Paquetes
1. Las clases se pueden agrupar según el modelo que se esta
construyendo.
2. Por convención, los nombres de los package están en
minúsculas
3. Diferentes packages pueden contener clases con el mismo
nombre

Nombre del
Nombre de la clase
paquete

pe.com.megabank.model. BankAccount

Nombre de la clase “completamente calificado”

25
 Modificadores de Acceso
Las variables y métodos en Java tiene restricciones de acceso, descrito
por los siguientes modificadores de acceso:
private: El acceso es limitado a la clase
Ejemplo: private int x;
default (sin modificador): Acceso limitado al paquete
Ejemplo: int x;
protected: Limitado al paquete y las subclases.
Ejemplo: protected void setName() { . . . }
public: Acceso desde todas las clases en todos los paquetes
Ejemplo: public String getName() { . . . }

26
 Accesibilidad a las clases
1. Las clases pueden referirse a otras clases dentro del mismo
paquete por el nombre de la clase solamente
2. Debe proporcionarse el nombre completamente calificado
(incluyendo el paquete) para las clases definidas en diferentes
paquetes
3. Se muestra como Tester y BankAccount se han definido en
diferentes paquetes

package pe.com.megabank.testing;

public class Tester {

public static void main(String[] args) {
pe.com.megabank.model.BankAccount cuenta
= new pe.com.megabank.model.BankAccount(“Rafael");
cuenta.acreditar(1000.0);
System.out.println(cuenta.getBalance());
}
} 27
 Sentencia import
1. La sentencia import permite utilizar clases sin calificarlas
completamente.

package pe.com.megabank.testing; Importar solo

una clase
import pe.com.megabank.model.BankAccount;

public class Tester {

public static void main(String[]
package args) {
com.megabank.testing;
BankAccount cuenta = new BankAccount(“Rafael");
cuenta.acreditar(1000.0);
import com.megabank.models.*;
System.out.println(cuenta.getBalance());
} public class Tester {
} public static void main(String[] args) {
BankAccount cuenta = new BankAccount(“Rafael");
cuenta.acreditar(1000.0);
Importar todas System.out.println(cuenta.getBalance());
las clases del }
package }
28
 FIN

29
Universidad Nacional de Ingeniería 29