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.

Programas en 2 clases

public class Ferreteria {

private double ingresos;
private double gastos;
private double presupuesto;

public Ferreteria()
{
ingresos=0;
gastos=0;
presupuesto=0;
}

public double getPresupuesto() {
return presupuesto;
}

public void setPresupuesto(double presupuesto) {
this.presupuesto = presupuesto;
}

public double getIngresos() {
return ingresos;
}

public void setIngresos(double ingresos) {
this.ingresos = ingresos;
}

public double getGastos() {
return gastos;
}

public void setGastos(double gastos) {
this.gastos = gastos;
}
}



import java.util.Scanner;
public class RunFerreteria {

static Ferreteria fer=new Ferreteria();
public static void main(String[]args)
{
Scanner sc=new Scanner(System.in);

System.out.println("Por favor ingresa tu presupuesto");
fer.setPresupuesto(sc.nextDouble());
System.out.println("Por favor ingresa los ingresos");
fer.setIngresos(sc.nextDouble());
System.out.println("Por favor ingresa los gastos");
fer.setGastos(sc.nextDouble());
ganar();
}
public static void ganar()
{
double porcentaje=0, ganancias=0;
ganancias= (fer.getIngresos()-fer.getGastos());
System.out.println("Tus ganancias son: " +ganancias );

porcentaje= (ganancias*100)/fer.getPresupuesto();
System.out.println("Tus ganancias en porcentaje son %"+ porcentaje);
}
}


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


public class Mascota {

private String animal;
private String nombre;
private String gusto;



public String getNombre() {
return nombre;
}

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

public Mascota()
{
animal="";
nombre="";
gusto="";
}

public String getAnimal() {
return animal;
}

public void setAnimal(String animal) {
this.animal = animal;
}

public String getGusto() {
return gusto;
}

public void setGusto(String gusto) {
this.gusto = gusto;
}

}


import java.util.Scanner;
public class RunMascota {

static Mascota fer=new Mascota();
public static void main(String[]args)
{
String animal="perro";
String respuesta="si";
Scanner sc=new Scanner(System.in);

System.out.println("¿Qué animal prefieres perro o gato?");
fer.setAnimal(sc.next());

if(fer.getAnimal().equals(animal))
{
System.out.println("¿Qúe nombre le pondrías al perro?");
fer.setNombre(sc.next());
System.out.println("¿Te gusta ese nombre?");
fer.setGusto(sc.next());
if(fer.getGusto().equals(respuesta))
{
System.out.println("Genial, a mi tambien me gusta");
}
else
{
System.out.println("Pero es un bonito nombre, que lastima ");
}
}
else
{
System.out.println("¿Qúe nombre le pondrías al gato?");
fer.setNombre(sc.next());
System.out.println("¿Te gusta ese nombre?");
fer.setGusto(sc.next());
if(fer.getGusto().equals(respuesta))
{
System.out.println("Genial, a mi tambien me gusta");
}
else
{
System.out.println("Pero es un bonito nombre, que lastima ");
}
}
}
}

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



public class Almuerzo {

private double costoAlmuerzo;
private double presupuesto ;

public Almuerzo()
{
costoAlmuerzo=0;
presupuesto=0;
}

public double getCostoAlmuerzo() {
return costoAlmuerzo;
}

public void setCostoAlmuerzo(double costoAlmuerzo) {
this.costoAlmuerzo = costoAlmuerzo;
}

public double getPresupuesto() {
return presupuesto;
}

public void setPresupuesto(double presupuesto) {
this.presupuesto = presupuesto;
}
}




import java.util.Scanner;
public class RunAlmuerzo {

static Almuerzo fer=new Almuerzo();
public static void main(String[]args)
{
Scanner sc=new Scanner(System.in);

System.out.println("Veo que hoy vas a almorzar en la universidad");
System.out.println("¿Cuánto dinero tienes?");
fer.setPresupuesto(sc.nextDouble());
System.out.println("¿Cuánto cuesta el almuerzo?");
fer.setCostoAlmuerzo(sc.nextDouble());
almorzar();
}
private static void almorzar() {
double almuerzo=0;
 
almuerzo=fer.getPresupuesto()/fer.getCostoAlmuerzo();
 
if(almuerzo<1)
{
System.out.println("No tienes suficiente dinero:(");
}
else
{
System.out.println("te alcanza para "+ (int)(almuerzo) +" almuerzo");
}

}
}

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



