24.- La clase HoraHMS.

24.- La clase HoraHMS. 


import java.util.*;



public class HoraHMS{

    /*La estructura de la clse HoraHMSHMS, con dos atributos que la conforman: h , m y s */              

    private int h;

    private int m;

    private int s;

        

      

    public HoraHMS(int hor, int min, int seg){

    this.h = hor;

    this.m = min;  

    this.s = seg;

    }

    

    public HoraHMS(){

     horaActualHMS();//Usamos el metodo horaAhora() en el constructor, para no repetir código.       

    }

    

    public int getH(){return this.h;}//devuelve this.h;


     public int getM(){return this.m;}//devuelve this.m;

    

    public int getS(){return this.s;}//devuelve this.s;

    

     public void setH(int hor){this.h=hor;}//sustituye this.h por hor;

    

     public void setM(int min){this.m = min;}//sustituye this.m por min

    

     public void setS(int seg){this.s = seg;}//sustituye this.s por seg;



    

    public static void main(String[] arg){//método main para probar

       Scanner t = new Scanner(System.in).useLocale(Locale.US);

        /*Lectura por teclado de una hora:

        HoraHMS entre [0,23];

        Minutos entre [0,59];

        Segundos entre [0,59];

        Resultado: HoraHMS introducida: hora : minutos : segundos;*/

        

        /*System.out.println("Introduzca la hora [0..23]");

        int hora = t.nextInt();

        System.out.println("Introduzca los minutos [0..59]");

        int minutos = t.nextInt();

        System.out.println("Introduzca los segundos [0..59]");

        int segundos = t.nextInt();

        horaA(hora, minutos, segundos);

        horaB(hora, minutos, segundos);

        HoraHMS h1 = new HoraHMS(hora,minutos,segundos);*/

        HoraHMS hora1 = new HoraHMS(00,00,00);

        HoraHMS hora2 = new HoraHMS(12,10,00);

        HoraHMS hora3 = new HoraHMS(12,20,10);

        int a = (hora1.toString().compareTo(hora2.toString()));

        int b = (hora2.toString().compareTo(hora2.toString()));

        int c = (hora3.toString().compareTo(hora2.toString()));

        System.out.println(a+"; "+b+"; "+c);

        

        //System.out.println(h1.aMinutos());

        //h1.toString();

        //String.valueOf(horaAhora()).toString();

        //horaAhora().toString();

        int hor =0;

        do{sHoraActualHMS();}

        while(hor <25);

        

    }    

       

    public  String horaHMS(int hora, int minutos, int segundos){//con otro modo distinto de obtener el formato hh:mm:ss

         String hor = null; String min = null; String seg = null; int n=0;

        hor = "0"+hora;n=hor.length(); hor = hor.substring(n-2); //Le sumamos el caracter o String 0 y luego recortamos a dos caracteres       

        min = "0"+minutos;n=min.length(); min = min.substring(n-2);

        seg = "0"+segundos;n=seg.length(); seg = seg.substring(n-2);

        return "\""+hor+":"+min+":"+seg+"\""+"\f";

    }

    

    public  HoraHMS horaActualHMS(){

        long t= System.currentTimeMillis()/1000;// milisegundos desde el 1 del 1 de 1970 al actual UTC

        long segundosHoy = t %(24*60*60);

        int horasHoy = (int)(segundosHoy/(60*60));//2 horas de diferencia horario verano

        int minutosAhora =(int)((segundosHoy/60))-(horasHoy)*60;

        int segundosAhora = (int)segundosHoy%(60);

        HoraHMS h= new HoraHMS(horasHoy+2,minutosAhora,segundosAhora);//2 horas de diferencia horario verano

        return h;

    }

    

    public static String sHoraActualHMS(){

        long seg = System.currentTimeMillis()/1000;        

        seg = seg%(24*60*60);        

        int hor = (int) seg/(60*60); //2 horas de diferencia horario verano       

        seg = seg-hor*(60*60);        

        int min = (int) seg/60;        

        seg = seg%60;

        hor = hor+2;

        System.out.println(hor+":"+min+":"+seg+"\f");

        return hor+":"+min+":"+seg;

    }

    

