viernes, 26 de septiembre de 2014

Herencia (Mamiferos)

Otro ejemplo de poo pero ahora solo sera de dos animales un conejo y un caballo del cual tienen una herencia de mamifero
----------------------------------------------------------------------------------------------
public abstract class Mamifero {//nombre de la clase
 
    private String especie;    //Atributos que comparten todos los mamiferos. o Caracteristicas
    private String estatura;
    private String color;
   
    public String getEstatura() {
        return estatura;
    }

    public void setEstatura(String estatura) {
        this.estatura = estatura;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }            
 
    public String getEspecie() {    // ES PRIVADO PORQUE SOLO PUEDE SER USADO POR LA CLASE MAMIFERO Y NO POR LAS CLASES HIJAS.
        return especie;
    }

    public void setEspecie(String especie) {
        this.especie = especie;
    }    
         
    // COMPORTAMIENTO DE TODOS LOS MAMIFEROS.
    public void comer(){
        System.out.println("Come");
    }
         
    public void dormir(){
        System.out.println("Duerme");
    }
}
------------------------------------------------------------------------------------------------
-------------------------Clase Conejo-------------------

public class Conejo extends Mamifero {
    
    // CARACTERISTICAS.
    int tamano_orejas;
    
    public int getTamano_orejas() {
        return tamano_orejas;
    }

    public void setTamano_orejas(int tamano_orejas) {
        this.tamano_orejas = tamano_orejas;
    }
    
    // COMPORTAMIENTO UNICO DEL CONEJO
    public void esconderse(){
        System.out.println("se esconde");
    }
    
    public void marcar(){
        System.out.println("marca territorio");
    }
}
--------------------------------------------------------------------------------------
-----------------------------Clase Caballo----------------------

public class Caballo  extends Mamifero {
   
    // CARACTERISTICA.    
    String sangre;                                      

    public String getSangre() {
        return sangre;
    }

    public void setSangre(String sangre) {
        this.sangre = sangre;
    }

    
    // COSAS QUE SOLO EL CABALLO PUEDE HACER
    public void relinchar(){
        System.out.println("Relincha");
    }
    
    public void cargar(){
        System.out.println("Carga material");
    }
}
----------------------------------------------------------------------------------
---------------------------Main-------------------------

public class Herenciadelosdos{ // NO ES NECESARIO QUE EXTIENDA DE MAMIFERO.
    
    public static void main(String[] args) {//metodo

        Conejo co = new Conejo();      
        Caballo ca = new Caballo();  
        
        
        co.setEspecie("Conejo");  // ESTE ATRIBUTO SE ENCUENTRA EN MAMIFEROS
        System.out.println(co.getEspecie());//Se imprime Especie
        co.setColor("Color blanco");  // ESTE ATRIBUTO SE ENCUENTRA EN MAMIFEROS
        System.out.println(co.getColor());  
        co.setEstatura("15cm"); // ESTE ATRIBUTO SE ENCUENTRA EN MAMIFEROS
        System.out.println(co.getEstatura());  
        co.setTamano_orejas(8);  // ESTE ATRIBUTO SE ENCUENTRA CLASE CONEJO
        System.out.println(co.getTamano_orejas());
        co.comer();  // METODO QUE COMPARTEN LOS MAMIFEROS
        co.dormir(); // METODO QUE COMPARTEN LOS MAMIFEROS
        co.esconderse(); // METODO SOLO DEL CONEJO
        co.marcar();     // METODO SOLO DEL CONEJO
        
        System.out.println("----------------------------");
                
        ca.setEspecie("Caballo");   // ESTE ATRIBUTO SE ENCUENTRA EN MAMIFEROS
        System.out.println(ca.getEspecie());
        ca.setColor("Color cafe");   // ESTE ATRIBUTO SE ENCUENTRA EN MAMIFEROS
        System.out.println(ca.getColor());
        ca.setEstatura("2m");   // ESTE ATRIBUTO SE ENCUENTRA EN MAMIFEROS
        System.out.println(ca.getEstatura());
        ca.setSangre("Caliente"); // ESTE ATRIBUTO SE ENCUENTRA CLASE CABALLO
        System.out.println(ca.getSangre());
        ca.comer();    // METODO QUE COMPARTEN LOS MAMIFEROS
        ca.dormir();   // METODO QUE COMPARTEN LOS MAMIFEROS
        ca.relinchar(); // METODO SOLO DEL CABALLO
        ca.cargar();    // METODO SOLO DEL CABALLO
        
   
    }
}

