Archivo

Posts Tagged ‘PEF2501’

Preparando Certamen 3 – Ejercicio 2 [POO – Java] PEF2501

noviembre 28, 2009 1 comentario

Otro Ejercicio de Java para practicar para el cetamen 3 de Programación Orientada a Objetos, Solo Tienen que hacer lo que les piden, Si no piden main y no piden testear la aplicación no lo hagan (Si les sobra tiempo pueden hacerlo).
Enunciado:
Una biblioteca requiere de una aplicación que sea capaz de llevar un registro de los alumnos de las carreras y los pedidos de libros

que ellos realizan. Para cubrir este requerimiento se ha creado
un conjunto de clases, cuya especificación es la siguiente:
CARRERA
ATRIBUTOS
nombre: String
duración: byte
acreditada: boolean
registroAlumnos: HashMap (considerar el RUT del
alumno como clave primaria (key))

MÉTODOS
Constructor sin parámetros
Constructor con parámetros (que reciba todos los atributos, obviando los alumnos, que deben ser ingresados posteriormente)
Accesador para cada atributo
Mutador para cada atributo
Método de impresión
Método addAlumno (que reciba un objeto del tipo Alumno ya inicializado y que valide la unicidad de registros mediante un mensaje en caso de que el alumno a ingresar ya se encuentre registrado).
ALUMNO
ATRIBUTOS:
RUT: String (máximo 10, los primeros 8 son números, luego el “-” y finalmente un número o una letra)
tipo: int (considerar uso de las siguientes constantes
Alumno.ADJUNTO:1,Alumno.REGULAR:2, Alumno.RETIRADO:3)
ciudad: String
prestamos: ArrayList
MÉTODOS:
Constructor sin parámetros
Constructor con parámetros (obviando los préstamos, que deben ser generados posteriormente)
Accesador para cada atributo
Mutador para cada atributo
Método de impresión
Método addPrestamo, que reciba como parámetro un objeto del tipo Préstamo ya inicializado.
Método booleano isResponsable, que devuelve true si los tres últimos préstamos han sido devueltos en la fecha que corresponde, false en su defecto, o si no existen préstamos registrados.
PRÉSTAMO
ATRIBUTOS:
fechaPréstamo: date
fechaDevolución: date (no puede ser inferior a la fecha de
préstamo).
libro: String
atrasado: boolean
MÉTODOS:
Constructor sin parámetros
Constructor con parámetros (que reciba todos los atributos, siendo atrasado: false)
Accesador para cada atributo
Mutador para cada atributo, excepto para el caso del atributo atrasado.
Método de impresión
Método devolverLibro() que recibe la fecha efectiva de la devolución y si es mayor a la fecha en la que debía ser devuelto el libro entonces deja el atributo atrasado seteado en true.
Todas las reglas de negocio deben controlarse con
Excepciones.(Considerar lanzar objetos Exception para el tipo
numérico y para el tipo String por separado, explicando en el
mensaje la regla de negocio no cumplida).

Descarga Código de fuente:
http://estebanfuentealba.net/ayudantia/PreparandoCertamen3EjercicioDos.rar

PD: Si quieren Testear El programa aqui les dejo un Main

/**
 * @(#)EjercicioDos.java
 *
 * EjercicioDos application
 *
 * @author Esteban Fuentealba
 * @version 1.00 2009/11/28
 */
import cl.duoc.pef.ejerciciodos.entidades.*;
import cl.duoc.pef.ejerciciodos.exception.*;
import java.util.*;
public class EjercicioDos {
    
    public static void main(String[] args) {
    	try {
	    	Carrera c = new Carrera("Informatica",(byte)4,true);
	    	
	    	Alumno alumnoA = new Alumno("11111111-1",Alumno.REGULAR,"Concepcion");
	    		Prestamo prestamoA = new Prestamo(new Date(2009,6,20),new Date(2009,6,25),"POO Avanzada");
	    		Prestamo prestamoB = new Prestamo(new Date(2009,7,20),new Date(2009,8,25),"Programacion para Principiantes");
	    		Prestamo prestamoC = new Prestamo(new Date(2009,9,20),new Date(2009,9,25),"Como  salir de la Depresión");
	    	alumnoA.addPrestamo(prestamoA);
	    	alumnoA.addPrestamo(prestamoB);
	    	alumnoA.addPrestamo(prestamoC);
	    	
	    	Alumno alumnoB = new Alumno("22222222-2",Alumno.ADJUNTO,"Concepcion");
	    		Prestamo prestamoD = new Prestamo(new Date(2009,7,20),new Date(2009,11,25),"Revista caras");
	    	alumnoB.addPrestamo(prestamoD);
	    	Alumno alumnoC = new Alumno("33333333-3",Alumno.REGULAR,"Concepcion");
	    	Alumno alumnoD = new Alumno("44444444-4",Alumno.RETIRADO,"Santiago");
	    	
	    	c.addAlumno(alumnoA);
	    	c.addAlumno(alumnoB);
	    	c.addAlumno(alumnoC);
	    	c.addAlumno(alumnoD);
	    	
	    	c.imprimir();
	    	prestamoB.devolverLibro(new Date(2010,0,0));
	    	System.out.println("Responsable: "+alumnoA.isResponsable());
    	} catch(NumberException exA) {
    		System.out.println(exA.getMessage());
    	} catch(StringException exB) {
    		System.out.println(exB.getMessage());
    	} catch(Exception exC) {
    		System.out.println(exC.getMessage());
    	}
   	}
}

