Clases envolventes

public class Datos {

    private Integer a= new Integer(45);   // Integer sirve para manejar como objeto el 45
    private Integer b= new Integer("50"); //Aqui sirve para guardar un caracter en un numero
   
   
    public Integer getA() {
        return a;
    }
    public void setA(Integer a) {
        this.a = a;
    }
    public Integer getB() {
        return b;
    }
    public void setB(Integer b) {
        this.b = b;
    }
   
}

----------------------------//_------------------------------------//--------------------------------------//-------------


public class Presentacion {

    public static void main(String[]args)
    {
        Datos ejemplo=new Datos();
       
       
        //Value
        int a = ejemplo.getA().intValue(); // Sirve para guardar lo que hay en un metodo ajeno en una variable
        int b= ejemplo.getB().intValue();
       
        System.out.println("Dato primitivo entero: "+ ejemplo.getA());// Manera larga (sin Value)
        System.out.println("Cadena de caracteres hechos enteros: "+ ejemplo.getB());
       
        System.out.println("Dato primitivo entero: "+ a);
        System.out.println("Cadena de caracteres hechos enteros: "+  b);//Manera Corta(Con Value)
       
        System.out.println("Ejemplo 0.1: a+b="+(a+b)); //Manera corta
        System.out.println("Ejemplo tres: con objetos: "+ (ejemplo.getA()+ejemplo.getB()));// Manera Larga
       
       
        // Parse
        int j= Integer.parseInt("5"); // Pasa un caracter numerico a entero (dentro del parentesis solo puede haber numeros)
       
        System.out.println("Suma entre parse y un numero: j + 3= "+ (j+3));
       
        //Value Of
        System.out.println("");
        System.out.println("");
        System.out.println("");
        System.out.println("");
       
       
         float j1=Float.valueOf("10f");
        System.out.println("No se que haga: "+ j1);
        //Binario
       
         Integer in2= Integer.valueOf("10", 2);
        System.out.println("No se que haga 2: "+ in2);
       
        System.out.println("Suma j1 + j= "+ (j1 + j));
    }
   
}

Biblioteca

public class Datos {

    private String [] arreglo;
    public final static int TAMANHO=6;
    private String[] revista;
    public final static int TAMANHOD=6;
    private String nombreU;
    private String documentoI;
    private int tipoU;
   
    Datos()
    {
        arreglo=new String[TAMANHO];
        revista= new String[TAMANHOD];
        nombreU="";
        documentoI="";
    }
   
    public String[] getArreglo() {
        return arreglo;
    }

    public void setArreglo(int indice, String arreglo) {
        this.arreglo[indice]=arreglo;
    }
   

    public String[] getRevista() {
        return revista;
    }

    public void setRevista(int indice, String revista) {
        this.revista[indice] = revista;
    }

   
    public String getNombreU() {
        return nombreU;
    }

    public void setNombreU(String nombreU) {
        this.nombreU = nombreU;
    }

   
   
    public String getDocumentoI() {
        return documentoI;
    }

    public void setDocumentoI(String documentoI) {
        this.documentoI = documentoI;
    }

    public int getTipoU() {
        return tipoU;
    }

    public void setTipoU(int tipoU) {
        this.tipoU = tipoU;
    } 
}

----------------------------------------//----------------------------------------------//--------------------------------

import java.util.Scanner;
public class Logica {

    Datos datos= new Datos();
    Scanner sc=new Scanner(System.in);
   
        public void tipoU(int numero)
        {
                switch (numero)
                {
                case 1:
                    System.out.println("Prueba o");
                    prestamoO();
                   
                break;
               
                case 2:
                    System.out.println("Prueba s");
                    //prestamoS();
                   
                break;
               
                default:
                System.out.print("Error, opción no valida. Vueve a intentar");
                datos.setTipoU(sc.nextInt());
                break;
                }
       
           
        }
       
       
        public void prestamoO()
        {
            int op;
            System.out.println("Ingresa tu documento de identidad");
            datos.setDocumentoI(sc.next());
            System.out.println("¿Qué desea retirar?");
            System.out.println("1. Libro");
            System.out.println("2. Revista");
            op=sc.nextInt();
           
            switch(op)
            {
            case 1:
                prestamoLibro();
            break;
            case 2:
                //prestamoRevista();
            break;
            default:
                System.out.println("Opcion no valida. Vuelve a intentar");
                op=sc.nextInt();
            break;
            }
        }
       
       
        public void prestamoLibro()
        {
            int cantidad;
            System.out.println("¿Cuántos libros deseas retirar?");
            cantidad=sc.nextInt();
           
            while(cantidad>3)
            {
                System.out.println("Solo puedes retirar 3 libros");
                System.out.println("¿Cuántos libros deseas retirar?");
                cantidad=sc.nextInt();
            }
            while(cantidad<0)
            {
                System.out.println("No puedes retirar esa cantidad de libros");
                System.out.println("¿Cuántos libros deseas retirar?");
                cantidad=sc.nextInt();
            }
            for(int indice=0; indice<cantidad;indice++)
            {
                String nombreLibro;
                System.out.println("Ingresa el nombre del libro");
                nombreLibro=sc.next();
                 datos.setArreglo(indice, nombreLibro);
            }
        }
}

