Programación: agosto 2017

jueves, 31 de agosto de 2017

ejercicio figuras geometricas

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package poo_figurasgeometrica;

/**
*
* @author SEDUCA
*/
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Cuadrado cua=new Cuadrado(10);
        Rectangulo rec=new Rectangulo(5,10);
        Triangulo tri=new Triangulo(5,5,5);

        System.out.println(cua.getArea()+" Esta es el Area del Cuadrado");

        System.out.println(cua.getPerimetro()+" Este es el Perimetro");



        System.out.println(rec.getArea()+" Esta es el Area del Rectangulo");

       System.out.println(rec.getPerimetro()+" Este es el Perimetro del Rectangulo");

        System.out.println(tri.getArea()+" Este es el Area del Triangulo");
        System.out.println(tri.getPerimetro()+" Este es el Perimetro");
    }


}

--------------------------

package poo_figurasgeometrica;

/**
*
* @author SEDUCA
*/
public abstract class FiguraGeometricas {
public abstract double getArea();
public abstract int getPerimetro();

}
...--------------------------------------
* and open the template in the editor.
*/
package poo_figurasgeometrica;

/**
*
* @author SEDUCA
*/

public class Rectangulo extends FiguraGeometricas {

    //Atributo
    private int base;
    private int altura;

    //Constructor
    public Rectangulo(int base,int altura){
       this.base=base;
       this.altura=altura;
    }

    //implemento el metodo adstracto que herede de persona:
    @Override
    public double getArea(){
        return (double)this.base*this.altura;
    }

    @Override
    public int getPerimetro (){
        return (this.base*2)+(this.altura*2);
    }
}

--------------------------------

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package poo_figurasgeometrica;

/**
*
* @author SEDUCA
*/
public class Cuadrado extends FiguraGeometricas{

    //Atributo
    private int lado;

    //Constructor
    public Cuadrado(int lado){
       this.lado=lado;
    }

    //implemento el metodo adstracto que herede de persona:
    @Override
    public double getArea(){
        return this.lado*this.lado;


    }
    @Override
    public int getPerimetro (){
        return this.lado*4;


    }


}
-----------------------------

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package poo_figurasgeometrica;

/**
*
* @author SEDUCA
*/
public class Triangulo extends FiguraGeometricas{
    private int lado1;
    private int lado2;
    private int lado3;

    //constructor

    public Triangulo(int lado1,int lado2,int lado3){
        this.lado1=lado1;
        this.lado2=lado2;
        this.lado3=lado3;


    }

    @Override
    public int getPerimetro() {
        return this.lado1+this.lado2+this.lado3;
    }

    @Override
    public double getArea() {
        double s= (double)this.getPerimetro()/2;
        double a= (double)this.lado1;
        double b=(double)this.lado2;
        double c=(double)this.lado3;
        return Math.sqrt(s*(s-a)*(s-b)*(s-c));
    }

}
--------------------------------

jueves, 17 de agosto de 2017

main del perro en movimiento

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
* @author SEDUCA
*/
public class Main {

     /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        //crear la clase (P1) dentro del principal

        Perro p1=new Perro();

       // p1.setNombre("Sultan");
        //p1.setRaza("Pincher");
        //p1.setNivelHambre(5);


       // System.out.println(p1.getNombre());
        //System.out.println(p1.getRaza());
        //System.out.println(p1.getnivelHambre());

            Perro p2=new Perro("Tomy","Dogo",5);
           // System.out.println(p2);

            p2.alimentar(2);
            p2.alimentar(2);
            p2.alimentar(1);
        //impresiones por pantallas utilizando el toString y Override

       // System.out.println(p1);

    }

}

perro con objetos y sus movimientos

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
* @author SEDUCA
*/
public class Perro {
//atributos:
    private String nombre;
    private String raza;
    private int nivelHambre;

    //constructor vacio
    public Perro( ){


    }
    //constructor sobre cargado
    public Perro(String Nombre, String Raza, int nivelHambre){
        this.nombre=nombre;
        this.raza=raza;
        this.nivelHambre=nivelHambre;
    }
    //setters: //recibe unargumento y lo envia a un elemento que es this.nombre
    public void setNombre(String nombre){
        this.nombre=nombre;
    }
    public void setRaza(String raza){
        this.raza=raza;
    }

    public void setNivelHambre(int nivelHambre){
        this.nivelHambre=nivelHambre;
    }


    //Getters:
    public String getNombre(){
        return this.nombre;

    }

    public String getRaza(){
        return this.raza;

    }

    public int getnivelHambre(){
        return this.nivelHambre;

    }

    //sobre escritura del metodo "toString()"
// @Override
    //public String toString(){

