Resumen Java Tema Pruebas y Calidad del Software

Las pruebas buscan errores y verifican que el programa cumple lo esperado y lo hace bien.
Son costosas en tiempo y recursos.

Hay que probar:
    Que haga lo esperado y no haga cosas inesperadas.
    Se buscan Situaciones anormales y fallos.
    Entradas de datos correctas e incorrectas.
    Probar primero partes pequeñas y luego las grandes.
   
Hay que documentar los casos de prueba, que parámetros recibe, qué debería devolver y que devuelve en cada caso.
Debería realizarlas automáticamente una aplicación o un usuario ajeno, no el propio programador.
Cada vez que se corrige un fallo hay que volver a probarlo todo.

-VERIFICACIÓN: Cumple la especificación?
-VALIDACIÓN: Cubre la necesidad del cliente?


INSPECCIÓN DE SOFTWARE: Análisis técnico del código, las especificaciones y los diagramas para comprobar que sea lo estipulado.
    Puede hacerse en todas las fases del desarrollo, y en partes incompletas al ser estático.
    (errores de compilación, código no alcanzable, variables no inicializadas o sin uso, bucles infinitos)
   
PRUEBAS DE SOFTWARE: Ejecutar el programa con datos ficticios y analizar las salidas.
    Solo pueden hacerse trás la fase de construcción y requieren planificación porque es dinámico.
   
    -De Integración:
        Sistema/Subsistema = funcionan juntos el sistema y componentes?
            *Tienen que ser incremental, se añade algo, se prueba, y repetir todo el proceso.
            Descendente>    1º estructura, luego los componentes
            Ascendente>        1º las funcionalidades pequeñas y luego se agrupan
           
        Rendimiento = fiabilidad y respuesta ante la carga de trabajo, buscar sobrecargas
        Entrega y aceptación = cumple los casos de uso y requerimientos?
            Los resultados a las entradas son los esperados?
            Forzar todos los errores y desbordamientos
           
       
    -Unitarias o de componentes, son correctos y funcionan cada clase o cada módulo?
        Descendente>    el control es el programa principal, se crean módulos colaboradores falsos, probar y sustituir por el real.
        Ascendente>        crear un monitor de prueba para examinar los módulos de nivel mas bajo, probar y sustituir por el módulo superior real, y volver a probar (regresión)
       
    -De Sistemas Ori.Obj: es correcto y útil el esquema de clases? Probar: todos los atributos y métodos de cada clase.
        Clases>    comprobar que hacen lo definido.
            *Basadas en escenarios =    probar los casos de uso mas comunes, después los menos, y luego los excepcionales.
            *Basadas en Subprocesos =    en cadenas de eventos.
           
       
   
DOCUMENTACION:
Para la organización y mantenimiento del código hay que documentarlo, indicando información sobre las funcionalidades, parámetros y resultados.
Precediendo de  /** COMENTARIO */  las clases, interfaces, métodos o atributos, con la herramienta (javadoc *.java -private –d javadoc) generamos la documentación en html automáticamente. Son heredables.
    -Etiquetas: @param, @return, @throws, @exception, @author, @version.

Resumen Java Tema Análisis y Diseño Orientado a Objetos

Ingeniería del Software: Se buscan soluciones mediante sistemas efectivos en calidad y coste, con un ciclo de vida ordenado en etapas:
1º-Planificación y Especificación
    2º-Análisis de requisitos
        3º-Especificación Funcional
            4º-Diseño
                5º-Codificación y Pruebas
                    6º-Implantación y Mantenimiento.
                   
FASES:
    1º-Planificación: captar las necesidades del cliente. Plantear Casos de Uso (que acción -> que reacción), [nombre, actores, importancia, descripción]. Sirve como contrato.
   
    2º-Analisis: traducir el problema en soluciones y decidir como llevarlo a cabo.    Ampliar Casos de uso. Punto de vista externo.

    3º-Funciones: crear el Diagrama de Clases con los objetos y roles, sus atributos y relaciones. Punto de vista interno.
   
    4º-Diseño: estructurar las soluciones, definir Diagrama de Clases detallado, las estructuras de datos y la interfaz.
   
    5º-Construcción: Escritura del código en iteraciones repetibles de subconjuntos para ir completando partes, probándolas y corrigiéndolas.
   
    6º-Instalación: puesta en marcha del sistema, y formación a los usuarios.
   