Saludos!

Anuncios

Preparando Certamen 3 – Ejercicio 1 [POO – Java] PEF2501

noviembre 28, 2009 1 comentario

Aquí un ejercicio para practicar para su certamen del día lunes, la profesora Yasna se los envió por blackboard a sus cuentas según me informan por interno xD.

 

 

 

Enunciado:
Se desea manejar los antecedentes de un curso. Cada curso cuenta
con un nombre y con una nómina de alumnos. Por su parte, cada
alumno cuenta con un ID, un nombre y un promedio final.

Algunos de los métodos asociados al curso son los que se indican a
continuación:

MÉTODO DESCRIPCIÓN
public void matricular(Alumno a) Permite AGREGAR al alumno ‘a’
al curso.
public boolean remover(Alumno a) Permite REMOVER al alumno ‘a’
del curso.
public boolean estaInscrito(Alumno a) Permite saber si el alumno ‘a’
se encuentra presente en el
curso

En el curso no se pueden tener alumnos repetidos, es decir, NO
SERÍA POSIBLE tratar de matricular a un mismo alumno dos veces.

Se pide implementar las clases que permitan almacenar los datos de
un curso y sus alumnos.

Se pide implementar la clase Main que contenga el método main que
permita cumplir con la siguiente funcionalidad:

· Crear a tres alumnos con los siguientes datos:
o ID = 1; NOMBRE = “ALFA”; PROMEDIO = 6.5
o ID = 2; NOMBRE = “BETA”; PROMEDIO = 4.5
o ID = 3; NOMBRE = “GAMMA”; PROMEDIO = 5.5
· Crear el curso llamado PEF2501
· Imprimir la nómina de alumnos del curso
· Matricular a ALFA y BETA en el curso PEF2501

· Imprimir en la salida estándar, utilizando el método
estaInscrito(), si el alumno llamado BETA se encuentra
inscrito en el curso.
· Imprimir en la salida estándar, utilizando el método
estaInscrito(), si el alumno llamado GAMMA se encuentra
inscrito en el curso.
· Remover del curso al alumno llamado BETA
· Imprimir la nómina del curso

Descarga Codigo de Fuente:
http://estebanfuentealba.net/ayudantia/PreparandoCertamen3EjercicioUno.rar

Saludos!

Java, Creando JTable con swing

noviembre 12, 2009 6 comentarios

Bueno aqui pondré una forma sencilla de crear nuestra primera tabla con java.
La siguiente imagen nos muestra como esta compuesta una tabla
tabla

Como muestra la imagen la tabla se compone de:

  • Columas (Verticales)
  • Filas (Horizontales)

A la vez, las filas se componen de Celdas dependiendo de la fila y columna.

La tabla de la imagen tiene 3 Columnas

  • Columna A
  • Columna B
  • Columna C

1 Fila con 3 Celdas

  • X
  • Y
  • Z

En Java existe un componente que nos permitirá dibujar éste tipo de tablas y su nombre es JTable

JTable tiene el constructor sobrecargado y uno de ellos me pide dos parametros:
JTable(Vector rowData, Vector columnNames)

Un Vector de Filas y un Vector de Columnas

Tip: Vector es una clase que implementa la interface List, ArrayList tambien implementa la interface List, por lo que la forma de uso de Vector y ArrayList es igual.

Teniendo el conocimiento de lo anterior ahora lo pasaremos a codigo.

/**
 * @(#)Tabla.java
 *
 * Tabla application
 *
 * @author EstebanFuentealba
 * @version 1.00 2009/11/11
 */
 
/* Importo lo necesario para poder dibujar ventanas */
import java.awt.*;
import javax.swing.*;
/* Importo la Clase Vector que se encuentra en el package java.util */
import java.util.Vector;

/* mi clase Tabla hereda de JFrame */
public class Tabla extends JFrame {
    
    public Tabla() {
    	/* Le setearé el titulo a la ventana */
    	super("Mi tabla");
    	/* a la ventana le doy dimensiones de 300 de ancho x 200 de alto */
    	this.setSize(300,200);
    	
    	/* Creo una instancia de la clase Vector llamada 'columnas' */
    	Vector columnas = new Vector();
    	/* 
    	 	A ese vector le agrego datos, estos datos vendrán a ser las
    	 	columnas de la tabla.
    	*/
    	columnas.add("Columna A");
    	columnas.add("Columna B");
    	columnas.add("Columna C");

    	
    	/* 
    	 	Creo una instancia de la clase Vector llamada 'filas' , este vector
    	 	tendrá todas las filas de la tabla.
    	*/
    	Vector filas = new Vector();
    	
    	/*
    	 	Creo otro objeto de la clase Vector llamado 'fila', esto representará a
    	 	una fila en particular y cada elemento que agregue a este vector
    	 	será una celda.
    	 */
    	Vector fila = new Vector();
    	
    	fila.add("X");
    	fila.add("Y");
    	fila.add("Z");
  
		/* Agrego la fila al vector que contiene todas las filas */
    	filas.add(fila);
    	
    	/* 
    	 	Creo una instancia de JTable y le paso como parametro los dos Vectores:
    	 		-filas
    	 		-columnas	
    	 */
    	JTable tbl = new JTable(filas,columnas);
    	/* Creo una instancia de JScrollPane y le paso como parametro la tabla */
    	JScrollPane panel =new JScrollPane(tbl);
		/* Por ultimo agrego ese objeto de JScrollPane al contenedor de la ventana */
    	this.getContentPane().add(panel);
    	
    	this.setVisible(true);
    }
    public static void main(String[] args) {
    	new Tabla();
    }
}