   //return "Esto es un perro -->>"+this.nombre+" "+
   ///       this.raza+" "+
      //   this.nivelHambre;


    //}
    //*************************
    public void alimentar(int porciones){
        if(this.nivelHambre==10){
            System.out.println("El perro esta lleno no se le puede alimentar");
        }else{
        if((this.nivelHambre+porciones)==10){
            System.out.println("ya se lleno");
            this.nivelHambre=this.nivelHambre+porciones;

        }else{
            if((this.nivelHambre+porciones)<10){

                System.out.println("todavia puede comer un poco mas");
                this.nivelHambre=this.nivelHambre+porciones;

            }else{

                System.out.println("se lleno y sobraron"+
                        (this.nivelHambre+porciones-10)+" porciones ");
                        this.nivelHambre= 10;
            }
        }


}}
}

martes, 15 de agosto de 2017

clase auto main

/* main
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package javaapplication8;

/**
*
* @author SEDUCA
*/
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        Auto a1=new Auto();
        System.out.println(a1);

        a1.setMarca("Ford");
        a1.setModelo("Focus");
        a1.setCilindrada(2000);
        a1.setVelocidad(0);

        System.out.println("Marca: "+ a1.getMarca());
        System.out.println("Modelo: "+ a1.getModelo());
        System.out.println("Cilindrada: "+ a1.getCilindrada());
        System.out.println("Velocidad: "+ a1.getVelocidad());

        System.out.println(a1);
        a1.acelerar(10);
        System.out.println(a1);

        Auto a2=new Auto("Volkswagen","Gol",1600,0);
        System.out.println(a2);
        a2.acelerar(100);
        System.out.println(a2);



    }

}

martes, 1 de agosto de 2017

pilas

CLASE STACK

A continuación vamos a explicar la clase Stack de

Java, que implementa la

interface List. Stack se

traduce por “pila” y para recordar su significado

podemos pensar en una pila de libros. También

veremos las características más im

portantes de esta nueva implementación y haremos un ejemplo a

modo de ejercicio.

STACK

La clase Stack es una clase de las llamadas de tipo LIFO

(Last In - First Out, o último en entrar - primero

en salir). Esta clase hereda de la clase que ya hemo

s estudiado anteriormente en el curso Vector y con 5

operaciones permite tratar un vector a modo de pila o stack.

Las operaciones básicas son

push

(que introduce un elemento en la pila),

pop

(que saca un elemento de

la pila),

peek

(consulta el primer elemento de la cima de la pila),

empty

(que comprueba si la pila está

vacía) y

(que busca un determinado elemento dentro de la pila y devuelve su posición dentro de

ella).

Esta clase es muy sencilla y al crear un objeto de ti

po Stack con el constructo

r básico evidentemente no

contendrá ningún elemento.

Un conjunto mucho más completo y consistente para operaciones de stack LIFO es proporcionado en la

interface Deque y sus implementaciones, pero nosotr

os de momento vamos a limitarnos al estudio de

la clase Stack.

EJEMPLO USO CLASE STACK

Realizaremos un ejemplo a modo de uso de pila. Un

o de los casos más usados en informática de una

pila es el de querer verificar si una determinada se

ntencia o instrucción está equilibrada en cuanto a

número de paréntesis, corchetes o llaves de aper

tura y cierre. Cuando se escribe código de

programación si no existe equilibrio entre signos de

apertura (por ejemplo un paréntesis de apertura) y

cierre (por ejemplo un paréntesis de cierre) ni siquiera debería procesarse la sentencia ya que no

estaría formalmente bien construida. De esto se enca

rgan los analizadores léxicos de los compiladores.

Así que vamos a utilizar esta vez tan solo una clas

e Programa con el método main, donde vamos a ir

analizando una sentencia para verificar si es equili

brada o no en símbolos de paréntesis, recorriendo

todos sus caracteres desde el

inicio hasta el final.

