programa hecho en eclipse sebre un carrito de compras donde se puede añadir el producto borrarlo o imprimir la factura total de la compra

2. TEMA: IMPLEMENTACIÓN DE UN CARRITO DE COMPRAS USANDO JAVA PARA SU DISEÑO.
OBJETIVO: dinamizar el proceso de compra en un almacén, es decir desarrollar un programa que nos
permita el ingreso, el borrador y almacenamiento de los productos, además de visualizar la lista de
productos que estamos comprando además de brindarnos una factura impresa y detalla.
FUNDAMENTO TEÓRICO.
Package
Los paquetes se declaran para almacenar y organizar los archivos de Java. El nombre de un paquete
consta usualmente de varias partes separadas por puntos. Cada una de estas partes será un directorio
nuevo dentro del sistema de archivos. Las clases que se creen dentro de un paquete determinado en
Eclipse llevarán añadida automáticamente la declaración "package" en su código fuente.
LOS InputStream: EL OBJETO System.in
Al igual que Java nos ofrece System.out para escribir en pantalla, tenemos System.in para leer de ella.
System.in es un objeto de una clase de java que se llama InputStream.
Para java, un InputStream es cualquier cosa de la que se leen bytes. Puede ser el teclado, un fichero,
un socket, o cualquier otro dispositivo de entrada. Esto, por un lado es una ventaja. Si todas esas
cosas son InputStream, podemos hacer código que lea de ellas sin saber qué estamos leyendo.
Por otro lado, es una pega. Como un InputStream es para leer bytes, sólo tiene métodos para leer
bytes. Nosotros queremos leer palabras o números del teclado, no bytes. Si escribimos en el teclado
una A mayúscula y la leemos con System.in, obtendremos un entero de valor 65, que es el valor del
byte correspondiente a la A.
LOS Reader
Para java, una clase Reader es una clase que lee caracteres. Esto se parece más a lo que queremos. Un
Reader tiene métodos para leer caracteres. Con esta clase ya podriamos trabajar. La pena es que
seguimos teniendo System.in, que es un InputStream y no un Reader.
¿Cómo convertimos el System.in en Reader?. Hay una clase en java, la InputStreamReader, que nos
hace esta conversión. Para obtener un Reader, únicamente tenemos que instanciar un
InputStreamReader pasándole en el constructor un InputStream. El código es el siguiente:
InputStreamReader isr = new InputStreamReader(System.in);

3. Estamos declarando una variable "isr" de tipo InputStreamReader. Creamos un objeto de esta clase
haciendo new InputStreamReader(...). Entre paréntesis le pasamos el InputStream que queremos
convertir a Reader, en este caso, el System.in
Ya tenemos el Reader. ¿Cómo funciona exactamente?
• InputStreamReader es un Reader. Se comporta igual que in Reader y se puede poner en
cualquier sitio que admita un Reader. Es decir, podemos leer de él caracteres.
• Al constuirlo le hemos pasado un InputStream, en concreto, System.in. InputStreamReader de
alguna forma se lo guarda dentro.
• Cuando a InputStreamReader le pedimos caracteres, él le pide al InputStream que tiene
guardado dentro los bytes, los convierte a caracteres y nos los devuelve.
LA CLASE BufferedReader
Con la clase InputStreamReader podríamos apañarnos. La pega es que nos da los caracteres sueltos. Si
estamos leyendo de teclado, el que usa el programa puede escribir 10 caracteres o 20 o 13. Si usamos
InputStreamReader, como lee caracteres sueltos, Tenemos que decirle cuántos queremos (que no lo
sabemos), o bien ir pidiendo de uno en uno hasta que no haya más.
Esto es un poco rollo y si sólo tuviéramos la clase InputStreamReader sería un trozo de código que
tendríamos que repetir por muchos lados. Para el cado concreto de leer de teclado, sería ideal si
hubiese una clase en java que nos lea de golpe todo lo que ha escrito el usuario de nuestro programa
y nos lo diera de un golpe.
Como la gente de Java son muy listos, esa clase existe en Java. Se llama BufferedReader. El
mecanismo para obtener un BufferedReader a partir de otro Reader cualquiera (por ejemplo el
InputStreamReader), es similar al que usamos antes. Lo instanciamos pasándole en el constructor el
Reader.
La clase ArrayList en Java
Las aplicaciones frecuentemente necesitan almacenar un grupo de datos en un sólo objeto. Los arrays
sirven bien para este propósito, pero algunas veces necesitamos incrementar o reducir
dinámicamente el número de elementos del array, o hacer que contenga distintos tipos de datos
Esto es común entre las aplicaciones como las tiendas online. Un cliente añade una mercancía a su
carro de la compra, y detrás de la escena, los ítems son almacenados y eliminados automáticamente.
Para esta clase de grupos de datos crecientes y menguantes, podemos usar la clase Vector, o la
reciente clase ArrayList del paquete java.util . Un ArrayList contiene tantos objetos como
necesitemos.

