Programación Orientada a Objetos

Programación Orientada a
Objetos
Implementación en Java
Angela C. Carrillo Ramos
Agenda
Implementación y uso de clases en
Java
Ejemplo clase CuentaBancaria
1
Ejemplo Diseño Cuenta Bancaria
(1)
Diseñar una clase que modele una Cuenta
Bancaria.. Una cuenta tiene un número,
Bancaria
nombre del cliente, clave, saldo y un
estado (activa, bloqueada, inactiva entre
otros).. A una cuenta se le puede consultar
otros)
su saldo, consignar, retirar, transferir,
bloquear, desbloquear y cambiar clave.
clave.
Implementación de clases en
JAVA (1)
Para implementar una clase en JAVA
se necesita un archivo
<clase>.java:
<clase>.
java:
contiene
la
descripción de la clase y la
implementación (el código) de los
métodos de la clase
2
Implementación de clases en
JAVA (2)
El archivo .java
class <NombreClase>
Aquí se declaran los
atributos de la clase
{
<atributos>
Aquí se declaran los
métodos de la clase
<métodos>
Clase Cuenta Bancaria
class Cuenta Bancaria
{
int numeroCuenta;
String nombreTitular;
String clave;
float saldo;
String estado;
metodo1
metodo2
}
}
Implementación de clases en
JAVA (3)
class <NombreClase>
{
/*-----------------------------------------------------------------------/*-----------------------------------------------------------------------*Atributos de la clase
*-------------------------------------------------------------------------------------------------------------------------------------------*/
*/
//----------------//
-----------------METODOS
METODOS -------- --------------------------------------
//----------------//
-----------------METODOS
METODOS CONSTRUCTORES
CONSTRUCTORES----------------------------------------------------------------//----------------//
-----------------METODOS
METODOS MODIFICADORES
MODIFICADORES----------------------------------------------------------------//----------------//
-----------------METODOS
METODOS ANALIZADORES
ANALIZADORES------------------------------------------------------------------}
3
Implementación de clases en
JAVA (4)
Declaración de atributos
class <NombreClase>
{
/*
/*--------------------------------------------------------------------------------------------------------------------------Tipo del atributo : int,
-------Descripción breve
*Atributos
de la
clase
double, float,
bool,
Nombre del atributo
qué representa
*-------------------------------------------------------------------*/
-----*/ String
private tipo atributo_1; // descripción del atributo
private tipo atributo_2; // descripción del atributo
...
private tipo atributo_n; // descripción del atributo.
de
}
Implementación de clases en
JAVA (5)
Cuenta BancariaBancaria-Declaración de
atributos
class CuentaBancaria
{
/*----------------------------------------------------/*----------------------------------------------------*Atributos de la clase
*-----------------------------------------------------------------------------------------------------*/
*/
private int numeroCuenta;
// Número de la Cuenta Bancaria
private String nombreTitular; // Nombre del Titular de la Cuenta
// Bancaria, diferente de vacía
//
private String clave;
// Clave de la Cuenta Bancaria
private float saldo;
// Saldo de la Cuenta Bancaria
private String estado;
// Estado de la Cuenta Bancaria,
// puede ser activa, inactiva o
bloqueada
}
4
Implementación de clases en
JAVA (6)
Declaración de métodosmétodos-encabezado
public tipo_resultado
<nombre_metodo>(<Lista de parametros> );
<Lista de parámetros> ::=
tipo parametro_1, tipo parametro_2, ... , tipo
parametro_N
Implementación de clases en
JAVA (7)
Declaración de métodos documentación
public tipo_resultado
<nombre_metodo>(tipo parametro_1, tipo parametro_2, ... , tipo parametro_N )
{
//----------------------------------------------------------------------//
----------------------------------------------------------------------// Descripción del propósito del método.
// ---------------------------------------------------------------------// Descripción de parametros:
//
parametro_1:
descripción
//
...
//
parametro_N:
descripción
// ---------------------------------------------------------------------// PRE: Precondición del método (aserciones sobre los parámetros).
// POS: Postcondición del método (aserciones sobre la respuesta y valores
//
finales).
//----------------------------------------------------------------------//
----------------------------------------------------------------------}
5
Implementación de clases en
JAVA (8)
CuentaBancaria-- Declaración de métodos
CuentaBancaria
public float
darSaldo()
{
//----------------------------------------------------------------------//
----------------------------------------------------------------------// Devuelve el saldo de la Cuenta Bancaria.
// ---------------------------------------------------------------------// PRE: True
// POS: darSaldo = saldo
//----------------------------------------------------------------------//
----------------------------------------------------------------------}
public int
darTitular()
{
//----------------------------------------------------------------------//
----------------------------------------------------------------------// Devuelve el Titular de la Cuenta Bancaria.
// ---------------------------------------------------------------------// PRE: True
// POS: darTitular = nombreTitular
//----------------------------------------------------------------------//
----------------------------------------------------------------------}
Implementación de clases en
JAVA (9)
Cuenta BancariaBancaria- Declaración de
métodos
public void
cambiarSaldo(float nuevoSaldo )
{
//-----------------------------------------------------------------//-----------------------------------------------------------------// Cambia el saldo de la Cuenta Bancaria por nuevoSaldo.
// ---------------------------------------------------------------// Descripción de parametros:
//
nuevoSaldo:
es el nuevo valor del saldo
// ---------------------------------------------------------------// PRE: nuevoSaldo >= 0
// POS: saldo==nuevoSaldo
//-----------------------------------------------------------------//-----------------------------------------------------------------}
6
Implementación de clases en
JAVA (10)
Cuenta BancariaBancaria- Declaración de
métodos
public void
cambiarEstado(String nuevoEstado )
{
//-----------------------------------------------------------------//-----------------------------------------------------------------// Cambia el estado de la Cuenta Bancaria por nuevoEstado.
// ----------------------------------------------------------------// Descripción de parametros:
//
nuevoEstado:
es el nuevo valor del estado
// ----------------------------------------------------------------// PRE: nuevoEstado no es vacío
// POS: estado==nuevoEstado
//---------------------------------------------------------------//---------------------------------------------------------------}
Implementación de clases en
JAVA (11)
Cuenta BancariaBancaria- Declaración de
métodos
public void
consignar(float consignacion )
{
//-----------------------------------------------------------------//-----------------------------------------------------------------// Suma al saldo de la Cuenta Bancaria el valor de la consignación.
// -----------------------------------------------------------------// Descripción de parametros:
//
consignacion:
es el valor a consignar en la Cuenta Bancaria
// ----------------------------------------------------------------// PRE: consignacion > 0
// POS: saldo = saldo + consignacion
//-----------------------------------------------------------------//-----------------------------------------------------------------}
7
Implementación de clases en
JAVA (12)
Declaración de métodosmétodos- Métodos
constructores
Los métodos constructores son los que se
ejecutan cuando se crea un objeto de la
clase.
Método sin parámetros
public <nombre_clase> ()
{
}
Método con parámetros
public <nombre_clase> (tipo par1,tipo par2, ..tipo parN)
{
}
Implementación de clases en
JAVA (13)
Cuenta Bancaria - Métodos
constructores
Método sin parámetros
public CuentaBancaria ()
{
}
Método con parámetros
public CuentaBancaria (int numero,String
Titular,float Saldo, String clave )
{
}
8
Implementación de clases en
JAVA(17)
Cuenta Bancaria: Implementación de
los métodos
Constructores
public CuentaBancaria()
{
numeroCuenta = 0;
nombreTitular= null;
clave= null;
saldo= 0;
estado= new String(“activa”);
}
Implementación de clases en
JAVA(18)
Cuenta Bancaria: Implementación de los
métodos
Constructores (cont)
public
CuentaBancaria(int numero,String Titular,float Saldo,
String Clave
)
{
numeroCuenta = numero;
nombreTitular= new String(Titular);
clave = new String(Clave);
saldo= Saldo;
estado= new String(“activa”);
}
9
Implementación de clases en
JAVA(19)
Cuenta Bancaria: Implementación de los
métodos
Constructores (cont)
public
CuentaBancaria(CuentaBancaria C )
{
numeroCuenta = C.darnumeroCuenta();
nombreTitular= new String(C.darTitular());
clave = new String(C.darClave());
saldo= C.darSaldo();
estado= new String(“activa”);
}
Implementación y uso de clases en
JAVA (20)
Cuenta Bancaria: Implementación de los
métodos
Analizadores
public
float
darSaldo()
{
return saldo;
}
10
Implementación y uso de clases en
JAVA (21)
Cuenta Bancaria: Implementación de los
métodos
Analizadores
public
String
darEstado()
{
return estado;
}
Implementación de clases en
JAVA(22)
Cuenta Bancaria: Implementación de
los métodos
Modificadores
public
void
cambiarSaldo(float nuevoSaldo)
{
saldo = nuevoSaldo;
}
11
Implementación de clases en
JAVA(23)
Cuenta Bancaria: Implementación de los
métodos
Modificadores
public
void
cambiarEstado(String nuevoEstado)
{
estado = new String(nuevoEstado);
}
Implementación de clases en
JAVA (24)
Cuenta Bancaria: Implementación de los
métodos
Modificadores
public void
consignar(float consignacion)
{
saldo = saldo + consignacion;
}
public void
retirar(float consignacion)
{
saldo = saldo - consignacion;
}
12
Implementación de clases en
JAVA (25)
Cuenta Bancaria: Implementación de los
métodos
Modificadores
public void
transferir(float transferencia, CuentaBancaria Destino)
{
this.retirar(transferencia);
Destino.consignar(transferencia);
}
Uso de clases en JAVA (4)
Esqueleto de un programa que usa interfaz de
consola:
class <NombreClase>{
// ---------------Declaracion
Declaracion de atributos y métodos de la clase
clase----------------------------public static void main(String
•Tipoargs[])
básico
{
•Clase
//-----//------Declaración
Declaración de Variables
Variables------------------------------------------Ejemplo:
tipo variable_1;
// descripción de la variable
CuentaBancaria c;
...
tipo variable _n; // descripción de la variable
Instrucción_1;
...
instrucción_N;
}
}
13
Uso de clases en JAVA (5)
Instrucciones de entrada/salida por consola
Salida: Mostrar por pantalla
System.out.println("Hola todos”);
System.out.println("El saldo es:" +
saldo);
Entrada: Leer de la pantalla
BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));
String t = in.readLine();
float saldo = Float.valueOf(t).floatValue();
Uso de clases en JAVA (6)
Ejemplo uso de la clase Cuenta Bancaria:
Leer los datos básicos de la Cuenta Bancarias,
hacer una consignación, un retiro y mostrar el saldo
actual..
actual
public static void main (String args[])
{
//-------------//--------------Declaración
Declaración de Variables
Variables--------------------------------------------------CuentaBancaria c;
// la Cuenta Bancaria a manejar
int n;
// número de la Cuenta Bancaria
float saldo;
// saldo de la Cuenta Bancaria
String Titular;
// Nombre del titular de la Cuenta Bancaria
String Clave;
// Clave de la Cuenta Bancaria
String Num;
// Cadena auxiliar para recibir el número de
// la Cuenta Bancaria
c=new CuentaBancaria(); // creamos una Cuenta Bancaria de número 0,
//con Titular y clave vacío, saldo en 0 y
//estado Activa
14
Uso de clases en JAVA (7)
Ejemplo uso de la clase Cuenta Bancaria:
Leer los datos básicos de la Cuenta Bancarias, hacer una consignación, un retiro y
mostrar el saldo actual.
//-------------//--------------Leer
Leer datos de Cuenta Bancaria
Bancaria------------------------------------BufferedReader in = new BufferedReader (new
InputStreamReader(System.in));
System.out.println( "Teclee el Titular de la Cuenta Bancaria" );
Titular = in.readLine();
System.out.println( "Teclee la clave de la Cuenta Bancaria" );
Clave = in.readLine();
System.out.println( "Teclee el número de la Cuenta Bancaria" );
Num = in.readLine();
n = Integer.valueOf(Num).intValue();
System.out.println( "Teclee el saldo de la Cuenta Bancaria" )
Num = in.readLine();
saldo = Float.valueOf(Num).floatValue();
Uso de clases en JAVA (8)
Ejemplo uso de la clase Cuenta Bancaria:
Leer los datos básicos de la Cuenta Bancarias, hacer una consignación, un retiro y
mostrar el saldo actual.
//---------------//----------------Cambiar
Cambiar datos de cuenta Bancaria
Bancaria------------------------------------c.cambiarTitular(Titular);
c.cambiarSaldo(saldo);
c.cambiarClave(Clave);
c.cambiarNumero(n);
//---------------//----------------Cambiar
Cambiar datos de f2
f2--------------------------------------------------------------c.consignar(200.000);
c.retirar(50.000);
System.out.println( ”El saldo actual es” + c.darSaldo() );
}
15