Con eso ya tienen una tabla funcionando =)

Saludos!

Categorías:Java Etiquetas: , , , , , ,

Preparando Certamen Ejercicio 2 (Venta de Pizza) PEF2501

octubre 31, 2009 3 comentarios

Este es un ejercicio que les envió la profesora tipo certamen

Enunciado:
Una empresa de venta de pizzas desea agilizar su servicio.

Se necesita una aplicación Java que permita al usuario ingresar
los datos de la venta y ver el costo asociado en pantalla.

Se ha diseñado la siguiente Interfaz de Usuario para esta
aplicación:
Preparando2

Se deben respetar las siguientes reglas:

La masa tiene un costo de:

MASA COSTO
Normal 1.500
Integral 2.500

· El ingrediente básico tiene un costo de:

INGREDIENTE COSTO
Jamón 450
Extra queso 650
Tomate 500

· El ingrediente extra tiene un costo de:

INGREDIENTE COSTO
SIN INGREDIENTE EXTRA 0
Champiñones 700
Aceitunas 500
Espárragos 600
Tocino 650

El costo total, considerando el DESCUENTO se calcula con la
siguiente fórmula:

Total CON DESCUENTO = (Costo masa +
Costo Ingrediente básico +
Costo Ingrediente Extra) * 0.93

El costo total, SIN DESCUENTO se calcula con la siguiente fórmula:

Total SIN DESCUENTO = (Costo masa +
Costo Ingrediente básico +
Costo Ingrediente Extra)

Además:

1. Se debe validar que el usuario escoja todos los datos antes
de realizar el cálculo, el cual se ejecuta al presionar el
botón Calcular. En ese momento se deben actualizar los datos
de la boleta (TOTAL SIN DESCUENTO)
2. No se debe permitir modificar el cuadro donde se despliega el
Total.
3. El botón Imprimir debe habilitar un Dialog, donde se indique
el total SIN DESCUENTO y el total CON DESCUENTO.
4. El botón Salir debe cerrar la aplicación
5. Crear una aplicación que levante la ventana y permite
interactuar con ella.

Descargar Código de Fuente:
http://estebanfuentealba.net/ayudantia/PreparandoCertamen2.rar

Certamen 2 Programacion Orientada a Objetos [2008]

Bueno aqui les dejo el Certamen 2 que se hizo el año pasado la profesora Yasna Meza , espero que les sirva.

Enunciado:
Una empresa de venta de computadores desea agilizar su servicio. Se ha
detectado que muchos consumidores asisten a este local para consultar la
venta de un computador.

Se necesita una aplicación Java que permita al usuario ingresar los datos de
la venta y ver el costo asociado en pantalla.

Se ha diseñado la siguiente Interfaz de Usuario para esta aplicación:

WCertamen2

Se deben respetar las siguientes reglas:

· El modelo tiene un costo de:

Modelo Costo
Pentium V 300.000
AMD Duron 270.000
Athlon 250.000

· La pantalla tiene un costo de:

Pantalla Costo
Sin Pantalla 0
Pantalla 14” 50.000
Pantalla 15” 66.000
Pantalla 17” 85.000
Pantalla 19” 125.000
Sobre 19” 140.000

· El disco duro tiene un costo de:

Disco Duro Costo
80 GB 44.000
120 GB 60.000
160 GB 89.000
200 GB 122.000

El costo de venta total, considerando el IVA se calcula con la siguiente
fórmula:

Total IVA = (Costo modelo + Costo Pantalla + Costo Disco Duro) * 1.19

El costo de venta total, sin IVA se calcula con la siguiente fórmula:

Total SIN IVA = (Costo modelo + Costo Pantalla + Costo Disco Duro)

Además:

1. Se debe validar que el usuario escoja todos los datos antes de realizar
el cálculo, el cual se ejecuta al presionar el botón Calcular.
2. No se debe permitir modificar el cuadro donde se despliega el Total.
3. El botón Imprimir debe habilitar un Dialog, donde se indique el total
sin IVA y el total con IVA.
4. Crear una aplicación que levante la ventana y permite interactuar con
ella.

Clase Certamen2.java

/**
 * @(#)Certamen2.java
 *
 * Certamen2 application
 *
 * @author 
 * @version 1.00 2009/10/28
 */
 
public class Certamen2 {
    
    public static void main(String[] args) {
    	new WCertamen();
    }
}

Clase WCertamen.java

/*
 *	Importo todos los packages necesario para poder crear ventanas
 *	
 */
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

/*
 *	Extiendo la clase WCertamen de JFrame, esto me permitirá heredar los metodos y atributos de la clase JFrame
 */
public class WCertamen extends JFrame {
	
	/* Atributos */
	