4. El paquete iterator
Un Iterator o Iterador es un patrón de diseño que nos ofrece una interfaz estándar para recorrer una
estructura de datos sin que nos tengamos que preocupar por la representación interna de los datos
de dicha estructura.
Esta forma de recorrer estructuras de datos ofrece muchas ventajas entre las que podemos destacar
que nuestro código no depende de la estructura de datos.
Por lo tanto la “estructura” puede ser un árbol binario o una lista doblemente enlazada ya que el
iterador nos abstrae del modo de realizar el recorrido. De este modo podemos sustituir de manera
sencilla estructuras de datos en nuestro código sin que se nos presenten problemas desagradables.
DESARROLLO DEL PROYECTO
ESQUEMA:
PACKAGE CLASS
APLICACIONES ApliMenu
PACKAGE CLASS
ENTIDADES Teclado
CLASS
Producto
CLASS
CarroDin
CLASS
Escritura

5. Contenido de las clases.
Clase Teclado.
Paquetes y librerías utilizadas.
package entidades;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
Descripción.
En esta etapa a través de las utilidades del Bufferedreader nos aseguramos el ingreso de la
información por medio del teclado, definiendo el tipo de datos que queremos que se ingresa para el
tratamiento los datos.
Definiendo la variable de número entero se diseña una estructura de control que nos indique si están
bien ingresados los datos.
Luego a través de la definición de variable cadena y a través del uso del String leerCaden, vamos a
manejar una estructura de control que nos permita hacer que se lea y almacene los datos ingresados
Finalmente después de haberse leído y almacenado los datos los se diseñan las condiciones y
restricciones.
public class Teclado {
private static BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
public static int leerEntero()throws IOException{
do{
try{
int numero;
numero = Integer.parseInt(stdIn.readLine());
return numero;
}catch (NumberFormatException e){
System.out.println("Error de formato");
System.out.println("Vuelva a ingresar el valor");
}
}
while(true);
}
public static String leerCadena()throws IOException{
String cadena;
cadena = stdIn.readLine();
return cadena;
}
public static double leerDouble() throws IOException {
while (true) {
String s = stdIn.readLine ();
try {
return Double.valueOf(s.trim()).doubleValue();
}
catch (NumberFormatException e) {
System.out.println("Error en el numero, prueba de nuevo.");
}
}
}
}

6. Clase producto
Paquetes y librerías utilizadas.
package entidades;
Descripción.
A través de la definición de las variables código numero entero, nombre como cadena de caracteres y
precio como entero con decimales, se almacena los valores y se los pide de retorno para que al final
se los pueda imprimir haciendo uso de la función que nos ofrece el System.out.println.
Definiendo el formato que hemos escogido es decir código, nombre y precio. Con los valores que se
irán asignando conforme se vaya almacenando los datos.
public class Producto {
private int codigo;
private String nombre;
private double precio;
public Producto(int codigo, String nombre, double precio) {
this.codigo = codigo;//this indica que pertenece a la clase
this.nombre = nombre;
this.precio = precio;
}
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public double getPrecio() {
return precio;
}
public void setPrecio(double precio) {
this.precio = precio;
}
public void imprimir(){
System.out.println( "codigo:"+ codigo + " nombre:" + nombre + " precio:" + precio);
}
}