Iremos construyendo nuestra pila apilando un símbolo (cada vez que detectemos un símbolo de

apertura o desapilando de ella cuando detectemos un símbolo de cierre. Tendremos que ir analizando

Interface List del api java. Clas

e Stack. Ejemplos resueltos.

todos los caracteres de una expresión y actuar cuan

do detectemos un paréntesis, operando en función

de si el paréntesis leído es de abrir (“(”) o cerrar (“)”

). El equilibrio en la escritura vendrá determinado al

terminar el análisis en función de si la pila está

vacía (hay equilibrio) o contiene algún elemento (no hay

equilibrio).

Ejemplo: analizamos la expresión “Hay varios país

es (México, España) que comparten el mismo idioma

(español o castellano).”

El resultado al finalizar el análisis de la sentenci

a sería que la pila está vacía, y esto querrá decir que

nuestra sentencia es equilibrada en paréntesis y por tanto el resultado es correcto.

Si analizáramos la expresión “Hay varios países

(México, España) que comparten el mismo idioma

(español o castellano.”

El resultado al finalizar el análisis será que la p

ila contiene un paréntesis, lo que quiere decir que la

expresión no es equilibrada y no tiene el mism

o número de paréntesis abiertos que cerrados.

Tendremos que tener en cuenta casos especiales como una expresión cuyo primer elemento sea un

paréntesis de cierre. Por ejemplo: “Hay varios pa

íses )México, España(“

la consideraríamos una

expresión incorrecta ya que si la pila está vacía

el primer elemento siempre tendrá que ser un

paréntesis de apertura y no uno de cierre. Tendremos en cuenta por tanto que además de equilibrio

exista corrección en la forma de construcción (que

no puedan existir cierres de paréntesis que no se

hayan abierto).

Vamos a escribir ahora el siguiente

código con el que vamos a trabajar:

/* Ejemplo Interface List, clase Stack aprenderaprogramar.com */

import java.util.Stack;

public class

Programa

{

public static void main(String arg[]) {

String cadenano = "(Cadena no equilibrada en paréntesis(()()()))))";

String cadenasi = "(Cadena equilibrada en parentesis())";

System.out.println("Verifica

ción equilibrado en paré

ntesis para cadenano:");

System.out.p

rintln(verificaParentesis(cadenano));

System.out.println("Verifica

ción equilibrado en paré

ntesis para cadenasi:");

System.out.println(verificaParentesis(cadenasi));

}

public static boolean

verificaParentesis

(String cadena) {

Stack<String> pila = new Stack<String>(); int i = 0;

while (i<cadena.length()) {

// Recorremos la expresión carácter a carácter

if(cadena.charAt(i)=='(') {pila.push("(");}

// Si el paréntesis es de apertura apilamos siempre

else if (cadena.charAt(i)==')') {

// Si el paréntesis es de cierre actuamos según el caso

if (!pila.empty()){ pila.pop(); }

// Si la pila no está vacía desapilamos

else { pila.push(")"); break; }

// La pila no puede empezar con un cierre, apilamos y salimos

}

i++;

}

if(pila.empty()){ return true; } else { return false; }

}

------------------------------------------------------------------------------------------------------

http://www.aprenderaprogramar.com/attachments/article/608/CU00923C%20Estructura%20de%20datos%20pila%20clase%20stack%20api%20java%20ejemplo%20resuelto.pdf

http://lineadecodigo.com/java/crear-una-pila-en-java/

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package javaapplication1;

import java.util.Stack;

/**
*
* @author SEDUCA
*/
public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        Stack<String> pilaNombres=new Stack<>();
        System.out.println(pilaNombres);
        pilaNombres.push("Jose");
        pilaNombres.push("Daniel");
        pilaNombres.push("Pedro");
        pilaNombres.push("Juan");

        System.out.println(pilaNombres); //muestra todos los elementos existentesen la pila
        System.out.println(pilaNombres.size()); //muestra la cantidad de elementos
        System.out.println(pilaNombres.peek()); //muestra el ultimo elemento sin sacar
        pilaNombres.pop();

       System.out.println(pilaNombres);
       System.out.println(pilaNombres.size());
       System.out.println(pilaNombres.peek());

       System.out.println("Saco la ultima que es:"+pilaNombres.pop());
       System.out.println(pilaNombres);
       pilaNombres.push("Fernando");
       if(! pilaNombres.isEmpty()){
          System.out.println(pilaNombres.pop());
       }

            }
}

otro ejercicio con procedimiento

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package ejercicio_pila_revertir;

import java.util.Stack;

/**
*
* @author SEDUCA
*/
public class Ejercicio_pila_revertir {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Stack<String> pilaNombres=new Stack<>();


        System.out.println(pilaNombres);
        pilaNombres.push("Jose");
        pilaNombres.push("Daniel");
        pilaNombres.push("Pedro");
        pilaNombres.push("Juan");


         InvertirPila(pilaNombres);

       }
       public static void InvertirPila(Stack<String> pPila){

       Stack<String> pilaAux=new Stack<>();
        Stack<String> pilaAux2=new Stack<>();

             while (!pPila.isEmpty()){
                 pilaAux.push(pPila.pop());

            }
            System.out.println(pilaAux);

            while (!pilaAux.empty()){
                 pilaAux2.push(pilaAux.pop());

            }

            System.out.println(pilaAux2);

            while (!pPila.empty()){
                 pPila.push(pilaAux2.pop());

            }

            System.out.println(pPila);


       }
            }

Programación