Beruflich Dokumente
Kultur Dokumente
ANALISIS DE REQUISITOS
Presentado a:
FRANKLIN LIZCANO CELIS
Tutor
INTRODUCCIÓN ......................................................................................................................................................3
OBJETIVOS ...............................................................................................................................................................4
PROYECTO A TRABJAR ........................................................................................................................................5
REQUISITOS FUNCIONALES: ...............................................................................................................................7
REQUISITOS NO FUNCIONALES .........................................................................................................................8
RESPUESTAS A LAS 16 PREGUNTAS..................................................................................................................9
CONCLUSIONES ....................................................................................................................................................28
REFERENCIAS BIBLIOGRÁFICAS .....................................................................................................................29
INTRODUCCIÓN
El diseño de programas es una actividad compleja que exige al planificador recoger informaciones
diversas y tomar decisiones a lo largo de un proceso, para satisfacer la necesidad del cliente final. Con
esta actividad se pretende avanzar frente a la programación, con el desarrollar habilidades para manejo
de programa como java, MSQL.
OBJETIVOS
OBJETIVO GENERAL:
Diseñar la primera etapa del proyecto planteado realizando el análisis de los requisitos que se aplicaran
para este. Proyectos que involucra el desarrollo de unos programas.
OBJETIVOS ESPECIFICOS:
Modelar y elaborar el prototipo de una herramienta computacional como elemento de ayuda
dentro del proceso de análisis de requerimientos para proyectos.
Identificar un proceso que facilite la recolección de datos que se manejen dentro del proceso de
análisis de requerimientos.
Utilizar este proceso de recolección como base de la información que se maneja dentro de la
herramienta computacional.
PROYECTO B
El Mini mercado Surtimax S.A es una empresa unifamiliar la cual es atendida por José Andrés Cárdenas
y Gloria Martínez, quienes son los Propietarios del Mini Mercado. Actualmente el Mini mercado solo
cuenta con cinco clientes (Véase figura 1) y solo ofrece algunos productos a la venta (Véase figura 2).
De igual manera se debe tener en cuenta otros roles de usuario (Véase figura 3).
Para lograr un buen funcionamiento del negocio se requiere el desarrollo de una aplicación que realice
los siguientes procesos:
Registro de Productos: El módulo debe permitir el ingreso de nuevos productos permitiendo registrar
su nombre, tipo de producto y unidad de medida.
Registro de Clientes: En este módulo debe permitir registrar el nombre, la edad, la dirección y el
teléfono celular de cada cliente.
Actualización Información de Productos: En este módulo se debe permitir actualizar la información
del producto ya registrado o la modificación de los datos relacionados con ésta.
Venta de productos: En este módulo debe permitir realizar el proceso de venta de productos,
registrando el producto y los datos básicos del cliente.
Consulta de Productos: En este módulo debe permitir consultar información relacionada con los
productos, teniendo como criterios de consulta como: El nombre del producto, el tipo de producto y
Unidad de Medida.
Finalmente, al ejecutar la aplicación, esta debe solicitar un password y Login para garantizar la
seguridad de la aplicación y el acceso solo a personal autorizado. Se debe tener en cuenta que no se
permite en el password los siguientes caracteres: #,!,¡,?,^,¿,|,° por lo que es obligatorio hacer uso de los
bloques de excepciones en Java para evitar estos caracteres.
Para el desarrollo de este proyecto se debe utilizar el paradigma orientado a objetos (clases, herencia,
polimorfismo, encapsulamiento, etc), así mismo se debe utilizar la base de datos MYSQL como base de
datos predeterminada. El código de la aplicación debe ser comentado en su totalidad.
Al finalizar el proyecto en la Fase 5 uno de los integrantes del grupo debe comprimir en una carpeta el
archivo ejecutable, y éste será el mismo que ejecutará el docente al momento de la calificación.
REQUISITOS FUNCIONALES:
REQUERIMIENTOS FUNCIONALES
Nº de
Nombre Observación
Requerimiento
Para llevar a cabo el registro del
producto se debe, tomar el
Registro de código de barras el cual será
1
productos leído por un lector de códigos e
ir añadiendo nuevos productos.
todo Cliente debe de ser creado
por un administrador del
sistema, el sistema le pedirá
Registro de
2 numero de cedula, nombre ,
Clientes
apellido , dirección y teléfono
los campos deben ser
coherentes con el tipo de dato
REQUERIMIENTOS NO FUNCIONALES
Nº de
Requerimiento Nombre Observación
debe permitir el registro
1 PROCESAMIENTO de productos en
segundos
el acceso al sistemas
debe ser cambiado solo
2 SEGURIDAD por el administrador del
sistema de acceso a
datos
Se refiere al esfuerzo
que tendrá el usuario
para aprender, usar,
3 USABILIDAD
ingresar datos e
interpretar los
resultados.
Demostrar en su
ejecución el menor
4 EFICIENCIA
tiempo de respuesta a
peticiones del usuario.
Destreza del software
5 DISPONIBILIDAD para brindar un servicio
correcto y estable.
Velar por la estabilidad
6 INTEGRIDAD evitando alteraciones
inadecuadas del sistema.
Pasó a paso operativo
que describe cómo ha de
7 OPERACIONAL ser usado el software
dentro del contexto de la
organización.
Debe cumplir con todas
las especificaciones
requeridas por las leyes
REGULTORIO, que le acogen, así
8 ÉTICO Y también debe aplicar
LEGISLATIVO cada ley regulatoria, sin
dejar de un lado el ser un
sistema libre de procesos
no legales.
RESPUESTAS A LAS 16 PREGUNTAS
Java es un lenguaje tipado y nos obliga a declarar nuestras variables antes de poder hacer uso de
ellas, con esta declaración le indicamos al compilador el espacio en memoria que debe de
reservar para almacenar la información. Por ejemplo:
Aquí estamos reservando memoria para una variable de tipo String y la identificamos con el
nombre “cliente”. De ahora en adelante si en el programa hablamos de cliente, estamos haciendo
referencia a esa porción de memoria y al valor que contiene.
Podemos asignarle algún valor en el momento de declarar una variable. Por ejemplo:
Aquí reservamos memoria para una cadena de caracteres y le asignamos el valor "Isaac Newton".
También podemos declararla y en otro lugar del programa fijarle un valor:
La sentencia para declarar una variable se resume como:
Definimos una variable de tipo String con el nombre "saludo". En la declaración de la variable
también la iniciamos con el valor "¡Hola mundo!". Luego llamamos al método que imprimirá el
texto en la pantalla haciendo referencia a la variable. En el programa original, explícitamente
introducíamos el texto que se mostraría, ahora solo escribimos el nombre de la variable. Cuando
el intérprete se encuentre con el nombre de esta variable, tendrá que buscar el valor que almacene
en la memoria para mostrarlo por pantalla.
Un variable puede cambiar su valor en el transcurso del programa (salvo que se preceda su
definición con la palabra: final
Siempre debemos inicializar una variable. Al compilar el programa, el compilador de Java leerá
el contenido de la variable y siempre verificará que tenga un valor. De lo contrario el programa
no compilará y mostrará un error. Un ejemplo de este caso:
En este caso el compilador mostrará un mensaje de error indicando que la variable x no se ha
iniciado con ningún valor. Como se puede observar esta variable solo se inicia cuando se cumple
una condición, sin embargo se indica que va a ser utilizada siempre. El compilador detecta este
posible error. Un ejemplo de solución posible sería:
Agregando estas líneas al final del código de la clase Uso Variables nos mostraría lo siguiente a
la salida:
El nombre debe ser único en el contexto del programa. Además debe seguir las siguientes reglas:
No puede ser una palabra reservada del lenguaje o un literal booleano (true o false)
Puede contener cualquier carácter Unicode, pero no puede comenzar con un número
No debe contener los símbolos que se utilicen como operadores ( +, - , ?, etc).
Existen dos categorías de variables: las de tipo primitivo y las referenciadas. Una variable de tipo
primitivo accede al valor asignado directamente. Las referenciadas acceden a través de un
puntero.
Es decir, no almacenan un valor sino una dirección de memoria. Estas últimas son utilizadas por
las matrices, las clases y las interfaces.
Por convención, los nombres de variables comienzan con una letra en minúscula. Si un nombre
consiste en más de una palabra, se escribirá sin espacios entre ellas y cada palabra (salvo la
primera) comenzará con una letra mayúscula (por ejemplo: estaBienEsteNombre
Cada variable debe tener un tipo de dato predefinido. Esto determina el rango de valores que
puede almacenar y qué operaciones se pueden realizar así como el resultado que te dará. Por
ejemplo, una variable de tipo entero puede almacenar números sin decimales y puede realizar
operaciones aritméticas, pero no puede contener palabras.
4. Sintaxis para imprimir en consola en Java:
Para imprimir por pantalla se hace uso del objeto System.out, que representa la salida estándar.
Típicamente este objeto se corresponde con la pantalla u otra salida especificada en las variables
de entorno del sistema en el que se ejecuta. El objeto System.out es del tipo java.io.PrintStream
y, por ello, dispone de métodos para escribir con formato en el flujo de salida, usualmente el
monitor.
Los más interesantes son: print, método sobrecargado que puede recoger cualquier tipo de datos
básico, cadena u objeto. println, idéntico a print salvo en que imprime un salto de línea final; o
format, que permite escribir los datos ajustándose a un determinado formato, de modo similar a
cómo lo hace el printf de C.
Así, la sentencia para imprimir por pantalla y dar dos salto de línea, el salto de línea propio del
Método y el indicado por '\n', es:
También podemos concatenar objetos de tipo String antes y luego imprimirlos, por ejemplo:
Cuando un objeto se concatena con una cadena o se imprime por pantalla, para su representación
se hace una llamada implícita a la implementación que haga de su método toString
Los dos tipos de comentarios anteriores son utilizados como guía dentro del código fuente, esto
es, a partir de ellos no son generados ningún tipo de documentación, cualquier palabra entre /* y
*/ es considerada comentario, al igual que todo renglón que inicie con //.
Para que un comentario sea contemplado en la generación de documentación se utiliza la
siguiente sintaxis
Todo elemento colocado entre los elementos /** */ será contemplado en la generación de
documentación, dependiendo de la ubicación de este comentario será generada la
documentación, esto es, si aparece antes de un elemento class es considerado documentación
para la Clase y así sucesivamente.
== Es igual
!= Es distinto
<, <=, >, >= Menor, menor o igual, mayor, mayor o igual
|| Operador or (o)
Clase:
Las clases en Java (Java Class) son plantillas para la creación de objetos, en lo que se conoce
como programación orientada a objetos, la cual es una de los principales paradigmas de
desarrollo de software en la actualidad.
Instancia de Clases:
Una clase es la estructura de un objeto, es decir, la definición de todos los elementos que
componen un objeto. Un objeto es, por lo tanto, el "resultado" de una clase. En realidad, un
objeto es una instancia de una clase, por lo que se pueden intercambiar los
Términos objeto o instancia (o incluso evento).
Una clase se compone de dos partes: atributos y métodos. Los atributos (denominados, por lo
general, datos miembros) se refieren al estado del objeto. Los métodos (denominados, por lo
general, funciones miembros) son funciones que pueden aplicarse a objetos.
Si tenemos una clase llamada auto, los objetos Peugeot y Renault serán instancias de esa clase.
También puede haber otros objetos Peugeot 406, diferenciados por su número de modelo.
Asimismo, dos instancias de una clase pueden tener los mismos atributos, pero considerarse
objetos distintos independientes. En un contexto real: dos camisas pueden ser idénticas, pero no
obstante, también ser diferentes de alguna manera. Sin embargo, si las mezclamos es imposible
distinguir una de la otra.
Atributo
Donde nombreVariable es el nombre que daremos a la variable, siendo un nombre válido según
las normas del lenguaje:
Por convención, en Java, los nombres de las variables empiezan con una letra minúscula
(Los nombres de las clases empiezan con una letra mayúscula).
Un nombre de variable Java: debe ser un identificador legal de Java comprendido en una serie de
caracteres Unicode. Unicode es un sistema de codificación que soporta texto escrito en distintos
lenguajes humanos. Unicode permite la codificación de 34.168 caracteres. Esto le permite
utilizar en sus programas Java varios alfabetos como el japonés, el griego, el ruso o el hebreo.
Esto es importante para que los programadores pueden escribir código en su lenguaje nativo.
No deben tener el mismo nombre que otras variables cuyas declaraciones aparezcan en el mismo
ámbito.
Tipo es el tipo de la variable, pudiendo ser un tipo básico o un objeto de una clase o de un
interfaz. También puede ser una matriz o vector.
Comportamiento
Del mismo modo que hay variables de instancia y de clase, también hay métodos de instancia y
de clase. En el primer caso, un objeto llama a un método para realizar una determinada tarea, en
el segundo, el método se llama desde la propia clase.
8. Tipos de clase
Clases en Java 4.1
Clase.
Las clases son la base de la Programación Orientada a Objetos. Una clase es una plantilla que
define la forma de un objeto; en ella se agrupan datos y métodos que operarán sobre esos datos.
En java, una clase se define con la palabra reservada class. Por convención, se declaran primero
las variables (atributos) miembro de la clase y luego las declaraciones e implementaciones de
métodos. Al diseñar una clase es conveniente tomar en cuenta lo siguiente:
En Java no existen variables ni métodos globales. Todas las variables y métodos deben
pertenecer a una clase.
Cuando una clase extiende a otra hereda todos sus atributos y métodos.
En Java no existe la herencia múltiple.
Object es la base de toda la jerarquía de clases de Java. Si al definir una clase no se especifica la
clase que extiende, por default deriva de Object. 4.1.1 Modificadores de Acceso a la clase Los
modificadores de acceso a clase son opcionales, se anteponen a la palabra reservada class, estos
son public, abstract y final.
public: la clase puede ser utilizada por objetos que estén fuera del paquete actual. Por omisión,
una clase sólo puede ser utilizada por otras clases dentro del mismo paquete en el que están
declaradas. abstract: Se usa para indicar que una clase es abstracta, esto significa que la clase
puede contener métodos sin implementación (abstractos). Una clase abstracta está diseñada para
ser una superclase y no pueden crear objetos de ella.
final: cuando una clase tiene el modificador final es una clase que no puede tener subclases.
Modificador de Acceso Class Nombre de Clase Declaración de variables miembros de la clase
[modificador] tipo campo1; [modificador] tipo campo2; … [modificador] tipo campoN;
Constructor(es) de la clase Métodos de la clase tipo método1( parámetros); tipo método2(
parámetros); … tipo métodoN( parámetros); ; Introducción a la Programación en Java Ing. Alma
Leticia Palacios Guerrero Pág. 25 4.1.2 Modificadores de Acceso campos de clase El uso de
clases permite proteger sus variables y métodos del acceso de otros objetos. Java proporciona
cuatro niveles de acceso para las variables y métodos miembros: private, protected, public y
acceso de paquete. Niveles de acceso permitidos por cada especificador: private protected public
package clase subclase paquete exterior private: Es el nivel de acceso más restringido. Los
miembros privados están disponibles sólo para la clase en las que está definidos. protected:
Permite que la misma clase, subclases y todas las clases dentro del mismo paquete tengan acceso
a los miembros protected. public: Todas las clases tienen acceso a los miembros públicos de la
clase. Los miembros públicos se emplean solamente cuando el acceso a ellos produce resultados
indeseables. package: Este nivel es el que se establece si no se indica un nivel de acceso a los
miembros. El acceso de paquete permite que las clases dentro del mismo paquete que la clase
tengan acceso a los miembros. Static: El campo static será el mismo para todas las instancias de
la clase. Final: El campo debe ser inicializado y no se puede modificar. 4.1.3
Modificadores de Acceso a Métodos de la Clase abstract: Es un método que no tiene cuerpo y
pertenece a una clase abstracta. Final: El método no se puede sobrescribir. Native: Su cuerpo está
implementando en otro lenguaje de programación public: El método está disponible para todas
las clases. Protected: Esta disponible solo para la clase donde fue definido y sus subclases.
Private: El método está disponible sólo para la clase a la que pertenece. static: Se puede accesar
sin necesidad de hacer una instancia de la clase a la cual pertenece. Synchronized: Es un método
monitoreado para evitar interferencias entre hilos
Que manipulan un mismo objeto. Este método debe detenerse antes de ser ejecutado por un hilo.
Interfaces
Una interface declara un conjunto de métodos y constantes sin especificar la implementación de
ningún método; es decir los métodos no tienen código. Estos pueden ser implementados a través
de una clase implementa una interface. Cuando una clase implementa una interface debe
proporcionar la implementación para todos los métodos de la interface. Para indicar que una
clase implementa una o más interfaces, se emplea la palabra implements seguida por una lista de
las interfaces implementados por la clase separadas por comas.
Packages Un paquete es una agrupación de clases. El programador puede crear sus propios
paquetes agregando una línea con la palabra package y el nombre del paquete al inicio de un
programa java. Un ejemplo seria la siguiente línea: package mis.paquetes; Los nombres de los
paquetes suelen escribirse con minúsculas, para diferenciarlos de las clases; el nombre de un
paquete puede estar formado por varias palabras separadas por puntos, por ejemplo
java.awt.event. Todas las clases que forman parte de un paquete deben estar en el mismo
directorio. Para utilizar un paquete dentro de un programa se debe de importar. Al importarlo no
se cargan todas las clases que contiene el paquete, sólo se cargan las clases public que se vayan a
utilizar. Al importar un paquete no se importan los subpaquetes. Para importarlos se debe hacer
explícitamente ya que en realidad son paquetes diferentes. Existen dos formas de utilizar import:
para una clase y para todo un package: import mis.paquetes.Teclado; // Importa solo la clase
Teclado import mis.paquetes.*; // Importa todas las clases contenidas en mis.paquetes
Objeto: Es un elemento declarado de un tipo de clase. Se conoce también como una instancia de
clase. La sintaxis para definir un objeto es nombreDeClase nombreObjeto; nombreDeClase
otroObjeto; Ejemplos: Transporte auto; 4.4.1 Instancias de Clase Una clase es una abstracción
lógica, mientras no se cree un objeto de esa clase no existe una representación de esa clase en la
memoria, cuando esto se declara y define un objeto de una clase, se dice que se realizó una
instancia. En Java crear un objeto implica tres acciones: declaración, asignación de memoria e
inicialización. 1) Declaración: La declaración de un objeto es simplemente una variable que
puede hacer referencia a un objeto. La declaración de un
Objeto tiene la forma: NombreClase nombreObjeto; donde NombreClase es la clase a la que el
objeto va a pertenecer y nombreObjeto es el nombre que va a tener el objeto. Ejemplo:
Transporte auto; Asignación de Memoria (Instanciación): El operador new asigna memoria
dinámica, esto es asignada en tiempo de ejecución, para un nuevo objeto y regresa una referencia
al objeto. 3) Inicialización. La inicialización de un objeto se lleva a cabo a través de un método
que lleva el mismo nombre que la clase el constructor. El constructor es invocado
automáticamente cada vez que se crea un objeto de una clase. Transporte auto=new Transporte().
Constructores La función primordial del constructor es reservar memoria e inicializar las
variables miembro de la clase. Los constructores no regresan valor, su parámetro implícito es el
objeto que se está creando. Una clase puede tener varios constructores, cada uno con diferentes
tipos y número de argumentos. Cuando una clase no tiene implementado un constructor entonces
utiliza el constructor de la clase Object. El constructor de una subclase puede llamar al
constructor de su superclase por medio de la palabra reservada super, seguida de los argumentos
entre paréntesis.
Una de las herramientas más efectivas para atacar este problema es la modularización. Esta
consiste en particionar un sistema de acuerdo con ciertos principios de diseño y a una estrategia
de desarrollo, gobernando las dependencias entre las partes resultantes.
Sin embargo, implementar una modularización adecuada no es algo trivial; las técnicas
disponibles son diversas y no existe consenso sobre cuáles son las mejores en cada caso.
Adicionalmente, la modularización en sí misma introduce nuevos retos, entre los que se cuentan
la dificultad de configuración y el denominado “infierno de dependencias”.
Las clases nuevas pueden heredar de las clases en las bibliotecas de clases. Las organizaciones
desarrollan sus propias bibliotecas de clases y pueden aprovechar las que ya están disponibles en
todo el mundo. Es probable que algún día, la mayoría de software nuevo se construya a partir de
componentes reutilizables estandarizados, como sucede actualmente con la mayoría de los
automóviles y del hardware de computadora. Esto facilitará el desarrollo de software más
poderoso, abundante y económico (Deitel).
Las superclases deben ser más generales y las subclases más específicas. Por ejemplo, un
PrestamoAuto es un Préstamo, así́ como PrestamoMejoraCasa y PréstamoHipotecario. Por ende,
en Java se puede decir que la clase PrestamoAuto hereda de la clase Préstamo. En este contexto,
dicha clase es una superclase y la clase PrestamoAuto es una subclase. Un PrestamoAuto es un
tipo específico de Préstamo, pero es incorrecto afirmar que todo Préstamo es un PrestamoAuto;
el Préstamo podría ser cualquier tipo de superclase y subclases.
Método Constructor
Es el único método que no se puede heredar. El constructor de cada subclase debe llamar en
forma implícita o explícita al constructor de la superclase para inicializar las variables de
instancia heredadas. Para ello se utiliza la sintaxis de llamada al constructor de la superclase: la
palabra clave súper, seguida de un conjunto de paréntesis que contiene los argumentos del
constructor de la superclase.
Si el constructor de la subclase no invocara al constructor de la superclase en forma explícita,
Java trataría de invocar al constructor predeterminado o sin argumentos de la superclase. En los
casos que la subclase no tenga un constructor así, el ́ compilador generaría un error.
Cualquier objeto java que pueda pasar más de un test "ES-UN" es considerado polimórfico. En
Java, todos los objetos son polimórficos ya que cualquier objeto pasaría un test "ES-UN" dado
que son de su propio tipo, además del de la clase Object.
Es importante saber que la única manera de acceder a un objeto es a través de una variable de
referencia. La variable de referencia sólo puede ser de un tipo. Una vez declarado el tipo de la
variable de referencia, no se puede cambiar.
La clase forma define los métodos dibujar y borrar. En la definición de estos métodos se
implementará el código común a todos los objetos de la clase. Sin embargo cuando definamos las
clases hijas, círculo y cuadrado, será necesario modificar estos métodos para adaptarlos a las
nuevas subclases. El método de la clase padre implementa aquellas acciones comunes. Las clases
hijas añaden las operaciones particulares que necesiten. Cuando utilicemos los métodos de la
clase forma no tendremos que hacer distinción entre cuadrados y círculos. Gracias al
polimorfismo se ejecutará el método adecuado en función de la subclase a la que pertenezca el
objeto.
En la declaración de una clase estamos definiendo el conjunto de métodos y campos que son
accesibles desde fuera de una clase o lo que a menudo se denomina contrato de la clase. Este
contrato determina cual va a ser la funcionalidad de la clase. Pero cuando extendemos una clase
para crear otra estamos ampliando este contrato añadiendo más funcionalidades. Por tanto
cuando creamos esa nueva clase hacemos uso de dos mecanismos. Por un lado la herencia para
reutilizar las partes comunes de la super-clase. Y por otro el polimorfismo, es decir el cambio en
la forma en la que se implementa el contrato de la superclase. Como vemos al escribir una
subclase podemos sobrescribir el contrato añadiendo nuevas funcionalidades, pero no cambiarlo.
A la hora de implementar el polimorfismo tendremos dos mecanismos de los que echar mano
para sobrescribir una clase: reemplazar la implementación de un método o añadir
funcionalidades a un método.
Es por ello que el encapsulamiento consiste en permitir la visibilidad de atributos y/o métodos,
en una clase determinada, teniendo así tres niveles de: privados (private) que se utilizaran solo en
esa clase, protegidos (protected) que se utilizaran por todas los métodos, clases y /o atributos
mientras se encuentre en el mismo package, y los públicos (public) que pueden ser usados por
cualquier clase o método.
¿Qué problemas podemos tener? pues que la cadena no sólo contenga números sino que venga
con espacios.
Si los espacios vienen al principio o al final, con un simple trim bastará para eliminarlos, por
ejemplo ("1")
numCadena.trim();
Si tenemos espacio entre los números deberíamos usar el método replaceAll (" 1 3 45 6")
Una vez realizados estos sencillos pasos podremos trabajar con los números enteros.
}
public class Vehiculo{
Vehiculo(string c) {
Color = c;
15. Qué función tiene el paquete Swing en Java y describa sus principales características.
Swing es una biblioteca gráfica para Java. Incluye widgets para interfaz gráfica de usuario tales como
cajas de texto, botones, listas desplegables y tablas.
AWT (Abstract Window Tolkit) Incluye las siguientes características:
1. Componentes gráficos nativos.
2. Un modelo de gestión de eventos.
3. Herramientas de gráficos e imágenes: fuentes, colores, etc.
4. Algoritmos de distribución de componentes. Estos algoritmos permiten construir la interfaz
delegando la colocación de los diferentes componentes a un algoritmo de distribución. Los
algoritmos de distribución permiten a las aplicaciones con interfaz gráfica de usuario responder
adecuadamente ante diferentes resoluciones de pantalla, cambios en el tamaño de la ventana, etc.
5. Clases para soportar cortar, copiar o arrastrar y soltar, e integración con el portapapeles nativo de
la plataforma.
Swing es un modelo de componentes para construir interfaces gráficas de usuario. Os componentes
Swing están completamente programados en java, y por tanto no utilizan los componentes nativos.
Swing está basado en el sistema de eventos de AWT, por lo que en ocasiones la documentación de
swing hace referencia a AWT. AWT también proporciona a swing el soporte para copiar-pegar y
arrastrar-soltar.
El modelo de componentes swing a veces es referido como JFC/Swing. JFC son las siglas de
Java Foundation Classes y es un supe conjunto de Swing (aunque se refieran juntos). En concreto
JFC incluye:
El modelo de componentes swing.
Apariencia gráfica de la interfaz de usuario configurable. En JFC se proporciona un sistema
de gestión de la extensible. Las aplicaciones pueden utilizar una apariencia independiente de
la plataforma o bien pueden utilizar la apariencia del sistema de ventanas sobre el que corren.
Accesibilidad. Permite la utilización, por ejemplo, de dispositivos braille para mostrar
información de la interfaz de usuario.
Java 2D API. Permite incorporar en las aplicaciones gráficos 2D, imágenes y texto, así como
enviar documentos de alta calidad a la impresora.
Internacionalización. Permite crear aplicaciones multilenguaje que pueden ser configuradas
para mostrar la interfaz de usuario utilizando el lenguaje de la zona en la que reside el
usuario.
Es preferible tener declaradas todas las posibles excepciones que se puedan generar en dicho método,
para lo que se utilizara la sentencia throws de la declaración de métodos.
Para poder lanzar una excepción es necesario crear un objeto de tipo Exception o alguna de sus
subclases como ArithmeticException y lanzarlo mediante la instrucción throw cmo se muestra en este
ejemplo:
class LanzaExcepcion {
public static void main(String argumentos[]) throws ArithmeticException {
int i=1, j=2;
if (i/j< 1)
throw new ArithmeticException();
else
System.out.println(i/j);
}
}
CONCLUSIONES
Se concluye que el análisis de requisitos aplicado de manera secuencial permite detectar posibles
fallos o errores de no fácil percepción. (Isaias Zuleta)
Es determinante que el lenguaje de programación JAVA es robusto y con capacidad de brindar la
mejor solución al problema planteado para el proyecto B. (Isaias Zuleta)
REFERENCIAS BIBLIOGRÁFICAS
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Imprimir_en_Pantalla
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Variables#Tipo_de_variable
https://javabasico.osmosislatina.com/curso/progbasico2/comentarios.htm
https://jarroba.com/herencia-en-la-programacion-orientada-a-objetos-ejemplo-en-java/
www.ciberaula.com/articulo/polimorfismo
http://www.edu4java.com/es/progbasica/progbasica17.html
https://sites.google.com/site/conceptosdejava/home/encapsulamiento-en-java
https://jarroba.com/excepciones-exception-en-java-con-ejemplos/
https://es.wikipedia.org/wiki/Swing_(biblioteca_gráfica)
Flórez, Fernández, Héctor Arturo. Programación orientada a objetos usando java, Ecoe Ediciones, 2012.
ProQuest Ebook Central, http://ebookcentral.proquest.com/lib/unadsp/detail.action?docID=3203026.