Você está na página 1de 34

CODIGO DE POLIMORFISMO E INTERFACE

DATOS **********
/**

Calcula informacin sobre un conjunto de datos de valores


*/
public class Datos {
private double suma;
private double maximo;
private int contador;
/**

Construye un conjunto de datos vaco.


*/
public Datos() {
suma = 0;
contador = 0;
maximo = 0;
}
/**
Aade un dato de valor al conjunto de datos
@param x un dato de valor
*/
public void adiciona(double x)
{
suma = suma + x;
if (contador == 0 || maximo < x) maximo = x;
contador++;
}
/**

Obtiene el promedio de los datos aadidos


@return el promedo o 0 si ningun dato ha sido adicionado

*/
public double getPromedio() {
if (contador == 0) return 0;
else return suma / contador;
}
/**

Obtiene el mayor de los datos aadidos.


@return el maximo o 0 si ningun dato ha sido aadido
*/
public double getMaximo() {
return maximo;
}
}

DatosTest **************

import java.util.Scanner;
/**
Este programa calcula el promedio y el maximo de un
de un conjunto de valores introducidos
*/
public class DatosTest {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Datos data = new Datos();
boolean hecho = false;
while (!hecho) {

System.out.print("Ingrese un valor, S para salir: ");


String ingreso = in.next();
if (ingreso.equalsIgnoreCase("S"))
hecho = true;
else {
double x = Double.parseDouble(ingreso);
data.adiciona(x);
}
}
System.out.println("Promedio = " + data.getPromedio());
System.out.println("Maximo = " + data.getMaximo());
}

MEDIR1 ########################
CuentaBancaria ***********
/**
Una cuenta de banco tiene un balance que
depsitos y retiros.
*/

puede cambiar por

public class CuentaBancaria implements Medir{


private double balance;
/**
* Construye una cuenta bancaria con un balance
*/

cero.

public CuentaBancaria(){
balance = 0;
}
/**
* Construye una cuenta bancaria con un balance inicial
* @param balanceInicial
*/
public CuentaBancaria(double balanceInicial){
balance = balanceInicial;
}
/**
* Deposita dinero en cuenta bancaria
* @param monto
*/
public void deposito(double monto){
double nuevoBalance = balance + monto;
balance = nuevoBalance;
}
/**
* Retira dinero de cuenta bancaria
* @param monto
*/
public void retiro(double monto){
double nuevoBalance = balance - monto;
balance = nuevoBalance;
}
/**
* Obtiene el balance actual de la cuenta bancaria
* @return balance actual
*/
public double getBalance(){

return balance;
}
/**
* Obtiene el balance actual de la cuenta bancaria
* con la interface Medir
* @return balance actual
*/
public double getMedir(){
return balance;
}
}

Moneda *************

/**
* Una moneda con un valor monetario
*/
public class Moneda implements Medir {
private double valor;
private String nombre;
/**
* Construye una moneda
* @param unValor valor monetario de la moneda
* @param unNombre nombre de la moneda
*/
public Moneda(double unValor, String unNombre){
valor = unValor;
nombre = unNombre;
}
/**
* Obtiene el valor de la moneda.
* @return el valor
*/
public double getValor(){
return valor;
}
/**
* Obtiene el nombre de la moneda.
* @return el nombre
*/
public String getNombre(){
return nombre;
}
/**
* Obtiene el valor con interface Medir
* @return el valor
*/
public double getMedir(){
return valor;
}
}

Medir *************
/**
* Describe cualquier clase cuyos objetos se puede medir.

*/
public interface Medir {
/**
* Calcula la medida del objeto.
* @return la medida
*/
double getMedir();
}

