UNMSM -44-

Los miembros de instancia son los métodos y las variables que pertenecen al objeto.
Los valores de las variables definen el estado del objeto.
Los métodos definen el comportamiento de un objeto. La implementación de los
métodos sí es compartida por todas las instancias.

Los miembros estáticos son los métodos y las variables que pertenecen a la clase.
Se diferencian en la definición por la palabra clave static.
Las variables estáticas son inicializadas cuando se carga la clase en runtime.
Los miembros estáticos pueden ser llamados utilizando el nombre de la clase o a
través de la referencia al objeto

• Variables de tipo simple de datos: El paso de parámetros se realiza siempre por

valor, es decir, el valor del parámetro de llamada no puede ser modificado en el
cuerpo del método ( El método trabaja con una copia del valor utilizado en la
llamada).
• Variables de tipo Objeto (referencias): El valor del parámetro de llamada si
puede ser modificado dentro del método. ( El método trabaja directamente con el
valor utilizado en la llamada).

Es la capacidad de crear una nueva clase a partir de otra clase ya existente.

La nueva clase puede definir nuevos atributos y métodos o modificar los ya
existentes, si como utilizar los atributos o metodos de la clase padre.
La clase padre se denomina superclase y la hija, subclase.
En Java la herencia es lineal (sólo existe un superclase para una subclase)
Utilizamos la palabra clave extends.
Se heredan los métodos permitidos.
Se puede sobreescribir algunos metodos de la superclase

La sobrecarga de métodos nos permite implementar un método de diferente manera.

La firma del método sobrecargado cambia.

public int metodo1(int a);

public int metodo1(int a, String c);

Es necesario cambiar la “firma” del método, no sólo los valores de devolución

Para sobrescribir un método debemos de tener en cuenta :

Debemos revisar el nivel de accesibilidad para comprobar que podemos
sobreescribir el método.
El método debe tener la misma “firma” o declaración que el de la clase
padre.

Mg. Javier CABRERA

UNMSM -45-

this –permite hacer referencia a elementos de la misma clase

super –permite hacer referencia a elementos de la clase padre

jercicios propuestos
2.-Implemente 4.- banco ,con los atributos nro de cuenta , nombre del
una clase llamado
cliente , tipo
.- Diseñe de ahorro( D=dólar
e implemente y S=soles)
en Java una y eltrabajar
clase para saldo; con
Implemente
triánguloslosisósceles.
métodosPara
para
deposito , retiro
lo, defina de dinero.
las variables y los métodos
de ejemplar constructores
mínimas que requiera,respectivos.
proporcione métodos de
Esta aplicación
onsulta, impleméntelo
un método : e implemente otros métodos para calcular el perímetro
constructor
el área de un triángulo.
a) Primero en modo de consola , empleando un ArrayList para almacenar un
conjunto de clientes , se debe elaborar un menú que contemple las siguientes
opciones:
(1) Nuevos ahorristas
(2) Consulta de Saldos
(3) Movimiento de Cuentas
(4) Listado de Ahorristas
(5) Anulación de cuentas
(6) Salir
En la opción 2 se realiza la búsqueda por medio de un numero de cuenta
En la opción 3 se realiza el deposito o retiro a través de un numero de cuenta
actualizando el saldo respectivo.
La anulación también se realiza por medio del nro de cuenta.

b) Realizar la misma aplicación pero empleando formularios.

Mg. Javier CABRERA

UNMSM -46-

3. ¿Cuál es el resultado del siguiente programa?

class Ejercicio {
public static void main(String [ ] args){
Clase1 obj1=new Clase1();
obj1.imprimir(24.3,5);
}
}
class Clase1 {
private double valor=9.8;
private int x=7;
public void imprimir(double valor, int x) {
System.out.print(valor+” “+this.x);
}
}

4.- 12. ¿Qué imprime el siguiente programa?