	/*
	 *	Aqui pondré todos los componentes que necesitaré usar a lo largo de la vida del programa,
	 *	Ej: Para despues asignarle un evento a los botones, sacar los datos de los combobox, etc
	 *	
	 */
	private JPanel panelArribaIzquierdo,panelArribaDerecho,panelAbajoIzquierdo,panelAbajoDerecho;
	private JTextField campoDeTexto;
	private JButton btnCalcular,btnSalir,btnImprimir;
	private JComboBox comboA,comboB;
	private ButtonGroup grupo;
	private JRadioButton radioA,radioB,radioC;
	/* Constructor por Defecto  */
	public WCertamen() {
		
		/* Con la palabra reservada "super" llamo al constructor por
		 * defecto de una entidad mas arriba en la jerarquia de clases
		 *
		 *	JFrame
		 *	|_______ WCertamen
		 *
		 *	En  este caso llamo a uno de los constructores de la Clase JFrame 
		 *	para setear el titulo de la ventana
		 *
		 */
		super("Certamen Dos");
		/* 
		 *	implemento el evento para que cuando al presionar el boton cerrar "X"
		 *	mi aplicacion se detenga.
		 **/
		this.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		/*
		 *	A la ventana le asigno un Ancho y un Alto, el primer parametro.
		 *		Forma de uso:	setSize( ANCHO , ALTO )
		 */
		this.setSize(500,300);
		this.setLocationRelativeTo(null);
		
		/*
		 *	Al contenedor de la ventana (Contendrá todos los componentes) le asigno una
		 *	grilla, en palabras simples creo una grilla de 2 Filas y 2 Columnas
		 *		Forma de uso: 	GridLayout( FILAS , COLUMNAS )
		 *	La ventana Quedarà dividida Algo mas o menos asi :
		 *				Columnas
		 *			_________________
		 *			|		|		|
		 *			|_______|_______|
		 *  Filas	|		|		|
		 *			|_______|_______|
		 */
		this.getContentPane().setLayout(new GridLayout(2,2));
		
		
		/*
		 *	Creo 4 Paneles para cada espacio de la grilla
		 */
		
		this.panelArribaIzquierdo = new JPanel();
		this.panelArribaDerecho = new JPanel();
		this.panelAbajoIzquierdo = new JPanel();
		this.panelAbajoDerecho = new JPanel();
		
		
		/* Le seteo una grilla al panel izquierdo de arriba de 3,2 */
		this.panelArribaIzquierdo.setLayout(new GridLayout(3,2));
		JLabel lblModelo = new JLabel("Modelo: ");
		
		/* Creo tres Radio Buttons y los agrupo en el atributo "grupo" */
		radioA = new JRadioButton("Pentium v");
		radioB = new JRadioButton("AMD");
		radioC = new JRadioButton("Athlon");
		grupo = new ButtonGroup();
		grupo.add(radioA);
		grupo.add(radioB);
		grupo.add(radioC);
		
		/* Agrego al panel panelArribaIzquierdo todos los componentes */
		this.panelArribaIzquierdo.add(lblModelo);
		this.panelArribaIzquierdo.add(radioA);
		this.panelArribaIzquierdo.add(new JLabel());
		this.panelArribaIzquierdo.add(radioB);
		this.panelArribaIzquierdo.add(new JLabel());
		this.panelArribaIzquierdo.add(radioC);
		
		
		
		/* Vamos a Crear el segundo panel de arriba */
		this.panelArribaDerecho.setBorder(new EmptyBorder(30,0,30,0));
		this.panelArribaDerecho.setLayout(new GridLayout(2,3));
		
		/* Instancio la clase JComboBox y se lo asigno al tributo "comboA" */
		this.comboA = new JComboBox();
		comboA.addItem("80");
		comboA.addItem("120");
		comboA.addItem("180");
		comboA.addItem("200");
		/* Agrego los Componentes al JPanel "panelArribaDerecho" */
		this.panelArribaDerecho.add(new JLabel("Disco Duro"));
		this.panelArribaDerecho.add(comboA);
		this.panelArribaDerecho.add(new JLabel("GB"));
		
		
		this.comboB = new JComboBox();
		comboB.addItem("Sin");
		comboB.addItem("14");
		comboB.addItem("15");
		comboB.addItem("17");
		comboB.addItem("19");
		comboB.addItem("Mayor a 19");
		this.panelArribaDerecho.add(new JLabel("Pantalla"));
		this.panelArribaDerecho.add(comboB);
		this.panelArribaDerecho.add(new JLabel("Pulg."));
		
		
		this.panelAbajoIzquierdo.setLayout(new GridBagLayout());
		
		this.btnImprimir = new JButton("Imprimir");
		this.btnSalir = new JButton("Salir");
	
		this.panelAbajoIzquierdo.add(btnImprimir);
		this.panelAbajoIzquierdo.add(btnSalir);
			
		this.panelAbajoDerecho.setBorder(new EmptyBorder(50,0,50,0));
		this.panelAbajoDerecho.setLayout(new GridLayout(1,3));
			
		this.btnCalcular = new JButton("Calcular");
		this.panelAbajoDerecho.add(btnCalcular);
		this.panelAbajoDerecho.add(new JLabel("Total"));
		
		
		this.campoDeTexto = new JTextField();
this.campoDeTexto.setEnabled(false);
		this.panelAbajoDerecho.add(campoDeTexto);
			
		/*
		 *	Agrego todos los Paneles al Contenedor de la ventana
		 */
		this.getContentPane().add(panelArribaIzquierdo);
		this.getContentPane().add(panelArribaDerecho);
		this.getContentPane().add(panelAbajoIzquierdo);
		this.getContentPane().add(panelAbajoDerecho);
		
		this.pack();
		/* Llamo a el metodo 'agregarEventos()' para asignar todos los eventos */
		agregarEventos();
		/* Muestro la Ventana */
		this.setVisible(true);
	}
	/*
	 *	Metodo que calcula el total de la suma entre:
	 *	 Modelo + Disco Duro + Pantalla
	 *	Devuelve un int con la suma sin IVA.
	 */
	public int calcularSinIva() {
		/* 
		 *	declaro una variable llamada 'total' y la inicializo en 0 ,
		 *	ésta variable me llevara la cuenta de la sumna de:
		 *	 Modelo + Disco Duro + Pantalla
		 */
		int total=0;
		
		/*	#########
		 *	## MODELO
		 *	#########
		 *
		 *	Pregunto si el JRadioButton 'radioA' está seleccionado,
		 *	de ser asi debo sumarle al total el valor de un Pentium V
		 */
		 if(radioA.isSelected()) {
		 	/* Le sumo al total $300.000*/
		 	total += 300000;
		 } 
		 /* Osino, si el 'radioB' esta seleccionado,
		  *	debo sumar al total $270.000
		  */
		 else if(radioB.isSelected()) {
		 	/* Le sumo al total $270.000*/
		 	total += 270000;
		 }
		 /* Osino, si el 'radioC' esta seleccionado,
		  *	debo sumar al total $270.000
		  */
		 else if(radioC.isSelected()) {
		 	/* Le sumo al total $250.000*/
		 	total += 250000;
		 }
		 /*
		  *	Osino quiere decir que no seleccione ningun radioButton, 
		  *	entonces deberia lanzar una alerta con un error y no sumar nada al total
		  */
		 else {
		 	JOptionPane.showMessageDialog(null,"ERROR: Debes seleccionar un Modelo");
		 }
		 
		 /*
		  *	Si arriba hay un error quiere decir que no sume nada al total, en ese caso, 'total' aun estará en 0
		  *	Entonces si el valor es mayor a 0 quiere decir que debo continuar con la 
		  *	suma de los valores de disco duro y pantalla.
		  */
		  if(total > 0) {
		  	
			/*	#########
			 *	## Disco Duro
			 *	#########
			 *
		  	 *	Ahora seguire sumando el valor de los discos duros,
		  	 *	Para eso iré preguntando cual es el 
		  	 *	valor (texto)  de la opcion del JComboBox seleccionada
		  	 */
		  	if(comboA.getSelectedItem().toString()=="80") {
		  		/* Si la opcion seleccionada en el combobox es 80 debo sumar al total $44000 */
		  		total += 44000;
		  	} else if(comboA.getSelectedItem().toString()=="120") {
		  		/* Osino, Si la opcion seleccionada en el combobox es 120 debo sumar al total $60000 */
		  		total += 60000;
		  	} else if(comboA.getSelectedItem().toString()=="160") {
		  		/* Osino, Si la opcion seleccionada en el combobox es 160 debo sumar al total $89000 */
		  		total += 89000;
		  	} else if(comboA.getSelectedItem().toString()=="200") {
		  		/* Osino, Si la opcion seleccionada en el combobox es 200 debo sumar al total $122000 */
		  		total += 122000;
		  	} 
		  	
		  	/*	#########
			 *	## Pantalla
			 *	#########
			 *	Ahora seguire sumando el valor de las Pantallas ,
		  	 *	Para eso iré preguntando cual es el 
		  	 *	valor (texto)  de la opcion del JComboBox seleccionada
		  	 */
			 if(comboB.getSelectedItem() == "14") {
			 	/* Si la opcion seleccionada en el combobox es 14 debo sumar al total $50000 */
			 	total += 50000;
			 }
			 else if(comboB.getSelectedItem() == "15") {
			 	/* Si la opcion seleccionada en el combobox es 15 debo sumar al total $66000 */
			 	total += 66000;
			 }
			 else if(comboB.getSelectedItem() == "17") {
			 	/* Si la opcion seleccionada en el combobox es 17 debo sumar al total $85000 */
			 	total += 85000;
			 }
			 else if(comboB.getSelectedItem() == "19") {
			 	/* Si la opcion seleccionada en el combobox es 19 debo sumar al total $125000 */
			 	total += 125000;
			 } else if(comboB.getSelectedItem() == "Mayor a 19") {
			 	/* Si la opcion seleccionada en el combobox es 'Mayor a 19' debo sumar al total $140000 */
			 	total += 140000;
			 } else {
			 	/* 
			 	 *	Si la opcion no es ninguna de las anteriores 
			 	 *	quiere decir que seleccione la opcion 'Sin' donde debo sumar $0 
			 	 */
			 }
		  } 
		  /* 
		   *	Con el calculo hecho retorno el valor de la Variable 'total'
		   */
		   return total;
		  
	}
	public void agregarEventos() {
		ActionListener calcular = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				/* Llamo al metodo 'calcularSinIva()' para traer el valor de la suma total */
				int sumaSinIva = calcularSinIva();
				/* 
				 *	Le asigno al campo de texto el total de la compra 
				 */
				campoDeTexto.setText(String.valueOf(sumaSinIva));
			}
		};
		btnCalcular.addActionListener(calcular);
		
		ActionListener imprimir = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				/* Llamo al metodo 'calcularSinIva()' para traer el valor de la suma total */
				int sumaSinIva = calcularSinIva();
				/* 
				 *	Le agrego el iva a la 'sumaSinIva' y lo guardo en la variable 'sumaConIva'
				 */
				double sumaConIva = sumaSinIva * 1.19;
				/* 
				 *	Desplego una alerta mostrando los datos
				 */
				JOptionPane.showMessageDialog(null,"Valor Sin Iva: "+sumaSinIva+"\nValor Con Iva: "+sumaConIva);
			}
		};
		btnImprimir.addActionListener(imprimir);
		
		ActionListener salir = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				/* Detengo la Ejecucion del programa */
				System.exit(0);
			}
		};
		btnSalir.addActionListener(salir);
	}

}

