UNIVERSIDAD_NACIONAL_ABIERTA_Y_A_DISTANC

Vista previa del material en texto

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 
2. ASPECTOS DE PROPIEDAD INTELECTUAL Y VERSIONAMIENTO 
3. INDICE DE CONTENIDO 
4. LISTADO DE TABLAS 
5. CARACTERÍSTICAS GENERALES 
6. DESCRIPCIÓN DE PRÁCTICAS 
 
PRACTICA No. 01 – Estructuras no dinámicas Utilizando Java Eclipse 
 
Ejercicios Propuestos por el tutor: 
 
Ejercicios a Realizar por el Estudiante: 
 
PRACTICA No. 02 – Estructuras dinámicas Utilizando Java Eclipse 
 
Ejercicios Propuestos por el tutor: 
 
Ejercicios a Realizar por el Estudiante: 
 
PRACTICA No. 03 – Base de Datos Modelo Relacional entidad Relación Access 
Utilizando Java Eclipse. 
 
Ejercicios Propuestos por el tutor: 
 
Ejercicios a Realizar por el Estudiante: 
 
PRACTICA No. 04 – Redes Encriptamiento y Desincriptamiento de un dato, Chat 
cliente Servidor, computacion Grafica Utilizando Java Eclipse 
 
Ejercicios Propuestos por el tutor: 
 
Ejercicios a Realizar por el Estudiante: 
 
7. Fuentes Documentales 
1 
2 
3 
4 
5 
8 
8 
11 
36 
37 
40 
73 
74 
 
76 
106 
109 
111 
119 
120 
 
 
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 aplicacionesque 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 
proyecto 
SI___ NO_X_ 
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 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 Autodirigida Remota X 
Otra ¿Cuál 
 
 
Porcentaje de evaluación 25 Puntos Plataforma Campus Virtual 
Horas de la practica 4 Horas Laboratorio ST y 12 Horas Independientes 
Temáticas de la práctica Estructuras no dinámicas con Java 
Utilizando Jcreator LE 
Intencionalidades 
formativas 
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 desarrollaruna 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 
Máximo 
Puntaje 
 
Estructura del 
Programa 
codificado en 
Java Eclipse 
 
Programas sin 
formato (0) 
Programas sin 
ejecutables (4) 
Programas 
ejecutables (8) 
8 
 
Redacción y 
Ortografía 
documentación 
del programa 
 
Programas No 
documentado 
(0) 
Programas 
Medio 
documentado 
(4) 
Programas Bien 
documentado 
(8) 
8 
Fines del 
programa 
 
Programa no 
cumple con lo 
sugerido (0) 
Programa 
regular con lo 
sugerido (4) 
Programa 
Cumple con lo 
sugerido (9) 
9 
TOTAL DE 
PUNTOS 
POSIBLES 
 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, “Diálogo de advertencia”, “Título del Mensaje”, 
JOptionPane.WARNING_MESSAGE); 
 
 
 
JOptionPane.showMessageDialog( null, “Diálogo de error”, “Título del Mensaje”, 
JOptionPane.ERROR_MESSAGE); 
 
 
 
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 COMPONENTEPRÁ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 INGENIERIAGUIA 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/ 
http://www.lawebdelprogramador.com/
http://www.programacion.com/
http://www.cimat.mx/~jlabreu/CursoJava/