CAMBIO DE BASE PARTE II

En este ejercicio , lo que se hizo fue simplemente agregarle un if y algunos else if para los casos en los cuales la base destino es mayor que 10 , si quisieran aumentar las bases disponibles pues simplemente le agregarian otro else if .

=======================================================

import java.io.*;

public class Cambio_base {

    public static void main(String[]args)throws IOException{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Ingresar el numero en base 10 :");
        int numero=Integer.parseInt(br.readLine());
        System.out.println("Ingresar la base numerica a convertir:");
        int base=Integer.parseInt(br.readLine());
        String resultado1="";
        String salida="";
        while(numero>=base){
           int resto=numero%base;
           numero=numero/base;
           if(resto<10){
               resultado1=resultado1+resto;
           }
           else if(resto==10){
               resultado1=resultado1+"A";
           }
           else if(resto==11){
               resultado1=resultado1+"B";
           }
           else if(resto==12){
               resultado1=resultado1+"C";
           }
           else if(resto==13){
               resultado1=resultado1+"D";
           }
           else if(resto==14){
               resultado1=resultado1+"E";
           }
           else if(resto==15){
               resultado1=resultado1+"F";
           }


        }
         resultado1=resultado1+String.valueOf(numero);
         for(int i=resultado1.length()-1;i>=0;i--){
             salida=salida+resultado1.charAt(i);
         }
        System.out.println("El numero en base " + base +" es:");
        System.out.println(salida);
    }

}

========================================================

Aqui una demostracion :

CAMBIO DE BASE , MENORES QUE 10

En este ejemplo se ingresa un numero en base 10 y luego la base a la que se convertirá , con el limitante que esta debe ser menor que 10 ,aún así este código puede ser de ayuda.

==========================================================
import java.io.*;

public class CambioDeBase {

    public static void main(String[]args)throws IOException{

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("*************CAMBIO DE BASE***************");
        System.out.println("==========================================");
        System.out.println("ingrese el numero en base diez: ");
        int numero=Integer.parseInt(br.readLine());
        System.out.println("base numerica final");
        int base=Integer.parseInt(br.readLine());
        String resto2="";
        String salida="";
        while(numero>=base){
            int resto=numero%base;
            numero=numero/base;
            String resto1=String.valueOf(resto);
            resto2=resto2+resto1;
        }
        resto2=resto2+String.valueOf(numero);
      
        for(int i=resto2.length()-1; i>=0 ;i--){
            salida=salida+resto2.charAt(i);
        }
        System.out.println("El numero en base " + base + " es: ");
        System.out.println(salida);
    }
}

=========================================================

EJEMPLO DE AWT

En este ejemplo , vamos a crear una pequeña aplicación que nos calculara el área y el perímetro de un triangulo , introduciendo primero los tres vértices de un triangulo cualquiera, hemos heredado de Frame
ademas implementando WindowsListener, ActionListener, KeyListener para gestionar los eventos de los
botones.
==================================================================
import java.awt.*;
import java.awt.event.*;

public class DibujoPrueba extends Frame implements WindowListener,ActionListener,KeyListener {

    //ELEMENTOS DE NUESTRO FRAME
    private Label L1,L2,L3,L4,L5=null;
    private Label V1,V2,V3,V4,V5,V6=null;
    private TextField T1,T2,T3,T4,T5,T6,T7,T8=null;
    private Button calculo=null;
    private Button limpio=null;
  
    //CONSTRUCTORES
    public DibujoPrueba(){
        super();
        configurarFrame();
    }
    public DibujoPrueba(String titulo){
        super(titulo);
        configurarFrame();
    }
    public void keyPressed(KeyEvent e){

        Object ob=e.getSource();
        char tecla=e.getKeyChar();
        if(ob.equals(T1)){
            if(tecla=='\n'){
                T2.requestFocus();
            }
        }
        if(ob.equals(T2)){
            if(tecla=='\n'){
                T3.requestFocus();
            }
        }
        if(ob.equals(T3)){
            if(tecla=='\n'){
                T4.requestFocus();
            }
        }
        if(ob.equals(T4)){
            if(tecla=='\n'){
                T5.requestFocus();
            }
        }
        if(ob.equals(T5)){
            if(tecla=='\n'){
                T6.requestFocus();
            }
        }
        if(ob.equals(T6)){
            if(tecla=='\n'){
                calcular();
            }
        }
    }
    public void keyReleased(KeyEvent e){}
    public void keyTyped(KeyEvent e){}

    public void aclarar(){
        T1.setText("");
        T2.setText("");
        T3.setText("");
        T4.setText("");
        T5.setText("");
        T6.setText("");
        T7.setText("");
        T8.setText("");
    }