Descargar Código de Fuente:
http://estebanfuentealba.net/ayudantia/Certamen2.rar

Categorías:Java Etiquetas: , , , ,

Preparando Certamen 2 GUI PEF2501

octubre 30, 2009 3 comentarios

A partir del diagrama de clases del Certamen 1 de PEF2501
Se pide:

– Construir la siguiente Aplicación

preparando

NOTA: Se valora el hecho de validaciones y ventanas de alerta si los textfield se envian sin datos.

– Al presionar Activar se deben habilitar los textfields y buttons del producto seleccionado.
– En el combobox se deben mostrar los nombres de libros y dvds agregados.
– El total se debe ir actualizando a medida de ir aumentando la lista.
– El boton Mostrar debera mostrar todos los datos del Producto seleccionado por medio de una alerta
Nombre – TIPO – Duracion/Paginas

Descargar Código de Fuente:
http://estebanfuentealba.net/ayudantia/PracticaCertamen.rar

Certamen 1 Parte Practica [PEF2501]

octubre 29, 2009 2 comentarios

Aquí dejo el Certamen de la seccion PEF2501 de Programacion Orientada A Objetos

Enunciado:

Considerando el siguiente diagrama de clases:
ModeloClasesCertamen

El método masBreve DEBERÁ DEVOLVER, entre dos productos, aquella que sea
menor. El criterio para escoger el menor DEPENDE del tipo de producto. Cuando
se trata de DVDs, se deberá comparar a través de la duración y cuando se
trata de libros se deberá comparar a través del número de páginas. El método
esMasBreve DEBERÁ devolver un valor lógico que indique si un producto es más
que otro.