7. Clase CarroDIn.
Paquetes y librerías usadas.
package entidades;
import java.util.ArrayList;
import java.util.Iterator;
Descripción.
A través de la definición de la variable entera id e índice, y mediante el uso de un arraylist llamado
producto. Realizamos una estructura que nos permite añadir el producto al arraylist llamado
producto, diseñando la función addproducto siempre se irán ingresando los productos y para usarla
después únicamente se necesitara llamar a la función.
Diseñamos la función buscar haciendo uso de la estructura de control for y el condicional if para
buscarlo a través de un código asignado al producto y realizar la búsqueda sin dificultad.
Diseñamos la función imprimir estructura de control for y el condicional if para buscarlo a través de
un código asignado al producto y tener similar a la anterior función. Se realiza un diseño similar para
la función promedioPrecios que nos va a mostrar datos que se imprimirán en la factura.
Finalmente se diseña la función de borrar pala lo cual se hacer uso del paquete iterator y a través de
una estructura de control (for) y el condicional if se remueve el código de el lugar donde se estaba
almacenando.
public class CarroDin { public double promedioPrecios(){
private int id; double total = 0;
private int indice;
private ArrayList <Producto> productos; for (Producto t : productos ){
public CarroDin(int initialId){ total += t.getPrecio();
id = initialId; }
productos = new ArrayList<Producto>(); System.out.println("El promedio de Precios
} es:"+total/productos.size()) ;
public void addProducto(Producto p){ return total;
productos.add(p);
} }
public void buscar(int Codigo){ public void borrarProducto(int Codigo){
for(Producto temporal: productos){
if(temporal.getCodigo() == Codigo){ for(Iterator<Producto> i = productos.iterator();
temporal.imprimir(); i.hasNext();){
}
} if(i.next().getCodigo() == Codigo){
}
public void imprimir(){ i.remove();
for (Producto temporal: productos){ }
if(temporal.getCodigo() != 0){ }
temporal.imprimir(); }
}
}
System.out.println("TOTAL =" + promedioPrecios()*1.12); }
}

8. Clase ApliMenu
Paquetes y librerías utilizadas.
package aplicaciones;
import java.io.IOException;
import entidades.CarroDin;
import entidades.Producto;
import entidades.Teclado;
Descripción.
Es esta estancia del programa nos preocupamos por diseñar un menú de fácil acceso y el cual va a ser
el visualizado por el usuario y solo se realiza las condiciones del switch y diseñamos cada caso que se
ha generado y en cada caso se hará el respectivo llamado de funciones que ya diseñamos
anteriormente.
public class ApliMenu {
public static void main(String[] args) {
// TODO Auto-generated method stub
Teclado t1 = new Teclado();
CarroDin miCarro = new CarroDin(6);
for(;;) {
try{
System.out.println(" ");
System.out.println(" MENU ");
System.out.println("1. Añadir Producto");
System.out.println("2. Buscar Producto");
System.out.println("3. Borrar Producto");
System.out.println("4. Imprimir Factura");
System.out.println("5. Promedio de Precios");
System.out.println("6. Salir");
System.out.println(" ");
System.out.println(" Escoja una opcion ");
int f = t1.leerEntero();
if (1 <= f && f<=6){
switch(f){
case 1:
System.out.println("Añada el producto a su carro");
System.out.println("Ejemploncodigo:23nnombre:tarjeta de rednprecio:46");
Producto a = new Producto(t1.leerEntero(),t1.leerCadena(),t1.leerDouble());
miCarro.addProducto(a);
System.out.println("Producto ingresado");
a.imprimir();
break;
case 2:
System.out.println("ingrese el codigo para buscar un producto");
miCarro.buscar(t1.leerEntero());
break;

9. case 3:
System.out.println("Ingrese el codigo del producto que desea eliminar ");
miCarro.borrarProducto(t1.leerEntero());
break;
case 4:
miCarro.imprimir();
break;
case 5:
miCarro.promedioPrecios();
break;
case 6:
return;
}
}
else
System.out.println("Ingrese un numero entre 1 y 6");
}catch(IOException e){
System.out.println("Error");
}
}
}
Clase escritura
Guardado de archivos haciendo uso de un archivo.txt
Paquetes y librerías utilizadas.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
Descripción.
Esta clase nos permite almacenar los registros de las compras hechas por los clientes en un archivo
.txt de manera que tendremos un respaldo que nos ayudará en el caso de emitir una factura por
ejemplo. O como aplicación estadística para ver que producto es que más se ha vendido en un
periodo de tiempo.
public class Escritura {
public static void main(String[] args) {
try{ String lineaArchivo;
String fuenteArchivo="soccer";
BufferedReader fuenteSalida;
fuenteSalida = new BufferedReader(
new StringReader(fuenteArchivo));
// Se define un stream de salida (PrintWriter)

10. // que tomara los datos de memoria (BufferedWriter)
// y los escribira en un archivo (FileWriter)
PrintWriter archivoSalida;
archivoSalida = new PrintWriter(
new BufferedWriter(
new FileWriter("C:lima.txt")));
while ((lineaArchivo = fuenteSalida.readLine()) != null)
archivoSalida.println(1 + ": " + lineaArchivo);
// Se cierra el stream de salida
archivoSalida.close(); }
catch (IOException e) {
System.out.println("Excepcion Entrada/Salida");
}
}}
CONCLUSIONES
• La clase ArrayList nos permite almacenar diferentes tipos de datos en un solo objeto. También
nos permite incrementar o reducir dinámicamente el número de elementos del Array. Como
ejemplo práctico hemos implementado el Carrito de Compras, donde su aplicación es
notoriamente visible cuando se añade o borra productos lo que hace que el número de
elementos varíe continuamente.
• Este proyecto se podría implementar en una papelería, tienda o minimercado, para lo cual se
necesitaría la ayuda de una base de datos lo cual no lo hemos hecho en este proyecto ya que
su enfoque está en la programación orientada a objetos y mas no a una conexión de base de
datos con aplicaciones de este tipo.