Unidad1 y 2

PROGRAMACIÓN ORIENTADA A

OBJETOS

M.C. Miriam Zulma Sánchez Hdz.

UNIDAD I. Introducción al Paradigma de la

Programación Orientada a Objetos

UNIDAD II. Clases y Objetos

UNIDAD III. Herencia

UNIDAD IV. Polimorfismo

UNIDAD V. Excepciones

UNIDAD VI. Flujos y Archivos

CONTENIDO GENERAL DE LA MATERIA

DISEÑAR E IMPLEMENTAR

OBJETOS DE PROGRAMACIÓN QUE

PERMITAN RESOLVER

SITUACIONES REALES Y DE

INGENIERÍA.

OBJETIVO DEL CURSO

UNIDAD 1: “INTRODUCCIÓN AL

PARADIGMA DE LA POO”

1.1 ELEMENTOS DEL MODELO DE OBJETOS: CLASES, OBJETOS, ABSTRACCIÓN, MODULARIDAD, ENCAPSULAMIENTO, HERENCIA.

1.2 LENGUAJE DE MODELADO UNIFICADO: DIAGRAMA DE CLASES.

CONTENIDO

M.C. Miriam Zulma Sánchez Hernández

Uno de los principales objetivos de POO es crear objetos, piezas de código autónomo, que puedan interactuar con otros objetos para resolver un problema.

La POO difiere de la programación procedural porque ésta enfatiza la secuencia de pasos codificados para resolver un problema, mientras que la POO hace énfasis en la creación e interacción de objetos.

QUE ES LA POO???


Identificando objetos

Los objetos pueden ser físicos o conceptuales. ◦ Una cuenta de cliente es un ejemplo de un objeto conceptual

porque no se puede tocar físicamente. Un cajero automático es algo que mucha gente toca todos los días y es un ejemplo de un objeto físico.

Los objetos tienen atributos (características).◦ Tal como tamaño, nombre, color, forma, etc. Los valores de los

atributos son referidos como el estado actual del objeto. Por ejemplo, un objeto puede tener un atributo color con el valor de rojo.

Los objetos tienen operaciones.(las cosas que pueden hacer)◦ Tal como asignar un valor, desplegar una pantalla, o incrementar

rapidez. Las operaciones usualmente afectan los atributos de los objetos.


Otro ejemplo… una puerta¿Atributos? ¿Operaciones?

color, tamaño, tipo_madera cerrar_puerta(), abrir_puerta()


Diseñando clases El identificar objetos ayuda a diseñar las clases (o

plantillas) para cada tipo de objetos en un sistema. En OO cada objeto de una clase es llamado una instancia de la clase, y tiene valores distintos en sus atributos, pero son los mismos atributos y las mismas operaciones.


• En Java los atributos son representados usando Variables, y las operaciones son representadas usando Métodos.

• Las Variables son el mecanismo para guardar datos.

• Los Métodos son el mecanismo para ejecutar una operación.

Atributos y Operaciones son…


RESUMIENDO…

Una clase es una plantilla que se usa para instanciar varios objetos individuales.

Una clase define el conjunto de elementos de datos (atributos) que definen los objetos, así como el conjunto de comportamientos o funciones (llamados métodos) que manipulan el objeto o realizan interacciones entre objetos relacionados.

Juntos, los atributos y métodos son llamados miembros

ABSTRACCIÓN◦ La abstracción en programación es la forma mas general de ver a un

objeto, sin meternos en su composición interior u otros componentes.

◦ Por ejemplo, la televisión, la abstracción de la televisión es un aparato que sirve para el entretenimiento, no nos interesa los circuitos, chips y demás cosas de la que esta integrada por dentro.

Fundamentos de POO

ENCAPSULAMIENTO◦ La encapsulación en programación significa agrupar a todos los

componentes de un objeto en uno solo, por medio de algo, para ocultar de la simple vista los componentes internos del objeto.

◦ Para quede mas claro, la television esta formada internamente por circuitos, chips, cinescopio y demas, la encapsulacion de la television es el cajon donde estan metidos todos estos componentes, este cajon los oculta de la simple vista, esto es la encapsulacion.