Calculadora (Usando Poo)

Hace rato que no me paro por el blog ahora les pondre el codigo de una calculadora usando herencia, encapsulamiento, polimorfismo etc, espero les sea de ayuda para aquellos que lo necesitan :)

--------------------------------------------------------------------------------------------------
package calculadord;
/** * * @author Abimael */
public class CalculadorD {

  private float numA,numB;
  private float R;
  private char Operacion;
      
  public CalculadorD (){//constructor
      this.numA = 0;
      this.numB = 0;
      this.R = 0;
      this.Operacion = ' ';
  }

    public float getNumA() {//SetsandGets
        return numA;
    }

    public void setNumA(float numA) {
        this.numA = numA;
    }

    public float getNumB() {
        return numB;
    }

    public void setNumB(float numB) {
        this.numB = numB;
    }

    public float getR() {
        return R;
    }

    public void setR(float R) {
        this.R = R;
    }

    public char getOperacion() {
        return Operacion;
    }

    public void setOperacion(char Operacion) {
        this.Operacion = Operacion;
    }
 
  }
----------------------------------------------------------------------------------
--------------------Metodos Calculadora Basica--------------
package calculadord;

/**
 *
 * @author Abimael
 */
public class CalculadoraBasica extends CalculadorD{

   
public static float sumar(float numA, float numB){
return  numA + numB; 
}

public static float resta(float numA, float numB){
return numA - numB; 
}



public static float multiplicar(float numA, float numB){
return numA * numB; 
}

   ---------------------------------------------------------------------------
--------------Metodos Calculadora Cientifica-------------- 
package calculadord;

/**
 *
 * @author Abimael
 */
public class Calculadoracientifica extends CalculadoraBasica {

    public static float raiz (float numA){
   float R = (float) Math.sqrt(numA);
   return R;
   
    }  
   public static float potencia (float numA, float numB){
    float R = (float)Math.pow(numA,numB);
    return R;
}
   public static float division(float numA, float numB){
return numA / numB; 
    }
}
-------------------------------------------------------------------------------
---------------------------------Main------------------------

public class Main  {
    
    private static CalculadorD obtenerdivision()throws ArithmeticException{
        Scanner Division = new Scanner(System.in);
        boolean Viri = true;
        boolean Suzie = true;
        CalculadorD Sion = new CalculadorD();
     do{
    try{    
        System.out.println("Ingresa Primer Operando");
        Sion.setNumA(Division.nextFloat());
        Viri=false;
     do{
    try{   
        System.out.println("Ingresa el Segundo:");
        Sion.setNumB(Division.nextFloat());
        Suzie=false;
        }catch(ArithmeticException Ari)
           {
             Division.nextLine();
             System.err.printf("Excepcion: %s", Ari);
             System.out.println("Cero es un denominador invalido intente de nuevo");
           }
         catch(InputMismatchException Armon)
         {
            Division.nextLine();
            System.out.println("Ingrese numero Correctamente: lol");
         }
   
       
          }while(Suzie);
        }catch(InputMismatchException Roman){
            Division.nextLine();
            System.out.println("Ingrese numero Correctamente");
        }
        }while(Viri);
      return Sion;
    }
    private static CalculadorD obtenerraiz()throws Exception{
     Scanner Chi = new Scanner(System.in);
     boolean Genjutsu = true;
     CalculadorD Ita = new CalculadorD();
 do{
   try
     {
     System.out.println("Ingresa Operando a sacar la raiz: ");
     Ita.setNumA(Chi.nextFloat());
     Genjutsu=false;
     }catch
         (InputMismatchException Kalel){
          Chi.nextLine();
         System.out.println("Ingrese operando valido... ");
     }
     }while(Genjutsu);     

     return Ita;
     }
     