Se pide que usted:

· Implemente el diagrama de clases anterior
(15 PUNTOS)

NOTA. Se valora el hecho de que aplique la mayor cantidad de conceptos
de OO que se han revisado en clases.

· Construya una aplicación en Java que permita cumplir con la siguiente
funcionalidad:

· R01 – Crear una lista de productos (DVDs y libros). El usuario debe
ingresar el total de productos que desea ingresar.
(5 PUNTOS)

· R02 – Imprimir un informe que responda a la siguiente estructura

NOMBRE PRODUCTO TIPO DURACIÓN/PÁGINAS
————— —- —————-

En la lista DEBEN aparecer primero los DVD y luego los libros.

(15 PUNTOS)

· R03 – A partir de un nombre, obtenido desde la entrada estándar,
mostrar la TODA información relacionada con el producto, indicando
además el tipo de producto del que se trata.

(5 PUNTOS)

· R04 – Pedir al usuario que ingrese dos números enteros, x e y,
comparar la especie que se encuentra en la posición x de la lista con
la especie que está en la posición y de la lista para luego mostrar,
en la salida estándar, EL OBJETO más extenso (libro con mayor número
de páginas o DVD de mayor duración).

(15 PUNTOS)

 

IOrden.java

/*
 *	Interfaz IOrden 
 */
interface IOrden {
	/* metodo "masBreve" , Recibe un "Object" y retorna un "Object" */
	Object masBreve(Object o);
	/* metodo "esMasBreve" , Recibe un "Producto" y retorna un "boolean" */
	boolean esMasBreve(Producto o);
}

Producto.java

/*
 *	Clase Producto Definida como abstract Para que las clases hijas 
 *	implementen los metodos de la interfaz IOrden
 */
public abstract class Producto implements IOrden {

	public String nombre;
	
	/* Constructor por defecto */
	public Producto() {
	}
	/* Accesador */
	public String getNombre() {
		return nombre;
	}
	/* Mutador */
	public void setNombre(String val) {
		this.nombre = val;
	}
	/*
	 *	Solo declaro los metodos de la interfaz, los declaro 
	 *	como abstract para que los implementen las clases hijas
	 */
	public abstract Object masBreve(Object o);
	public abstract boolean esMasBreve(Producto o);
	
	/*
	 *	Sobre escribo el metodo "toString"
	 */
	public String toString() {
		return "Nombre: "+this.getNombre();
	}
	
}

Libro.java

/*
 *	Clase Libro extiende de Producto, 
 *	Implementa los metodos que la clase padre no implemento
 */
 