Fundamentos de POO

MODULARIDAD La Modularidad es la propiedad que permite subdividir una aplicación

en partes más pequeñas (llamadas módulos), cada una de las cuales debe ser tan independiente como sea posible de la aplicación en sí y de las restantes partes.

La modularización consiste en dividir un programa en módulos que se puedan compilar por separado, pero que tienen conexiones con otros módulos. Al igual que la encapsulación, los lenguajes soportan la Modularidad de diversas formas.

Fundamentos de POO

HERENCIA La herencia es específica de la programación orientada a objetos,

donde una clase nueva se crea a partir de una clase existente.

La principal ventaja de la herencia es la capacidad para definir atributos y métodos nuevos para la subclase, que luego se aplican a los atributos y métodos heredados.

Esta particularidad permite crear una estructura jerárquica de clases cada vez más especializada. La gran ventaja es que uno ya no debe comenzar desde cero cuando desea especializar una clase existente.

Fundamentos de POO

¿Qué es UML?o UML es un lenguaje estándar que nos permite

representar, especificar, visualizar, construir y documentar los elementos que se aúnan para conformar el sistema orientado a objetos en estudio.

Característicaso Es un lenguaje de propósito general. o Es un software libre. o No es una metodología completa y estricta. o Se ha convertido en un estándar mundial.

1.2. LENGUAJE DE MODELADO UNIFICADO: DIAGRAMA DE CLASES

Modelado Diagrama

Establecimiento de los requisitos de usuario

Diagrama de Casos de Uso

Modelado de la estructura estática

(análisis o diseño)

Diagrama de Clases

Modelado de interacción

Diagrama de Colaboración

Diagrama de Secuencia

Modelado dinámico

Diagrama de Estados

Diagrama de Actividades

Modelado de implementació

n

Diagrama de Componentes

Diagrama de Distribución

Sus diagramas

DIAGRAMAS DE CLASES

Un diagrama de clases sirve para visualizar las relaciones entre las clases que involucran el sistema, las cuales pueden ser asociativas, de herencia, de uso y de contenimiento.

Diagrama de clases

Un diagrama de clases esta compuesto por los siguientes elementos:

Clase: atributos, métodos y visibilidad. Relaciones: Herencia, Composición,

Agregación, Asociación y Uso.

http://www.dcc.uchile.cl/~psalinas/uml/modelo.html

http://www.dcc.uchile.cl/~psalinas/uml/modelo.html

Métodos: Los métodos u operaciones de una clase son la forma en como ésta interactúa con su entorno, éstos pueden tener las características:

• public (+): Indica que el método será visible tanto dentro como fuera de la clase, es decir, es accsesible desde todos lados.

• private (-): Indica que el método sólo será accesible desde dentro de la clase (sólo otros métodos de la clase lo pueden accesar).