UML (Unified Modeling Languaje)
    Es una notacion visual para representar diagramas, orientado a Objetos (con entidades, relaciones, atributos y operaciones). Nos da una perspectiva del sistema. Representan fases o etapas.
   
    -Diagrama de Casos de Uso, muestra casos de uso, actores y sus relaciones:   
        ACTOR: Elemento externo al sistema que interactúa con el. Rol(es) del usuario.
        CASO DE USO: Unidad funcional coherente realizada por el sistema (acción-reacción).
            EXTEND: el que apunta aumenta el comportamiento del Apuntado.
            INCLUDE: el que apunta incluye la función del apuntado.
           
       
    -Diagrama de Clases muestra clases(nombre, atributos y operaciones), interfaces(sin inplementación) y sus relaciones. Es estático.
        Asociaciones pueden ser entre 2 clases (binarias) o mas. Cardinalidad (0,1,n)...(0,1,n)
            AGREGACIÓN:  TODO <>--- PARTE
            COMPOSICIÓN: 1 <#>--- n   Pertenencia.
            HERENCIA: PADRE <|--- Hija
           

Trucos:   
        subrayar los nombres, ver que relaciones tienen para plantear Clases.
        buscar "es", "tiene", "consta de" para hallar las Relaciones.
        las descripciones contendrán Atributos.
        los verbos indican las Operaciones, y la información que intercambian son los parámetros.

Resumen Java Tema Ficheros y Persistencia

A través de un flujo (Stream): I/O, leer/escribir, Read/Write, ya sea a un fichero, a una red o a memoria. java.io
Los Streams se abren, se utilizan y SIEMPRE se cierran con .close(). Pueden producir excepciones catch(IOException ioe)

File sirve para manejar archivos, obtener información o crearlos, pero no es un flujo. exist(), isFile(), isDirectory().


RandomAccessFile(fichero, r/rw) permite acceder a una posición concreta y empezar a leer/escribir una cantidad concreta de bytes: seek(), getFilePointer(), length(), mark(), reset(), writeDouble(), readDouble().



Con las hijas de Reader y Writer se pueden manejar Bytes (8bits) o caracteres (16bits).
    Con InputStream y OutputStream bytes para datos binarios (imágenes, sonidos, videos).
    InputStreamReader y OutputStreamReader para caracteres unicode (16bits) desde o hacia bytes.
  
  
    FileReader (leer) y FileWriter (escribir) para ficheros de caracteres.
      
        -BufferedReader lee caracteres y texto desde un flujo; readLine(), close()  
            BufferedReader br = new BufferedReader(    new FileReader("ejemplo.txt")    );
            while ((cad = br.readLine()) != null)     System.out.println(cad);


        -BufferedWriter escribe caracteres y texto a un flujo en paquetes reduciendo el número de accesos; writeLine(), flush(), close()
            BufferedWriter bw = new BufferedWriter(    new FileWriter("salida.txt")    );
            bw.write(cad1);
            bw.newLine();
            bw.write(cad2);
            bw.flush();

              
            -PrintWriter facilita la escritura de valores primitivos y datos con print() y println()
                PrintWriter salida = new PrintWriter(   new BufferedWriter(    new FileWriter("salida.txt")    )    );
                salida.println(cad1);
                salida.println(cad2);



    FileInputStream lee bytes desde un archivo
        -InputStreamReader traduce los bytes que lee del flujo a caracteres con cierta codificación (€,ñ,í,ó):
            BufferedReader br = new BufferedReader(   new InputStreamReader(   new FileInputStream("ejemplo.txt")   , "ISO-8859-1")   );





SERIALIZACION: Guardar o leer un objeto entero en disco.
La clase que se vaya a serializar tiene que implementar la interfaz "Serializable".