public class Sexo {

private String sexo;
private int edad ;

public Sexo()
{
sexo="";
edad=0;
}

public String getSexo() {
return sexo;
}

public void setSexo(String sexo) {
this.sexo = sexo;
}

public int getEdad() {
return edad;
}

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


import java.util.Scanner;
public class RunFerreteria {

static Ferreteria fer=new Ferreteria();
public static void main(String[]args)
{
Scanner sc=new Scanner(System.in);

System.out.println("¿Eres hombre o mujer?");
fer.setSexo(sc.next());
System.out.println("¿Qué edad tienes?");
fer.setEdad(sc.nextInt());
Edad();
}
private static void Edad() {
String sexo="hombre";
 
if(fer.getSexo().equals(sexo))
{
if(fer.getEdad()<=10)
{
System.out.println("Eres un niño");
}
else
{
if(fer.getEdad()>10 && fer.getEdad()<=30)
{
System.out.println("Eres un hombre joven");
}
else
{
if(fer.getEdad()>30 && fer.getEdad()<=50)
{
System.out.println("Eres un hombre adulto");
}
else
{
System.out.println("Eres un hombre mayor");
}
}
}
 
}
else
{
if(fer.getEdad()<=10)
{
System.out.println("Eres una niña");
}
else
{
if(fer.getEdad()>10 && fer.getEdad()<=30)
{
System.out.println("Eres una mujer joven");
}
else
{
if(fer.getEdad()>30 && fer.getEdad()<=50)
{
System.out.println("Eres una mujer adulta");
}
else
{
System.out.println("Eres una mujer mayor");
}
}
}
}

}
}

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



public class Articulo {

private int codigo;
private String nombre;
private int precio;

public Articulo()
{
this.codigo=codigo;
this.nombre=nombre;
this.precio=precio;
}

public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getPrecio() {
return precio;
}
public void setPrecio(int precio) {
this.precio = precio;
}


}




import java.util.Scanner;
public class RunArticulo {

static Scanner sc= new Scanner(System.in);
static Articulo art; 

public static void main (String[]args)
{
int opc, creado=0;
boolean meno=false, validar=false;
System.out.println("Bienvenido ¿qué quieres hacer?");
System.out.println(" 1. Crear artículo");
System.out.println(" 2. Editar artículo");
System.out.println(" 3. Mostrar artículo");
System.out.println(" 4. Salir");
opc=sc.nextInt();
while(meno==false)
{
if(opc==2)
{
if(creado==1)
{
ModificarArt();
System.out.println("¿Quiéres hacer otra cosa? escoje del menu");
opc=sc.nextInt();
}
else
{
System.out.println("Tienes que crear un articulo primero");
System.out.println("Ve a la opción de crear");
opc=sc.nextInt();
}
}
else
{
if(opc==1)
{
CrearArt();
creado=creado+1;
System.out.println("¿Quiéres hacer otra cosa? escoje del menu");
opc=sc.nextInt();
}
else
{
if(opc==3)
{
if(creado==1)
{
MostrarArticulo();
}
else
{
System.out.println("Tienes que crear un articulo primero");
System.out.println("Ve a la opción de crear");
opc=sc.nextInt();
}
}
else
{
if(opc==4)
{
System.out.println("Fue un placer ayudarte");
System.exit(0);
}
else
{
System.out.println("Escoje una opción valida");
opc=sc.nextInt();
}
}
}
}
}

}//cierre main

private static void CrearArt() 
{
Articulo art= new Articulo();
System.out.println("\t Crear articulo");
System.out.println("Código: ");
art.setCodigo(sc.nextInt());
System.out.println("Nombre: ");
art.setNombre(sc.next());
System.out.println("Precio: ");
art.setPrecio(sc.nextInt());
System.out.println("¡Articulo creado con exito!");
}

private static void ModificarArt()
{
System.out.println("\t Edita el articulo");
System.out.println("Nuevo codigo: ");
art.setCodigo(sc.nextInt());
System.out.println("Nuevo nombre: ");
art.setNombre(sc.next());
System.out.println("Nuevo precio: ");
art.setPrecio(sc.nextInt());
System.out.println("¡Articulo modificado con exito!");
}

private static void MostrarArticulo()
{
System.out.println("\t Articulo");
System.out.println("Nombre: "+ art.getNombre());
System.out.println("Código: "+ art.getCodigo());
System.out.println("Precio: "+ art.getPrecio());
}
}

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



public class Ferreteria {

private double dinero;

public Ferreteria()
{
dinero=0;
}

public double getDinero() {
return dinero;
}

public void setDinero(double dinero) {
this.dinero = dinero;
}

}


import java.util.Scanner;
public class RunFerreteria {

static Ferreteria fer=new Ferreteria();
public static void main(String[]args)
{
Scanner sc=new Scanner(System.in);

System.out.println("Ahora sabras para que celular te4 alcanza con tu suelo");
System.out.println("Ingresa tu salario");
fer.setDinero(sc.nextDouble());
celular();
}

public static void celular()
{
double salarioM=689.454;
double tipoCelular=salarioM*2;
double tipoCelularD=salarioM*3;
if(fer.getDinero()<= salarioM)
{
System.out.println("Celular gama baja");
}
else
{
if(fer.getDinero()>salarioM && fer.getDinero()<=tipoCelular)
{
System.out.println("Celular gama media");
}
else
{
if(fer.getDinero()>tipoCelular && fer.getDinero()<=tipoCelularD)
{
System.out.println("Celular gama Alta");
}
}
}
}
}