    public void calcular(){
        double x1=0;
        double y1=0;
        double x2=0;
        double y2=0;
        double x3=0;
        double y3=0;

        x1=Double.valueOf(T1.getText()).doubleValue();
        y1=Double.valueOf(T2.getText()).doubleValue();
        x2=Double.valueOf(T3.getText()).doubleValue();
        y2=Double.valueOf(T4.getText()).doubleValue();
        x3=Double.valueOf(T5.getText()).doubleValue();
        y3=Double.valueOf(T6.getText()).doubleValue();

        double area=Math.abs((0.5)*(y1*(x2-x3) + y2*(x3-x1) + y3*(x1-x2)));
        double lado1=Math.sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
        double lado2=Math.sqrt((x2-x3)*(x2-x3) + (y2-y3)*(y2-y3));
        double lado3=Math.sqrt((x1-x3)*(x1-x3) + (y1-y3)*(y1-y3));
        double perimetro=lado1+lado2+lado3;

        T7.setText(String.valueOf(area));
        T8.setText(String.valueOf(perimetro));
              
    }

    public void actionPerformed(ActionEvent e){
        Object ob=e.getSource();
        if(ob.equals(calculo)){
            calcular();
        }
        else if(ob.equals(limpio)){
            aclarar();
        }
    }

    public static void main(java.lang.String[]args){
        DibujoPrueba D1=new DibujoPrueba();
        D1.show();
    }
    private void configurarFrame(){
        this.addWindowListener(this);
        this.setLayout(null);
        this.setBackground(Color.BLUE);
        this.setResizable(true);

        L1=new Label("VERTICE 1");
        L1.setBounds(20,40,70,20);
        add(L1);

        L2=new Label("VERTICE 2");
        L2.setBounds(20,60,70,20);
        add(L2);

        L3=new Label("VERTICE 3");
        L3.setBounds(20,80,70,20);
        add(L3);

        L4=new Label("AREA");
        L4.setBounds(20,120,70,20);
        add(L4);

        L5=new Label("PERIMETRO");
        L5.setBounds(20,140,80,20);
        add(L5);

        V1=new Label("X1");
        V1.setBounds(160,40,100,20);
        add(V1);

        V2=new Label("Y1");
        V2.setBounds(450,40,100,20);
        add(V2);

        V3=new Label("X2");
        V3.setBounds(160,60,100,20);
        add(V3);

        V4=new Label("Y2");
        V4.setBounds(450,60,100,20);
        add(V4);

        V5=new Label("X3");
        V5.setBounds(160,80,100,20);
        add(V5);

        V6=new Label("Y3");
        V6.setBounds(450,80,100,20);
        add(V6);

        T1=new TextField();
        T1.setBounds(270,40,80,20);
        T1.addKeyListener(this);
        add(T1);

        T2=new TextField();
        T2.setBounds(560,40,80,20);
        T2.addKeyListener(this);
        add(T2);

        T3=new TextField();
        T3.setBounds(270,60,80,20);
        T3.addKeyListener(this);
        add(T3);

        T4=new TextField();
        T4.setBounds(560,60,80,20);
        T4.addKeyListener(this);
        add(T4);

        T5=new TextField();
        T5.setBounds(270,80,80,20);
        T5.addKeyListener(this);
        add(T5);

        T6=new TextField();
        T6.setBounds(560,80,80,20);
        T6.addKeyListener(this);
        add(T6);

        T7=new TextField();
        T7.setBounds(140,120,100,20);
        T7.addKeyListener(this);
        add(T7);

        T8=new TextField();
        T8.setBounds(140,140,100,20);
        T8.addKeyListener(this);
        add(T8);

        calculo=new Button("CALCULAR");
        calculo.setBounds(20,160,100,20);
        calculo.addActionListener(this);
        add(calculo);

        limpio=new Button("RESET");
        limpio.setBounds(20,180,100,20);
        limpio.addActionListener(this);
        add(limpio);

        setSize(700,210);
        setLocation(200,200);

    }
    public void windowActivated(WindowEvent e){}
    public void windowClosed(WindowEvent e){}
    public void windowClosing(WindowEvent e){
        Window w=e.getWindow();
        if(w.equals(this)){
            this.dispose();
            System.exit(0);
        }
    }
    public void windowDeactivated(WindowEvent e){}
    public void windowDeiconified(WindowEvent e){}
    public void windowIconified(WindowEvent e){}
    public void windowOpened(WindowEvent e){}
}

============================================================

Aqui , podemos ver el resultado de nuestro pequeño codigo.

Rotacion de caracteres

