Unidad1 y 2

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

 DISEÑAR E IMPLEMENTAR OBJETOS DE
PROGRAMACIÓN QUE PERMITAN
RESOLVER SITUACIONES REALES Y DE
INGENIERÍA.

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

1.2 LENGUAJE DE MODELADO UNIFICADO:
DIAGRAMA DE CLASES.

 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.
M.C. Miriam Zulma Sánchez Hernández

 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? color, tamaño, tipo_madera
¿Operaciones? cerrar_puerta(),
abrir_puerta()


 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.


 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.

 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.

 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.

 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.

 ¿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ísticas
o 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.

Modelado Diagrama

Establecimiento de Diagrama de
los requisitos Casos de Uso
de usuario

Modelado de la Diagrama de
estructura Clases
estática (análisis
o diseño)
Modelado de Diagrama de
interacción Colaboración
Diagrama de
Secuencia
Modelado Diagrama de
dinámico Estados
Diagrama de
Actividades
Modelado de Diagrama de
implementación Componentes
Diagrama de
Distribución

 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.

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.

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).

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.

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

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


<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.


<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.


Un 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.

 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

<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.

 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.

 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 misma
Clase es fácil. Solo incluye el nombre
del método worker y sus argumentos
si tiene.
--Modificar el de la clase String sin
crear objeto

 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);

 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.

 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()

 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 { class Rectangulo {
public static void main(String args[]){ private double base, altura;
Rectangulo r = new Rectangulo(3.0,7.0); public Rectangulo(double b, double h) {
System.out.println(“El área es ”+ r.calcArea()); base = b; altura=h}
} public double calcArea()
} {
return base*altura;
}
}

class Matem {
static long factorial (int n){
long p=1;
for (int i=2;i<=n; i++)
p*=i;
return p;
}
class CalculoFact {
// …
}
final int M=15;
for (int n=1; i<=M; i++)
System.out.println (n + “! =“ + Matem.factorial(n);
}
}

 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.

package dolmen; import dolmen.*;

public class Primera { public class Prueba {

private void goliar() {…} public static void main (String args[]) {

public double homero() { Segunda st=new Segunda();

goliar(); } Primera pt=new Primera();

protected void jureste() {…} st.balsas(); Correcto, es publico

String salustio() {…} pt.homero(); //Correcto, es público

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

public class Segunda { //paquete

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

 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 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; 6
metodo2(i);
}
void metodo2(int n)
{
int k=9;
n+=k;
}

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 {
class PorValorObjeto {
String fecha;
public static void main(String args[]){
int dias;
Miriam mir=new Miriam();
Miriam() {
System.out.println(“Propiedades del objeto en la
fecha=“17-04-2007”;
creación”);
dias=22;
mir.mostrar();
}
modifica(mir);
void mostrar() {
System.out.println(“Propiedades del objeto
System.out.println(“Fecha actual: “ +
fecha + “t Dias =“ + dias); modificado: “);

} mir.mostrar();

} }
static void modifica(Miriam obj) {
obj.fecha = “22-05-1972”;
obj.dias = 22;
}
}

 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.
Definición de
Figura calcularArea()
Perimetro()

Implementación de
calcularArea()
Perimetro()
Circulo Rectángulo

 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);

TestCalculadora.class
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) {
return num1 + num2;
}

Calculadora.class public static float suma(int num1, float num2, int num3)
{
return num1 + num2 + num3;
}
}

 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 que ejemplifican varios de los
conceptos revisados en la unidad

import javax.swing.*;
public class PosNeg {
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';

}
}

import javax.swing.*;
public class UnoDivideOtro {
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;
}
}

 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.

 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 {
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);
}
}

 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=Unset
private 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
public class ConstructorPlayeraTest {
o B");
}//fin del case
ConstructorPlayera myPlayera = new ConstructorPlayera('R');
}//Fin del constructor
char colorCode;
public char getColorCode(){
colorCode = myPlayera.getColorCode();
return colorCode;
System.out.println("Código del color: " + colorCode);
}
}
}
}

 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

Más contenido relacionado

La actualidad más candente

Similar a Unidad1 y 2

Unidad1 y 2