DatosPrueba ************
/**
* Este programa pone a prueba la clase Datos
*/
public class DatosPrueba {
public static void main(String[] args) {
Datos datosBanco = new Datos();
datosBanco.adiciona(new CuentaBancaria(0));
datosBanco.adiciona(new CuentaBancaria(10000));
datosBanco.adiciona(new CuentaBancaria(2000));
System.out.println("Balance promedio = " +
datosBanco.getPromedio());
Medir max = datosBanco.getMaximo();
System.out.println("Balance maximo =" + max.getMedir());
Datos datosMoneda = new Datos();
datosMoneda.adiciona(new Moneda(1, "sol"));
datosMoneda.adiciona(new Moneda(0.5, "cincuenta"));
datosMoneda.adiciona(new Moneda(0.2, "veinte"));
System.out.println("Valor promedio = " + datosMoneda.getPromedio());
max = datosMoneda.getMaximo();
System.out.println("El valor mas alto = " + max.getMedir());
}

MEDIR2 ###########################################################
Datos2 ****************
/**
* Calcula el promedio de un conjunto de valores de datos.
*/
public class Datos2 {
private double suma;
private Object maximo;
private int contador;
private Medir2 medida;
/**
* Construye un conjunto de datos vaco con una medida dado.
* @param unaMedida
*/
public Datos2(Medir2 unaMedida){
suma = 0;
contador = 0;
maximo = null;

medida = unaMedida;
}
/**
* Aade un valor al conjunto de datos
* @param x un dato con un valor
*/
public void adiciona(Object x){
suma += medida.medir(x);
if(contador == 0 || medida.medir(maximo)< medida.medir(x) )
maximo = x;
contador++;
}
/**
* Obtiene el promedio de los datos adicionados.
* @return el promedio o 0 si no se ha aadido datos
*/
public double getPromedio(){
if (contador == 0)return 0;
else return suma / contador;
}
/**
* Obtiene el mayor de los datos agregados
* @return el mximo o 0 si no se ha aadido datos
*/
public Object getMaximo(){
return maximo;
}
}

Medir2 **************
public interface Medir2 {
/**
* Calcula la medida de un objeto
* @param unObjeto el objeto a ser medido
* @return la medida
*/
double medir(Object unObjeto);
}

RectangleMeasure *******************
import java.awt.Rectangle;
/**
* Los objetos de clase MedirRectangulo por area
*/
public class MedirRectangulo implements Medir2{
public double medir(Object unObjeto){
Rectangle r = (Rectangle)unObjeto;
double area = r.getWidth()*r.getHeight();
return area;
}
}

DatosPrueba2 ******************
import java.awt.Rectangle;

/**
* Este programa demuestra el uso de Medir2
*/
public class DatosPrueba2 {
public static void main(String[] args) {
Medir2 m = new MedirRectangulo();
Datos2 d = new Datos2(m);
d.adiciona(new Rectangle(5, 10, 20, 30));
d.adiciona(new Rectangle(10, 20, 30, 40));
d.adiciona(new Rectangle(20, 30, 5, 15));
System.out.println("Area promedio: " + d.getPromedio());
System.out.println("Esperado: 625");
Rectangle max = (Rectangle) d.getMaximo();
System.out.println("Maxima area del rectangulo: " + max);
System.out.println("Esperado: "
+ "java.awt.Rectangle[x=10,y=20,width=30,height=40]");
}

MEDIR3 ############################################################
Datos3 **********************************
public class Datos3 {
private double suma;
private Object maximo;
private int contador;
private Medir3 medida;
/**
* Construye un conjunto de datos vaco con una medida dado.
* @param unaMedida
*/
public Datos3(Medir3 unaMedida){
suma = 0;
contador = 0;
maximo = null;
medida = unaMedida;
}
/**
* Aade un valor al conjunto de datos
* @param x un dato con un valor
*/
public void adiciona(Object x){
suma += medida.medir(x);
if(contador == 0 || medida.medir(maximo)< medida.medir(x) )
maximo = x;
contador++;
}
/**
* Obtiene el promedio de los datos adicionados.
* @return el promedio o 0 si no se ha aadido datos
*/
public double getPromedio(){
if (contador == 0)return 0;

else return suma / contador;

/**
* Obtiene el mayor de los datos agregados
* @return el mximo o 0 si no se ha aadido datos
*/
public Object getMaximo(){
return maximo;
}
}

Medir3 ************
public interface Medir3 {
/**
* Calcula la medida de un objeto
* @param unObjeto el objeto a ser medido
* @return la medida
*/
double medir(Object unObjeto);
}

INTERFACE GRAFICA
BOTON1 ########################################################
ClickListener ************
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
/**
* Este programa muestra cmo instalar un ActionListener
*/
public class VisorBoton {
private static final int ANCHO_MARCO = 100;
private static final int ALTO_MARCO = 60;
public static void main(String[] args) {
JFrame marco = new JFrame();
JButton boton = new JButton(" Click! ");
marco.add(boton);
ActionListener listener = new ClickListener();
boton.addActionListener(listener);

marco.setSize(ANCHO_MARCO, ALTO_MARCO);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);

VisorBoton****************
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
/**
* Este programa muestra cmo instalar un ActionListener
*/

public class VisorBoton {


private static final int ANCHO_MARCO = 100;
private static final int ALTO_MARCO = 60;
public static void main(String[] args) {
JFrame marco = new JFrame();
JButton boton = new JButton(" Click! ");
marco.add(boton);
ActionListener listener = new ClickListener();
boton.addActionListener(listener);

marco.setSize(ANCHO_MARCO, ALTO_MARCO);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);

BOTON2
CuentaBancaria

/**
Una cuenta de banco tiene un balance que
depsitos y retiros.
*/

puede cambiar por

public class CuentaBancaria implements Medir{


private double balance;
/**
* Construye una cuenta bancaria con un balance
*/

cero.

public CuentaBancaria(){
balance = 0;
}
/**
* Construye una cuenta bancaria con un balance inicial
* @param balanceInicial
*/
public CuentaBancaria(double balanceInicial){
balance = balanceInicial;
}
/**
* Deposita dinero en cuenta bancaria
* @param monto
*/
public void deposito(double monto){
double nuevoBalance = balance + monto;
balance = nuevoBalance;
}
/**
* Retira dinero de cuenta bancaria
* @param monto
*/
public void retiro(double monto){
double nuevoBalance = balance - monto;
balance = nuevoBalance;
}
/**
* Obtiene el balance actual de la cuenta bancaria

* @return balance actual


*/
public double getBalance(){
return balance;
}

VisorInversin *****************
import
import
import
import

java.awt.event.ActionEvent;
java.awt.event.ActionListener;
javax.swing.JButton;
javax.swing.JFrame;

/**
* Este programa demuestra cmo un ActionListener puede acceder
una variable de un bloque que lo circunda.
*/
public class VisorInversion {
private static final int ANCHO_MARCO = 300;
private static final int ALTO_MARCO = 60;
private static final double TASA_INTERES = 10;
private static final double BALANCE_INICIAL = 1000;
public static void main(String[] args) {
JFrame marco = new JFrame();
//Boton para activar el calculo
JButton boton = new JButton("AdicionaInters ");
marco.add(boton);
/// /La aplicacin aade inters a la cuenta bancaria
final CuentaBancaria cuenta = new CuentaBancaria(BALANCE_INICIAL);
class AdicionaInteresListener implements ActionListener{
public void actionPerformed(ActionEvent e){
//El mtodo listener accede a la variable cuenta
//desde el bloque circundante
double interes = cuenta.getBalance()*TASA_INTERES/100;
cuenta.deposito(interes);
System.out.println ("balance:" + cuenta.getBalance ());
}
}
ActionListener listener = new AdicionaInteresListener();
boton.addActionListener(listener);
marco.setSize(ANCHO_MARCO, ALTO_MARCO);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);
}
}

BOTON3
CuentaBancaria

/**
Una cuenta de banco tiene un balance que
depsitos y retiros.
*/

puede cambiar por

public class CuentaBancaria implements Medir{


private double balance;
/**
* Construye una cuenta bancaria con un balance
*/

cero.

public CuentaBancaria(){
balance = 0;
}
/**
* Construye una cuenta bancaria con un balance inicial
* @param balanceInicial
*/
public CuentaBancaria(double balanceInicial){
balance = balanceInicial;
}
/**
* Deposita dinero en cuenta bancaria
* @param monto
*/
public void deposito(double monto){
double nuevoBalance = balance + monto;
balance = nuevoBalance;
}
/**
* Retira dinero de cuenta bancaria
* @param monto
*/
public void retiro(double monto){
double nuevoBalance = balance - monto;
balance = nuevoBalance;
}
/**
* Obtiene el balance actual de la cuenta bancaria
* @return balance actual
*/
public double getBalance(){
return balance;
}
/**
* Obtiene el balance actual de la cuenta bancaria
* con la interface Medir
* @return balance actual
*/
public double getMedir(){
return balance;
}

VisorInversion2*****************
import
import
import
import
import
import

java.awt.Label;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
javax.swing.JButton;
javax.swing.JFrame;
javax.swing.JLabel;

import javax.swing.JPanel;
/**
* Este programa muestra el crecimiento de una inversin.
*/
public class VisorInversion2 {
private static final int ANCHO_MARCO = 400;
private static final int ALTO_MARCO = 100;
private static final double TASA_INTERES = 10;
private static final double BALANCE_INICIAL = 1000;
public static void main(String[] args) {
JFrame marco = new JFrame();
//Boton para activar el calculo
JButton boton = new JButton("Adiciona Inters ");
marco.add(boton);
/// /La aplicacin aade inters a la cuenta bancaria
final CuentaBancaria cuenta = new CuentaBancaria(BALANCE_INICIAL);
//Label para mostrar los resultados
final JLabel etiqueta = new JLabel("Balance: " +
cuenta.getBalance());
//El panel que mantiene las componentes de la interface del usuario
JPanel panel = new JPanel();
panel.add(boton);
panel.add(etiqueta);
marco.add(panel);
class AdicionaInteresListener implements ActionListener{
public void actionPerformed(ActionEvent e){
double interes = cuenta.getBalance()*TASA_INTERES/100;
cuenta.deposito(interes);
etiqueta.setText("Balance: " + cuenta.getBalance());
}
}
ActionListener listener = new AdicionaInteresListener();
boton.addActionListener(listener);

marco.setSize(ANCHO_MARCO, ALTO_MARCO);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);

TEMPORIZADOR ############################################
RectanguloComponente************
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;

import javax.swing.JComponent;
/**
* Este componente muestra un rectngulo que se puede mover.
*/
public class RectanguloComponente extends JComponent{

private
private
private
private

static
static
static
static

final
final
final
final

int
int
int
int

RECTAN_X = 100;
RECTAN_Y = 100;
RECTAN_ANCHO = 20;
RECTAN_ALTO = 30;

private Rectangle rectan;


public RectanguloComponente(){
//El rectngulo que el mtodo paintComponent dibuja
rectan = new Rectangle(RECTAN_X, RECTAN_Y, RECTAN_ANCHO,
RECTAN_ALTO);
}
public void paintComponent(Graphics g){
Graphics2D g2 = (Graphics2D)g;
g2.draw(rectan);
}
/**
* Mueve el rectangulo un desplazamiento dado
* @param dx distancia que se mueve en direccin x.
* @param dy distancia que se mueve en direccin y.
*/
public void mover(int dx, int dy){
rectan.translate(dx, dy);
repaint();
}
}

RectangleMover ************************
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.Timer;
/**
* Este programa mueve un rectangulo
*/
public class RectanguloMover {
private static final int ANCHO_MARCO = 500;
private static final int ALTO_MARCO = 600;
public static void main(String[] args) {
JFrame marco = new JFrame();
marco.setSize(ANCHO_MARCO, ALTO_MARCO);
marco.setTitle("Animacin de un Rectangulo");
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
final RectanguloComponente componente = new RectanguloComponente();
marco.add(componente);
marco.setVisible(true);
class TemporizadorListener implements ActionListener{
public void actionPerformed(ActionEvent e){
componente.mover(2, 1);
}
}
ActionListener listener = new TemporizadorListener();

final int DEMORA = 200;//Milisegundos entre ticks del temporizador


Timer t = new Timer(DEMORA, listener);
t.start();
}

MOUSE #################################################
RectanguloComponente ****************
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import javax.swing.JComponent;
/**
* Este componente muestra un rectngulo que se puede mover.
*/
public class RectanguloComponente1 extends JComponent{
private static final int RECTAN_X = 100;
private static final int RECTAN_Y = 100;
private static final int RECTAN_ANCHO = 20;
private static final int RECTAN_ALTO = 30;
private Rectangle rectan;
public RectanguloComponente1(){
//El rectngulo que el mtodo paintComponent dibuja
rectan = new Rectangle(RECTAN_X, RECTAN_Y, RECTAN_ANCHO,
RECTAN_ALTO);
}
public void paintComponent(Graphics g){
Graphics2D g2 = (Graphics2D)g;
g2.draw(rectan);
}
/**
* Mueve el rectngulo a la ubicacin dada.
* @param x nueva ubicacin posicin de x
* @param y nueva ubicacin posicin de y
*/
public void moverA (int x, int y){
rectan.setLocation(x, y);
repaint();
}
}

RectanguloCompVisor ********

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JFrame;
public class RectanguloCompVisor {
private static final int ANCHO_MARCO = 500;
private static final int ALTO_MARCO = 600;

public static void main(String[] args) {


final RectanguloComponente1 comp = new RectanguloComponente1();
//Adiciona listener al presionar el mouse
class MousePresionListener implements MouseListener{
public void mousePressed(MouseEvent e){
int x = e.getX();
int y = e.getY();
comp.moverA(x, y);
}
// Mtodos no hacer nada
public void mouseReleased (MouseEvent e) {}
public void mouseClicked (MouseEvent e) {}
public void mouseEntered (MouseEvent e) {}
public void mouseExited (MouseEvent e) {}
}
MouseListener listener = new MousePresionListener();
comp.addMouseListener(listener);

}
}

JFrame marco = new JFrame();


marco.add(comp);
marco.setSize(ANCHO_MARCO, ALTO_MARCO);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);

CODIGO SOBRE HERENCIA


CUENTAS # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
CuentaBancaria *************
/**
Una cuenta de banco tiene un balance que
depsitos y retiros.
*/

puede cambiarse por

public class CuentaBancaria {


private double balance;
/**
* Construye una cuenta bancaria con un balance
*/

cero.

public CuentaBancaria(){
balance = 0;
}
/**
* Construye una cuenta bancaria con un balance inicial
* @param balanceInicial
*/
public CuentaBancaria(double balanceInicial){
balance = balanceInicial;
}
/**
* Deposita dinero en cuenta bancaria
* @param monto
*/
public void deposito(double monto){
balance += monto;
}
/**
* Retira dinero de cuenta bancaria
* @param monto
*/
public void retiro(double monto){
balance -= monto;
}
/**
* Obtiene el balance actual de la cuenta bancaria
* @return balance actual
*/
public double getBalance(){
return balance;
}
/**
* Transferencia de dinero de la cuenta bancaria a otra cuenta
* @param monto cantidad a transferir
* @param otro otra cuenta
*/
public void transferencia (double monto, CuentaBancaria otro){
retiro(monto);
otro.deposito(monto);
}
}

CuentaAhorros *************
/**
* Una cuenta que devenga intereses a una tasa fija.
*/
public class CuentaAhorro extends CuentaBancaria{
private double tasaDelnteres;
/**
* Construye una cuenta bancaria con una tasa de inters dada.
* @param tasa tasa de inters
*/
public CuentaAhorro(double tasa){
tasaDelnteres = tasa;
}
/**
* Incorpora los intereses devengados al balance de la cuenta.
*/
public void adicionaInteres(){
double interes = getBalance()*tasaDelnteres/100;
deposito(interes);
}
}

CuentaCorriente *************
public class CuentaCorriente extends CuentaBancaria{
private static final int TRANSACCION_GRATIS= 3;
private static final double TRANSACCION_HONORARIO = 2.0;
private int contadorTransaccion;
/**
* Construye una cuenta corriente con un saldo determinado.
* @param balanceInicial balance inicial
*/
public CuentaCorriente(double balanceInicial){
//Constructor de superclase
super(balanceInicial);
//Inicializa cuenta de transaccin
contadorTransaccion = 0;
}
public void deposito(double monto){
contadorTransaccion++;
//Ahora adiciona el monto al balance
super.deposito(monto);
}
public void retiro(double monto){
contadorTransaccion++;
//Ahora sustrae un monto al balance
super.retiro(monto);
}
/**
* Deduce los honorarios acumulados y resetea
* el contador de transacciones
*/
public void deduceHonorario(){
if (contadorTransaccion > TRANSACCION_GRATIS){
double honorario = TRANSACCION_HONORARIO*(contadorTransaccion
- TRANSACCION_GRATIS);
super.retiro(honorario);
}

contadorTransaccion = 0;
}
}

CuentaPrueba ***********

/**
* Este programa pone a prueba la clase CuentaBancaria y
* sus subclases.
*/
public class CuentaPrueba {
public static void main(String[] args) {
CuentaAhorro ahorroMama = new CuentaAhorro(0.5);
CuentaCorriente cuentaPedro = new CuentaCorriente(100);
ahorroMama.deposito(10000);
ahorroMama.transferencia(2000, cuentaPedro);
cuentaPedro.retiro(1500);
cuentaPedro.retiro(80);
ahorroMama.transferencia(1000, cuentaPedro);
cuentaPedro.retiro(400);
//Simular el fin de mes
ahorroMama.adicionaInteres();
cuentaPedro.deduceHonorario();
System.out.println("Balance del ahorro de Mama: "
+ ahorroMama.getBalance());
System.out.println("Esperado: 7035");
System.out.println("Balance de cuenta de Pedro: "
+ cuentaPedro.getBalance());
System.out.println("Esperado: 1116");
}
}

EMPLEADOS # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
Empleado *************
/**
* Un empleado con un nombre y un mecanismo para el clculo de pago semanal.
*/
public class Empleado {
private String nombre;
/**
* Construye empleado con un nombre vaco
*/
public Empleado(){
nombre = "";
}
/**
* Establece el nombre de este empleado.

* @param nomEmpleado nombre del empleado


*/
public void setNombre(String nomEmpleado){
nombre = nomEmpleado;
}
/**
* Obtiene el nombre de este empleado.
* @return el nombre del mpleado
*/
public String getNombre(){
return nombre;
}
/**
* Calcula el salario de una semana de trabajo.
* @param horasTrabajadas nmero de horas trabajadas en la semana
* @return el pago por un nmero determinado de horas trabajadas
*/
public double pagoSemanal(int horasTrabajadas){
return 0;
}
}

Gerente *************

public class Gerente extends EmpleadoAsalariado{


private double bonoSemanal;
/**
* Construye un gerente con nombre, sueldo anual y bono semanal
* @param nombre
* @param salario
* @param bono
*/
public Gerente(String nombre, double salario, double bono){
super(nombre,salario);
bonoSemanal = bono;
}

public double pagoSemanal(int horas){


return super.pagoSemanal(horas) + bonoSemanal;
}

HorasEmpleado *************
public class EmpleadoPorHoras extends Empleado {
private double pagoPorHora;

hora.

/**
* Construye un empleado por horas con un nombre y

el monto de pago por

* @param nombre nombre del empleado


* @param salario monto de pago por hora
*/
public EmpleadoPorHoras(String nombre, double salario){
setNombre(nombre);
pagoPorHora = salario;
}
public double pagoSemanal(int horasTrabajadas){
double pago = horasTrabajadas * pagoPorHora;

if(horasTrabajadas > 40){


pago += ((horasTrabajadas - 40)*0.5) * pagoPorHora;
}
return pago;
}

EmpleadoAsalariado *************
public class EmpleadoAsalariado extends Empleado{
private double salarioAnual;
/**
* Construye un empleado asalariado con un nombre y salario anual.
* @param nombre nombre del empleado
* @param salario salario anual
*/
public EmpleadoAsalariado(String nombre, double salario){
setNombre(nombre);
salarioAnual = salario;
}

public double pagoSemanal(int horasTrabajadas){


final int SEMANAS_POR_ANNO = 52;
return salarioAnual / SEMANAS_POR_ANNO;
}

SalarioDemo *************
import java.util.Scanner;
public class SalarioDemo {
public static void main(String[] args) {
Empleado[] personal = new Empleado[3];
personal[0] = new EmpleadoPorHoras("Quispe,Pedro", 30);
personal[1] = new EmpleadoAsalariado("Roca, Luz", 52000);
personal[2] = new Gerente("Ruiz, Maria", 104000, 50);
Scanner in = new Scanner(System.in);
for(Empleado e : personal){
System.out.print("Horas trabajadas por " + e.getNombre() + ": ");
int horas = in.nextInt();
System.out.println("Salario: " + e.pagoSemanal(horas));
}
}

FRAME # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
CuentaBancaria *************
/**
Una cuenta de banco tiene un balance que
depsitos y retiros.
*/

puede cambiarse por

public class CuentaBancaria {


private double balance;
/**
* Construye una cuenta bancaria con un balance
*/

cero.

public CuentaBancaria(){
balance = 0;
}
/**
* Construye una cuenta bancaria con un balance inicial
* @param balanceInicial
*/
public CuentaBancaria(double balanceInicial){
balance = balanceInicial;
}
/**
* Deposita dinero en cuenta bancaria
* @param monto
*/
public void deposito(double monto){
balance += monto;
}
/**
* Retira dinero de cuenta bancaria
* @param monto
*/
public void retiro(double monto){
balance -= monto;
}
/**
* Obtiene el balance actual de la cuenta bancaria
* @return balance actual
*/
public double getBalance(){
return balance;
}
/**
* Transferencia de dinero de la cuenta bancaria a otra cuenta
* @param monto cantidad a transferir
* @param otro otra cuenta
*/
public void transferencia (double monto, CuentaBancaria otro){
retiro(monto);
otro.deposito(monto);
}
}

InversionFrame *************

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import
import
import
import

javax.swing.JButton;
javax.swing.JFrame;
javax.swing.JLabel;
javax.swing.JPanel;

public class InversionFrame extends JFrame {


private
private
private
private

JButton boton;
JLabel label;
JPanel panel;
CuentaBancaria cuenta;

private static final int FRAME_ANCHO = 400;


private static final int FRAME_ALTO = 100;
private static final double TASA_INTERES = 10;
private static final double BALANCE_INICIAL = 1000;
public InversionFrame(){
cuenta = new CuentaBancaria(BALANCE_INICIAL);
//Usar variables de instancia para los componentes
label = new JLabel("balance: " + cuenta.getBalance());
//Use mtodos de ayuda
crearBoton();
crearPanel();
}

setSize(FRAME_ANCHO, FRAME_ALTO);

private void crearBoton(){


boton = new JButton("Adiciona inters ");
ActionListener listener = new AdicionaInteresListner();
boton.addActionListener(listener);
}
private void crearPanel() {
panel = new JPanel();
panel.add(boton);
panel.add(label);
add(panel);
}

class AdicionaInteresListner implements ActionListener {


public void actionPerformed(ActionEvent e) {
double interest = cuenta.getBalance() * TASA_INTERES / 100;
cuenta.deposito(interest);
label.setText("balance: " + cuenta.getBalance());
}
}

InversionVisor *************
import javax.swing.JFrame;
public class InversionVisor {
public static void main(String[] args){
JFrame frame = new InversionFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

CODIGO GUI
TEXFIELD # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
CuentaBancaria ****************
/**
Una cuenta de banco tiene un balance que
depsitos y retiros.
*/

puede cambiarse por

public class CuentaBancaria {


private double balance;
/**
* Construye una cuenta bancaria con un balance
*/

cero.

public CuentaBancaria(){
balance = 0;
}
/**
* Construye una cuenta bancaria con un balance inicial
* @param balanceInicial
*/
public CuentaBancaria(double balanceInicial){
balance = balanceInicial;
}
/**
* Deposita dinero en cuenta bancaria
* @param monto
*/
public void deposito(double monto){
balance += monto;
}
/**
* Retira dinero de cuenta bancaria
* @param monto
*/
public void retiro(double monto){
balance -= monto;
}
/**
* Obtiene el balance actual de la cuenta bancaria
* @return balance actual
*/
public double getBalance(){
return balance;
}
}

InversionFrame ****************
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import
import
import
import

javax.swing.JButton;
javax.swing.JFrame;
javax.swing.JLabel;
javax.swing.JPanel;

import javax.swing.JTextField;
/**
* Un frame muestra el crecimiento de una inversin con inters variable.
*/
public class InversionFrame extends JFrame{
private static final int FRAME_ANCHO = 450;
private static final int FRAME_ALTO = 100;
private static final double TASA_POR_DEFECTO = 5;
private static final double BALANCE_INICIAL = 1000;
private
private
private
private
private
private

JLabel tasaLabel;
JTextField tasaField;
JButton boton;
JLabel resultadoLabel;
JPanel panel;
CuentaBancaria cuenta;

public InversionFrame(){
cuenta = new CuentaBancaria(BALANCE_INICIAL);
// Use variables de instancia para los componentes
resultadoLabel = new JLabel("balance: " + cuenta.getBalance());
// Use mtodos de ayuda
crearTextField();
crearBoton();
crearPanel();
setSize(FRAME_ANCHO, FRAME_ALTO);
}
private void crearTextField(){
tasaLabel = new JLabel("Tasa de inters ");
final int FIELD_ANCHO = 10;
tasaField = new JTextField(FIELD_ANCHO);
tasaField.setText("" + TASA_POR_DEFECTO);

}
private void crearBoton(){
boton = new JButton("Adiciona Inters");
class AdicionaInteresListener implements ActionListener{
public void actionPerformed(ActionEvent e) {
double tasa = Double.parseDouble(tasaField.getText());
double interes = cuenta.getBalance() * tasa / 100;
cuenta.deposito(interes);
resultadoLabel.setText("balance: " + cuenta.getBalance());
}
}
ActionListener listener = new AdicionaInteresListener();
boton.addActionListener(listener);

}
private void crearPanel(){
panel = new JPanel();
panel.add(tasaLabel);
panel.add(tasaField);
panel.add(boton);
panel.add(resultadoLabel);
add(panel);

InversioVisor ****************
import javax.swing.JFrame;
/*
* Este programa muestra el crecimiento de una inversin.
*/
public class InversionVisor {
public static void main(String[] args) {
JFrame frame = new InversionFrame();
frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
frame.setVisible (true);
}
}

TEXTAREA # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
CuentaBancaria ****************
/**
Una cuenta de banco tiene un balance que
depsitos y retiros.
*/

puede cambiarse por

public class CuentaBancaria {


private double balance;
/**
* Construye una cuenta bancaria con un balance
*/

cero.

public CuentaBancaria(){
balance = 0;
}
/**
* Construye una cuenta bancaria con un balance inicial
* @param balanceInicial
*/
public CuentaBancaria(double balanceInicial){
balance = balanceInicial;
}
/**
* Deposita dinero en cuenta bancaria
* @param monto
*/
public void deposito(double monto){
balance += monto;
}
/**
* Retira dinero de cuenta bancaria
* @param monto
*/
public void retiro(double monto){
balance -= monto;
}

/**
* Obtiene el balance actual de la cuenta bancaria
* @return balance actual
*/
public double getBalance(){
return balance;
}

InversionFrame2 ****************
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import
import
import
import
import
import
import
import

javax.swing.JButton;
javax.swing.JFrame;
javax.swing.JLabel;
javax.swing.JPanel;
javax.swing.JScrollBar;
javax.swing.JScrollPane;
javax.swing.JTextArea;
javax.swing.JTextField;

/**
* Un frame muestra el crecimiento de una inversin con inters variable.
*/
public class InversionFrame2 extends JFrame{
private static final int FRAME_ANCHO = 400;
private static final int FRAME_ALTO = 250;
private
private
private
private

static
static
static
static

final
final
final
final

int AREA_FILA = 10;


int AREA_COLUMNA = 30;
double TASA_POR_DEFECTO = 5;
double BALANCE_INICIAL = 1000;

private
private
private
private
private
private

JLabel tasaLabel;
JTextField tasaField;
JButton boton;
JTextArea resultadoArea;
JPanel panel;
CuentaBancaria cuenta;

public InversionFrame2(){
cuenta = new CuentaBancaria(BALANCE_INICIAL);
// Use variables de instancia para los componentes
resultadoArea = new JTextArea(AREA_FILA, AREA_COLUMNA);
resultadoArea.setEditable(false);
// Use mtodos de ayuda
crearTextField();
crearBoton();
crearPanel();
setSize(FRAME_ANCHO, FRAME_ALTO);
}
private void crearTextField(){
tasaLabel = new JLabel("Tasa de inters ");
final int FIELD_ANCHO = 10;
tasaField = new JTextField(FIELD_ANCHO);

tasaField.setText("" + TASA_POR_DEFECTO);
}
private void crearBoton(){
boton = new JButton("Adiciona Inters");
class AdicionaInteresListener implements ActionListener{
public void actionPerformed(ActionEvent e) {
double tasa = Double.parseDouble(tasaField.getText());
double interes = cuenta.getBalance() * tasa / 100;
cuenta.deposito(interes);
resultadoArea.append(cuenta.getBalance() + "\n");
}
}
ActionListener listener = new AdicionaInteresListener();
boton.addActionListener(listener);

}
private void crearPanel(){
panel = new JPanel();
panel.add(tasaLabel);
panel.add(tasaField);
panel.add(boton);
JScrollPane scrollPane = new JScrollPane(resultadoArea);
panel.add(scrollPane);
add(panel);
}

InversionFrame2Visor ****************
import javax.swing.JFrame;
public class InversionFrame2Visor {

public static void main(String[] args) {


JFrame frame = new InversionFrame2();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}

OPCIN # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
FuenteVisorFrame ****************
import
import
import
import

java.awt.BorderLayout;
java.awt.Font;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;

import
import
import
import
import

javax.swing.JFrame;
javax.swing.JLabel;
javax.swing.JMenu;
javax.swing.JMenuBar;
javax.swing.JMenuItem;

/*
* Este frame tiene un men con comandos para cambiar la fuente
* de una muestra de texto.
*/
public class FuenteVisor2Frame extends JFrame {
private static final int FRAME_ANCHO = 600;
private static final int FRAME_ALTO = 400;

private
private
private
private

JLabel muestraField;
String nombreTipo;
int fuenteEstilo;
int fuenteTamano;

/**
* Construye el frame
*/
public FuenteVisor2Frame(){
//Construye muestra de texto
muestraField = new JLabel("Programacin Orientado a Objetos");
add(muestraField,BorderLayout.CENTER);
//Construye men
JMenuBar barraMenu = new JMenuBar();
setJMenuBar(barraMenu);
barraMenu.add(creaArchivoMenu());
barraMenu.add(creaFuenteMenu());
nombreTipo = "Serif";
fuenteTamano = 24;
fuenteEstilo = Font.PLAIN;
setMuestraFuente();
setSize(FRAME_ANCHO, FRAME_ALTO);
}
/**
* Crea el men Archivo.
* @return el menu
*/
public JMenu creaArchivoMenu(){
JMenu menu = new JMenu();
menu.add(creaArchivoSalida());
return menu;
}
/**
* Crea el Archivo-> Salir del item menu y establece su action listener.
* @return el menu item
*/
public JMenuItem creaArchivoSalida(){
JMenuItem item = new JMenuItem("Salir");
class MenuItemListener implements ActionListener{
public void actionPerformed(ActionEvent e){
System.exit(0);
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}
/**
* Crea el submen Fuente
* @return el men
*/
public JMenu creaFuenteMenu(){
JMenu menu = new JMenu("Fuente");
menu.add(creaTipoMenu());
menu.add(creaTamanoMenu());

menu.add(creaEstiloMenu());
return menu;
}
/**
* Crea el men Tipo.
* @return el men
*/
public JMenu creaTipoMenu(){
JMenu menu = new JMenu("Tipo");
menu.add(creaTipoItem("Serif"));
menu.add(creaTipoItem("SansSerif"));
menu.add(creaTipoItem("Monospaced"));
return menu;
}
/**
* Crea el submen tamao
* @return el men
*/
public JMenu creaTamanoMenu(){
JMenu menu = new JMenu("Tamao");
menu.add(creaTamanoItem("Pequeo", -1));
menu.add(creaTamanoItem("Grande", 1));
return menu;
}
/**
* Crea el submen estilo
* @return el men
*/
public JMenu creaEstiloMenu(){
JMenu menu = new JMenu("Estilo");
menu.add(creaEstiloItem("Plano", Font.PLAIN));
menu.add(creaEstiloItem("Negrita", Font.BOLD));
menu.add(creaEstiloItem("Italica", Font.ITALIC));
menu.add(creaEstiloItem("Negrita Italica", Font.BOLD
+ Font.ITALIC));
return menu;
}
/**
* Crea un men item para cambiar el tipo de fuente
* y establecer su action listener.
* @param nombre el nombre del tipo de fuente
* @return el menu item
*/
public JMenuItem creaTipoItem(final String nombre){
JMenuItem item = new JMenuItem(nombre);
class MenuItemListener implements ActionListener {
public void actionPerformed(ActionEvent event) {
nombreTipo = nombre;
setMuestraFuente();
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}

/**
* Crea un men item para cambiar el tamao de la fuente
* y establecer su action listener.
* @param nombre el nombre del menu item
* @param ds el nomto en el que va cambiar de tamao
* @return el menu item
*/
public JMenuItem creaTamanoItem(String nombre, final int ds){
JMenuItem item = new JMenuItem(nombre);
class MenuItemListener implements ActionListener {
public void actionPerformed(ActionEvent event) {
fuenteTamano += ds;
setMuestraFuente();
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}
/**
* Crea un men item para cambiar el estilo de la fuente
* y establecer su action listener.
* @param nombreTipo el nombre del menu item
* @param estilo el nuevo estilo de la fuente
* @return el menu item
*/
public JMenuItem creaEstiloItem(String nombre, final int estilo){
JMenuItem item = new JMenuItem(nombre);
class MenuItemListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
fuenteEstilo = estilo;
setMuestraFuente();
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}
/**
* Define el tipo de letra del texto de la muestra.
*/
public void setMuestraFuente(){
Font f = new Font(nombreTipo, fuenteEstilo, fuenteTamano);
muestraField.setFont(f);
muestraField.repaint();
}
}
FuenteVisor *************
import javax.swing.JFrame;
public class FuenteVisor {
public static void main(String[] args) {
JFrame frame = new FuenteVisorFrame();
frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
frame.setTitle ("Visor de Fuente");

frame.setVisible (true);

MEN # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
FontViewer2Frame ****************
import
import
import
import

java.awt.BorderLayout;
java.awt.Font;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;

import
import
import
import
import

javax.swing.JFrame;
javax.swing.JLabel;
javax.swing.JMenu;
javax.swing.JMenuBar;
javax.swing.JMenuItem;

/*
* Este frame tiene un men con comandos para cambiar la fuente
* de una muestra de texto.
*/
public class FuenteVisor2Frame extends JFrame {
private static final int FRAME_ANCHO = 600;
private static final int FRAME_ALTO = 400;
private
private
private
private

JLabel muestraField;
String nombreTipo;
int fuenteEstilo;
int fuenteTamano;

/**
* Construye el frame
*/
public FuenteVisor2Frame(){
//Construye muestra de texto
muestraField = new JLabel("Programacin Orientado a Objetos");
add(muestraField,BorderLayout.CENTER);
//Construye men
JMenuBar barraMenu = new JMenuBar();
setJMenuBar(barraMenu);
barraMenu.add(creaArchivoMenu());
barraMenu.add(creaFuenteMenu());
nombreTipo = "Serif";
fuenteTamano = 24;
fuenteEstilo = Font.PLAIN;
setMuestraFuente();
setSize(FRAME_ANCHO, FRAME_ALTO);

}
/**
* Crea el men Fuente.
* @return menu
*/
public JMenu creaArchivoMenu(){
JMenu menu = new JMenu();
menu.add(creaArchivoSalida());
return menu;

}
/**
* Crea el Archivo-> Salir del item menu y establece su action listener.
* @return el menu item
*/
public JMenuItem creaArchivoSalida(){
JMenuItem item = new JMenuItem("Salir");
class MenuItemListener implements ActionListener{
public void actionPerformed(ActionEvent e){
System.exit(0);
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}
/**
* Crea el men Fuente
* @return el men
*/
public JMenu creaFuenteMenu(){
JMenu menu = new JMenu("Fuente");
menu.add(creaTipoMenu());
menu.add(creaTamanoMenu());
menu.add(creaEstiloMenu());
return menu;
}
/**
* Crea el men Tipo.
* @return
*/
public JMenu creaTipoMenu(){
JMenu menu = new JMenu("Tipo");
menu.add(creaTipoItem("Serif"));
menu.add(creaTipoItem("SansSerif"));
menu.add(creaTipoItem("Monospaced"));
return menu;
}
/**
*
* @return
*/
public JMenu creaTamanoMenu(){
JMenu menu = new JMenu("Tamao");
menu.add(creaTamanoItem("Pequeo", -1));
menu.add(creaTamanoItem("Grande", 1));
return menu;
}
/**
*
* @return
*/
public JMenu creaEstiloMenu(){
JMenu menu = new JMenu("Estilo");
menu.add(creaEstiloItem("Plano", Font.PLAIN));
menu.add(creaEstiloItem("Negrita", Font.BOLD));

menu.add(creaEstiloItem("Italica", Font.ITALIC));
menu.add(creaEstiloItem("Negrita Italica", Font.BOLD
+ Font.ITALIC));
return menu;
}
/**
* Crea un men item para cambiar el tipo de fuente
* y establecer su action listener.
* @param nombre el nombre del tipo de fuente
* @return el menu item
*/
public JMenuItem creaTipoItem(final String nombre){
JMenuItem item = new JMenuItem(nombre);
class MenuItemListener implements ActionListener {
public void actionPerformed(ActionEvent event) {
nombreTipo = nombre;
setMuestraFuente();
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}
/**
* Crea un men item para cambiar el tamao de la fuente
* y establecer su action listener.
* @param nombre el nombre del menu item
* @param ds el nomto en el que va cambiar de tamao
* @return el menu item
*/
public JMenuItem creaTamanoItem(String nombre, final int ds){
JMenuItem item = new JMenuItem(nombre);
class MenuItemListener implements ActionListener {
public void actionPerformed(ActionEvent event) {
fuenteTamano += ds;
setMuestraFuente();
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}
/**
* Crea un men item para cambiar el estilo de la fuente
* y establecer su action listener.
* @param nombreTipo el nombre del menu item
* @param estilo el nuevo estilo de la fuente
* @return el menu item
*/
public JMenuItem creaEstiloItem(String nombre, final int estilo){
JMenuItem item = new JMenuItem(nombre);
class MenuItemListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
fuenteEstilo = estilo;
setMuestraFuente();

}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}
/**
* Define el tipo de letra del texto de la muestra.
*/
public void setMuestraFuente(){
Font f = new Font(nombreTipo, fuenteEstilo, fuenteTamano);
muestraField.setFont(f);
muestraField.repaint();
}
}

FontViewer2 ****************
import javax.swing.JFrame;

public class FuenteVisor2 {


public static void main(String[] args) {
JFrame frame = new FuenteVisor2Frame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

Deslizante # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
ColorVisorframe ****************
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import
import
import
import
import
import

javax.swing.JFrame;
javax.swing.JLabel;
javax.swing.JPanel;
javax.swing.JSlider;
javax.swing.event.ChangeEvent;
javax.swing.event.ChangeListener;

public class ColorVisorFrame extends JFrame {


private static final int FRAME_ANCHO = 300;
private static final int FRAME_ALTO = 400;
private
private
private
private

JPanel colorPanel;
JSlider rojoSlider;
JSlider verdeSlider;
JSlider azulSlider;

public ColorVisorFrame(){
colorPanel = new JPanel();

}
/**
*
*/

add(colorPanel, BorderLayout.CENTER);
creaControlPanel();
setMuestraColor();
setSize(FRAME_ANCHO, FRAME_ALTO);

public void creaControlPanel(){


class ColorListener implements ChangeListener {
public void stateChanged(ChangeEvent event){
setMuestraColor();
}
}
ChangeListener listener = new ColorListener();
rojoSlider = new JSlider(0, 255, 255);
rojoSlider.addChangeListener(listener);
verdeSlider = new JSlider(0, 255, 175);
verdeSlider.addChangeListener(listener);
azulSlider = new JSlider(0, 255, 175);
azulSlider.addChangeListener(listener);
JPanel controlPanel = new JPanel();
controlPanel.setLayout(new GridLayout(3, 2));
controlPanel.add(new JLabel("Rojo"));
controlPanel.add(rojoSlider);
controlPanel.add(new JLabel("Verde"));
controlPanel.add(verdeSlider);
controlPanel.add(new JLabel("Azul"));
controlPanel.add(azulSlider);
add(controlPanel, BorderLayout.SOUTH);
}
/**
* Lee los valores del Slider y establece el
* panel al colo seleccionado
*/
public void setMuestraColor(){
//Lee los vaslores del Slider
int rojo = rojoSlider.getValue();
int verde = verdeSlider.getValue();
int azul = azulSlider.getValue();
//Establece el fondo del panel al color seleccionado
colorPanel.setBackground(new Color(rojo, verde, azul));
colorPanel.repaint();
}
}

ColorViewer ****************
import javax.swing.JFrame;
public class ColorVisor {
public static void main(String[] args) {
ColorVisorFrame frame = new ColorVisorFrame();
frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
frame.setVisible (true);
}
}