public class Libro extends Producto {
	
	/* Atributos */
	public int paginas;
	
	/* Constructor por defecto */
	public Libro() {}
	
	/* Accesador */
	public int getPaginas() {
		return paginas;
	}
	/* Mutadores */
	public void setPaginas(int val) {
		this.paginas = val;
	}
	
	/*
	 *	Implementacion del metodo "esMasBreve" definido en la interfaz "IOrden"
	 *	recibe como parametro un Producto y retorna un boolean (true o false)
	 */
	public boolean esMasBreve(Producto o) {
		/* 
		 *	Al producto que le paso por parametro 
		 *	le hago un Cast, una conversion implícita de Producto a Libro 
		 *	para poder acceder a los metodos de Libro
		 */
		Libro producto = (Libro)o;
		/*
		 *	Comparo las paginas de éste (this) objeto con las 
		 *	del libro que pase por parametro
		 */
		if(this.getPaginas() < producto.getPaginas()) {
			/* 	
			 *	Si las paginas de éste Libro son menores a las paginas del 
			 *	libro pasado por el parametro retorno true 
			 */
			return true;
			/* Osino retorno false */
		} else {
			return false;
		}
	}
	
	/*
	 *	Implementacion del metodo "masBreve" definido en la interfaz "IOrden"
	 *	Recibe como parametro un "Object" y retorna el Objeto mas breve (menor)
	 */
	public Object masBreve(Object o) {
		/* 
		 *	uso el metodo esMasBreve definido arriba y
		 *	Pregunto si éste (this) "objeto" es mas breve que el que pase por parametro
		 */
		if(this.esMasBreve((Producto)o)) {
			/*
			 *	Retorno todo este objeto (this)
			 */
			return this;
		} else {
			return o;
		}
	}
	
	/*
	 *	Sobre escribo el metodo "toString"
	 */
	public String toString() {
		return "Tipo: Libro "+super.toString()+" Paginas: "+this.getPaginas();
	}
	
}

DVD.java

/*
 *	Clase DVD extiende de Producto, 
 *	Implementa los metodos que la clase padre no implemento.
 */
 
 public class DVD extends Producto {
	
	/* Atributos */
	private byte duracion;
	
	/* Constructor por defecto */
	public DVD() {
	}
	
	/* Accesador */
	public byte getDuracion() {
		return this.duracion;
	}
	
	/* Mutadores */
	public void setDuracion(byte val) {
		this.duracion = val;
	}
	
	/*
	 *	Implementacion del metodo "esMasBreve" definido en la interfaz "IOrden"
	 *	recibe como parametro un Producto y retorna un boolean (true o false)
	 */
	public boolean esMasBreve(Producto o) {
		/* 
		 *	Al producto que le paso por parametro 
		 *	le hago un Cast, una conversion implícita de Producto a DVD 
		 *	para poder acceder a los metodos de DVD
		 */
		DVD producto = (DVD) o;
		/*
		 *	Comparo el valor de la duracion de éste (this) objeto con las 
		 *	del dvd que pase por parametro
		 */
		if(this.getDuracion() < producto.getDuracion()) {
			/* 	
			 *	Si la duracion de éste DVD es menor a la duracion del 
			 *	DVD pasado por parametro retorno true 
			 */
			return true;
			/* Osino retorno false */
		} else {
			return false;
		}
	}
	
	/*
	 *	Implementacion del metodo "masBreve" definido en la interfaz "IOrden"
	 *	Recibe como parametro un "Object" y retorna el Objeto mas breve (menor)
	 */
	public Object masBreve(Object o) {
		if(this.esMasBreve((Producto)o)) {
			return this;
		} else {
			return o;
		}
	}
	
	/*
	 *	Sobre escribo el metodo "toString"
	 */
	public String toString() {
		return "Tipo: DVD "+super.toString()+" Duración: "+this.getDuracion();
	}
}

CertamenA.java

/**
 * @(#)CertamenA.java
 *
 * CertamenA application
 *
 * @author 	Esteban Fuentealba
 * @version 1.00 2009/10/28
 */

/* 
 *	Hago el Import para usar la clase Scanner
 *	que me permite leer datos desde teclado
 */
import java.util.Scanner;
 
public class CertamenA {
    