-ObjectOutputStream escribe los objetos en un fichero en datos binarios con writeObject(objeto):
    ObjectOutputStream oos = new ObjectOutputStream(    new FileOutputStream("fichero.dat")    );
    oos.writeObject(objetoaguardar);
    oos.close();


-ObjectInputStream siempre hay que hacer un cast al tipo de fichero correcto que recuperemos con readObject():
    ObjectInputStream ois = new ObjectInputStream(    new FileInputStream("fichero.dat")    );
    ClaseDestino recipiente = (ClaseDestino) ois.readObject();

Resumen Java Tema Estructuras de Datos

-Busqueda Sequencial: Recorre una colección de elementos y devuelve la posición o el primero que cumpla la condición buscada.
-Busqueda Binaria: Mira el elemento central, si no es el buscado y es menor repite por el lado mayor, o viceversa.  Requiere(Lista Ordenda, Nº Elementos y acceso por posición).

-Ordenación por Inserción Directa: 2 Partes: Ordenada y Resto, coge el 1º del resto y lo coloca en su sitio en la ordenada. Nº Iteracciones = Nº Elementos.
-Ordenación por Selección Directa: 2 Partes: Ordenada y Resto, busca en el resto el menor y lo coloca en la ordenada. Nº Iteracciones = Nº Elementos.
-Ordenación por Intercambio Directo (Burbuja): Pasadas sucesivas comparando cada ítem con el siguiente e intercambiarlos para ordenar.


-Tipos Enumerados: Clase con un conjunto de valores fijos definido. java.lang.Enum. toString(), ordinal(), values():
    Sintaxis: Public enum DiasSemana{L,M,X,J,V,S,D}; DiasSemana ds = DiasSemana.L;


COLECCIONES (Genéricos, valen para cualquier tipo de clase= Collection   ):
    Algoritmos: Collections.short(), binarySearch(), reverse(), min(), max(), frecuency(), rotate(), suffle(), swap(), compareTo(), getClass(), getSimpleName().

    -LISTAS (LIST: Almacena en orden de inserción):
                ArrayList es un array dinámico de objetos. add(), remove(), get(), set(), contains(), indexOf(), lastIndexOf().
    -CONJUNTOS (SET: No puede contener duplicados):  
                HashSet: genera claves hash que enlaza a los valores, sin duplicados. add(), remove().
                TreeSet: Forma de árbol, rangos, ordenados. add(), remove().
    -MAPAS (MAP: Clave-Valor, sin duplicados, búsquedas rápidas):
                HashMap: Diccionario de claves-valores, put(clave,valor), get(clave), remove(clave).
                TreeMap: Árbol con objetos ordenados por clave. put(clave,valor), get(clave), remove(clave).
    -QUEUE: Entradas y Salidas por diciplina COLA (FIFO,LIFO...)
                Iteradores: para recorrer elementos, hasNext() y next(), y ListIterator añade hasPrevious() y previous().

Resumen Java Tema GUI (Graphical User Interface)

Contenedores (agrupan controles)
    Layouts (establecen el orden de los componentes)
        Componentes (elementos gráficos)

       
Se producirán eventos (ratón, teclado), que serán recibidos por los Listeners que lanzarán el Handler (manejador) con el código a ejecutar:
        EVENTO(ActionEvent), OYENTE(ActionListener), MÉTODO(actionPerformed), COMPONENTES(JButton)

       
       
CONTENEDORES:
-JWindow: Ventana sin título ni borde
-JFrame: Marco con borde y título. Puede tener una barra de menú.
-JDialog: Ventana completa propia que no puede existir sin un JFrame como padre.
-JApplet: Permite crear un applet swing (aplicaciones web java que se ejecutan en el navegador).
-JPanel: Contenedor intermedio genérico de Componentes.

    .getContentPane() permite acceder al padre y add(boton) le añade componentes.

   
   
