universidad nacional abierta ya distancia

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUÍA COMPONENTE PRÁCTICO
301403 – PROGRAMACION ORIENTADA A OBJETOS
CESAR ORLANDO JIMENEZ ANGARITA
(Director Nacional)
Zona: Centro Bogotá Cundinamarca,
Cead: José Acevedo y Gómez
Enero 2013
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
2. ASPECTOS DE PROPIEDAD INTELECTUAL Y VERSIONAMIENTO
Curso Académico Modulo Programación Orientada a Objetos
Libros de la Biblioteca Virtual de Unad en Programación Orientada a Objetos
Consulta de Internet Programación Orientada a Objetos
Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS,
JSP tm Editorial Pearson Prentice Hall Quinta Edición.
David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión
2 de Java Editorial Addison Wesley.
Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma.
Agustin Froute Java 2 Manual Usuario tutorial 3 Edición Editorial Alfaomega Ra-Ma 5.
Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el
lenguaje de programación JAVA.
Arnow, D., Weiss, G., Introducción a la programación con JAVA, Addison wesley, 2000.
Larman, C., UML y patrones, Prentice Hall, 1998.
Meyer, B., Construcción de software orientado a objetos, Prentice Hall, segunda edición, 1997.
Wu, T., Introducción a la programación orientada a objetos con Java, Mc Graw Hill, 2000.
Joyanes, L., Programación orientada a objetos, Segunda edición, Mc Graw Hill, 1998.
Grez Voss, Introducción Orientada a Objetos, Editorial Mc Graw Hill, 1994.
Joyanes, L., C++ a su alcance un enfoque orientada a objetos, Editorial, Mc Graw Hill, 1994.
Cesar Becerra Santamaría, C++ Una Herramienta para la Programación Orientada a Objetos,
Editorial Mc Graw Hill, 1.993.
Fco Javier Ceballos, Programación Orientada a Objetos con C++,Editorial Alfaomega, 1.998.
Nathan Meyers, Programación JAVA en Linux, Editorial Prentice Hall, 2.000.
www.lawebdelprogramador.com
www.programacion.com
http://www.cimat.mx/~jlabreu/CursoJava/
http://www.mindview.net/Books/TIJ
http://java.sun.com/docs/books/tutorial/
http://programacion.com/java/tutoriales/
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
3. INDICE DE CONTENIDO
Pág.
1. PRESENTACION
1
2. ASPECTOS DE PROPIEDAD INTELECTUAL Y VERSIONAMIENTO
2
3. INDICE DE CONTENIDO
3
4. LISTADO DE TABLAS
4
5. CARACTERÍSTICAS GENERALES
5
6. DESCRIPCIÓN DE PRÁCTICAS
8
PRACTICA No. 01 – Estructuras no dinámicas Utilizando Java Eclipse
8
Ejercicios Propuestos por el tutor:
11
Ejercicios a Realizar por el Estudiante:
36
PRACTICA No. 02 – Estructuras dinámicas Utilizando Java Eclipse
37
Ejercicios Propuestos por el tutor:
40
Ejercicios a Realizar por el Estudiante:
73
PRACTICA No. 03 – Base de Datos Modelo Relacional entidad Relación Access
Utilizando Java Eclipse.
74
Ejercicios Propuestos por el tutor:
76
Ejercicios a Realizar por el Estudiante:
106
PRACTICA No. 04 – Redes Encriptamiento y Desincriptamiento de un dato, Chat
cliente Servidor, computacion Grafica Utilizando Java Eclipse
109
Ejercicios Propuestos por el tutor:
Ejercicios a Realizar por el Estudiante:
111
119
120
7. Fuentes Documentales
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
5. CARACTERÍSTICAS GENERALES
Introducción
Actualmente una de las áreas más importantes en la industria y el
ámbito académico es la orientación a objetos, el curso que a
continuación se relaciona tiene el nombre de Programación Orientada
a Objetos el cual es teórico – práctico, de 3 créditos y hace parte de la
formación profesional en el programa de Ingeniería de Sistemas.
El curso está compuesto por tres unidades académicas didácticas:
Unidad Uno comprende la introducción y elementos básicos de la
programación orientada a objetos (POO) y las propiedades básicas
de la POO aplicado con JAVA.
Unidad Dos hace referencia al diseño de la estructura y
comportamiento de un objeto y se inicia con los Fundamentos de la
programación en el lenguaje JAVA.
Unidad tres se enfocan en el trabajo con las clases, el manejo de la
herencia y la extensión de las clases aplicado con JAVA.
Justificación
El uso de y aplicaciones de herramientas enfocadas a la POO, hacen
que el profesional en Ingeniería sea capaz de diseñar y desarrollar
aplicaciones que permitan dar soluciones integrales a las
necesidades del medio que lo rodea utilizando un compilador de
JAVA.
El curso de POO le permite al estudiante desarrollar su creatividad
con el animo de dar soluciones a problemas cotidianos de su trabajo,
le da la capacitada de comparar la programación estructurada con la
programación orientada a objetos y enfrentar los retos del cambio, le
permite desarrollar su capacidad de comunicación, y su espíritu
Investigativo y crítico con una lenguaje de programación orientado a
objetos.
Para lograr la apropiación de todo el contenido temático el estudiante
aplicara en todo momento su autoformación y se apoyara en el tutor
para la resolución de dudas, también se tendrán uso de herramientas
tecnológicas para la interacción con los tutores y alumnos dentro de
los laboratorios.
Intencionalidades
formativas
Propósitos:
Dar a conocer a los estudiantes de una forma clara los conceptos
fundamentales de la Programación Orientada a Objetos en JAVA.
Dar a Conocer a los estudiantes las ventajas de aplicar la
Programación Orientada a Objetos ya que simplifica la construcción
de programas y lo motiva para estudiar las características del
lenguaje JAVA.
Capacitar a los estudiantes a comprender y utilizar herramientas de
Programación Orientadas a Objetos como JAVA, para el diseño de
aplicaciones.
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
Objetivos:
Que el estudiante Describa los conceptos que caracterizan al modelo
Programación Orientada a Objetos Utilizando JAVA.
Que el estudiante Valore en que medida las técnicas Programación
Orientada a Objetos favorecen la calidad del software, analizando
sobre todo cómo facilitan la reutilización y extensibilidad en JAVA.
Que el estudiante entienda la importancia de trabajar Herramientas
Programación Orientadas a Objetos, para el desarrollo de nuevas
aplicaciones empresariales en JAVA.
Que le estudiante Aprenda un lenguaje Programación Orientada a
Objetos, junto a su entorno de programación.
Que el estudiante aplique técnicas de programación Orientada a
Objetos en JAVA.
Que el estudiante identifique analice y diseñe ejemplos de aplicación
en JAVA
Metas:
Al terminar este curso de Programación Orientada a Objetos el
estudiante:
Desarrollara aplicaciones teniendo en cuenta los fundamentos
teóricos, y el manejo de objetos como principal elemento de
Construcción de soluciones en JAVA.
Tendrá la capacidad de analizar, diseñar y desarrollar software
utilizando el entorno de Programación Orientada a Objetos con JAVA.
Adquiera destrezas en el uso de las herramientas como el JAVA para
el desarrollo de aplicaciones que den soluciones confiables y
permitan mejorar procesos.
Competencias:
El estudiante comprende e interpreta todos los conceptos
fundamentales de la Programación Orientada a Objetos, para poder
analiza, diseñar, desarrollar e implantar aplicaciones más robustas y
con código reutilizable con JAVA.
El estudiante adquiere destrezas en el uso de procedimientos que le
permitan analizar, diseñar y desarrollar aplicaciones haciendo uso de
la programación Orientada a Objetos con JAVA.
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
El estudiante aprende un lenguaje Programación Orientada a Objetos,
junto a su entorno de programación JAVA.
Denominación de
practicas
Práctica 01: Estructuras no dinámicas Utilizando Java Eclipse
Practica 02: Estructuras dinámicas Utilizando Java Eclipse
Practica 03: Base de Datos Modelo Relacional entidad Relación
Access Utilizando Java Eclipse
Practica 04: Redes Encriptamiento y desincriptamiento de un dato,
Chat cliente Servidor Utilizando Java Eclipse
Practica 05: Computación Grafica 2D y 3D Utilizando Jcreator Java
Eclipse
Número de horas
4 Horas por laboratorio, 4 Cinco Laboratorios, un total 16 Horas
Porcentaje
25 Puntos de la plataforma Campus Virtual
Curso Evaluado por SI___
proyecto
Seguridad
industrial
NO_X_
No Ingresar Alimentos líquidos o sólidos al Laboratorio. Para
que se presente algún corto circuito.
No ingresar fumando al Laboratorio. Para que moleste a los
compañeros.
No ingresar otros aparatos electrónicos como radios, Walkman,
para que no interfieran en el desarrollo del laboratorio.
No Cambiar los computadores de sitio sin autorización del
monitor del laboratorio.
No reconfigurar los equipos de computo ya que este presta
servicio a toda la comunidad unadista.
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
6. DESCRIPCIÓN DE PRÁCTICAS
PRACTICA No. 01 – Estructuras no dinámicas con Java Utilizando Jcreator LE
Tipo de practica
Presencial
Otra ¿Cuál
Porcentaje de evaluación
Horas de la practica
Temáticas de la práctica
Intencionalidades
formativas
Autodirigida
Remota
X
25 Puntos Plataforma Campus Virtual
4 Horas Laboratorio ST y 12 Horas Independientes
Estructuras no dinámicas con Java
Utilizando Jcreator LE
Propósito(s):
Desarrollar destreza en los estudiantes de las estructuras no
dinámicas que permitan conceptuar los fundamentos básicos
en el desarrollo programas informáticos mediante la utilización
de un lenguaje de programación Java.
Comprender las técnicas básicas del diseño de Estructuras no
dinámicas en algoritmos y la lógica de programación en Java.
Adquirir destrezas y habilidades en la toma decisiones,
utilizando las estructuras no dinámicas y mediante la mediación
Tutorial, lecturas complementarias, trabajo individual y
cooperativo para el desarrollo de algoritmos en Java.
Codificar estructuras no dinámicas en un lenguaje de
programación diferentes supuestos semánticos y problemas
cotidianos en JAVA.
Meta(s):
El estudiante desarrolla el proyecto y los diferentes talleres en
forma adecuada, utilizando las diferentes técnicas y estrategias
estudiadas a lo largo del curso de Java.
El estudiante está en capacidad de desarrollar “software”,
partiendo de los diferentes supuestos planteados, y quedando
motivado para seguir en la línea de programación de
computadoras con lenguaje de programación JAVA.
El estudiante desarrolla habilidades que lo lleven por el camino
del pensamiento crítico, permitiéndoles aprender, comprender,
practicar y aplicar nueva información, que parte de experiencias
del medio ambiente, hasta llegar al auto concepto, formando un
individuo critico y pensador.
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
Competencia(s):
El estudiante describe y analiza de manera adecuada y
sistematizada las técnicas y pautas para la construcción y
secuencia de un algoritmo codificado en JAVA.
El estudiante diseña y aplica algoritmos y diagramas de flujo en
la construcción de programas, como técnica principal en la
resolución de un determinado problema en JAVA.
El estudiante mediante lecturas y mediaciones sobre técnicas
de construcción de software analiza, sistematiza y pone en
práctica las buenas practicas de desarrollo de algoritmos y de
programación en lenguaje JAVA.
Fundamentación Teórica:
Estructuras no dinámicas Conceptos, antecedentes y desarrollo de los algoritmos,
Estructuras no dinámicas General de un Algoritmo
Estructuras no dinámicas mediante un lenguaje de programación en JAVA.
Estructuras no dinámicas Arreglos mediante un lenguaje de programación en JAVA
Estructuras no dinámicas Vectores mediante un lenguaje de programación en JAVA
Estructuras no dinámicas Métodos de búsqueda mediante un lenguaje de programación en JAVA
Estructuras no dinámicas Métodos de Ordenamiento mediante un lenguaje de programación en JAVA
Estructuras no dinámicas y Archivos mediante un lenguaje de programación en JAVA
Descripción de la practica:
El estudiante debe instalar una maquina virtual y Java Eclipse en su casa, este software
debe ser bajado a través de internet de la página Sum Macrosystem
El estudiante debe bajar la Guía de Laboratorio para la práctica de la Plataforma campus
Virtual del curso Académico de Programación Orientada a Objetos.
El estudiante mediante la herramienta de copiar y pegar debe practicar los diferentes
ejercicios propuestos en esta guía para que vaya adquiriendo destreza en el lenguaje de
programación Java.
El estudiante debe de estar en capacidad de investigar los diferentes códigos de java ya
que todos los ejercicios que propone la guía de laboratorio están propuestos java.swing.*,
o ambiente grafico y el estudiante debe tener las condiciones de pasarlo en java.io.*, o
ambiente en código de línea todos los propuestos en estas.
Recursos a utilizar en la práctica (Equipos / instrumentos)
Computadores Modernos con buena Configuración y con software licenciado
Software a utilizar en la práctica u otro tipo de requerimiento para el desarrollo de la
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
práctica:
Instalación de la maquina virtual e Instancian del Java Eclipse
Seguridad Industrial:
No Ingresar Alimentos líquidos o sólidos al Laboratorio. Para que se presente algún corto circuito
No ingresar fumando al Laboratorio. Para que moleste a los compañeros
No ingresar otros aparatos electrónicos como radios, Walkman, para que no interfieran en el
desarrollo del laboratorio.
No Cambiar los computadores de sitio sin autorización del monitor del laboratorio.
No desconfigurar los los equipos de computo ya que este presta servicio a toda la comunidad
unadista.
Metodología
Conocimiento previo para el desarrollo de la práctica. El estudiante de ver el Curso Académico de
Programación Orientada a Objetos tiene que tener buenas bases de Algoritmos, Introducción a
Programación, Estructura de Datos, Bases de Datos, Redes de Comunicación,
Forma de trabajo: El estudiante analizara primero todo los programas propuestos por el tutor de
laboratorio los cuales están analizados, diseñados y desarrollados completamente listos para que
su código sea copiado y pegado en JAVA y luego ser ejecutados, luego el estudiante de haber
analizado el código se enfrentara a la tarea de desarrollar una serie de programas por sí solo.
Procedimiento: El Estudiante debe investigar como puede hacer estos mismos programas
utilizando las librerías import java.io.* y applet
Sistema de Evaluación
El sistema de evaluación estará a cargo de los tutores de Laboratorio ya que ellos son
autónomos de calificar bien sea en grupos o de forma individual el trabajo realizado en los
laboratorios
Informe o productos a entregar
Los estudiantes debe entregar los ejercicios propuestos en la guía de laboratorio en
java.io.*; y applet
Rúbrica de evaluación
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA "UNAD"
ESCUELA CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
PROGRAMA INGENIERIA DE SISTEMAS
Practica 01 Estructuras no dinámicas Utilizando Java Eclipse
Rúbrica de Evaluación:
Ítem
Evaluado
Valoración
Baja
Valoración
Media
Valoración
Alta
Estructura del
Programas sin
formato (0)
Programas sin
ejecutables (4)
Programas
ejecutables (8)
8
Programas No
documentado
(0)
Programas
Medio
documentado
(4)
Programas Bien
documentado
(8)
8
Programa no
cumple con lo
sugerido (0)
Programa
regular con lo
sugerido (4)
Programa
Cumple con lo
sugerido (9)
9
Programa
codificado en
Java Eclipse
Redacción y
Ortografía
documentación
del programa
Fines del
programa
TOTAL DE
PUNTOS
POSIBLES
Máximo
Puntaje
25
Nota: Estudiante que no se presente al componente practico en las fechas propuestas
por los diferentes Cead o Ceres y que no desarrollen las guías propuestas para estos
laboratorios, tendrá una nota total de CERO: (0)
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
Retroalimentación
La retroalimentación de los diferentes productos entregados en el laboratorio serán
evaluados por el tutor Plataforma Campus Virtual.
Ejercicios Propuestos por el tutor:
Guía de Laboratorio Estructuras no dinámicas utilizando el lenguaje de programación Java
trabajos con java.swing.*; o ambiente grafico :
Desarrollo del primer taller
Después de tener instado el Aplicativo Java Eclupse, usted debe seguir los siguientes pasos para
el desarrollo de cualquier programa en java:
1. Abra el Aplicativo Java Eclipse
(Inicio > Todos Los Programas > JCREATOR LE > JCREATOR LE)
2. Es Necesario crear el archivo java:
Menú File > New > File
a. En la casilla de texto Name: coloque el nombre del programa con extensión java), en este caso
LecturaVector.
b. En la Casilla de Texto Location: C:\ o utilice el botón … y seleccione C: (Carpeta Raíz).
c. Pulse el Botón Finish.
3. En la Ventana de Código escriba:
import javax.swing.*;
public class LecturaVector
{
public static void main(String[] args)
{
int n,i,j,aux;
int A[];
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: "));
A=new int[n];
for(i=0;i<A.length;i++)
{
A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: "));
}
System.out.println("Vector Leido");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
System.exit(0);
}
}
4. Compile y Ejecute el Programa
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
Menú Build > Compile File
Menú Build > Execute File
1. CAJAS DE DIALOGO
El método showMessageDialog
Este método nos permite mostrar diálogos que muestran un mensaje y contienen un botón de
aceptación. Los parámetro mínimos necesarios dependen del carácter del mensaje aunque general
mente son la ventana padre, el mensaje a mostrar, el título del diálogo y el tipo de mensaje que se
mostrará. En las siguientes figuras podremos ver algunos ejemplos junto al código que lo genera.
JOptionPane.showMessageDialog( null, “Diálogo de información”);
JOptionPane.showMessageDialog( null,
JOptionPane.WARNING_MESSAGE);
JOptionPane.showMessageDialog(
JOptionPane.ERROR_MESSAGE);
null,
“Diálogo
“Diálogo
de
advertencia”,
de
error”,
“Título
“Título
del
del
Mensaje”,
Mensaje”,
El método showInputDialog
Este método nos permite mostrar diálogos estandarizados que nos piden que introduzcamos algún
dato. Al igual que en los métodos anteriores los argumentos que utilizan principalmente son el
mensaje a mostrar, el título, etc. A continuación vemos un ejemplo de uso de este método.
String n = JOptionPane.showInputDialog(null, "Introduce el dato");
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
Como podemos observar en el código anterior este método nos devuelve una cadena que contiene
los datos que hemos introducido en el diálogo.
donde las cajas de Dialogo están en el paquete de clases javax.swing, por eso, en la cláusula
import javax.swing.*;
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
2. Definiciones de Arreglos
1. Declaración de un arreglo:
int A[]; // A es un arreglo de enteros
int A[10]; // error, el tamaño no va aquí
int[] A; // A es un arreglo de enteros
int A,B[]; // A es un entero, B un arreglo
int[] A,B; // A y B son arreglos
String S[]; // S es un arreglo de strings
S[1]="" // error, el arreglo no ha sido
// creado
2.
Creación de un arreglo
int A[]= new int[10]; // 10 enteros
Subindicación de un arreglo:
A[0], A[1], ..., A[9] // correcto
A[10]
// error, índice fuera
// de rango
3.
Modificación de un arreglo:
A[3]= 8;
4.
Tamaño de un arreglo:
A.length // correcto
A.length() // error, sin paréntesis
5.
Inicialización de un arreglo:
for (int i=0; i<A.length; i++)
A[i]= i;
6.
Asignación de punteros a arreglos
int B[];
B= A;
// A y B son el mismo arreglo
if (A==B) // Comparación de punteros
// true!
...
A[0]= 10;
B[0]
// también 10
7. Copia de un arreglo:
B= (int[])A.clone();
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
3. LECTURA DE UN VECTOR POR TECLADO
import javax.swing.*;
public class LecturaVector
{
public static void main(String[] args)
{
int n,i,j,aux;
int A[];
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: "));
A=new int[n];
for(i=0;i<A.length;i++)
{
A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: "));
}
System.out.println("Vector Leido");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
System.exit(0);
}
}
4. ASIGNACION A UN VECTOR DE NUMEROS ALEATORIOS
import javax.swing.*;
import java.util.*;
public class LectorVectorAleatoria
{
public static void main(String[] args)
{
int n,i,j,aux;
int A[];
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: "));
A=new int[n];
Random R=new Random(); //Objeto que genera el aleatorio
for(i=0;i<A.length;i++)
{
A[i]=Math.abs(R.nextInt()%100+1); // R,nextInt()%100+1)::Aleatorio Entero desde 1 hasta los
siguientes 100
}
System.out.println("Vector Leido");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
5. ORDENAMIENTO DE UN VECTOR. METODO LINEAL
import javax.swing.*;
public class OrdenarLineal
{
public static void main(String[] args)
{
int n,i,j,aux;
int A[];
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: "));
A=new int[n];
for(i=0;i<A.length;i++)
{
A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: "));
}
System.out.println("Vector Leido");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
for(i=0;i<A.length-1;i++)
for(j=i+1;j<A.length;j++)
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
System.out.println("Vector Ordenado");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
6. ORDENAMIENTO DE UN VECTOR. METODO BURBUJA
import javax.swing.*;
public class OrdenarBurbuja
{
public static void main(String[] args)
{
int n,i,j,aux;
int A[];
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: "));
A=new int[n];
for(i=0;i<A.length;i++)
{
A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: "));
}
System.out.println("Vector Leido");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
for(i=1;i<=A.length-1;i++)
for(j=0;j<A.length-i;j++)
if(A[j]>A[j+1])
{
aux=A[j];
A[j]=A[j+1];
A[j+1]=aux;
}
System.out.println("Vector Ordenado");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
7. BUSQUEDA DE UN ELEMENTO EN UN VECTOR ORDENADO. METODO
SECUENCIAL
import javax.swing.*;
public class BuscarLinealOrdenado
{
public static void main(String[] args)
{
int n,i,j,aux;
int A[];
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: "));
A=new int[n];
for(i=0;i<A.length;i++)
{
A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: "));
}
System.out.println("Vector Leido");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
for(i=0;i<A.length-1;i++)
for(j=i+1;j<A.length;j++)
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
System.out.println("Vector Ordenado");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
j=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite el Numero a Buscar: "));
i=0;
while(i<A.length && A[i]<j)
i++;
if(i<A.length && A[i]==j)
System.out.println("Existe: "+j+" en la Posicion: "+i);
else
System.out.println("No Existe ");
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
8. BUSQUEDA DE UN ELEMENTO EN UN VECTOR ORDENADO. METODO
BINARIA
import javax.swing.*;
public class BuscarBinaria
{
public static void main(String[] args)
{
int n,i,j,aux,mitad,menor,mayor;
int A[];
n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: "));
A=new int[n];
for(i=0;i<A.length;i++)
{
A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: "));
}
System.out.println("Vector Leido");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
for(i=0;i<A.length-1;i++)
for(j=i+1;j<A.length;j++)
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
System.out.println("Vector Ordenado");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
j=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite el Numero a Buscar: "));
menor=0;
mayor=A.length-1;
do
{
mitad=(menor+mayor)/2;
if(A[mitad]>j)
mayor=mitad-1;
if(A[mitad]<j)
menor=mitad+1;
}
while(A[mitad]!=j && mayor>=menor);
if(A[mitad]==j)
System.out.println("Existe: "+j+" en la Posicion: "+mitad);
else
System.out.println("No Existe ");
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
9. IMPLEMENTACION DE CLASES QUE ADMINISTRAN ARREGLOS
9.1. Programa 1. Creación de una clase Arreglo
import javax.swing.*;
import java.util.*;
class Arreglo
{
int A[]=new int[100];
int aux;
int i,j,n;
public Arreglo(int B[]) //Constructor
{
if(B.length<=100)
n=B.length;
else
n=100;
for(i=0;i<n;i++)
A[i]=B[i];
}
boolean verificarasc() // Verifica Ordenamiento ascendente
{
for(i=0;i<n-1 && A[i]<=A[i+1];i++);
if(i<n-1)
return false;
else
return true;
}
boolean verificardesc() // Verifica Ordenamiento Descendente
{
for(i=0;i<n-1 && A[i]>=A[i+1];i++);
if(i<n-1)
return false;
else
return true;
}
boolean buscarasc(int x) // Busqueda Ascendente
{
for(i=0;i<n && A[i]<x;i++);
if(i<n && A[i]==x)
return true;
else
return false;
}
boolean buscardesc(int x) // Busqueda Descendente
{
for(i=0;i<n && A[i]>x;i++);
if(i<n && A[i]==x)
return true;
else
return false;
}
boolean busqueda(int x) // Busqueda Normal
{
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
for(i=0;i<n && A[i]!=x;i++);
if(i<n)
return true;
else
return false;
}
void consulta() // Recorrer el contenido de vector
{
StringBuffer S=new StringBuffer();
for(i=0;i<n;i++)
{
S.append(A[i]);
S.append('\n');
}
JOptionPane.showMessageDialog(null,S.toString());
}
void lectura() // Leer el Vector
{
for(i=0;i<n;i++)
{
A[i]=Integer.parseInt(JOptionPane.showInputDialog(null," Vector Posicion ["+i+"]"));
}
}
void ordenarasc() // Ordenar Ascendente
{
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
}
void ordenardesc()// Ordenar Descendente
{
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(A[i]<A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
}
}
public class Arreglos
{
public static void main(String args[])
{
int i,opcion,x;
int B[]=new int[10];
Random R=new Random();
for(i=0;i<B.length;i++)
B[i]=Math.abs(R.nextInt()%100+1);
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
String S=new String();
Arreglo Z=new Arreglo(B);
String Menu="1. Lectura \n 2. Ordenar Ascendente \n 3. Ordenar Descendente \n 4. Busqueda \n 5.
Consulta \n6. Salir \n Seleccion Opcion[1..6]";
do
{
do
{
S=JOptionPane.showInputDialog(null,Menu);
try
{
opcion=Integer.parseInt(S);
}
catch(NumberFormatException e)
{
opcion=0; // Error de Conversion
}
}while(opcion<1 || opcion>6);
if(opcion!=6)
{
switch(opcion)
{
case 1:Z.lectura();
break;
case 2:Z.ordenarasc();
break;
case 3:Z.ordenardesc();
break;
case 4:
x=Integer.parseInt(JOptionPane.showInputDialog(null," Numero a Buscar "));
if(!Z.buscarasc(x) && !Z.buscardesc(x) && !Z.busqueda(x))
JOptionPane.showMessageDialog(null,x+" No existe");
else
JOptionPane.showMessageDialog(null,x+" Existe");
break;
case 5: Z.consulta();
}
}
}while(opcion!=6);
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
9.2.. Programa 2. Uso de un Objeto StringBuffer para la presentación de un
vector.
import java.util.*;
import javax.swing.*;
class CasoVector1
{
StringBuffer P=new StringBuffer();
int i,j,aux;
int A[]=new int[10];
Random R=new Random();
public CasoVector1()
{
P.append("Vector de Entrada: ");
for(i=0;i<A.length;i++)
{
P.append(" ");
A[i]=Math.abs(R.nextInt()%99+1);
P.append(A[i]);
}
ordenar();
adicionOrdenado();
}
void ordenar()
{
for(i=0;i<A.length-1;i++)
for(j=i+1;j<A.length;j++)
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
}
String impresion()
{
return P.toString();
}
void adicionOrdenado()
{
P.append(" Vector Ordenado: ");
for(i=0;i<A.length;i++)
{
P.append(" ");
P.append(A[i]);
}
}
}
class CasoVector2
{
StringBuffer P=new StringBuffer("Vector de Entrada: Vector de Salida: ");
StringBuffer Q;
int i,j,aux;
int A[]=new int[10];
Random R=new Random();
public CasoVector2()
{
for(i=0;i<A.length;i++)
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
A[i]=Math.abs(R.nextInt()%99+1);
j=new String(P.toString()).indexOf(':');
insertar(j);
ordenar();
j=new String(P.toString()).lastIndexOf(':');
insertar(j);
}
void insertar(int k)
{
Q=new StringBuffer();
for(i=0;i<A.length;i++)
{
Q.append(" ");
Q.append(A[i]);
}
P.insert(k+1,Q.toString());
}
void ordenar()
{
for(i=0;i<A.length-1;i++)
for(j=i+1;j<A.length;j++)
if(A[i]>A[j])
{
aux=A[i];
A[i]=A[j];
A[j]=aux;
}
}
String impresion()
{
return P.toString();
}
}
public class VectorCasos
{
public static void main(String[] args)
{
CasoVector1 X=new CasoVector1();
CasoVector2 Y=new CasoVector2();
JOptionPane.showMessageDialog(null," Caso Vector 1: \n"+X.impresion().toString());
JOptionPane.showMessageDialog(null," Caso Vector 2: \n"+Y.impresion().toString());
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
9.3. Programa 3. Invertir un Arreglo
import javax.swing.*;
class Inverso
{
int i,j,k;
void pasar(char C[],String S)
{
j=-1;
for(i=S.length()-1;i>=0;i--)
{
j++;
C[j]=S.charAt(i);
}
}
String pasar(String S)
{
char C[]=new char[S.length()];
j=-1;
for(i=S.length()-1;i>=0;i--)
{
j++;
C[j]=S.charAt(i);
}
return new String().valueOf(C).toString();
}
/*
String pasar(String S)
{
StringBuffer B=new StringBuffer();
for(i=S.length()-1;i>=0;i--)
B.append(S.charAt(i));
return B.toString();
}*/
void pasar(int C[],int n)
{
j=-1;
while(n>0)
{
j++;
C[j]=n%10;
n/=10;
}
}
int pasar(int n)
{
int m=n;
k=0;
while(m>0)
{
if(k==0)
k=1;
else
k*=10;
m/=10;
}
m=0;
while(n>0)
{
m=m+((n%10)*k);
n/=10;
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
k/=10;
}
return m;
}
}
public class PasoInverso
{
public static void main(String[] args)
{
Inverso I=new Inverso();
String S;
int n;
do
{
n=0;
S=JOptionPane.showInputDialog(null," Digite Valor a Invertir: ");
try
{
n=Integer.parseInt(S);
}
catch(NumberFormatException e){n=0;}
}
while(n==0);
char C[]=new char[S.length()];
int A[]=new int[S.length()];
StringBuffer B=new StringBuffer();
int i;
I.pasar(C,S);
I.pasar(A,n);
JOptionPane.showMessageDialog(null," Valor Inverso de String a char[]: "+new String().valueOf(C).toString());
for(i=0;i<A.length;i++)
B.append(A[i]);
JOptionPane.showMessageDialog(null," Valor Inverso de un Entero a int[]: "+B.toString());
JOptionPane.showMessageDialog(null," Valor Inverso de String a String "+new String().valueOf(I.pasar(S)).toString());
JOptionPane.showMessageDialog(null," Valor Inverso de String a int "+B.toString());
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
10. PROGRAMACION AVANZADA. USO DE MATRICES
10.1. Programa Lectura y Escritura de Matrices
import java.util.*;
import javax.swing.*;
class LecturaEscrituraMatriz
{
public static void main(String[] args)
{
int filas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las Filas: "));
int columnas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las columnas: "));
int i,j;
Random R=new Random();
int A[][]=new int[filas][columnas];
//Lectura()
for(i=0;i<filas;i++)
for(j=0;j<columnas;j++)
A[i][j]=Math.abs(R.nextInt()%99+1);
//Escritura
System.out.println(" ------ Matriz Leida -------");
for(i=0;i<filas;i++)
{
System.out.println();
for(j=0;j<columnas;j++)
{
if(A[i][j]>=10)
System.out.print(A[i][j]+" ");
else
System.out.print(A[i][j]+" ");
}
}
System.out.println();
System.exit(0);
}
}
10.2. Programa Lectura y Escritura de Matrices
import java.util.*;
import javax.swing.*;
class SumaDiagTran
{
public static void main(String[] args)
{
int filas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las Filas: "));
int columnas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las columnas: "));
int i,j,k;
int d=0,t=columnas-1;
int sumad=0,sumat=0;
Random R=new Random();
int A[][]=new int[filas][columnas];
//Lectura()
for(i=0;i<filas;i++)
for(j=0;j<columnas;j++)
A[i][j]=Math.abs(R.nextInt()%10+1);
for(i=0;i<filas;i++)
{
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
sumad=sumad+A[i][d];
sumat=sumat+A[i][t];
d++;
t--;
}
//Escritura
System.out.println(" ------ Matriz Leida -------");
for(i=0;i<filas;i++)
{
System.out.println();
for(j=0;j<columnas;j++)
{
if(A[i][j]>=10)
System.out.print(A[i][j]+" ");
else
System.out.print(A[i][j]+" ");
}
}
System.out.println();
System.out.println("Suma de Diagonal: "+sumad+" Suma Transversal: "+sumat);
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
10.2. Programa Suma de Diagonales y Transversales
import java.util.*;
import javax.swing.*;
class SumaDiagTran
{
public static void main(String[] args)
{
int n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Dimension: "));
int i,j,k;
int d=0,t=n-1;
int sumad=0,sumat=0;
Random R=new Random();
int A[][]=new int[n][n];
//Lectura()
for(i=0;i<n;i++)
for(j=0;j<n;j++)
A[i][j]=Math.abs(R.nextInt()%10+1);
for(i=0;i<n;i++)
{
sumad=sumad+A[i][d];
sumat=sumat+A[i][t];
d++;
t--;
}
//Escritura
System.out.println(" ------ Matriz Leida -------");
for(i=0;i<n;i++)
{
System.out.println();
for(j=0;j<n;j++)
{
if(A[i][j]>=10)
System.out.print(A[i][j]+" ");
else
System.out.print(A[i][j]+" ");
}
}
System.out.println();
System.out.println("Suma de Diagonal: "+sumad+" Suma Transversal: "+sumat);
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
10.3. Programa de Diagonal
import java.util.*;
import javax.swing.*;
class Diagonal
{
public static void main(String[] args)
{
int n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Dimension: "));
int i,j,k;
int d=0,t=n-1;
int A[][]=new int[n][n];
//Lectura()
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(i==j)
A[i][j]=1;
else
A[i][j]=0;
//Escritura
System.out.println(" ------ Diagonal -----");
for(i=0;i<n;i++)
{
System.out.println();
for(j=0;j<n;j++)
System.out.print(A[i][j]+" ");
}
System.out.println();
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
10.4. Programa de Copas
import javax.swing.*;
class Copas
{
public static void main(String[] args)
{
int n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Dimension: "));
int i,j,k;
int d=0,t=n-1;
Random R=new Random();
int A[][]=new int[n][n];
//Lectura()
for(i=0;i<n;i++)
for(j=0;j<n;j++)
A[i][j]=0;
for(i=0;i<n;i++)
{
for(j=d;j<=t;j++)
A[i][j]=1;
for(j=t;j<=d;j++)
A[i][j]=1;
d++;
t--;
}
//Escritura
System.out.println(" ------ Copas-----");
for(i=0;i<n;i++)
{
System.out.println();
for(j=0;j<n;j++)
{
if(A[i][j]==0)
System.out.print(" ");
else
System.out.print("*");
}
}
System.out.println();
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
10.5. Programa Simulación de un Inventario
import java.util.*;
import javax.swing.*;
class Inventario
{
int i,j,k;
final int n=10;
int A[][]=new int[n][4]; //Simulador de un Kardex
Random R=new Random();
public Inventario()
{
for(k=0;k<n;k++)
{
do
{
j=Math.abs(R.nextInt()%999+1);
}
while(existe(j)!=-1);
A[k][0]=j; // Referencia del Articulo
A[k][1]=Math.abs(R.nextInt()%999+1); // Cantidad de Articulos
A[k][2]=0; // Entrada de Productos
A[k][3]=0; // Salida de Productos
}
}
int existe(int x)
{
boolean esta=false;
i=0;
while(i<n && !esta)
{
if(A[i][0]==x)
esta=true;
else
i++;
}
if(esta)
return i;
else
return -1;
}
void venta(int cant,int pos)
{
if(A[pos][1]>=cant)
{
A[pos][1]=A[pos][1]-cant;
A[pos][3]=A[pos][3]+cant;
}
else
JOptionPane.showMessageDialog(null,"No se puede realizar la venta...no hay existencia");
}
void compra(int cant,int pos)
{
A[pos][1]=A[pos][1]+cant;
A[pos][2]=A[pos][2]+cant;
}
String impresion()
{
StringBuffer P=new StringBuffer();
P.append(" CODIGO SALDO ENTRADA SALIDA");
for(i=0;i<n;i++)
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
{
P.append("\n ");
for(j=0;j<4;j++)
{
P.append(A[i][j]);
if(A[i][j]<10)
P.append(" ");
if(A[i][j]<100)
P.append(" ");
P.append("
");
}
}
return P.toString();
}
}
public class Kardex
{
public static void main(String[] args)
{
Inventario X=new Inventario();
Object[] Opcion={"1. Compra","2. Venta","3. Consulta","4.Cierre"};
int opc,pos;
String S;
do
{
S=(String) JOptionPane.showInputDialog(null,"Opciones: "," Almacen
Doris",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[2]);
opc=Character.digit(S.charAt(0),10);
switch(opc)
{
case 1:
pos=X.existe(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo ")));
if(pos==-1)
JOptionPane.showMessageDialog(null,"No existe Codigo");
else
X.compra(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Cantidad a Comprar ")),pos);
break;
case 2:
pos=X.existe(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo ")));
if(pos==-1)
JOptionPane.showMessageDialog(null,"No existe Codigo");
else
X.venta(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Cantidad a Venta ")),pos);
break;
case 3:
JOptionPane.showMessageDialog(null,"
Inventario \n"+X.impresion().toString());
}
}while(opc!=4);
System.exit(0);
}
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
10.6. Programa Simulación de un Parqueadero
import javax.swing.*;
import java.util.*;
class Parqueo
{
int n=10,i,j,k;
int h,m,ha,hf;
int Militar[][]=new int[10][10]; // Hora Militar de Entrada de Vehiculo
int Entrada[][]=new int[10][10]; // Hora de Entrada Vehiculo AM/PM
int Placa[][]=new int[10][10]; // Placa del Vehiculo
int hora=5,minuto=59;
Random R=new Random();
boolean lleno()
{
k=0;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(Entrada[i][j]!=0)
k++;
if(k==n*n)
return true;
else
return false;
}
void reloj()
{
int hi=hora+2;
ha=(hora*60)+minuto;
do
{
do
{
h=Math.abs(R.nextInt()%21+hora);
}
while(h<hora || h>hora+2);
m=Math.abs(R.nextInt()%59+0);
hf=(h*60)+m;
}
while(hf<=ha);
hora=h;
minuto=m;
}
boolean noatiende()
{
if(hora>=20)
return true;
else
return false;
}
void asignar(int placa)
{
do
{
i=m=Math.abs(R.nextInt()%(n-1)+0);
j=m=Math.abs(R.nextInt()%(n-1)+0);
}
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
while(Entrada[i][j]!=0);
reloj();
Militar[i][j]=(hora*100)+minuto;
Entrada[i][j]=(hora*60)+minuto;
Placa[i][j]=placa;
}
boolean existe(int placa)
{
boolean esta=false;
i=0;
while(i<n && !esta)
{
j=0;
while(j<n && !esta)
if(Placa[i][j]==placa)
esta=true;
else
j++;
if(!esta)
i++;
}
return esta;
}
String leerReloj(int hm)
{
String H=new String(new String().valueOf(hm/100));
String M=new String(new String().valueOf(hm%100));
String P=new String(":");
return new String(H.concat(P.concat(M))).toString();
}
int salida(int placa)
{
if(existe(placa))
{
reloj();
hf=(hora*60)+minuto;
ha=
(hora*100)+minuto;
k=(hf-Entrada[i][j])*10;
JOptionPane.showMessageDialog(null,"Placa: "+placa+"\n Hora de Entrada: "+leerReloj(Militar[i][j]).toString()+" \n Hora de
Salida: "+leerReloj(ha).toString()+" \n Pago:"+k);
Entrada[i][j]=0;
Placa[i][j]=0;
Militar[i][j]=0;
}
else
{
JOptionPane.showMessageDialog(null,"No existe la placa:"+placa);
k=0;
}
return k;
}
String impresion()
{
StringBuffer P=new StringBuffer();
P.append(" PLACA ENTRADA");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(Placa[i][j]!=0)
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
{
P.append("\n ");
P.append(Placa[i][j]);
P.append("
");
P.append(Militar[i][j]);
}
return P.toString();
}
}
public class Parqueadero
{
public static void main(String[] args)
{
Object[] Opcion={"1. Entrada","2. Salida","3. Consulta","4. Cierre"};
int opc,placa;
String S;
Parqueo P=new Parqueo();
do
{
S=(String) JOptionPane.showInputDialog(null,"Opciones: "," Parqueadero
Doris",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[0]);
opc=Character.digit(S.charAt(0),10);
switch(opc)
{
case 1:
if(!P.noatiende() && !P.lleno())
{
placa=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Placa: "," Parqueadero
Doris",JOptionPane.QUESTION_MESSAGE));
if(P.existe(placa))
JOptionPane.showMessageDialog(null,"Placa: "+placa+" Ya Esta en el Parqueadero");
else
P.asignar(placa);
}
break;
case 2:
if(!P.noatiende())
{
placa=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Placa: "," Parqueadero
Doris",JOptionPane.QUESTION_MESSAGE));
P.salida(placa);
}
break;
case 3:
JOptionPane.showMessageDialog(null,"
Parqueadero Doris \n"+P.impresion().toString());
}
}
while(opc!=4);
System.exit(0);
}
}
Ejercicios a Realizar por el Estudiante:
El estudiante después de adquirir destreza y conocimiento acerca de lenguaje de
programación JAVA debe realizar todos los programas propuesto por el tutor y debe
pasarlos con código comando utilizando java.io.* y applet ; ya que los expuestos
anteriormente viene desarrollados en java.swing.*; o ambiente grafico.
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA
GUIA COMPONENTE PRÁCTICO DEL CURSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS
7. FUENTES DOCUMENTALES
Curso Académico Modulo Programación Orientada a Objetos
Libros de la Biblioteca Virtual de Unad en Programación Orientada a Objetos
Consulta de Internet Programación Orientada a Objetos
Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS,
JSP tm Editorial Pearson Prentice Hall Quinta Edición.
David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión
2 de Java Editorial Addison Wesley.
Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma.
Agustin Froute Java 2 Manual Usuario tutorial 3 Edición Editorial Alfaomega Ra-Ma 5.
Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el
lenguaje de programación JAVA.
Arnow, D., Weiss, G., Introducción a la programación con JAVA, Addison wesley, 2000.
Larman, C., UML y patrones, Prentice Hall, 1998.
Meyer, B., Construcción de software orientado a objetos, Prentice Hall, segunda edición, 1997.
Wu, T., Introducción a la programación orientada a objetos con Java, Mc Graw Hill, 2000.
Joyanes, L., Programación orientada a objetos, Segunda edición, Mc Graw Hill, 1998.
Grez Voss, Introducción Orientada a Objetos, Editorial Mc Graw Hill, 1994.
Joyanes, L., C++ a su alcance un enfoque orientada a objetos, Editorial, Mc Graw Hill, 1994.
Cesar Becerra Santamaría, C++ Una Herramienta para la Programación Orientada a Objetos,
Editorial Mc Graw Hill, 1.993.
Fco Javier Ceballos, Programación Orientada a Objetos con C++,Editorial Alfaomega, 1.998.
Nathan Meyers, Programación JAVA en Linux, Editorial Prentice Hall, 2.000.
www.lawebdelprogramador.com
www.programacion.com
http://www.cimat.mx/~jlabreu/CursoJava/
http://www.mindview.net/Books/TIJ
http://java.sun.com/docs/books/tutorial/
http://programacion.com/java/tutoriales/