class Principal {

public static void main(String[] args) {

Autor autor =new Autor ("Paul", "Auster");
Libro libro= new Libro ("La trilogía de Nueva York", autor); System.out.println
(libro.getTitulo()+" de " +
(libro.getAutor()).toString());
}

class Libro {

private String titulo;

private Autor autor;

public Libro(String titulo, Autor autor) {

this.titulo = titulo;
this.autor = autor;
}

public Autor getAutor() {

return autor;
}

public String getTitulo() {

return titulo;
}

Mg. Javier CABRERA

UNMSM -47-

class Autor {

private String nombre;

private String apellido;

public Autor (String nombre, String apellido) {

this.nombre = nombre;
this.apellido=apellido;
}

public String toString () {

return nombre+ " " +apellido;
}
}

Mg. Javier CABRERA

UNMSM -48-

APLIACION GENERAL DE MANTENIMIENTOS EMPLEANDO CLASES

Objetivo.- Que el alumno se capaz de implementar clases y manejo de ArrayList para

almacenar datos para un conjunto de items y a partir de ello realizar las operaciones de
Listado, modificación y eliminación de datos.

Las pantallas a emplear son las siguientes:

Mg. Javier CABRERA

UNMSM -49-

1.- La opción de anulación es a través del código del empleado :

Mg. Javier CABRERA

UNMSM -50-

La Modificación de Datos:
También se realiza mediante el código del empleado

Mg. Javier CABRERA

UNMSM -51-

Los pasos a realizar:

1.- Diagrama de clases:

Mg. Javier
CABRERA
UNMSM -52-

1.- Establecer los paquetes para las clases, inagenes y el paquete de prueba.

Empleado.java
package pack2;

public class Empleado {

private String code;
private String nome;
private char sec;
private double horas;
private double pt;
private static int nro=0;
/** Creates a new instance of Empleado */
public Empleado() {
nro++;
}

public Empleado( String cod,String nom, char sec, double hr ) {

this();

Mg. Javier CABRERA

UNMSM -53-

this.code=cod;
this.nome=nom;
this.sec=sec;
this.horas=hr;
}

public String getCode() {

return code;
}

public void setCode(String code) {

this.code = code;
}

public String getNome() {

return nome;
}

public void setNome(String nome) {

this.nome = nome;
}

public char getSec() {

return sec;
}

public void setSec(char sec) {

this.sec = sec;
}

public double getHoras() {

return horas;
}

public void setHoras(double horas) {

this.horas = horas;
}

public double getPt() {

return pt;
}

public static int getNro() {

return nro;
}

2.- La clase de Empleados.java (un arreglo para almacenar varios empleados)

Mg. Javier CABRERA

UNMSM -54-

package pack2;
import java.util.ArrayList;
import javax.swMg.*;
public class Empleados {
private ArrayList emp;

public Empleados() {
emp=new ArrayList();

}
//para actualizar
public void update(Empleado e,int indice){
emp.set(indice,e);
}
//para adicionar nuevos empleados
public void AddEmp(Empleado e){
try{

emp.add(e);
}catch(Exception ex){
System.out.print("\n "+ex.getMessage());
}
}
//obtener un Empleado a partir de un indice
public Empleado GetEmp(int ind){
return (Empleado) emp.get(ind);
}
//obtener el tamaño del arraylist
public int Nroemp(){
return emp.size();
}
//busqueda por numero devolviendo su indice
public int Busca(int n){
for(int i=0;i<Nroemp();i++){
if(n==GetEmp(i).getNro()){
return i;
}

}
return -1;

//una sobrecarga Busqueda por Codigo, devolviendo su indice

public int Busca(String code){
for(int i=0;i<Nroemp();i++){
if(code.equals(GetEmp(i).getCode())){
return i;
}

Mg. Javier CABRERA

UNMSM -55-

}
return -1;

//quita un empleado a partir de un indice

public void Elimina(int nro){
emp.remove(nro);

}
//calcula el total pasando como dato un indice del arraylist
private double total(int f){
double tot;
if(this.GetEmp(f).getSec()=='A')
tot=this.GetEmp(f).getHoras()*13;
else
tot=this.GetEmp(f).getHoras()*15;
return tot;
}
//pasando un textArea va mostrar en dicho objeto la lista de datos
public void ListaArea(javax.swMg.JTextArea xarea){
xarea.setText("Lista de Empleados \n");
xarea.append("\n Codigo \tNombre \t\tHoras\t Pago Total");
for(int f=0;f<Nroemp();f++){
xarea.append("\n"+ GetEmp(f).getCode()+
"\t"+GetEmp(f).getNome() +
"\t\t"+GetEmp(f).getHoras()+
"\t"+this.total(f));
}

}
//un listado simple mediante consola
public void Lista(){
//System.out.print("\nnro \t codigo \t nombre \t total");
for(int f=0;f<Nroemp();f++){
System.out.print("\n"+ this.GetEmp(f).getNro()+
"\t"+GetEmp(f).getCode()+
"\t"+GetEmp(f).getNome() +
"\t"+this.total(f));
}
} // fin del metodo

}fin de la clase

Mg. Javier CABRERA

UNMSM -56-

La ventana principal tipo Jdialog (EmpDialog.java)

package pruebas;
import pack1.prueba;
import pack2.*;
import javax.swMg.JOptionPane;
public class EmpDialog extends javax.swMg.JDialog {
static Empleados emp;
static Empleado uno;
/** Creates new form EmpDialog */

public EmpDialog(java.awt.Frame parent, boolean modal) {

super(parent, modal);
initComponents();
emp=new Empleados();
this.jRx.setVisible(false);
this.limpiar();
}
private void txthrKeyReleased(java.awt.event.KeyEvent evt) {
// TODO add your handling code here:
String dato=this.txthr.getText();
if(dato.trim().length()==0)
{ this.jbtAcepta.setEnabled(false);
return;
}
else{
try{
double p=Double.parseDouble(dato);
this.jbtAcepta.setEnabled(true);

}catch(Exception ex){
JOptionPane.showMessageDialog(this,"El dato debe ser numerico","error",
JOptionPane.ERROR_MESSAGE);

private void txtcodKeyReleased(java.awt.event.KeyEvent evt) {

// CUANDO SE INGRESA EL CODIGO
if(txtcod.getText().trim().length()==0){
this.jbtAcepta.setEnabled(false);
return;
}
else{
this.jbtAcepta.setEnabled(true);

Mg. Javier CABRERA

UNMSM -57-

private void JbtnModificaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
boolean flag=false;
String code,nom; double horas;
code=this.txtcod.getText().trim();
int b=emp.Busca(code);
if(b==-1){
this.jTextArea1.setText("Codigo no existe");
return;
}
nom=emp.GetEmp(b).getNome();
horas=emp.GetEmp(b).getHoras();
pruebas.ModiEmpDialog ven=new
pruebas.ModiEmpDialog(null,true,code,nom,horas);
ven.setVisible(true);
if(ven.getFlag()==true){ //elimina el empleado
Empleado x=new Empleado();
x.setCode(code);
x.setHoras(ven.getHoras());
x.setNome(ven.getNom());
emp.update(x,b);
this.jTextArea1.setText("Registro actualizado");
}

private void JbeliminaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
boolean flag=false;
String code,nom;
double horas;
code=this.txtcod.getText().trim();
int b=emp.Busca(code);
if(b==-1){
this.jTextArea1.setText("Codigo no existe");
return;
}
nom=emp.GetEmp(b).getNome();
horas=emp.GetEmp(b).getHoras();
DelEmpDialog ven=new DelEmpDialog(null,true,code,nom,horas);
ven.setVisible(true);
if(ven.getFlag()==true){ //elimina el empleado
emp.Elimina(b);

Mg. Javier CABRERA

UNMSM -58-

this.jTextArea1.setText("Registro eliminado");
}

private void jbtnListaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
emp.ListaArea(this.jTextArea1);
}

private void jbtAceptaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
uno=new Empleado();
uno.setCode(this.txtcod.getText());
uno.setNome(this.txtnom.getText());
uno.setHoras(Double.parseDouble(this.txthr.getText()));
if(this.jRa.isSelected())
uno.setSec('A');
else
uno.setSec('B');
emp.AddEmp(uno);
JOptionPane.showMessageDialog(this,"Datos Aceptados");
limpiar();

void limpiar(){
this.txtcod.setText("");
this.txthr.setText("");
this.txtnom.setText("");
this.jRx.setSelected(true);//para deseleccionar las otras opciones
this.txtcod.requestFocus();

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new EmpDialog(new javax.swMg.JFrame(), true).setVisible(true);
}
});
}

La ventana de Eliminación (DelEmpDialog.Java)

Mg. Javier CABRERA

UNMSM -59-

package pruebas;

/**
*
* @author UNMSM
*/
public class DelEmpDialog extends javax.swMg.JDialog {
private boolean flag=false;
/** Creates new form DelEmpDialog */
public DelEmpDialog(java.awt.Frame parent, boolean modal,
String nom, String cod, double ptot
){
super(parent, modal);
initComponents();
this.jLbcod.setText(cod);
this.jLbnom.setText(nom);
this.jLbtot.setText(""+ptot);

public boolean getFlag(){

return flag;
}
public void setFlag(boolean valor){
this.flag=valor;
}

private void jbtnAceptaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
this.flag=true;
this.setVisible(false);

Ventana de Dialogo para modificar los datos de un empleado:

package pruebas;

/**
*
* @author UNMSM
*/
public class ModiEmpDialog extends javax.swMg.JDialog {
private boolean flag=false;
private String nom;
private double horas;
/** Creates new form ModiEmpDialog */
public ModiEmpDialog(java.awt.Frame parent, boolean modal,
String cod,String nom, double hr
){
super(parent, modal);

Mg. Javier CABRERA

UNMSM -60-

initComponents();
this.jlbcod.setText(cod);
this.jlbnom.setText(nom);
this.jlbhoras.setText(""+hr);
this.jtxthoras.setText(""+hr);
this.jtxtnom.setText(nom);
}

public boolean getFlag(){

return flag;
}
public void setFlag(boolean f){
this.flag=f;
}
private void jbCancelaActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.setFlag(false);
this.setVisible(false);
}

private void jbtncambiaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
this.setHoras(Double.parseDouble(this.jtxthoras.getText()));
this.setFlag(true);
this.setNom(this.jtxtnom.getText());
this.setVisible(false);

/**
* @param args the command line arguments
*/

public String getNom() {

return nom;
}

public void setNom(String nom) {

this.nom = nom;
}

public double getHoras() {

return horas;
}

public void setHoras(double horas) {

this.horas = horas;
}

Mg. Javier CABRERA

UNMSM -61-

Mg. Javier CABRERA

UNMSM -62-

CAPITULO DE HERENCIAS
La herencia permite crear una clase nueva (subclase o clase derivada) que tenga el
mismo comportamiento que otra (superclase o clase base) y además extienda o
adapte ese comportamiento
a unas necesidades específicas.
La nueva subclase heredará los atributos y los métodos de la clase base, los cuales se
añadirán a los definidos en la propia subclase.

La capacidad de descomponer un problema o concepto en un conjunto de

objetos relacionados entre sí, y cuyo comportamiento es fácilmente
identificable, puede ser muy útil para el desarrollo de programas informáticos.

B. Jerarquía

La herencia es el mecanismo fundamental de relación entre clases en la

orientación a objetos. Relaciona las clases de manera jerárquica; una clase
padre o superclase sobre otras clases hijas o subclases.

Imagen 4: Ejemplo de otro árbol de herencia

Los descendientes de una clase heredan todas las variables y métodos que
sus ascendientes hayan especificado como heredables, además de crear los
suyos propios.

La característica de herencia, nos permite definir nuevas clases derivadas de

otra ya existente, que la especializan de alguna manera. Así logramos definir
una jerarquía de clases, que se puede mostrar mediante un árbol de herencia.

C. Tipos de Herencia

En la orientación a objetos, se consideran dos tipos de herencia, simple y

múltiple. En el caso de la primera, una clase sólo puede derivar de una única
superclase. Para el segundo tipo, una clase puede descender de varias
superclases.

D. Declaración

Para indicar que una clase deriva de otra, heredando sus propiedades
(métodos y atributos), se usa el término extends, como en el siguiente ejemplo:

public class SubClase extends SuperClase {

// Contenido de la clase

Mg. Javier CABRERA

UNMSM -63-

Por ejemplo, creamos una clase Persona

public class Persona {

String nombre;
int edad;
String domicilio;
public Persona() {
}
void asignarEdad(int ed){
this.edad=ed;
}
void asignarNombre(String nom){
nombre=nom;
}
int obtenerEdad(){
return edad;
}
String obtenerNombre(){
return nombre;
}
}

Luego creamos una subclase llamada Alumno

public class Alumno extends Persona{

int semestre;
String seccion;
public Alumno() {
}

void asignarSemestre(int semes){

semestre=semes;
}
void asignarSeccion(String sec){
seccion=sec;
}
int obtenerSemestre(){
return semestre;
}

String obtenerSeccion(){
return grupo;
}
}

La palabra clave extends se utiliza para decir que deseamos crear una
subclase de la clase que es nombrada a continuación, en nuestro caso Alumno
es hija de Persona.

Mg. Javier CABRERA

UNMSM -64-

E. Limitaciones en la herencia

Todos los campos y métodos de una clase son siempre accesibles para el
código de la misma clase.

Sin embargo los tres primeros modificadores (public, private y protected) son
los más comunes que se usan para controlar el acceso desde otras clases, y
para controlar la herencia por las subclases.

public: Los miembros declarados public son accesibles en cualquier lugar en

que sea accesible la clase, y son heredados por las subclases.

private: Los miembros declarados private son accesibles sólo en la

propia clase.
protected: Los miembros declarados protected son accesibles sólo para
sus subclases

Por ejemplo veamos otra clase:

class Padre { // Hereda de Object

// Atributos
private int numeroFavorito, nacidoHace, dineroDisponible;
// Métodos
public int getApuesta() {
return numeroFavorito;
}
protected int getEdad() {
return nacidoHace;
}
private int getSaldo() {
return dineroDisponible;
}
}
class Hija extends Padre {
// Definición
}
class Visita {
// Definición
}

En este ejemplo, un objeto de la clase Hija, hereda los tres atributos

(numeroFavorito, nacidoHace y dineroDisponible) y los tres métodos (
getApuesta(), getEdad() y getSaldo() ) de la clase Padre, y podrá invocarlos.
Cuando se llame al método getEdad() de un objeto de la clase Hija, se
devolverá el valor de la variable de instancia nacidoHace de ese objeto, y no de
uno de la clase Padre.

Sin embargo, un objeto de la clase Hija, no podrá invocar al método getSaldo()

de un objeto de la clase Padre, con lo que se evita que el Hijo conozca el
estado de la cuenta corriente de un Padre.

Mg. Javier CABRERA

UNMSM -65-

La clase Visita, solo podrá acceder al método getApuesta(), para averiguar el

número favorito de un Padre, pero de ninguna manera podrá conocer ni su
saldo, ni su edad

Las clases no pueden declararse ni protected , ni private .

F. COMPOSICIÓN

La técnica en la que una clase se compone o contiene instancias de otras

clases se denomina composición. Es una técnica muy habitual cuando se
diseñan clases.

Por ejemplo analicemos el sig. código:

class Circulo {
Punto centro;
int radio;
float superficie() {
return 3.14 * radio * radio;
}
}

Diríamos que un Circulo tiene un Punto (centro) y un radio.

G. REDEFINICIÓN DE MÉTODOS. EL USO DE super.

Analicemos el siguiente ejemplo:

class Empleado {
String nombre;
int numEmpleado , sueldo;

static private int contador = 0;

Empleado(String nombre, int sueldo) {

this.nombre = nombre;
this.sueldo = sueldo;
numEmpleado = ++contador;
}

public void aumentarSueldo(int porcentaje) {

sueldo += (int)(sueldo * aumento / 100);
}

Mg. Javier CABRERA

UNMSM -66-

public String toString() {

return "Num. empleado " + numEmpleado + "
Nombre: " + nombre +
" Sueldo: " + sueldo;
}
}

En el ejemplo el Empleado se caracteriza por un nombre (String) y por un

número de empleado y sueldo (enteros). La clase define un constructor que
asigna los valores de nombre y sueldo y calcula el número de empleado a partir
de un contador (variable estática que siempre irá aumentando), y dos métodos,
uno para calcular el nuevo sueldo cuando se produce un aumento de sueldo
(método aumentarSueldo) y un segundo que devuelve una representación de
los datos del empleado en un StrMg.(método toString).
Con esta representación podemos pensar en otra clase que reúna todas las
características de Empleado y añada alguna propia. Por ejemplo, la clase
Ejecutivo. A los objetos de esta clase se les podría aplicar todos los datos y
métodos de la clase Empleado y añadir algunos, como por ejemplo el hecho de
que un Ejecutivo tiene un presupuesto.
Así diríamos que la clase Ejecutivo extiende o hereda la clase Empleado. Esto
en Java se hace con la cláusula extends que se incorpora en la definición de la
clase, de la siguiente forma:

class Ejecutivo extends Empleado {

int presupuesto;
void asignarPresupuesto(int p) {
presupuesto = p;
}
}

Con esta definición un Ejecutivo es un Empleado que además tiene algún

rasgo distintivo propio. El cuerpo de la clase Ejecutivo incorpora sólo los
miembros que son específicos de esta clase, pero implícitamente tiene todo lo
que tiene la clase Empleado.
A Empleado se le llama clase base o superclase y a Ejecutivo clase derivada o
subclase.
Los objetos de las clases derivadas se crean igual que los de la clase base y
pueden acceder tanto sus datos y métodos como a los de la clase base. Por
ejemplo:

Ejecutivo jefe = new Ejecutivo( "Armando Mucho",

1000);
jefe.asignarPresupuesto(1500);
jefe.aumentarSueldo(5);

Atención!: Un Ejecutivo ES un Empleado, pero lo contrario no es cierto. Si

escribimos:

Mg. Javier CABRERA

UNMSM -67-

Empleado curri = new Empleado ( "Esteban Comex

Plota" , 100) ;
curri.asignarPresupuesto(5000); // error

se producirá un error de compilación pues en la clase Empleado no existe

ningún método llamado asignarPresupuesto.

Ahora bien veamos como podemos redefinir un método

Se podría pensar en redefinir algunos métodos de la clase base pero haciendo

que métodos con el mismo nombre y características se comporten de forma
distinta. Por ejemplo podríamos pensar en rediseñar el método toString de la
clase Empleado añadiendo las características propias de la clase Ejecutivo. Así
se podría poner:

class Ejecutivo extends Empleado {

int presupuesto;

void asignarPresupuesto(int p) {
presupuesto = p;
}

public String toString() {

String s = super.toString();
s = s + " Presupuesto: " + presupuesto;
return s;
}
}

De esta forma cuando se invoque jefe.toString() se usará el método toString de

la clase Ejecutivo en lugar del existente en la clase Empleado.

Observe en el ejemplo el uso de super, que representa referencia interna

implícita a la clase base (superclase). Mediante super.toString() se invoca el
método toString de la clase Empleado

Continuando con el uso de super e inicialización de clases derivadas

Cuando se crea un objeto de una clase derivada se crea implícitamente un

objeto de la clase base que se inicializa con su constructor correspondiente. Si
en la creación del objeto se usa el constructor no-args, entonces se produce
una llamada implícita al constructor no-args para la clase base. Pero si se usan
otros constructores es necesario invocarlos explicitamente.

En nuestro ejemplo dado que la clase método define un constructor,

necesitaremos también un constructor para la clase Ejecutivo, que podemos
completar así:

class Ejecutivo extends Empleado {

int presupuesto;

Mg. Javier CABRERA

UNMSM -68-

Ejecutivo (String n, int s) {

super(n,s);
}

void asignarPresupuesto(int p) {
presupuesto = p;
}

public String toString() {

String s = super.toString();
s = s + " Presupuesto: " + presupuesto;
return s;
}
}

Observe que el constructor de Ejecutivo invoca directamente al constructor de

Empleado mediante super(argumentos). En caso de resultar necesaria la
invocación al constructor de la superclase debe ser la primera sentencia del
constructor de la subclase.

Ejemplo 2.- Elaborar la clase documento que sera heredado por la clase
Factura y la clase boleta:
Documento
String numero
String fecha
Double monto

Factura Boleta
String ruc String Nombre

import javax.swMg.JOptionPane;
import java.util.ArrayList;
public class GestorVentas {
public static ArrayList ListaD=new ArrayList();
public static void main(String[] args) {
int op;
String Menu="(0)Salir\n" +
"(1)Nueva Factura\n" +
"(2)Nueva Boleta\n" +
"(3)LIstar Todos\n" +
"(4)Listar Facturas\n" +
"(5)Listar Boletas\n" +
"(6)Buscar Facturas\n" +
"(7)Calcular Igv\n";
for(;;){

Mg. Javier CABRERA

UNMSM -69-

op=Integer.parseInt(JOptionPane.showInputDialog(Menu));
switch(op){
case 0: System.exit(0);break;
case 1: nuevaFactura();break;
case 2: nuevaBoleta();break;
case 3: listarTodos();break;
case 4: listarFacturas();break;
case 5: lsitarBoletas();break;
case 6: buscarfatura(num);break;
case 7: calcularIgv();break;
default: JOptionPane.showMessageDialog(null,"Opcion Incorrecta");
} //fin del switch
}//del for
} //del main

public static void nuevaFatura(){ Factura F=new Factura();

F.Fecha=JOptionPane.showInputDialog("Ingrese la Fecha");
F.Monto=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el
Monto"));
F.Numero=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el Numero"));
F.Ruc=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el Ruc"));
ListaD.add(F);
}
public static void nuevaBoleta(){ Boleta B=new Boleta();
B.Fecha=JOptionPane.showInputDialog("Ingrese la Fecha");
B.Monto=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el
Monto"));
B.Numero=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el
Numero"));
B.Nombre=JOptionPane.showInputDialog("Ingrese el Nombre");
ListaD.add(B);
}
public static void listarTodos(){
for(int i=0;i<ListaD.size();i++){
if(ListaD.get(i) instanceof Factura){
((Factura)ListaD.get(i)).imprimir();
}else{
((Boleta)ListaD.get(i)).imprimir();
}
}
}
public static void listarFacturas(){
for(int i=0;i<ListaD.size();i++){
if(ListaD.get(i)instanceof Factura) {
((Factura)ListaD.get(i)).imprimir();
}
}

Mg. Javier CABRERA

UNMSM -70-

}
public static void listarBoletas(){
for(int i=0;i<ListaD.size();i++){
if(ListaD.get(i) instanceof Boleta){
((Boleta)ListaD.get(i)).imprimir();
}
}
}
public static void buscarfatura(int num){
int num;
num=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero"));
for(int i=0;i<ListaD.size();i++){
if(ListaD.get(i) instanceof Factura){
if(((Factura)ListaD.get(i)).Numero==num){
((Factura)ListaD.get(i)).imprimir();
}
}
}
}
public static void calcularIgv(){ for(int
i=0;i<ListaD.size();i++){
if(ListaD.get(i) instanceof Factura){
((Factura)ListaD.get(i)).imprimir();
double igv;
double monto=((Factura)ListaD.get(i)).Monto;
igv= monto-(monto/1.19);
System.out.println("Su Igv es ......"+igv);
}
}
}
}
//fin de la clase principal gestor de Ventas
class Documento{
String Fecha;
double Monto;
int Numero;
void imprimir(){
System.out.println("Fecha :"+Fecha);
System.out.println("Monto :"+Monto);
System.out.println("Numero:"+Numero);
}
}
//
class Boleta extends Documento{
String Nombre;
void imprimir(){
System.out.println("Nombre :"+Nombre);
}
}
//

Mg. Javier CABRERA

UNMSM -71-

class Factura extends Documento{

int Ruc;
void imprimir(){
super.imprimir();
System.out.println("Ruc :"+Ruc);
}
}

Ejercicios:

1Crear una clase animal (nombre, nro de patas, sexo) crear las subclases Perro (atributo
raza, atributo habla), gallo( metodo canta), Gato(metodo maulla)

2.- crear la clase TarjetaCredito( nro de tarjeta, nombre del cliente, fecha de caducacion)
crear las subclases TarjetaDorada(linea de credito, Cargo ), TarjetaTotus(sueldo del
cliente, Empresa donde trabaja) realizar las subclases ademas comprobarlo en el main
para asignar los datos.

3.- (Sistema de Nómina) Elaborar un programa que permita procesar la nómina de una
empresa.
Para ello considere el siguiente diagrama de clases:

Ing. Alberto Moreno

UNMSM -72-

Un empleado (Empleado=Employee) debe tener un primer nombre, apellido paterno y

número de seguro social. Además, un EmpleadoAsalariado (SalariedEmployee) debe
tener un salario semanal; un EmpleadoPorHoras (HourlyEmployee) debe tener un
sueldo y el número de horas trabajadas; un EmpleadoPorComision
(CommissionEmployee) debe tener una tasa por comisiones y ventas brutas; y un
EmpleadoBaseMasComision (BasePlusCommissionEmployee) debe tener un salario
base. Cada clase debe tener las construcciones apropiadas, los métodos relevantes sets y
gets. Escriba un programa que cree instancias de objetos de cada una de las clases, y
que muestre toda la información asociada con cada objeto (incluyendo la información
heredada).

Interfaz Gráfica de Usuario (GUI)

Mg. Javier CABRERA

UNMSM -73-

EJEMPLOS DE HERENCIA
Crear una clase circulo cuyo atributo
import java.text.DecimalFormat; es el radio y los métodos a crear son
public class herencia01 { Area() y Print() para el calculo del
area del circulo e impresión
public static void main(String[] args) { respectiva de los datos.
// TODO code application logic here Crear la clase Cilindro cuyo atributo
circulo x=new circulo(); son :radio y altura hacer la herencia
x.setRadio(5); correspondiente para el calculo de su
x.imprime(); área y volumen del cilindro.
Cilindro y=new Cilindro();
y.setRadio(7);
y.altura=12;
y.imprime();

}
//LA CLASE PRINCIPAL CIRCULO
class circulo{
private int radio;
DecimalFormat dos=new DecimalFormat("0.00");

double area(){
return radio*radio*Math.PI;
}
void imprime(){
System.out.print("\n area del circulo "+dos.format(area()));
}

public int getRadio() { //ENCAPSULA EL DATO PARA LEER

return radio;
}

public void setRadio(int radio) { // PARA ESCRIBIR

this.radio = radio;
}

}
class Cilindro extends circulo{ //CLASE EXTENDIDA DE LA CLASE CIRCULO
int altura;
double area(){
double ac;
ac=super.area()*altura;

return ac;
}
void imprime(){
super.imprime();

Mg. Javier CABRERA

UNMSM -74-

System.out.print("\n area del cilindro:"+dos.format(area()));

}
}

Poliformismo.- un método puede comportarse de muchas formas de acuerdo a la clase

donde se emplea dicho método , por ejemplo el calculo del promedio depende de la
clase si es pregrado el calculo del promedio es :(n1*0.25+ n2*0.25 +0.50*n3) y para
PostGrado =(n1+n2+n3)/3

Postgrado
Alumno
public Alumno()
public Imprime()
public abstract Promedio()
package herencia;
Pregrado
Clase Alumno.java //herencia de la clase alumno
public class AlumnoPostgrado extends
package herencia; Alumno {
abstract class Alumno { private
String matricula; private public AlumnoPostgrado(String nom,
String nombre; protected String mat,
double n1, n2, n3; double n1, double n2, double n3)
//constructor de la clase alumno {
public Alumno(String mat, String n, super(mat,nom,n1,n2,n3);
double n1, double n2, double n3) { }
matricula = mat;
nombre = n; public double calcularNota() {
this.n1 = n1; return (n1+n2+n3)/3.0;
this.n2 = n2; }
this.n3 = n3; }
}
public void Imprime(){
System.out.print("\n Matricula:"+this.matricula);
System.out.print("\n Nombre:"+this.nombre);
System.out.print("\n nota1:"+this.n1);
System.out.print("\n nota2:"+this.n2);
System.out.print("\n nota3:"+this.n3);

}
// metodo abstracto para el polimorfismo
abstract double calcularNota();

Mg. Javier CABRERA

UNMSM -75-

package herencia;

public class AlumnoPregrado extends Alumno {

/** Creates a new instance of AlumnoPregrado */

public AlumnoPregrado(String nom, String mat,
double n1, double n2, double n3) {
super(mat,nom,n1,n2,n3);
}

public double calcularNota() {

return n1*0.25 + n2*0.25 + n3*0.5;
}
}

Comprobación de las clases

package herencia;

import java.util.*;

public class prueba1 {

public static void main(String[] args) {

ArrayList x = new ArrayList();
AlumnoPregrado apre;
AlumnoPostgrado apos;
Alumno a;
apre = new AlumnoPregrado("Laura","1",5,6,4);
x.add(apre);
apre = new AlumnoPregrado("Claudia","2",4,7,7);
x.add(apre);
apos = new AlumnoPostgrado("Juan","3",5,6,4);
x.add(apos);
apos = new AlumnoPostgrado("Ana","4",4,7,7);
x.add(apos);

// Calculo de notas SIN polimorfismo

for (int i=0; i<x.size(); i++) {
if (x.get(i) instanceof AlumnoPregrado) {

Mg. Javier CABRERA

UNMSM -76-

apre = (AlumnoPregrado)x.get(i);
apre.Imprime();

System.out.println("\n promedio:"+apre.calcularNota());
}
else {
apos = (AlumnoPostgrado)x.get(i);
System.out.println(apos.calcularNota());
}
}

// Calculo de notas aprovechando el polimorfismo

System.out.print("\n impresion 2");

for (int i=0; i<x.size(); i++) {

a = (Alumno)x.get(i);
a.Imprime();

System.out.println("\n promedio:"+a.calcularNota());
}
}

Gestión de Excepciones
Las excepciones son el mecanismo por el cual pueden controlarse en un programa Java
las condiciones de error que se producen. Estas condiciones de error pueden ser errores
en la lógica del programa como un índice de un array fuera de su rango, una división
por cero o errores disparados por los propios objetos que denuncian algún tipo de estado
no previsto, o condición que no pueden manejar.

La idea general es que cuando un objeto encuentra una condición que no sabe manejar
crea y dispara una excepción que deberá ser capturada por el que le llamó o por alguien
más arriba en la pila de llamadas. Las excepciones son objetos que contienen
información del error que se ha producido y que heredan de la clase Throwable o de la
clase Exception. Si nadie captura la excepción interviene un manejador por defecto que
normalmente imprime información que ayuda a encontrar quién produjo la excepción.

Existen dos categorías de excepciones:

Excepciones verificadas: El compilador obliga a verificarlas. Son todas las que

son lanzadas explicitamente por objetos de usuario.
Excepciones no verificadas: El compilador no obliga a su verificación. Son
excepciones como divisiones por cero, excepciones de puntero nulo, o índices
fuera de rango.

Mg. Javier CABRERA

UNMSM -77-

Generación de excepciones

Supongamos que tenemos una clase Empresa que tiene un array de objetos Empleado
(clase vista en capítulos anteriores). En esta clase podríamos tener métodos para
contratar un Empleado (añadir un nuevo objeto al array), despedirlo (quilarlo del array)
u obtener el nombre a partir del número de empleado. La clase podría ser algo así como
lo siguiente:

public class Empresa {

String nombre;
Empleado [] listaEmpleados;
int totalEmpleados = 0;
. . .
Empresa(String n, int maxEmp) {
nombre = n;
listaEmpleados = new Empleado [maxEmp];
}
. . .
void nuevoEmpleado(String nombre, int sueldo) {
if (totalEmpleados < listaEmpleados.length ) {
listaEmpleados[totalEmpleados++] = new Empleado(nombre,sueldo);
}
}
}

Observese en el método nuevoEmpleado que se comprueba que hay sitio en el array

para almacenar la referencia al nuevo empleado. Si lo hay se crea el objeto. Pero si no lo
hay el método no hace nada más. No da ninguna indicación de si la operación ha tenido
éxito o no. Se podría hacer una modificación para que, por ejemplo el método
devolviera un valor booleano true si la operación se ha completado con éxito y false si
ha habido algún problema.

Otra posibilidad es generar una excepción verificada (Una excepción no verificada se

produciría si no se comprobara si el nuevo empleado va a caber o no en el array).
Vamos a ver como se haría esto.

Las excepciones son clases, que heredan de la clase genérica Exception. Es necesario
por tanto asignar un nombre a nuestra excepción. Se suelen asignar nombres que den
alguna idea del tipo de error que controlan. En nuestro ejemplo le vamos a llamar
CapacidadEmpresaExcedida.

Para que un método lance una excepción:

Debe declarar el tipo de excepción que lanza con la cláusula throws, en su

declaración.
Debe lanzar la excepción, en el punto del código adecuado con la sentencia
throw.

En nuestro ejemplo:

void nuevoEmpleado(String nombre, int sueldo) throws

CapacidadEmpresaExcedida {
if (totalEmpleados < listaEmpleados.length) {

Mg. Javier CABRERA

UNMSM -78-

listaEmpleados[totalEmpleados++] = new Empleado(nombre,sueldo);

}
else throw new CapacidadEmpresaExcedida(nombre);
}

Además, necesitamos escribir la clase CapacidadEmpresaExcedida. Sería algo

así:

public class CapacidadEmpresaExcedida extends Exception {

CapacidadEmpresaExcedida(String nombre) {
super("No es posible añadir el empleado " + nombre);
}
. . .
}

La sentencia throw crea un objeto de la clase CapacidadEmpresaExcedida . El

constructor tiene un argumento (el nombre del empleado). El constructor simplemente
llama al constructor de la superclase pasándole como argumento un texto explicativo del
error ( y el nombre del empleado que no se ha podido añadir).

La clase de la excepción puede declarar otros métodos o guardar datos de depuración

que se consideren oportunos. El único requisito es que extienda la clase Exception.
Consultar la documentación del API para ver una descripción completa de la clase
Exception.

De esta forma se pueden construir métodos que generen excepciones.

Captura de excepciones

Con la primera versión del método nuevoEmpleado (sin excepción) se invocaría este
método de la siguiente forma:

Empresa em = new Empresa("La Mundial");

em.nuevoEmpleado("Adán Primero",500);

Si se utilizara este formato en el segundo caso (con excepción) el compilador produciría

un error indicando que no se ha capturado la excepción verificada lanzada por el método
nuevoEmpleado. Para capturar la excepción es utiliza la construcción try / catch, de la
siguiente forma:

Empresa em = new Empresa("La Mundial");

try {
em.nuevoEmpleado("Adán Primero",500);
} catch (CapacidadEmpresaExcedida exc) {
System.out.println(exc.toString());
System.exit(1);
}

Se encierra el código que puede lanzar la excepción en un bloque try / catch. A

continuación del catch se indica que tipo de excepción se va a capturar.
Después del catch se escribe el código que se ejecutará si se lanza la excepción.
Si no se lanza la excepción el bloque catch no se ejecuta.

Mg. Javier CABRERA

UTP -79-

El formato general del bloque try / catch es:

try {
. . .
} catch (Clase_Excepcion nombre) { . . .}
catch (Clase_Excepcion nombre) { . . .}
. . .

Observese que se puede capturar más de un tipo de excepción declarando más de una
sentencia catch. También se puede capturar una excepción genérica (clase Exception)
que engloba a todas las demás.

Supongamos que, en nuestro ejemplo es el método main de una clase el que invoca el
método nuevoEmpleado. Si no quiere capturar la excepción debe hacer lo siguiente:

public static void main(String [] args) throws

CapacidadEmpresaExcedida {
Empresa em = new Empresa("La Mundial");
em.nuevoEmpleado("Adán Primero",500);
}

Cláusula finally

La cláusula finally forma parte del bloque try / catch y sirve para especificar
un bloque de código que se ejecutará tanto si se lanza la excepción como si no. Puede
servir para limpieza del estado interno de los objetos afectados o para liberar recursos
externos (descriptores de fichero, por ejemplo). La sintaxis global del bloque try /
catch / finally es:

try {
. . .
} catch (Clase_Excepcion nombre) {...}
catch (Clase_Excepcion nombre) {...}
. . .
finally {...}
UTP -80-

Links de interés para el curso

tema link
Características del java http://www.webtaller.com/manual-
java/caracteristicas-java.php
Conceptos básicos http://www.webtaller.com/manual-
java/programacion.php
Control de flujo http://www.webtaller.com/manual-java/control-
flujo.php
Introducción a variables y http://www.webtaller.com/manual-java/variables-
métodos metodos.php
Presentación, introducción, http://www.monografias.com/trabajos42/manual-
cadenas de caracteres, sentencias de-java/manual-de-java.shtml
de control, arreglos, clases y
herencia
Funciones matemáticas, uso de http://www.cec.uchile.cl/manuales/contenidos/Java/
String, Uso de StringBuffers