-------------------------------------------------//---------------------------------------------------//-------------//----

import java.util.Scanner;
public class Presentacionnnnnn {

    public static void  main(String[]args)
    {
        Scanner sc=new Scanner(System.in);
        Logica logica= new Logica();
        Datos datos= new Datos();
        System.out.println("Bienvenido a la biblioteca");
       
        System.out.println("Tipo de usuario:");
        System.out.println("1. Ocasional");
        System.out.println("2. Socio");
        datos.setTipoU(sc.nextInt());
        logica.tipoU(datos.getTipoU());
       
    }
}

Ejercicio de matriz

package Datos;

public class Datos {

    private String datos[][];
   
    public Datos()
    {
        this.datos=datos;
    }

    public String[][] getDatos() {
        return datos;
    }

    public void setDatos(String[][] datos) {
        this.datos = datos;
    }
}

---------------------------------//-------------------------------------------//-------------------------------------------

package Logica;

import Datos.Datos;
import java.util.Scanner;

public class Logica {
   
    Datos datos= new Datos();
   
    public void pedir()
    {
        int numAlumnos, a;
        Scanner sc=new Scanner(System.in);
        System.out.println("Bienvenido");
        System.out.println("¿Cuántos alumnos vas ingresar?");
        numAlumnos= sc.nextInt();
       
       
        String dato[][]=new String[numAlumnos][3];   // PREGUNTAR ¿POR QUÉ NO FUNCIONA CON 2 EN COLUMNAS?
       
        for(int indiceF=0; indiceF<numAlumnos; indiceF++)
        {
       
            for(int indiceC=0; indiceC<=2;indiceC++)
            {
                if(indiceC==0)
                {
                    System.out.println("Alumno "+ (indiceF+1));
                    System.out.println("Nombre: ");
                    dato[indiceF][indiceC]=sc.next();   
                }
                else
                {
                    if(indiceC==1)
                    {
                        System.out.println("Edad: ");
                        dato[indiceF][indiceC]=sc.next();
                    }
                    else
                    {
                        if(indiceC==2)
                        {
                            System.out.println("Documento: ");
                            dato[indiceF][indiceC]=sc.next();
                        }
                    }
                }
            }
        }
        System.out.println("Alumnos registrados con éxito");
        datos.setDatos(dato);
       
        System.out.println("Los datos de los aulmnos registrados son: ");
       
        for(int i=0; i<datos.getDatos().length;i++) // <------------------ Mostrar la matriz
        {
            for(int j=0; j<=datos.getDatos().length;j++)
            {   
                if(j==0)
                {
                    System.out.println("Alumno "+ (i+1));
                    System.out.println("Nombre: "+datos.getDatos()[i][j]); // <----------- Se muestra lo que hay en esas posiciones
                   
                }
                else
                {
                    if(j==1)
                    {
                        System.out.println("Edad: "+datos.getDatos()[i][j]);
                       
                    }
                    else
                    {
                        if(j==2)
                        {
                            System.out.println("Documento: "+datos.getDatos()[i][j]);
                        }
                    }
                }
            }
        }
       
    }
}
------------------------------//---------------------------------------------//-------------------------------------//---

package Presentacion;
import Logica.Logica;
import Datos.Datos;
public class Presentacion {

    public static void main(String[]args)
    {
        Logica logica=new Logica();
        Datos datos= new Datos();
       
        logica.pedir();
    }
}

Arreglos tipo objeto

package Datos;

public class Datos {

    private String nombre;
    private int edad;

    public Datos()
    {
        this.nombre= nombre;
        this.edad= edad;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
}
------------------------------------------------//_--------------------------------------------//-----------------------/

package Logica;
import Datos.Datos;
import java.util.Scanner;
public class Prueba {

    Datos dt= new Datos();
    Scanner sc= new Scanner(System.in);
    Datos vector[];
    public void prueba()
    {
        vector= new Datos[1];
        System.out.println("Ingresa el nombre: ");
        dt.setNombre(sc.nextLine());
        System.out.println("Ingresa Edad: ");
        dt.setEdad(sc.nextInt());
       
        vector[0]= new Datos();
       
        mostrar(vector);
    }
   