En este problema lo que se quiere es rotar los caracteres de una determinada palabra o frase , el cual se ingresara por consola , por ejemplo :
Se ingresa JAVA , entonces la salida tiene que ser :
JAVA
AJAV
VAJA
AVAJ
JAVA
Es decir la palabra rotara hasta que vuelva a quedar ordenada. Aquí se hizo uso de dos métodos ampliamente usados de la clase String , como son charAt() y substring( inicio  ,  fin ) .

He aquí el código :
================================================================

import java.io.*;

public class Rotacion {

    public static void main(String[]args)throws IOException{

        int i;
        String entrada;
        String salida;


        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Ingrese la frase a rotar :");
        entrada=br.readLine();

        for(i=0;i<=entrada.length()-1;i++){

            entrada=entrada.charAt(entrada.length()-1)+ entrada.substring(0,entrada.length()-1);
            System.out.println(entrada);
        }
      
    }
}

================================================================

He aquí la simulación :

Métodos Estáticos

Generalmente los metodos y los campos usados en una clase estan asociados a los objetos , sin embargo no siempre es así , ya que puede haber métodos genéricos cuya finalidad no dependa del objeto a tratar, a estos métodos se les suele llamar métodos estáticos.  Puesto que el método estático no depende de un objeto en particular podemos invocarlo sin tener que crear un objeto  , la sintaxis en esta caso seria :         Nombre_De_La_Clase . método();  aunque si se le llama desde el interior de la misma clase solo bastaria escribir el nombre del metodo .

Por ejemplo en la clase Motocicleta :

       class Motocicleta  {
      
             String color;
             String marca;
             int placa;
         static  int ruedas=2;
          static int  numRuedas () {
                   return  ruedas;
                                          }
                                  
                   }
 Solo he colocado un método que nos da el numero de  ruedas de la motocicleta , pero como todas las motocicletas tienen dos ruedas , entonces podemos decir que el numero de ruedas no depende de ningún objeto en particular de la clase Motocicleta y por lo tanto lo podemos considerar un método estático.

Ordenar numeros de menor a mayor

En este ejemplo , se preguntara primero cuantos números se van a ingresar para luego introducir los mismos y finalmente se mostraran los números de menor a mayor . Observe que se usa un array llamado datos   para guardar los números y luego compararlos entre si , para obtener los números ordenados.
Código :

===============================================================

import java.io.*;

public class Ordenar {

    public static void main(String[]args)throws IOException{

               int i,n;
               BufferedReader br;
               br=new BufferedReader(new InputStreamReader(System.in));

          System.out.println("Cuantos numeros va  a ingresar :");
          n=Integer.parseInt(br.readLine());
          System.out.println("Usted ingresara " + n + " numeros");
          int datos[]= new int[n];
          System.out.println("Ingrese los numeros :"  );
          for(i=0;i<n;i++){
               datos[i]=Integer.parseInt(br.readLine()); }

          for(i=0;i<n-1;i++)                                             {

              int min=i;
                   for(int j=i+1;j<n;j++)     {
                       if(datos[j]<datos[min])      {
                       min=j;}
                                              }
                  if(i!=min){
                       int aux =datos[i];
                       datos[i]=datos[min];
                       datos[min] = aux;}



                                                                          }
          System.out.println("Los numeros de menor a manor son :");
          for(int k=0; k<n;k++)

            System.out.print(datos[k] + "  ");
    }

   }

===============================================================

Simulacion : 

Ejemplo sobre promedios

En este ejemplo se mostrara un pequeño codigo sobre promedio de notas, en el cual primero se  preguntara cuantas notas va a ingresar para luego introducir las mismas y como resultado nos dira el promedio de estas y a parte nos dira cuales de estas notas fueron superiores al promedio :
Codigo :
==============================================================

import java.io.*;

public class Promedio {

  
    public Promedio(){
        super();
    }

    public static void main(String[]args)throws IOException{

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        System.out.println("Cuantas notas va a ingresar: ");
        int numNotas=Integer.parseInt(br.readLine());
        int []notas=new int[numNotas];
        double promedio=0;
       double acumulado=0;
        for(int i=0;i<=numNotas-1;i++){
            System.out.println("Ingrese la nota numero " +i );
            notas[i]=Integer.parseInt(br.readLine());
            acumulado=acumulado + notas[i];
                                      }
         promedio=acumulado/numNotas;
        System.out.println("el promedio es :" + promedio);
        System.out.println("===========================");
        System.out.println("LAS NOTAS MAYORES AL PROMEDIO SON: ");
       for(int j=0;j<=numNotas-1;j++){
           if(notas[j]>promedio){
            
               System.out.println(notas[j]);
           }
          }
      }
}
===============================================================

Simulacion :