Академический Документы
Профессиональный Документы
Культура Документы
Grupo: 301403_30
O también:
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.
class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(int x1, int y1, int w, int h){
x=x1;
y=y1;
ancho=w;
alto=h;
}
}
class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(int w, int h){
x=0;
y=0;
ancho=w;
alto=h;
}
}
Por ejemplo al ver una declaración de métodos en una clase abstracta solo
podemos observar algunas líneas que solamente tienen los datos que van a
recibir los métodos, pero el código que ejecutara el método no está, eso
quiere.
Decir que podría estar en otro sitio. Se puede decir que es una base para la
herencia.
Clase Final: Una clase final es la que acaba con una cadena de herencia. De
la clase final no se puede heredar nada. Al decir que termina la cadena de
herencia significa que ya no se sub-divide en más clases, pues indica que es
el final de las divisiones.
Las organizaciones de clases en java suelen ser de la siguiente forma:
class A{}
class B extends A { }
Con lo que se indica que de la clase A sale una sub-clase o clase hija que es
B. Pero se puede modificar este tipo de organizaciones al usar “final”.
Sería de la siguiente forma:
final class A { }
Con lo que se está indicando que de la clase A no van a salir otras clases. Es
posible mezclar final con public, es decir, se puede tener algo como esto:
public final class A{ }
Uno puede declarar su clase como “final” por algunos motivos.
Motivo de seguridad.
Motivo de eficiencia.
está declarada como “final”, por lo tanto no permite crear una sub-clase
String y darle un método length() que yo haya creado y que haga algo
diferente a devolverme la longitud de una cadena. El otro motivo para usar
“final” es la eficiencia. Se trabaja solo con instancias de la clase sin tener que
ir a las sub-clases, así puedes optimizar esa clase.
Ilustración 1 Modularización
https://www.fing.edu.uy/inco/cursos/fpr/wiki/index.php/Archivo:Modularizacion.png
Cuando una tarea debe realizarse más de una vez en un mismo programa, la
modularización evita la programación redundante, ya que una vez definida la
tarea como un módulo independiente, puede ser invocada desde cualquier
parte del código; se aprecia también una menor longitud del programa.
Otra ventaja de importancia es la claridad que resulta de la descomposición
de un programa en módulos concisos e independientes, representando cada
uno de estos una parte bien definida del problema en su conjunto, permitiendo
escribir y depurar el código más fácil. Su estructura lógica es más clara, lo cual
es sumamente útil si el programa es largo y complicado.
Superclases y Subclases
En esta estructura jerárquica, cada clase tiene solo una clase padre, la clase
padre de cualquier clase es conocida como su superclase, la clase hija de
una superclase es llamada una subclase.
Clase A
-----------------------------
Id: integer
Nombre: String
Apellidos String
Edad: integer
Viajar(): void
Concentrarse(): void
Entrenamiento(): void
Partido(): void
Clase B Clase D Clase C
----------------------------- -------------------------------------------- -------------------------------
dorsal: integer Id federacion: integer titulacion: String
demarcacion: String aniosExperiencia: integer
planificarEntrenamiento(): void
entrevista(): void --------------------------------
darMasaje(): void
Clase E
---------------------------------
Id: integer
pasarInstrumentos: String
auxiliar(): void
Dónde: A es la superclase de B, C y D.
C es la superclase de E.
B, C y D son subclases de A.
E es una subclase de C.
Analizando este código vemos que cuenta con variables enteras públicas, tipo
y clase que pueden ser accedidas desde una instancia de la clase MiClase,
esto está bien, pero que pasa si asignamos un valor no previsto para la
variable, donde no hay nada que nos lo impida, donde se requiere una
solución que nos permita validar el contenido de la variable que se le va a
asignar y escondiendo la variable impidiendo el acceso de forma directa,
siendo este el principio básico del encapsulamiento; para ello
realizaríamos lo siguiente;
- Una forma seria usar un modificador de acceso.
- Hacer métodos de acceso públicos obligando el acceso a las variables por
medio de estos métodos.
- Usar convenciones de código para los nombres de los métodos, set y get.
R:
Específicamente para int, puedes usar los siguientes métodos
de la clase Integer
Ejemplo :
R:
01 package ciclos;
02
03 /**
04 *
05 * @author xymind
06 */
07 public class Main {
08
09 /**
10 * @param args the command line arguments
11 */
12 public static void main(String[] args) {
13
14 iniciarCiclo();//aqui estamos ejecutando el metodo escrito en
15 //la parte de abajo, se puede utilizar mas de 1 vez
16 }
17
18 /*Comienza el metodo
19 Este metodo no regresa valores, es un metodo que unicamente
realiza un procedimiento, por lo que se declara como "void" seguido
20
del
21 nombre que tendra el metodo*/
22 public void iniciarCiclo(){
23
24 int x=0;
25 while(x!=7)
26 {
27 System.out.println("X vale: "+x);
28 x++;
29
30 }
31 }
32
33 }
2.15 Qué función tiene el paquete Swing en Java y describa sus principales
características.
R:
Contenedores
Como vimos en entradas anteriores, un contenedor es el tapiz donde
pintaremos nuestros componentes gráficos, existen contenedores principales,
entre estos se encuentran JFrame y JDialog pero también existen otros
contendedores incluidos dentro de los mencionados...
JFrame: Es la Ventana de aplicación, el contenedor principal
JDialog: Una ventana de tipo Ventana de diálogo, también puede ser un
contenedor principal.
JPanel: Permite la creación de paneles independientes donde se almacenan
otros componentes.
JScrollPane: permite la vinculación de barras de desplazamiento en un
contenedor.
JSplitPane: permite la creación de un contenedor dividido en 2 secciones.
JTabbedPane: Permite la creación de pestañas, cada pestaña representa un
contenedor independiente.
JDesktopPane : Permite crear ventanas dentro de una ventana principal
JToolBar : Permite introducir una Barra de herramientas
Componentes Atómicos
Los componentes atómicos son los elementos que no pueden almacenar otros
objetos o componentes gráficos, por ejemplo, un JPanel no es Atómico, ya que
en el podemos almacenar JButtons, JTextField entre otros...
JLabel – Permite Vincular Etiquetas, tanto de texto como de imágenes
JButton – Permite vincular Botones simples.
JCheckBox – Son Casilla de verificación, ideal para selección múltiples.
JRadioButton – Permite presentar opciones de selección similares a las
checkbox, solo que el enfoque de estas es de única selección.
JToggleButton – Botón que al oprimirlo se quedará presionado hasta que se
ejecute otro evento.
JComboBox – Permite mostrar una lista de elementos como un combo de
selección.
JScrollBar – Permite mostrar una barra de desplazamiento, regularmente
usada en Áreas de texto o paneles donde el contenido es mayor que el tamaño
del componente.
JSeparator – Permite separar opciones, es una barra simple.
JSlider - Permite vincular un Deslizador en nuestra ventana.
JSpinner – permite vincular una caja de texto con botones integrados para
seleccionar algún valor.
JProgressBar – Establece una barra de progreso.
Componentes de Texto.
Son todos aquellos que nos permiten procesar cadenas de texto, sea como
entrada o salida de información.
JTextField – Permite introducir un campo de texto simple.
JFormattedTextField – Permite introducir un campo de texto con formato, (si
definimos que solo recibe números no permitirá letras...)
JPasswordField – Campo de texto que oculta los caracteres ingresados.
JTextArea – Permite vincular un área de texto donde el usuario ingresara
información o simplemente para presentar cadenas de texto.
JEditorPane –Permite vincular un área de texto con propiedades de formato.
JTextPane – Similar al anterior, permitiendo otras opciones de formato,
colores, iconos entre otros.
Componentes de Menú.
Estos componentes permiten vincular opciones de menú en nuestras
ventanas, tipo menú principal, como por ejemplo el conocido Inicio, Archivo,
Edición etc.
JMenuBar: Permite vincular una barra de menús.
JMenu– Permite vincular botones o enlaces que al ser pulsados despliegan un
menú principal.
JMenuItem: Botón u opción que se encuentra en un menú.
JCheckBoxMenuItem: Elemento del menú como opciones de checkbox.
JRadioButtonMenuItem: Elemento del menú como botón de selección.
JPopupMenu: Opciones de menú emergente.
Componentes Complejos
Estos son componentes un poco más avanzados, cumplen con funciones más
enfocadas a procesos específicos y complejos, como por ejemplo obtener gran
cantidad de información de una base de datos, trabajo con nodos, colores
entre otros.
JTable – Permite vincular una tabla de datos con sus respectivas filas y
columnas.
JTree - Carga un árbol donde se establece cierta jerarquía visual, tipo
directorio.
JList – Permite cargar una lista de elementos, dependiendo de las propiedades
puede tenerse una lista de selección múltiple.
JFileChooser – Es un componente que permite la búsqueda y selección de
ficheros entre otras.
JColorChooser – Componente que permite cargar un panel selector de color
JOptionPane – No es algo complejo sino mas un componente independiente
que permite mostrar un cuadro de diálogo personalizable.
2.16 Consultar la estructura y sintaxis de cómo funcionan las excepciones
en Java.
Objetivo General
Desarrollar una aplicación para el mini mercado Surtimax S.A. con el cuál se
pueda realizar el registro de productos y clientes y la actualización de la
información, consulta y ventas de productos.
Objetivos Específicos
Requisitos Funcionales
Requisitos no Funcionales
Referencias Bibliográficas
Cristian David Henao H. Ingeniero de Sistemas y Computación (Universidad del Quindío - Colombia)
http://codejavu.blogspot.com.co/2013/09/componentes-java-swing.html
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/clases.htm
http://codigoprogramacion.com/cursos/java/87-curso-javautilizando-metodos-en-
java.html#.Wn0XSXy1vIU
Jarroba. (2018). Polimorfismo en Java (Parte I), con ejemplos - Jarroba. [online]
Available at: https://jarroba.com/polimorfismo-en-java-parte-i-con-ejemplos/
[Accessed 11 Feb. 2018].