• protected (#): Indica que el método no será accesible desde fuera de la clase, pero si podrá ser accesado por métodos de la clase además de métodos de las subclases que se deriven (ver herencia).

ATRIBUTOS Y MÉTODOS EN LAS CLASES

Ejemplo de un Diagrama de Clases

Unidad 2: “CLASES Y OBJETOS

2.1. DECLARACIÓN DE CLASES: ATRIBUTOS, MÉTODOS,

ENCAPSULAMIENTO.

2.2. INSTANCIACIÓN DE UNA CLASE.

2.3. REFERENCIA AL OBJETO ACTUAL.

2.4. MÉTODOS: DECLARACIÓN, MENSAJES, PASO DE

PARÁMETROS,RETORNO DE VALORES.

2.5. CONSTRUCTORES Y DESTRUCTORES: DECLARACIÓN, USO

Y APLICACIONES.

2.6. SOBRECARGA DE MÉTODOS.

2.7. SOBRECARGA DE OPERADORES: CONCEPTO Y UTILIDAD,

OPERADORES UNARIOS Y BINARIOS.

CONTENIDO


2.1. Declaración de clases

En JAVA la declaración de clases toma la siguiente forma:

<modifier>* class <class_name> { <attribute_declaration>* <constructor_declaration>* <method_declaration>*}


2.1. Declaración de atributos<modifier>* <type> <name>

[=<initial_value>];

public class Foo { private int x; private float y = 10000.0F; private String name = “Luis González”;

La palabra private indica que el atributo solo es accesible por los métodos dentro de la clase. El tipo puede ser primitivo o de cualquier clase.


2.1. Declaración de métodos

<modifier>* <return_type><name> (<argument>*) {

<statement>* }

Los modificadores pueden ser public, protected o private.

El modificador de acceso público indica que el método puede ser llamado desde otro código.

El método privado indica que el método puede ser llamado solo por otros métodos dentro de la clase.

El método protected es descrito más adelante.


Ejemplo

2.4. METODOSUn método es un bloque de código que tiene un nombre, tipo de acceso, tipo de retorno y una lista de argumentos o parámetros.

MÉTODOS

Las clases constan de dos elementos principales: variables de instancia y métodos.

Una definición de un método consta de dos partes: cabecera y cuerpo.

Sintaxis:

tipo nombre (lista de parámetros)

{

//cuerpo del método

}

tipo Especifica el tipo de datos devuelto por el método.

nombre El nombre que identifica al método

Modificadores de métodos<modifier>* <return_type><name> (<argument>*) {

<statement>* }

Los modificadores pueden ser public, protected o private. El modificador de acceso público indica que el método puede ser

llamado desde otro código. El método privado indica que el método puede ser llamado solo

por otros métodos dentro de la clase. El método protected es descrito más adelante.

Ejemplo

Accesando a Métodos

El operador punto(.) permite accesar a atributos y métodos no privados de una clase.

Dentro de un método no se necesita usar esta notación para accesar miembros locales del método.

Generalmente se crean métodos set() y get() para accesar a miembros de un objeto que no es local.

Métodos Calling y Worker

El método calling es el que invoca o “llama” a otro método para hacer algún trabajo.

Inversamente, el método worker hace algún trabajo para el método que lo invocó.

***Llamar un método en la mismaClase es fácil. Solo incluye el nombredel método worker y sus argumentossi tiene.--Modificar el de la clase String sin crear objeto

Creando métodos y variables static

Los métodos y variables que son únicos en una instancia son llamadas métodos de instancia y variables de instancia.

Existen métodos que no requieren instanciación, como el método main. Este es llamado método de clase o método estático, ya que lo puedes invocar sin crear primero un objeto.

Similarmente, las variables de clase o variables static se pueden usar sin crear un objeto.

public class Habitación{ static int Baño;

}System.out.println(Habitación.Baño);

Método main()

Todas las aplicaciones Java comienzan llamando al método main() que se sitúa en la clase cuyo nombre ha sido dado a la máquina virtual Java (JVM) para comenzar la ejecución del programa.

No todas las clases necesitan un método main(), solo las clases que son el punto de arranque del programa.

El método main() se declara static, ya que es llamado por la máquina Java en tiempo de ejecución antes de que se cree cualquier objeto.

Los argumentos que se pasan al método main() pueden ser cualquiera de la línea de órdenes que se introduce cuando se ejecuta el programa.

Método main()

Ejemplo: La clase Párrafo contiene sólo el método main(). Éste consta de una línea de código para dar salida por pantalla a la frase “Este es el verbo” junto a la cadena args[0] de la línea de órdenes

public class Parrafo {

public static void main(String args[]) {

System.out.println(“Esto es lo que escribiste” + args[0]);

}

}

Este archivo se compila y se ejecuta en modo línea de órdenes.java Parrafo HOLA

La salida por pantalla seráEsto es lo que escribiste HOLA

**Los argumentos de la línea de órdenes se consideran argumentos del método main()

RETORNO DE VALORES DE UN MÉTODO

La sentencia return se utiliza para salir del método actual y devolver el valor especificado por el tipo de retorno del método. Si el tipo de retorno del método es void, la palabra reservada return se utiliza sola o se omite.

public class Retorno {

public static void main(String args[]){

Rectangulo r = new Rectangulo(3.0,7.0);

System.out.println(“El área es ”+ r.calcArea());

}

}

class Rectangulo {

private double base, altura;

public Rectangulo(double b, double h) {

base = b; altura=h}

public double calcArea()

{

return base*altura;

}

}

LLAMADA A UN MÉTODOclass Matem {

static long factorial (int n){

long p=1;

for (int i=2;i<=n; i++)

p*=i;

return p;

}

// …

}

class CalculoFact {

public static void main(String args[]) {

final int M=15;

for (int n=1; i<=M; i++)

System.out.println (n + “! =“ + Matem.factorial(n);

}

}

ACCESO A MÉTODOS

Cada método tiene un tipo asociado que se utiliza para controlar el acceso al método. El tipo de acceso puede estar ausente (no se especifica), public, private o protected

Un método public se puede llamar por cualquier código que tenga la acceso a la clase.

Un método private solo se puede llamar desde otro método de la clase en que se define el método privado.

Un método protected se puede llamar desde otro método de la clase en que mismo método está definido y por cualquier otro método de las clases que heredan de la clase en que está definido el método. También está disponible en cualquier objeto de las clases pertenecientes al mismo paquete que la clase en que está definido el método.

Si no se especifica ningún tipo de acceso, se utiliza el acceso por defecto, que significa que el método es accesible a todas las clases contenidas en el mismo paquete, pero no es accesible fuera de ese paquete.

Ejemplo de niveles de acceso

package dolmen;

public class Primera {

private void goliar() {…}

public double homero() {

goliar(); }

protected void jureste() {…}

String salustio() {…}

}

public class Segunda {

public void balsas() {

Primera p = new Primera();

p.goliar(); //error, el método goliar es privado

p.salustio(); //Correcto, esta en el mismo paq

}

}

//fin del paquete

import dolmen.*;

public class Prueba {

public static void main (String args[]) {

Segunda st=new Segunda();

Primera pt=new Primera();

st.balsas(); Correcto, es publico

pt.homero(); //Correcto, es público

pt.salustio(); //Error, no esta en el mismo

//paquete

}

}

PASO DE ARGUMENTOS A MÉTODOS

Los argumentos se pasan a los métodos en Java por valor. Se hace una copia del tipo de dato primitivo (int, float, …) o la referencia al objeto de la clase o array y se pasa al método.

Se suele denominar parámetro a la variable definida en el método y que tiene un valor cuando se llama al método (a veces también se le conoce como parámetro formal) y argumento (a veces también se le conoce como parámetro real) es el valor que se pasa al método cuando se invoca.

cuadrado(23)

Pasa 23 como argumento

int cuadrado (int n) n recibe el valor 23

Paso de parámetros por valor

Paso por valor (también llamado paso por copia) significa que cuando Java compila el método y el código que llama al método, el método recibe una copia de los valores de los parámetros.

Si se cambia el valor de un parámetro variable local, el cambio solo afecta al método y no tiene efecto fuera del método.

En la técnica de paso por parámetro por valor, el método receptor no puede modificar la variable del método (parámetro pasado).

void calMetodo(){ int i=6; metodo2(i);}

void metodo2(int n){ int k=9; n+=k;}

6

IMPORTANTE!! La manera de pasar parámetros en Java es por valor. Cuando se pasa un objeto, realmente lo que se pasa es una referencia al objeto, esa referencia, el método llamado no puede modificarla (pasa la copia); sí pueden modificarse los datos miembro del objeto.Los arrays en Java se consideran objetos, podrán modificarse los elementos del array, pero no la referencia a éste.

class porValor {

public static void main (String args[]) {

int n=10;

System.out.println(“Antes de llamar a demoLocal, n=” + n);

demoLocal(n);

System.out.println(“Después de la llamada, n=” + n);

}

static void demoLocal(int valor) {

System.out.println(“Dentro de demoLocal, valor=” + valor);

valor=999;

System.out.println(“Dentro de demoLocal, valor=” + valor);

}

}

class Miriam {

String fecha;

int dias;

Miriam() {

fecha=“17-04-2007”;

dias=22;

}

void mostrar() {

System.out.println(“Fecha actual: “ + fecha + “\t Dias =“ + dias);

}

}

class PorValorObjeto {

public static void main(String args[]){

Miriam mir=new Miriam();

System.out.println(“Propiedades del objeto en la

creación”);

mir.mostrar();

modifica(mir);

System.out.println(“Propiedades del objeto

modificado: “);

mir.mostrar();

}

static void modifica(Miriam obj) {

obj.fecha = “22-05-1972”;

obj.dias = 22;

}

}

METODOS ABSTRACTOS Los métodos abstractos se utilizan en clases abstractas

para imponer una cierta funcionalidad a las subclases de las clases abstractas. Los métodos abstractos se designan por la palabra reservada abstract y no tienen cuerpo.

La implementación de los métodos abstractos se deja a las subclases. Por ejemplo, en una clase Figura se definen los métodos abstractos calcularArea() y Perimetro(). Las subclases Circulo y Rectangulo tendran sus propias implementaciones de estos métodos.

Figura

Circulo Rectángulo

Definición decalcularArea()Perimetro()

Implementación decalcularArea()Perimetro()

2.6. Sobrecarga de Métodos En Java pueden haber métodos en una clase que tengan el

mismo nombre pero diferentes argumentos, a esto se le conoce como Sobrecarga de métodos.

SOBRECARGA es mismo nombre de método, distintos argumentos y puede retornar diferente valor.

Ejemplo:public int sum(int num1, int num2);public int sum(float num1, float num2, int num3);public int sum(int num1, float num2);

public class TestCalculadora { public static void main(String args[ ]) { System.out.println("La suma es: "+ Calculadora.suma(5, 4)); System.out.println("La suma es: "+ Calculadora.suma(5.5F, 4.3F)); System.out.println("La suma es: "+ Calculadora.suma(5, 4.5F, 6)); } }

public class Calculadora { public static int suma(int num1, int num2) { System.out.println("Método suma1"); return num1 + num2; } public static float suma(float num1, float num2) { System.out.println("Método suma2"); return num1 + num2; } public static float suma(int num1, float num2, int num3) { System.out.println("Método suma3"); return num1 + num2 + num3; }}

TestCalculadora.class

Calculadora.class

Sobreescritura de métodos Si un método es definido en una subclase

con el mismo nombre, el mismo tipo de retorno y exactamente la misma lista de argumentos de un método de la clase padre, entonces el nuevo método está sobreescribiendo al anterior.

Un método que es sobreescrito tiene distinto comportamiento que el método que lo sobreescribe.

package figuras;public abstract class Figuras { public Figuras() { } public abstract void CalculoArea();}

------------------------------------------------------------------------------------------------package figuras;import java.util.*;import figuras.Figuras.*;public class FigurasTest { public static void main(String[] args) { Collection <Figuras> lista = new ArrayList <Figuras>(); lista.add(new Triangulo()); lista.add(new Circulo()); lista.add(new Cuadrado()); for(Figuras i: lista)//nuevo for i.CalculoArea(); } }

package figuras;public class Circulo extends Figuras {public void CalculoArea(){ double pi=3.1416,area=0.0; int radio=10; area=(pi*radio)*(pi*radio); System.out.println("El area de un circulo es: "+area);}}

-----------------------------------------------------------------------------------------------------------------------package figuras;public class Triangulo extends Figuras{ public void CalculoArea() { int base=10,altura=10; double area=0.0; area=(base*altura)/2; System.out.println("El area del triangulo es: "+area); }}

EJERCICIOS RESUELTOS DE

MÉTODOSEjercicios que ejemplifican varios de los

conceptos revisados en la unidad

Escribir un método que tenga un argumento de tipo entero y que devuelva la letra P si el número es positivo, y la letra N si es cero o negativo.

import javax.swing.*;public class PosNeg {public static void main(String args[]) { int num=Integer.parseInt(JOptionPane.showInputDialog("Dame un número: ")); if (SeraPosNeg(num)=='P') JOptionPane.showMessageDialog(null, "El número "+ num+" es Positivo","POSITIVO O NEGATIVO",JOptionPane.PLAIN_MESSAGE); else JOptionPane.showMessageDialog(null, "El número "+ num+" es Negativo o Cero","POSITIVO O NEGATIVO",JOptionPane.PLAIN_MESSAGE);}

static char SeraPosNeg (int n){ if(n>0) return 'P'; else return 'N'; }}

Escribir un método lógico de dos argumentos enteros, que devuelva true si uno divide al otro y false en caso contrario.

import javax.swing.*;public class UnoDivideOtro { public static void main(String args[]){ int num1=Integer.parseInt(JOptionPane.showInputDialog("Dame un número entero: ")); int num2=Integer.parseInt(JOptionPane.showInputDialog("Dame otro número entero: ")); if (divide(num1, num2)) JOptionPane.showMessageDialog(null, "El número "+ num1+" ES DIVISIBLE POR "+ num2,"DIVIDE",JOptionPane.PLAIN_MESSAGE); else JOptionPane.showMessageDialog(null, "El número "+ num1+" NO ES DIVISIBLE POR "+ num2,"DIVIDE",JOptionPane.PLAIN_MESSAGE); } static boolean divide(int n1, int n2){ if (n1%n2==0) return true; else return false; }}

2.5. CONSTRUCTORES

Declaración de constructores

Un constructor es un conjunto de instrucciones diseñadas para inicializar una instancia.

Los parámetros pueden ser pasados al constructor de la misma manera que un método. Su declaración básica es:

[<modifier> <class_name> (<argument>*) {<statement>

}

***Los constructores no son métodos, ya que no pueden retornar valores y no tienen herencia.

El constructor Default

Cada clase tiene al menos un constructor. Si no se escribe un constructor, Java proporciona uno por default. Este constructor no tiene argumentos y tiene un cuerpo vacío.

Si se declara un constructor en una clase que no tenia constructores, se pierde el constructor por default.

INVOCACION AUTOMÁTICA DE LOS CONSTRUCTORES

import java.io.*;class MyDate{ public int day; public int month; public int year; public MyDate(int day, int month, int year){ //day=10; month=05; year=2005; this.day=day; this.month=month; this.year=year; }}public class TestMyDate { public static void main(String args[]){ MyDate fecha = new MyDate(18,05,72); System.out.println("El dia es: "+ fecha.day); System.out.println("El mes es: "+ fecha.month); System.out.println("el año es: "+ fecha.year); } }

Constructores: creación y sobrecarga

Los constructores son estructuras parecidas a los métodos que son invocados automáticamente cuando se instancia un objeto.

Los constructores son usualmente usados para inicializar valores en un objeto.

El nombre de un constructor debe ser el mismo de la clase.

Puede o no tener argumentos, y puede o no, tener líneas de código en su cuerpo.

public class ConstructorPlayera { private int playeraID = 0;private String description = "-descripcion requerida-";

//Los códigos de color son R=Red, B=Blue, G=Green, U=Unsetprivate char colorCode = 'U';private double precio = 0.0;private int cantidadInStock = 0;

public ConstructorPlayera(char Codeinicial) { switch(Codeinicial){ case 'R': case 'G': case 'B': colorCode = Codeinicial; break; default: System.out.println("Código de color inválido, use R,G o B"); }//fin del case }//Fin del constructor public char getColorCode(){ return colorCode;}}

public class ConstructorPlayeraTest { public static void main(String args[]) { ConstructorPlayera myPlayera = new ConstructorPlayera('R'); char colorCode; colorCode = myPlayera.getColorCode(); System.out.println("Código del color: " + colorCode); } }

Sobrecarga de constructores Asi como los métodos, los constructores pueden ser

sobrecargados. La sobrecarga de constructores ofrece una variedad de

maneras en que los objetos pueden ser creados e inicializados usando una sola clase.

public class ConstructorPlayera{public ConstructorPlayera();public ConstructorPlayera(char codeInicial);public ConstructorPlayera(char codeInicial, int quantityInicial);

Unidad1 y 2

Documents

Transcript of Unidad1 y 2