LAYOUTS:
-BorderLayout: colocamos los elementos en North, South, East, West, y Center. Es el Default de JFrame y JDialog.
-GridLayout: se colocan en una rejilla de dimensiones x*y
-FlowLayout: los elementos van seguidos en fila uno tras otro.
-NullLayout: tenemos que especificar a mano las coordenadas de cada componente.


   
COMPONENTES: javax.swing.JComponent es la clase base de Swing
    JLabel: setText(), setFont()
    JButton: produce ActionEvent, addActionListener(actionPerformed que implemente la interfaz ActionListener)
    JTextArea, JTextField, JPasswordField: campos para escribir líneas, textos o contraseñas. getText() y setText()
    JComboBox: desplegables con elementos para seleccionar. setEditable(bool). Igual que JButton= ActionListener, addActionListener(), actionPerformed()
    JList: Listas de items para seleccionar uno o varios. Produce ListSelectionEvent->addListSelectionListener()->valueChanged()
    JScrollPane: desplazador para moverse por mas contenidos.
    JCheckBox: Cuadrados marcables, producen  ItemEvent->ItemListener->itemStateChanged(), addItemListener()
    JRadioButton: Selectores de opciones únicas, se agrupan en ButtonGroup.add(), funcionan igual que botones.
   
        .setToolTipText("texto info") para añadir una nota emergente con información.
       
    Menus:
        JMenuBar: la barra en la que se colocan los menus
        JMenu: componente menu que al ser pulsado desplegará opciones. addSeparator()
        JMenuItem: Cada elemento que contendrá el menu. Igual que los botones
   
   
   
   
    JToolBar: Barras de Herramientas movibles y acoplables, con JButton con texto o iconos. addSeparator()
   
    JTabbedPane: tendrá pestañas que contendrán JPanel con contenido. addTab(), setSelectedIndex()
   
    -JFileChooser: nos permite la selección para apertura o guardado de un fichero. Es modal, con showOpenDialog y showSaveDialog().
    -JFormattedTextField: permite forzar formatos básicos en texto mediante máscaras (fechas, monedas) en conjunto con InputVerifier.
    -JSpinner: rota entre unos valores con un orden mostrando únicamente uno. SpinnerListModel(array), SpinnerNumberModel para números y SpinnerDateModel para fechas.
    -JTable: Tablas para mostrar datos en una rejilla de columnas y filas. Se construyen con arrays y permiten edición.
    -AbstractBorder: implementa interfaz Border y permite marcar bordes.
   
    JOptionPane: para mostrar diálogos de opciones, se captura el resultado y se analiza.
        .showConfirmDialog( Si, No, Cancelar)
        .showInputDialog( recoge un texto en un textbox y lo devuelve)
        .showMessageDialog( para errores, avisos, información)
        .showOptionDialog( combinación de los 3 anteriores)
       
       
       
*Podemos determinar el aspecto de la aplicación (metal, motif, windows) con:
    UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel";

Resumen Java Tema Excepciones

Excepción: error que detiene la ejecución. Lanza un objeto que podemos capturar con try{...}catch(Exception ex){...} y asi fortalecer, estabilizar y preparar la aplicación para recuperarse en casos de error.
Si se produce en un método y no es capturada escalará hasta el método que lo llamó recursivamente, y si no es capturada nunca, detendrá la ejecución.


try { Envuelve el código que podrá lanzar excepciones, las captura y se las pasa al manejador catch adecuado. }
catch { Puede haber varios, del mas específico al mas general, y es lo que se ejecutará en caso de error }
finally { Esta porción de código se ejecutará SIEMPRE, haya error o no, es útil para cerrar conexiones y flujos }

throw new Exception(): permite lanzar manualmente una excepción (tiene que heredar de Throwable)

public void método throws xException: indica que el metodo puede producir x excepciones y no las controla.

Throwable (padre)
    -Error (hija) errores fatales no recuperables.
    -Exception (hija) errores de los que se puede recuperar. getMessage(), printStackTrace()
        Se pueden crear hijas de Exception para hacer excepciones personalizadas.
        Tipos comunes:     ArithmeticException, NullPointerException, ClassCastException, NegativeArraySizeException, ArrayIndexOutOfBoundsException, NoClassDefFoundException