     private static CalculadorD obtenerpotencia()throws Exception{
     Scanner Excel = new Scanner(System.in);
     boolean Vegeta = true;
     boolean Kakashi = true;   
     CalculadorD Ita = new CalculadorD();
 do{
    try{
     System.out.println("Ingresa el Número: ");
     Ita.setNumA(Excel.nextFloat());
     Vegeta=false;
 do{
    try{   
     System.out.println("Ingresa el Número de la potencia:  ");
     Ita.setNumB(Excel.nextFloat()); 
     Kakashi=false;
     }catch   (InputMismatchException Lorel){
     Excel.nextLine();
     System.out.println("Ingrese operando valido... ");
     }
     }while(Kakashi);
     }catch
     (InputMismatchException Lorel){
     Excel.nextLine();
     System.out.println("Ingrese operando valido... ");
     }
     }while(Vegeta);
     return Ita;
     }
     
private static CalculadorD obtenerDatos()throws ArithmeticException{
         
    Scanner Rocky = new Scanner(System.in);//Para leer datos
     boolean continuarCiclo = true;//
     boolean continuarCiclo2 = true;
     CalculadorD Sasuke = new CalculadorD();//CalculadorD 
   
     do{
     try{
    
     System.out.println("Ingresa el primer numero: ");
     Sasuke.setNumA(Rocky.nextFloat());
     continuarCiclo=false;
     
     do {
     try
         {
         System.out.println("Ingresa El segundo: ");
         Sasuke.setNumB(Rocky.nextFloat());
         continuarCiclo2=false; 
         }
         catch (InputMismatchException Mael)
         {
          Rocky.nextLine();
          System.out.println(
          "Debe introducir numeros. Intente de nuevo.");
         }   
   
     }while(continuarCiclo2);
         }        
         catch (InputMismatchException Abi)
         {
         Rocky.nextLine();
         System.out.println(
         "Debe introducir numeros. Intente de nuevo.");
         }
         }while(continuarCiclo);
         return Sasuke;
         }
  

    
     public static void main(String[] args){ 
            
        int Goku=0;
        while(Goku != 7){
      
        System.out.println("-----------------Que operacion desea realizar------------------------------");
        System.out.println("1. Suma:");
        System.out.println("2. Resta:");
        System.out.println("3. Multiplicacion:");
        System.out.println("4. Division:");
        System.out.println("5. Raiz:");
        System.out.println("6. Potencia:");
        System.out.println("7. Fin de operacion");
    
        System.out.println("Su eleccion:");
            
        CalculadorD Rocky;//Objeto
        Scanner Terminator = new Scanner (System.in);//lee las lineas que introduzcas 
        try{
        Goku = Terminator.nextInt();
       
   
       
     float R;
     switch(Goku){
      case 1:
     Rocky = obtenerDatos(); 
     R = CalculadoraBasica.sumar(Rocky.getNumA(), Rocky.getNumB()); 
     System.out.println("Resultado:");
     System.out.println(R);
     break;
   
      case 2:
     Rocky = obtenerDatos(); 
     R = CalculadoraBasica.resta(Rocky.getNumA(), Rocky.getNumB()); 
     System.out.println("Resultado:");
     System.out.println(R);
     break;
   
     case 3:
     Rocky = obtenerDatos(); 
     R = CalculadoraBasica.multiplicar(Rocky.getNumA(), Rocky.getNumB()); 
     System.out.println("Resultado:");
     System.out.println(R);
     break;
         
     case 4:
      boolean Larra=true; 
     
   do{ 
     Rocky = obtenerdivision(); 
     R = Calculadoracientifica.division(Rocky.getNumA(), Rocky.getNumB()); 
     if (Rocky.getNumB()  == 0)
      {
     System.out.println("Valor no valido");
      }
     else if (Rocky.getNumB() <= 1)
     {
     Larra=false;
     System.out.println("Resultado:");
     System.out.println(R);
     }
     }while(Larra);
     break;
        
     case 5:
     boolean Mon= true;
     do{
     Rocky = obtenerraiz();
     R = Calculadoracientifica.raiz(Rocky.getNumA());
     if (Rocky.getNumA()<=-1)
     {
     System.out.println("Error numeros negativos");   
     }
     else if (Rocky.getNumB() <= 1)
     {
     Mon=false;
     System.out.println("Resultado:");
     System.out.println(R);
     }
     }while(Mon);
     break;
         
     case 6:
     Rocky = obtenerpotencia(); 
     R = Calculadoracientifica.potencia(Rocky.getNumA(), Rocky.getNumB()); 
     System.out.println("Resultado: ");
     System.out.println(R);
     break;
         
     case 7:
     System.out.println("Adios...."); 
         
     break;
    
     default: 
     System.out.print("Eleccion incorrecta........intente nuevamente\n" );
  
     }
     }catch(Exception e)
     {
     System.out.print("Intente nuevamente....\n ");
     }
     }     
     }
     }