    public int aMinutos(){

         int minutos = this.h*60 +this.m;        

         return minutos;

    }

    

    public  String toString(){ //Constructor horas manualmente

        String hh = null;String mm = null; String ss = null;

        HoraHMS h1 = new HoraHMS(h,m,s);

        if(h<=9)hh= 0+""+h;else hh =""+h;

        if(m<=9)mm= 0+""+m;else mm =""+m;

        if(s<=9)ss= 0+""+s;else ss =""+s;

        System.out.println(hh+":"+mm +":"+ss);

        return hh+":"+mm +":"+ss;

    }

    

    public int compareTo(HoraHMS hora2){

        Scanner t = new Scanner(System.in).useLocale(Locale.US);

        HoraHMS hora1 = new HoraHMS(this.h, this.m, this.s);

        System.out.println("Introduzca la hora [0..23]");

        int hora = t.nextInt();

        System.out.println("Introduzca los minutos [0..59]");

        int minutos = t.nextInt();

        System.out.println("Introduzca los segundos [0..59]");

        int segundos = t.nextInt();

        hora2 = new HoraHMS(hora, minutos,segundos);

        int a = (hora1.toString().compareTo(hora2.toString()));

        System.out.println(a);

        return a;

    }

    

    public boolean equals(Object o){

       return  o instanceof HoraHMS 

        && this.h == ((HoraHMS) o).h

        && this.m == ((HoraHMS) o).m

        && this.s == ((HoraHMS) o).s;

    }    

    

    }

  

Comentarios

Publicar un comentario

Entradas populares de este blog

13 Tipo primitivo Char.

Imagen
13 Tipo primitivo Char .  • El tipo char permite representar valores consistentes en un único carácter (letras, dígitos y caracteres especiales).  • Un literal de tipo carácter se representa internamente como un valor entero positivo (sin la representación en complemento a dos).  • Java usa el estándar de codificación de caracteres Unicode para asociar a cada carácter un código numérico. Mediante Unicode es posible representar millones de caracteres diferentes.  • Los 256 primeros caracteres del Unicode coinciden con los del estándar de 8 bits ASCII/ANSI (American Standard Code for Information Interchange / American National Standards Institute). Los literales de tipo char se escriben entre comillas simples.   char aMayus =‘A’,  bMinus =‘b’,   interrog = ‘?’,  digito0 = ‘0’,   espacioEnBlanco = ‘ ’; Además, al codificarse internamente los caracteres como números naturales:       – Hay compatibilidad de char ...
Leer más

11.- Variable constante

 11.- Variable constante Cuando a una variable se le declara con el modificador final sólo admite un valor que es el inicial. Nunca puede cambiar, por eso se le llama tambien variable constante.                         final tipo  nomVariable  = expresion;//expresión del tipo. ejemplo:           final double PI = 3.1416; Este valor es el que utilizará siempre que se llame a PI.
Leer más

27.- Tipos complejos o referencia: Métodos

 27.- Tipos complejos o referencia: Métodos. En cualquier clase Java, y tal como ya hemos visto en las clases predefinidas (Point, String, ...) se van a poder incluir definiciones de métodos de los siguientes tipos:          -  Constructores: Se usan para crear e inicializar un objeto de la clase (con el operador new), entre los que se encuentra el constructor por defecto.           -   Métodos de instancia: Métodos que se aplican, con la notación de punto, sobre un objeto de la clase previamente construido.           -  Métodos estáticos: aquellos que no precisan que exista un objeto de la clase al que se les pueda aplicar.           -  Se denomina objeto en curso al objeto concreto que se está creando o al que se le está aplicando el método. Cada vez que se usa uno de estos métodos se dice que se hace una llamada o invocación al método y se ...
Leer más