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 mensaje parametros

4

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

modificador de acceso

tipo de retorno

nombre del metodo

lista de parametros

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 argumento

nombre 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; private String tipo = "Drama"; private int numeroDeOscares; } // implicito // explicito // implicito

9

Inicialización de atributos
1. Los atributos se inician implícitamente como: char byte, short, int, long boolean float, double Referencia a Objeto '0' 0 false 0.0 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.
public BankAccount(String nombre) { setPropietario(nombre); } Definicion del Constructor 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; } 14 Cuantos constructores encuentra en Pelicula.Java?

}

TestConstructores.java

public class TestConstructores { public static void main (String[] args) {

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; } }

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()); } }
15 Que muestra el programa?

La referencia this
1. Los métodos de instancia reciben el argumento implícitamente que se refiere al mismo objeto. this

public class Pelicula { private String titulo; public void setTitulo(String titulo) { this.titulo = titulo; } }

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

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 { código entre constructores private String titulo; usando la referencia this. private String tipo; public Pelicula() { Un constructor invoca a this("Pelicula sin definir"); otro pasándole los } argumento que requiere. public Pelicula (String titulo) { 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 import java.util.*; public class Pelicula { // iniciación explicita private static int numeroDias = 3; // iniciación compleja private static double precioMinimo; static { Date hoy = new Date(); // si es Domingo if (hoy.getDay() == 0) precioMinimo = 5.10; else precioMinimo = 3.29; } public int getNumeroDias() { return numeroDias; } public double getPrecioMinimo() { return precioMinimo; } }

1. Los atributos de clase se pueden iniciar en la declaración. 2. La iniciación ocurre cuando se carga la clase en memoria. 3. Para una iniciación compleja se usara un bloque static

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 paquete

Nombre de la clase

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; import pe.com.megabank.model.BankAccount;

Importar solo una clase

public class Tester { public static void main(String[] args) { package 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

Sign up to vote on this title
UsefulNot useful