    public void mostrar (Datos[] vec)
    {
        System.out.println("Edad: "+vec[0].getEdad());
        System.out.println("nombre: "+ vec[0].getNombre());
    }
}
--------------------------------------//-----------------------------------------//-----------------------------------//---
El ejercicio no funciona correctamente


package Presentacion;
import Logica.Prueba;
public class Presentacion {

    public static void main(String[]args)
    {
        Prueba prue= new Prueba();
       
        prue.prueba();
    }
}

Programación en tres capas

Ejemplo de interfaz (Java)

public interface Caminar {

public void caminar();
}

/------------------------------------/------------------------------------------/---------------------------------------/

public interface Nadar {

public void nadar();

}

/------------------------------------/------------------------------------------/---------------------------------------/

public interface Volar {

public void volar();

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Mamifero implements Caminar{

public void caminar() {

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Ave implements Caminar{

public void caminar() {

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Felino extends Mamifero implements Nadar {

public void nadar() {

} 

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Gato extends Felino{

public void nadar()

{

System.out.println("Este Gato Nada");

}

public void caminar()

{

System.out.println("Este Gato Camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Tigre extends Felino{

public void nadar()

{

System.out.println("Este Tigre Nada");

}

public void caminar()

{

System.out.println("Este Tigre Camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Murcielago extends Mamifero implements Volar {

public void volar() {

System.out.println("Murcielago vuela");

}

public void caminar()

{

System.out.println("Murcielago camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Avestuz extends Ave {

public void caminar()

{

System.out.println("Avestruz camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Loro extends Ave implements Volar{

public void volar() {

System.out.println("Loro vuela");

}

public void caminar()

{

System.out.println("Loro camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Run {

public static void main(String[]args)

{

Gato gato= new Gato();

Tigre tigre=new Tigre();

Murcielago murci=new Murcielago();

Avestuz aves=new Avestuz();

Loro loro=new Loro();

System.out.println("Gato: ");

gato.caminar();

gato.nadar();

System.out.println("\nTigre: ");

tigre.caminar();

tigre.nadar();

System.out.println("\nMurcielago: ");

murci.caminar();

murci.volar();

System.out.println("\nAvestruz: ");

aves.caminar();

System.out.println("\nLoro: ");

loro.caminar();

loro.volar();

}

}

Herencia, Polimorfismo, clase abstracta y sobreescritura

Herencia

Creación de nuevas clases basadas en clases existentes.
Cuando heredamos de una clase existente, reusamos métodos y campos, y agregamos nuevos campos y métodos para cumplir con la nueva situación.
A través de la referencia podemos agregar nuevos campos y podemos agregar o sobremontar métodos

Sobremontar: redefinir el método en la clase heredada

Sobreescritura

Se usa para que una sub clase se modifique o se agregue funcionalidades del método heredado

ejemplo:

class ClaseP{
           void nuevoMetodo(int valo)
            {
                .......
            }
          String unNuevoMetodo()
          {
               ........
           }
}


class ClaseQ extends ClaseP{

       void miMetodo(int valo)
        {
             System.out.println("Hola");
        }
      String unNuevoMetodo()
        {
           System.out.println("Hola, otra vez");
        }
 }

Clase abstracta

Sirve para unificar datos u operaciones de subclases
código:
             public abstract class NombreClase{
}

Características:

• No se pueden crear objetos de esta clase
• Al menos un método tiene que ser abstracto

Métodos abstractos (Características)

• No tiene cuerpo(Es decir, no lleva llaves)
• Termina en punto y coma
• Solo existe dentro de una clase abstracta
• Estos tienen que forzosamente ser sobreescritos en las sub clases

ejemplo: abstract public void generarNomina(Parametros);

Polimorfismo

Se refiere a la propiedad por la que es posible enviar mensajes sintácticamente iguales a objetos de tipos distintos, este concepto esta ligado directamente con el concepto de herencia.

El polimorfismo en palabras mas simple consiste en un pedazo de código que se puede utilizar de diferentes manera en las clases hijas, en caso de no especializarlas las clase hijas hacen los métodos de la clase padre

          

ejemplo:

public abstract class SeleccionFutbol{

   

   public abstract void entrenamiento();

 

  public void partidoFutbol(){

    

        System.out.println("Asiste al partido (Esta es la clase padre)");

   }

}

public class Entrenador extends SeleccionFutbol{

   @Override

   public void entrenador(){

  

        System.out.println("Direige un entrenamiento(Esta es la sub clase)");

    }

}

@Override

Sirve para sobreescribir el código, en el caso de un objeto abstracto, sirve para especializar un método en una sub clase y en un método normal es para cambiar la función del método.