    public static void main(String[] args) {
    	
    	
    	/* 
    	 *	Creo una instancia de Scanner
    	 *	le paso como parametro "System.in" (Entrada por Teclado)
    	 */
    	Scanner scan = new Scanner(System.in);
    	
    	
    	/* 	#########################
    	 *	#	R01					#
    	 *	#########################
    	 *
    	 *	Pido al usuario que ingrese la cantidad de Productos 
    	 */
    	System.out.println("Ingresa la cantidad de productos");
    	
    	/* 
    	 *	Espero que el usuario ingrese por teclado el numero del largo del array
    	 */
    	 
    	String lecturaDeTeclado = scan.nextLine();
    	int numero = Integer.parseInt(lecturaDeTeclado);
    	Producto[] productos = new Producto[numero];
    	/* 
    	 *	Creo una variable "contador" inicializado en 0 que sera el indice del array
    	 */
    	int contador = 0;
    	
    	
    	
		/*
    	 *	Pido al Usuario que ingrese Libros o DVDs
    	 */
    	for(int j=0; j< productos.length; j++) {
    	 	System.out.println("¿ Que Quieres Ingresar? ");
    	 	System.out.println("1.- Libro");
    	 	System.out.println("2.- DVD");
    	 	/*
    	 	 *	Espero que el usuario ingrese una opción
    	 	 */
    	 	int opcion = Integer.parseInt(scan.nextLine());
    	 	
    	 	/*
    	 	 *	Si el texto ingresado por teclado es un 1 
    	 	 *	Crearé un objeto de la clase Libro 
    	 	 */
    	 	if(opcion == 1) {
    	 		Libro l = new Libro();
    	 		System.out.println("Ingresa el Nombre del Libro");
		    	l.setNombre(scan.nextLine());
		    	System.out.println("Ingresa el numero de páginas del Libro");
		    	l.paginas = Integer.parseInt(scan.nextLine());
		    	
		    	/*
		    	 * 	Agrego el Objeto de Libro al arreglo de Productos
		    	 *	lo agrego en la posicion "contador", variable que cree mas arriba
		    	 */
		    	productos[contador] = l;
		    	/*
		    	 *	Incremento el contador de Productos
		    	 */
		    	contador++;
    	 	} 
    	 	/*
    	 	 *	Si el texto ingresado por teclado es un 2
    	 	 *	Crearé un objeto de la clase DVD y lo agregaré al arreglo de Productos
    	 	 */
    	 	 else if(opcion == 2) {
    	 		DVD d = new DVD();
    	 		System.out.println("Ingresa el Nombre del DVD");
		    	d.setNombre(scan.nextLine());
		    	System.out.println("Ingresa la Duración del DVD");
		    	d.setDuracion(Byte.parseByte(scan.nextLine()));
		    	
		    	/*
		    	 * 	Agrego el Objeto de DVD al arreglo de Productos
		    	 *	lo agrego en la posicion "contador", variable que cree mas arriba
		    	 */
		    	productos[contador] = d;
		    	/*
		    	 *	Incremento el contador de Productos
		    	 */
		    	contador++;
    	 	}
    	}

    	/* 	#########################
    	 *	#	R02					#
    	 *	#########################
		*/
		
    	System.out.println("Nombre\t\t\t\tTipo\t\t\t\tPaginas");
    	/* Recorro el arreglo de productos para mostrar todos los DVDs */
    	for(int indice=0; indice < productos.length; indice++) {
    		/* Del arreglo saco el producto en la posicion "indice" */
    		Producto producto = productos[indice];
    		/* Pregunto si el producto sacado es una instancia de la clase DVD*/
    		if(producto instanceof DVD) {
    			DVD unObjeto = (DVD)producto; 
    			System.out.println(producto.getNombre()+"\t\t\t\tDVD\t\t\t\t"+unObjeto.getDuracion());
    		} 
    	}
    	/* Recorro el arreglo de productos para mostrar todos los Libros */
    	for(int indice=0; indice < productos.length; indice++) {
    		/* Del arreglo saco el producto en la posicion "indice" */
    		Producto producto = productos[indice];
    		/* Pregunto si el producto sacado es una instancia de la clase Libro */
    		if(producto instanceof Libro) {
    			Libro a = (Libro)producto;
    			System.out.println(producto.getNombre()+"\t\t\t\tLibro\t\t\t\t"+a.getPaginas());
    		}
    	}
    	
    	/* 	#########################
    	*	#	R03					#
    	*	#########################
		*/
		
    	System.out.println("Ingresa el nombre a Busca");
    	String nombreABuscar = scan.nextLine();
    	/* 	
    	 *	Recorro el arreglo de productos para buscar en 
    	 *	todos los productos la palabra ingresada
    	 */
    	for(int indice=0; indice < productos.length; indice++) {
    		/* Del arreglo saco el producto en la posicion "indice" */
    		Producto p = productos[indice];
    		/* 
    		 *	Del producto llamo al metodo "getNombre" para que me 
    		 *	devuelva el nombre del producto , ese nombre lo dejo en minusculas (La Busquueda es sensible a Mayusculas y Minusculas)
    		 *	y pregunto si el nombre del producto contiene la palabra ingresada (Tambien en Minuscula)
    		 */
			if(p.getNombre().toLowerCase().contains(nombreABuscar.toLowerCase())) {
				/* 
				 *	Si la condicion se cumple imprimo el objeto
				 *	Como notarán no llamo a ningun metodo del objeto "p", esto es porque 
				 *	en las clases está Sobre escrito el metodo "toString"
				 */
				System.out.println(p);
			}	
    	}
    	
    	/* 	#########################
    	*	#	R04					#
    	*	#########################
		*/
    	System.out.println("Ingresa Numero x");
    	int numeroX = Integer.parseInt(scan.nextLine());
    	
    	System.out.println("Ingresa Numero Y");
    	int numeroY = Integer.parseInt(scan.nextLine());
    	
    	Producto primero = productos[numeroX];
    	Producto segundo = productos[numeroY];
    	
    
    	Object esMenor = primero.masBreve(segundo);
    	System.out.println("Objeto Menor:");
    	System.out.println(esMenor);
    }
}

Descargar Codigo de Fuente:
http://estebanfuentealba.net/ayudantia/Certamen1-PEF2501.rar

Saludos!.

Categorías:Java Etiquetas: , , ,