Как написать часы на java

I’m making a digital clock for a project and I have four classes: DigitalTimeUI, which is the JFrame class, TitlePanel, DigitPanel, and ColonPanel, which are JPanels for the item stated. When it is finished, it should look like this:

enter image description here

The part I am stuck on is adding the DigitPanels to the frame in the UI class. Here’s what I have in the main class right now:

public class DigitalTimeUI extends JFrame {

public static GregorianCalendar currentDate;
final static int CLOCKWIDTH = 605;
final static int CLOCKHEIGHT = 200;

public static void main(String[] args) {
    int numOfDigits = 6;
    int startingX = 0;
    int startingY = 0;

    Font clockFont = new Font("Tahoma", Font.BOLD, 72);
    JFrame clock = new JFrame();

    clock.setSize(CLOCKWIDTH, CLOCKHEIGHT);
    clock.setVisible(true);
    clock.setResizable(false);
    clock.setDefaultCloseOperation(EXIT_ON_CLOSE);

    TitlePanel titlePanel = new TitlePanel();
    JLabel title = new JLabel("DIGITAL CLOCK");
    title.setFont(clockFont);
    title.setForeground(Color.BLACK);
    titlePanel.add(title);
    clock.add(titlePanel);

    DigitPanel digitPanel = new DigitPanel();
    JLabel digit;
    startingY = 115;
    while (numOfDigits > 0) {
        if ((numOfDigits % 2) == 0) {
            startingX += 5;
            digit = new JLabel(String.valueOf(0));

        }

    }
  }
}

The code is kind of a mess right now, I’ve still got some cleaning up to do after I get that last part figured out. That bottom part is just some scrap from my attempts to display the 6 digit fields. I think the main problem I’m having is finding a way to split up the time returned from GregorianCalendar and put them into 6 different boxes, then an efficient way to put them into the frame using a while loop or whatnot.

To clarify: The above picture was given to me by the instructor as a guideline to go by when formatting my clock. It also has 9 panels in it. The «DIGITAL TIME» is a panel of the TitlePanel class. The digit boxes are of the DigitPanel class and there are 6 of them. The colon boxes are of the ColonPanel class and there are two of them. The issue I am having is with splitting up the time into 6 different boxes. Like, where the picture shows «48», I need a way to take the value from GregorianCalendar.MINUTE or whatever and split it into a 4 and an 8 to put into each of those boxes. Thanks.

Источник

Introduction

In this article, we are going to describe how to make an analogue clock using the Graphics class in Java. To make an analogue clock we need to use the Thread and Graphics Classes of Java. The threading concept is used to move the second, minute and hours hands of the clock and the Graphics class is used to create a line and oval and colour of the hands.

These are the steps for creating an analogue clock.

Step 1: Import the necessary packages.

  1. import java.awt.Color;  
  2. import java.awt.Font;  
  3. import java.awt.Graphics;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.Date;  
  6. import java.util.Locale;  
  7. import javax.swing.JFrame;  
  8. import javax.swing.JPanel; 

Step 2: Define a variable and make the object of the SimpleDate format class. Here the xcenter and ycenter variables are used to define the centre coordinate of the clock and the lastxs and lastys variables used to define the End coordinate of the second’s hand and the other variables are lastxm, lastym, lastxh, lastyh are also used for defining the end coordinate of the minutes and hours hands.

  1. Thread thread = null;  
  2. SimpleDateFormat formatter = new SimpleDateFormat(«s», Locale.getDefault());  
  3. Date currentDate;  
  4. int xcenter = 175, ycenter = 175, lastxs = 0, lastys = 0, lastxm = 0, lastym = 0,  
  5. lastxh = 0,lastyh = 0; 

Step 3: We are creating a structured method for the design of the analog clock. In this method we set the digit (3,6,9,12) coordinates and create an oval and set the color of digit and oval.

  1. private void drawStructure(Graphics g)   
  2. {  
  3.  g.setFont(new Font(«TimesRoman», Font.BOLD, 20));  
  4.  g.setColor(Color.black);  
  5.  g.fillOval(xcenter — 150, ycenter — 150, 300, 300);  
  6.  g.setColor(Color.blue);  
  7.  g.drawString(«abhishek dubey», 113, 300);  
  8.  g.setColor(Color.green);  
  9.  g.drawString(«9», xcenter — 145, ycenter + 0);  
  10.  g.drawString(«3», xcenter + 135, ycenter + 0);  
  11.  g.drawString(«12», xcenter — 10, ycenter — 130);  
  12.  g.drawString(«6», xcenter — 10, ycenter + 145);  
  13. }   

Step 4: Calculate the seconds, minutes and hours coordinates from the current time by getting the system time. And convert the value into an integer form.

  1. xsecond = (int) (Math.cos(second * 3.14f / 30 — 3.14f / 2) * 120 + xcenter);  
  2. ysecond = (int) (Math.sin(second * 3.14f / 30 — 3.14f / 2) * 120 + ycenter);  
  3. xminute = (int) (Math.cos(minute * 3.14f / 30 — 3.14f / 2) * 100 + xcenter);  
  4. yminute = (int) (Math.sin(minute * 3.14f / 30 — 3.14f / 2) * 100 + ycenter);  
  5. xhour = (int) (Math.cos((hour * 30 + minute / 2) * 3.14f / 180 — 3.14f / 2) * 80 + xcenter);  
  6. yhour = (int) (Math.sin((hour * 30 + minute / 2) * 3.14f / 180 — 3.14f / 2) * 80 + ycenter;} 

Step 5: For moving needle logics. Actually in the following line we define some general condition that is found in all types of clocks such as when the seconds hand reaches 12 then the minutes hand moves 1 step and then after moving 5 steps of the minutes hand then 1-stepmoves a hours needle.

  1. g.setColor(Color.magenta);  
  2. if (xsecond != lastxs || ysecond != lastys)   
  3. {  
  4.  g.drawLine(xcenter, ycenter, lastxs, lastys);  
  5. }  
  6. if (xminute != lastxm || yminute != lastym)   
  7. {  
  8.  g.drawLine(xcenter, ycenter — 1, lastxm, lastym);  
  9.  g.drawLine(xcenter — 1, ycenter, lastxm, lastym);  
  10. }  
  11. if (xhour != lastxh || yhour != lastyh)   
  12. {  
  13.  g.drawLine(xcenter, ycenter — 1, lastxh, lastyh);  
  14.  g.drawLine(xcenter — 1, ycenter, lastxh, lastyh);  
  15. }  
  16. g.setColor(Color.magenta);  
  17. g.drawLine(xcenter, ycenter, xsecond, ysecond);   

Step 6: For moving needle minute and hours. this code for set the color of needle and moving forward rest of if conditions.

  1. g.setColor(Color.red);  
  2. g.drawLine(xcenter, ycenter — 1, xminute, yminute);  
  3. g.drawLine(xcenter — 1, ycenter, xminute, yminute);  
  4. g.setColor(Color.green);  
  5. g.drawLine(xcenter, ycenter — 1, xhour, yhour);  
  6. g.drawLine(xcenter — 1, ycenter, xhour, yhour);  
  7. lastxs = xsecond;  
  8. lastys = ysecond;  
  9. lastxm = xminute;  
  10. lastym = yminute;  
  11. lastxh = xhour;  
  12. lastyh = yhour;

Step 7: Define the method of Runable Interface. In the following, all the methods of the Runable interface must be overriden with the definitons of their own functionality within the stop method we pass 100 microseconds and this method throws an interrupt exception so these are put into a try block.

  1. public void start()   
  2. {  
  3.  if (thread == null)   
  4.  {  
  5.   thread = new Thread(this);  
  6.   thread.start();  
  7.  }  
  8. }  
  9. public void stop()   
  10. {  
  11.  thread = null;  
  12. }  
  13. public void run()   
  14. {  
  15.  while (thread != null)   
  16.  {  
  17.   try   
  18.   {  
  19.    Thread.sleep(100);  
  20.   } catch (InterruptedException e) {}  
  21.   repaint();  
  22.  }  
  23.  thread = null;  
  24. }  
  25. public void update(Graphics g)   
  26. {  
  27.  paint(g);  
  28. }   

Step 8: Creating a frame within main methods. In the following code we define three things creating the object of the Color and Frame Clock classes and set the background color and add a content pane on the frame.

  1. public static void main(String args[])   
  2. {  
  3.  JFrame window = new JFrame();  
  4.  Color c = new Color(118, 73, 190);  
  5.  window.setBackground(c);  
  6.  window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  7.  window.setBounds(0, 0, 400, 400);  
  8.  Clock clock = new Clock();  
  9.  window.getContentPane().add(clock);  
  10.  window.setVisible(true);  
  11.  clock.start();  
  12. }  

Complete Code

  1. import java.awt.Color;  
  2. import java.awt.Font;  
  3. import java.awt.Graphics;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.Date;  
  6. import java.util.Locale;  
  7. import javax.swing.JFrame;  
  8. import javax.swing.JPanel;  
  9. public class Clock extends JPanel implements Runnable  
  10. {  
  11.  Thread thread = null;  
  12.  SimpleDateFormat formatter = new SimpleDateFormat(«s», Locale.getDefault());  
  13.  Date currentDate;  
  14.  int xcenter = 175, ycenter = 175, lastxs = 0, lastys = 0, lastxm = 0, lastym = 0, lastxh = 0, lastyh = 0;  
  15.  private void drawStructure(Graphics g) {  
  16.   g.setFont(new Font(«TimesRoman», Font.BOLD, 20));  
  17.   g.setColor(Color.black);  
  18.   g.fillOval(xcenter — 150, ycenter — 150, 300, 300);  
  19.   g.setColor(Color.blue);  
  20.   g.drawString(«abhishek dubey», 113, 300);  
  21.   g.setColor(Color.green);  
  22.   g.drawString(«9», xcenter — 145, ycenter + 0);  
  23.   g.drawString(«3», xcenter + 135, ycenter + 0);  
  24.   g.drawString(«12», xcenter — 10, ycenter — 130);  
  25.   g.drawString(«6», xcenter — 10, ycenter + 145);  
  26.  }  
  27.  public void paint(Graphics g)   
  28.  {  
  29.   int xhour, yhour, xminute, yminute, xsecond, ysecond, second, minute, hour;  
  30.   drawStructure(g);  
  31.   currentDate = new Date();  
  32.   formatter.applyPattern(«s»);  
  33.   second = Integer.parseInt(formatter.format(currentDate));  
  34.   formatter.applyPattern(«m»);  
  35.   minute = Integer.parseInt(formatter.format(currentDate));  
  36.   formatter.applyPattern(«h»);  
  37.   hour = Integer.parseInt(formatter.format(currentDate));  
  38.   xsecond = (int)(Math.cos(second * 3.14 f / 30 — 3.14 f / 2) * 120 + xcenter);  
  39.   ysecond = (int)(Math.sin(second * 3.14 f / 30 — 3.14 f / 2) * 120 + ycenter);  
  40.   xminute = (int)(Math.cos(minute * 3.14 f / 30 — 3.14 f / 2) * 100 + xcenter);  
  41.   yminute = (int)(Math.sin(minute * 3.14 f / 30 — 3.14 f / 2) * 100 + ycenter);  
  42.   xhour = (int)(Math.cos((hour * 30 + minute / 2) * 3.14 f / 180 — 3.14 f / 2) * 80 + xcenter);  
  43.   yhour = (int)(Math.sin((hour * 30 + minute / 2) * 3.14 f / 180 — 3.14 f / 2) * 80 + ycenter);  
  44.     
  45.   g.setColor(Color.magenta);  
  46.   if (xsecond != lastxs || ysecond != lastys)   
  47.   {  
  48.    g.drawLine(xcenter, ycenter, lastxs, lastys);  
  49.   }  
  50.   if (xminute != lastxm || yminute != lastym)   
  51.   {  
  52.    g.drawLine(xcenter, ycenter — 1, lastxm, lastym);  
  53.    g.drawLine(xcenter — 1, ycenter, lastxm, lastym);  
  54.   }  
  55.   if (xhour != lastxh || yhour != lastyh)   
  56.   {  
  57.    g.drawLine(xcenter, ycenter — 1, lastxh, lastyh);  
  58.    g.drawLine(xcenter — 1, ycenter, lastxh, lastyh);  
  59.   }  
  60.   g.setColor(Color.magenta);  
  61.   g.drawLine(xcenter, ycenter, xsecond, ysecond);  
  62.   g.setColor(Color.red);  
  63.   g.drawLine(xcenter, ycenter — 1, xminute, yminute);  
  64.   g.drawLine(xcenter — 1, ycenter, xminute, yminute);  
  65.   g.setColor(Color.green);  
  66.   g.drawLine(xcenter, ycenter — 1, xhour, yhour);  
  67.   g.drawLine(xcenter — 1, ycenter, xhour, yhour);  
  68.   lastxs = xsecond;  
  69.   lastys = ysecond;  
  70.   lastxm = xminute;  
  71.   lastym = yminute;  
  72.   lastxh = xhour;  
  73.   lastyh = yhour;  
  74.  }  
  75.  public void start()   
  76.  {  
  77.   if (thread == null)   
  78.   {  
  79.    thread = new Thread(this);  
  80.    thread.start();  
  81.   }  
  82.  }  
  83.  public void stop()   
  84.  {  
  85.   thread = null;  
  86.  }  
  87.  public void run()   
  88.  {  
  89.   while (thread != null)   
  90.   {  
  91.    try   
  92.    {  
  93.     Thread.sleep(100);  
  94.    }   
  95.    catch (InterruptedException e) {}  
  96.    repaint();  
  97.   }  
  98.   thread = null;  
  99.  }  
  100.  public void update(Graphics g)   
  101.  {  
  102.   paint(g);  
  103.  }  
  104.  public static void main(String args[])   
  105.  {  
  106.   JFrame window = new JFrame();  
  107.   Color c = new Color(118, 73, 190);  
  108.   window.setBackground(c);  
  109.   window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  110.   window.setBounds(0, 0, 400, 400);  
  111.   Clock clock = new Clock();  
  112.   window.getContentPane().add(clock);  
  113.   window.setVisible(true);  
  114.   clock.start();  
  115.  }  
  116. }   

OUTPUT

 

 

Источник

Introduction

In this article, we are going to describe how to make an analogue clock using the Graphics class in Java. To make an analogue clock we need to use the Thread and Graphics Classes of Java. The threading concept is used to move the second, minute and hours hands of the clock and the Graphics class is used to create a line and oval and colour of the hands.

These are the steps for creating an analogue clock.

Step 1: Import the necessary packages.

  1. import java.awt.Color;  
  2. import java.awt.Font;  
  3. import java.awt.Graphics;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.Date;  
  6. import java.util.Locale;  
  7. import javax.swing.JFrame;  
  8. import javax.swing.JPanel; 

Step 2: Define a variable and make the object of the SimpleDate format class. Here the xcenter and ycenter variables are used to define the centre coordinate of the clock and the lastxs and lastys variables used to define the End coordinate of the second’s hand and the other variables are lastxm, lastym, lastxh, lastyh are also used for defining the end coordinate of the minutes and hours hands.

  1. Thread thread = null;  
  2. SimpleDateFormat formatter = new SimpleDateFormat(«s», Locale.getDefault());  
  3. Date currentDate;  
  4. int xcenter = 175, ycenter = 175, lastxs = 0, lastys = 0, lastxm = 0, lastym = 0,  
  5. lastxh = 0,lastyh = 0; 

Step 3: We are creating a structured method for the design of the analog clock. In this method we set the digit (3,6,9,12) coordinates and create an oval and set the color of digit and oval.

  1. private void drawStructure(Graphics g)   
  2. {  
  3.  g.setFont(new Font(«TimesRoman», Font.BOLD, 20));  
  4.  g.setColor(Color.black);  
  5.  g.fillOval(xcenter — 150, ycenter — 150, 300, 300);  
  6.  g.setColor(Color.blue);  
  7.  g.drawString(«abhishek dubey», 113, 300);  
  8.  g.setColor(Color.green);  
  9.  g.drawString(«9», xcenter — 145, ycenter + 0);  
  10.  g.drawString(«3», xcenter + 135, ycenter + 0);  
  11.  g.drawString(«12», xcenter — 10, ycenter — 130);  
  12.  g.drawString(«6», xcenter — 10, ycenter + 145);  
  13. }   

Step 4: Calculate the seconds, minutes and hours coordinates from the current time by getting the system time. And convert the value into an integer form.

  1. xsecond = (int) (Math.cos(second * 3.14f / 30 — 3.14f / 2) * 120 + xcenter);  
  2. ysecond = (int) (Math.sin(second * 3.14f / 30 — 3.14f / 2) * 120 + ycenter);  
  3. xminute = (int) (Math.cos(minute * 3.14f / 30 — 3.14f / 2) * 100 + xcenter);  
  4. yminute = (int) (Math.sin(minute * 3.14f / 30 — 3.14f / 2) * 100 + ycenter);  
  5. xhour = (int) (Math.cos((hour * 30 + minute / 2) * 3.14f / 180 — 3.14f / 2) * 80 + xcenter);  
  6. yhour = (int) (Math.sin((hour * 30 + minute / 2) * 3.14f / 180 — 3.14f / 2) * 80 + ycenter;} 

Step 5: For moving needle logics. Actually in the following line we define some general condition that is found in all types of clocks such as when the seconds hand reaches 12 then the minutes hand moves 1 step and then after moving 5 steps of the minutes hand then 1-stepmoves a hours needle.

  1. g.setColor(Color.magenta);  
  2. if (xsecond != lastxs || ysecond != lastys)   
  3. {  
  4.  g.drawLine(xcenter, ycenter, lastxs, lastys);  
  5. }  
  6. if (xminute != lastxm || yminute != lastym)   
  7. {  
  8.  g.drawLine(xcenter, ycenter — 1, lastxm, lastym);  
  9.  g.drawLine(xcenter — 1, ycenter, lastxm, lastym);  
  10. }  
  11. if (xhour != lastxh || yhour != lastyh)   
  12. {  
  13.  g.drawLine(xcenter, ycenter — 1, lastxh, lastyh);  
  14.  g.drawLine(xcenter — 1, ycenter, lastxh, lastyh);  
  15. }  
  16. g.setColor(Color.magenta);  
  17. g.drawLine(xcenter, ycenter, xsecond, ysecond);   

Step 6: For moving needle minute and hours. this code for set the color of needle and moving forward rest of if conditions.

  1. g.setColor(Color.red);  
  2. g.drawLine(xcenter, ycenter — 1, xminute, yminute);  
  3. g.drawLine(xcenter — 1, ycenter, xminute, yminute);  
  4. g.setColor(Color.green);  
  5. g.drawLine(xcenter, ycenter — 1, xhour, yhour);  
  6. g.drawLine(xcenter — 1, ycenter, xhour, yhour);  
  7. lastxs = xsecond;  
  8. lastys = ysecond;  
  9. lastxm = xminute;  
  10. lastym = yminute;  
  11. lastxh = xhour;  
  12. lastyh = yhour;

Step 7: Define the method of Runable Interface. In the following, all the methods of the Runable interface must be overriden with the definitons of their own functionality within the stop method we pass 100 microseconds and this method throws an interrupt exception so these are put into a try block.

  1. public void start()   
  2. {  
  3.  if (thread == null)   
  4.  {  
  5.   thread = new Thread(this);  
  6.   thread.start();  
  7.  }  
  8. }  
  9. public void stop()   
  10. {  
  11.  thread = null;  
  12. }  
  13. public void run()   
  14. {  
  15.  while (thread != null)   
  16.  {  
  17.   try   
  18.   {  
  19.    Thread.sleep(100);  
  20.   } catch (InterruptedException e) {}  
  21.   repaint();  
  22.  }  
  23.  thread = null;  
  24. }  
  25. public void update(Graphics g)   
  26. {  
  27.  paint(g);  
  28. }   

Step 8: Creating a frame within main methods. In the following code we define three things creating the object of the Color and Frame Clock classes and set the background color and add a content pane on the frame.

  1. public static void main(String args[])   
  2. {  
  3.  JFrame window = new JFrame();  
  4.  Color c = new Color(118, 73, 190);  
  5.  window.setBackground(c);  
  6.  window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  7.  window.setBounds(0, 0, 400, 400);  
  8.  Clock clock = new Clock();  
  9.  window.getContentPane().add(clock);  
  10.  window.setVisible(true);  
  11.  clock.start();  
  12. }  

Complete Code

  1. import java.awt.Color;  
  2. import java.awt.Font;  
  3. import java.awt.Graphics;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.Date;  
  6. import java.util.Locale;  
  7. import javax.swing.JFrame;  
  8. import javax.swing.JPanel;  
  9. public class Clock extends JPanel implements Runnable  
  10. {  
  11.  Thread thread = null;  
  12.  SimpleDateFormat formatter = new SimpleDateFormat(«s», Locale.getDefault());  
  13.  Date currentDate;  
  14.  int xcenter = 175, ycenter = 175, lastxs = 0, lastys = 0, lastxm = 0, lastym = 0, lastxh = 0, lastyh = 0;  
  15.  private void drawStructure(Graphics g) {  
  16.   g.setFont(new Font(«TimesRoman», Font.BOLD, 20));  
  17.   g.setColor(Color.black);  
  18.   g.fillOval(xcenter — 150, ycenter — 150, 300, 300);  
  19.   g.setColor(Color.blue);  
  20.   g.drawString(«abhishek dubey», 113, 300);  
  21.   g.setColor(Color.green);  
  22.   g.drawString(«9», xcenter — 145, ycenter + 0);  
  23.   g.drawString(«3», xcenter + 135, ycenter + 0);  
  24.   g.drawString(«12», xcenter — 10, ycenter — 130);  
  25.   g.drawString(«6», xcenter — 10, ycenter + 145);  
  26.  }  
  27.  public void paint(Graphics g)   
  28.  {  
  29.   int xhour, yhour, xminute, yminute, xsecond, ysecond, second, minute, hour;  
  30.   drawStructure(g);  
  31.   currentDate = new Date();  
  32.   formatter.applyPattern(«s»);  
  33.   second = Integer.parseInt(formatter.format(currentDate));  
  34.   formatter.applyPattern(«m»);  
  35.   minute = Integer.parseInt(formatter.format(currentDate));  
  36.   formatter.applyPattern(«h»);  
  37.   hour = Integer.parseInt(formatter.format(currentDate));  
  38.   xsecond = (int)(Math.cos(second * 3.14 f / 30 — 3.14 f / 2) * 120 + xcenter);  
  39.   ysecond = (int)(Math.sin(second * 3.14 f / 30 — 3.14 f / 2) * 120 + ycenter);  
  40.   xminute = (int)(Math.cos(minute * 3.14 f / 30 — 3.14 f / 2) * 100 + xcenter);  
  41.   yminute = (int)(Math.sin(minute * 3.14 f / 30 — 3.14 f / 2) * 100 + ycenter);  
  42.   xhour = (int)(Math.cos((hour * 30 + minute / 2) * 3.14 f / 180 — 3.14 f / 2) * 80 + xcenter);  
  43.   yhour = (int)(Math.sin((hour * 30 + minute / 2) * 3.14 f / 180 — 3.14 f / 2) * 80 + ycenter);  
  44.     
  45.   g.setColor(Color.magenta);  
  46.   if (xsecond != lastxs || ysecond != lastys)   
  47.   {  
  48.    g.drawLine(xcenter, ycenter, lastxs, lastys);  
  49.   }  
  50.   if (xminute != lastxm || yminute != lastym)   
  51.   {  
  52.    g.drawLine(xcenter, ycenter — 1, lastxm, lastym);  
  53.    g.drawLine(xcenter — 1, ycenter, lastxm, lastym);  
  54.   }  
  55.   if (xhour != lastxh || yhour != lastyh)   
  56.   {  
  57.    g.drawLine(xcenter, ycenter — 1, lastxh, lastyh);  
  58.    g.drawLine(xcenter — 1, ycenter, lastxh, lastyh);  
  59.   }  
  60.   g.setColor(Color.magenta);  
  61.   g.drawLine(xcenter, ycenter, xsecond, ysecond);  
  62.   g.setColor(Color.red);  
  63.   g.drawLine(xcenter, ycenter — 1, xminute, yminute);  
  64.   g.drawLine(xcenter — 1, ycenter, xminute, yminute);  
  65.   g.setColor(Color.green);  
  66.   g.drawLine(xcenter, ycenter — 1, xhour, yhour);  
  67.   g.drawLine(xcenter — 1, ycenter, xhour, yhour);  
  68.   lastxs = xsecond;  
  69.   lastys = ysecond;  
  70.   lastxm = xminute;  
  71.   lastym = yminute;  
  72.   lastxh = xhour;  
  73.   lastyh = yhour;  
  74.  }  
  75.  public void start()   
  76.  {  
  77.   if (thread == null)   
  78.   {  
  79.    thread = new Thread(this);  
  80.    thread.start();  
  81.   }  
  82.  }  
  83.  public void stop()   
  84.  {  
  85.   thread = null;  
  86.  }  
  87.  public void run()   
  88.  {  
  89.   while (thread != null)   
  90.   {  
  91.    try   
  92.    {  
  93.     Thread.sleep(100);  
  94.    }   
  95.    catch (InterruptedException e) {}  
  96.    repaint();  
  97.   }  
  98.   thread = null;  
  99.  }  
  100.  public void update(Graphics g)   
  101.  {  
  102.   paint(g);  
  103.  }  
  104.  public static void main(String args[])   
  105.  {  
  106.   JFrame window = new JFrame();  
  107.   Color c = new Color(118, 73, 190);  
  108.   window.setBackground(c);  
  109.   window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  110.   window.setBounds(0, 0, 400, 400);  
  111.   Clock clock = new Clock();  
  112.   window.getContentPane().add(clock);  
  113.   window.setVisible(true);  
  114.   clock.start();  
  115.  }  
  116. }   

OUTPUT

 

 

Источник

In this tutorial, we’ll learn how to create a digital clock in Java that looks like the one below:


Create digital clock in Java

To create GUI based applications, Java provides Swing framework which is a graphical user interface framework that includes a set of classes that are powerful and flexible.

To create a digital clock, we will use JFrame, JLabel, and Timer class from the Swing framework. The JFrame class is used to construct a top-level window for a Java application. The JLabel class is used to display a string and the Timer class is used to fire events at specified intervals.

The following code creates and displays a digital clock in Java:


import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.Timer;

public class DigitalClock {

	static void display() {
		// create window for clock
		JFrame clockFrame = new JFrame("Digital Clock");
		clockFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// create label to print time
		JLabel timeLabel = new JLabel("", SwingConstants.CENTER);
		timeLabel.setPreferredSize(new Dimension(400, 100));
		timeLabel.setFont(new Font("Calibri", Font.BOLD, 50));
		clockFrame.getContentPane().add(timeLabel, BorderLayout.CENTER);

		//call pack() before setLocationRelativeTo ()
		//pack() determines the size of the window for centering the window
		clockFrame.pack();
		clockFrame.setLocationRelativeTo(null);
		// Display the window
		clockFrame.setVisible(true);

		int delay = 100;
		Timer timer = new Timer(delay, new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				LocalDateTime now = LocalDateTime.now();
				DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
				String formattedDateTime = now.format(formatter);
				timeLabel.setText(formattedDateTime);
			}
		});

		timer.start();
    }

	public static void main(String args[]) {
		display();
	}
}

Источник

Руководство по классу часов Java

1. обзор

В этом руководстве мы перейдем кlook into the Java Clock class from the java.time package. Мы объясним, что такое классClock и как его использовать.

2. КлассClock

Clock был добавлен в Java 8 и обеспечивает доступ к моменту времени с использованием наилучших доступных системных часов, а также для использования в качестве поставщика времени, который может быть эффективно заглушен для целей тестирования.

Текущая дата и время зависят от часового пояса, а для глобализованных приложений необходим поставщик времени, чтобы гарантировать, что дата и время созданы с правильным часовым поясом.

Этот класс помогает нам проверить, работают ли изменения в нашем коде с разными часовыми поясами или — при использовании фиксированных часов — это время не влияет на наш код.

КлассClock абстрактный, поэтому мы не можем создать его экземпляр. Можно использовать следующие фабричные методы:

  • offset(Clock, Duration) – возвращает часы, которые смещены на указанныйDuration. Основным вариантом использования этого является симуляция бега в будущем или в прошлом.

  • systemUTC() –  возвращает часы, представляющие часовой пояс UTC

  • fixed(Instant, ZoneId) –  всегда возвращает один и тот жеInstant. Основной пример использования этого — тестирование, где фиксированные часы гарантируют, что тесты не зависят от текущих часов.

Мы собираемся изучить большинство методов, доступных в классеClock.

2.1. instant()с

Этот метод возвращает момент, представляющий текущий момент, определенный часами: 

Clock clock = Clock.systemDefaultZone();
Instant instant = clock.instant();
System.out.println(instant);

будет производить:

2.2. systemUTC()с

Этот метод возвращает объектClock, представляющий текущий момент в зоне UTC: 

Clock clock = Clock.systemUTC();
System.out.println("UTC time :: " + clock.instant());

будет производить: 

UTC time :: 2018-04-04T17:40:12.353Z

2.3. system()с

Этот статический метод возвращает объектClock для часового пояса, идентифицированного данным идентификатором часового пояса: 

Clock clock = Clock.system(ZoneId.of("Asia/Calcutta"));
System.out.println(clock.instant());

будет производить:

2.4. systemDefaultZone()с

Этот статический метод возвращает объектClock, представляющий текущий момент и использующий часовой пояс по умолчанию для системы, в которой он работает: 

Clock clock = Clock.systemDefaultZone();
System.out.println(clock);

Вышеуказанные строки дают следующий результат (при условии, что нашим часовым поясом по умолчанию является «Азия / Калькутта»): 

SystemClock[Asia/Calcutta]

Мы можем добиться того же поведения, передавZoneId.systemDefault(): 

Clock clock = Clock.system(ZoneId.systemDefault());

2.5. millis()с

Этот метод возвращает текущий момент часов в миллисекундах. Предоставляетсяto allow the use of the clock in high-performance use cases where the creation of an object would be unacceptable. Этот метод можно использовать там, где в противном случае мы использовали быSystem.currentTimeInMillis(): 

Clock clock = Clock.systemDefaultZone();
System.out.println(clock.millis());

будет производить:

2.6. offset()с

Этот статический метод возвращает мгновение из указанных базовых часов с добавленной указанной продолжительностью.

Если длительность отрицательна, то результирующий момент часов будет раньше заданных базовых часов.

Using offset, we can get instants in the past and future of the given base clock. Если мы передадим нулевую продолжительность, мы получим те же часы, что и заданные базовые часы: 

Clock baseClock = Clock.systemDefaultZone();

// result clock will be later than baseClock
Clock clock = Clock.offset(baseClock, Duration.ofHours(72));
System.out.println(clock5.instant());

// result clock will be same as baseClock                           
clock = Clock.offset(baseClock, Duration.ZERO);
System.out.println(clock.instant());

// result clock will be earlier than baseClock            
clock = Clock.offset(baseClock, Duration.ofHours(-72));
System.out.println(clock.instant());

будет производить: 

2018-04-10T13:24:07.347Z
2018-04-07T13:24:07.348Z
2018-04-04T13:24:07.348Z

2.7. tick()с

Этот статический метод возвращает моменты из указанных часовrounded to the nearest occurrence of the specified duration. Указанная длительность часов должна быть положительной: 

Clock clockDefaultZone = Clock.systemDefaultZone();
Clock clocktick = Clock.tick(clockDefaultZone, Duration.ofSeconds(30));

System.out.println("Clock Default Zone: " + clockDefaultZone.instant());
System.out.println("Clock tick: " + clocktick.instant());

будет производить: 

Clock Default Zone: 2018-04-07T16:42:05.473Z
Clock tick: 2018-04-07T16:42:00Z

2.8. tickSeconds()с

Этот статический метод возвращает текущее мгновенное значение в целых секундах для данного часового пояса. Эти часы всегда будут иметь полеnano-of-second равным нулю: 

ZoneId zoneId = ZoneId.of("Asia/Calcutta");
Clock clock = Clock.tickSeconds(zoneId);
System.out.println(clock.instant());

будет производить:

То же самое можно сделать, используяtick(): 

Clock clock = Clock.tick(Clock.system(ZoneId.of("Asia/Calcutta")), Duration.ofSeconds(1));

2.9. tickMinutes()с

Этот статический метод возвращает тиканье часов в целых минутах для указанного часового пояса. Эти часы всегда будут иметь поляnano-of-second иsecond-of-minute равными нулю: 

ZoneId zoneId = ZoneId.of("Asia/Calcutta");
Clock clock = Clock.tickMinutes(zoneId);
System.out.println(clock.instant());

будет производить:

То же самое можно сделать, используяtick(): 

Clock clock = Clock.tick(Clock.system(ZoneId.of("Asia/Calcutta")), Duration.ofMinutes(1));

2.10. withZone()с

Этот метод возвращает копию этих часов с другим часовым поясом.

Если у нас есть экземпляр часов для определенного часового пояса, мы можем сделать копию этих часов для другого часового пояса: 

ZoneId zoneSingapore = ZoneId.of("Asia/Singapore");  
Clock clockSingapore = Clock.system(zoneSingapore); 
System.out.println(clockSingapore.instant());

ZoneId zoneCalcutta = ZoneId.of("Asia/Calcutta");
Clock clockCalcutta = clockSingapore.withZone(zoneCalcutta);
System.out.println(clockCalcutta.instant());

будет производить: 

2018-04-07T17:55:43.035Z
2018-04-07T17:55:43.035Z

2.11. getZone()с

Этот метод возвращает часовой пояс данногоClock. 

Clock clock = Clock.systemDefaultZone();
ZoneId zone = clock.getZone();
System.out.println(zone.getId());

будет производить:

2.12. фиксированный()

Этот метод возвращает часы, которыеalways returns the same instant. Основной вариант использования этого метода — тестирование, где фиксированные часы гарантируют, что тесты не зависят от текущих часов. 

Clock fixedClock = Clock.fixed(Instant.parse("2018-04-29T10:15:30.00Z"),
ZoneId.of("Asia/Calcutta"));
System.out.println(fixedClock);

будет производить: 

FixedClock[2018-04-29T10:15:30Z,Asia/Calcutta]

3. Заключение

В этой статье мы углубились в класс JavaClock и различные способы его использования с доступными методами.

Источник

Здравствуйте!
Задача:

Реализуйте простые домашние часы.

На вход подаётся число секунд, которое прошло с момента начала суток (00:00:00). Выведите текущее время в формате ЧЧ:ММ:СС.

Примечание 1. Используйте 24-часовой формат.

Примечание 2. Для преобразования типа int в тип String (если это понадобится) можно использовать встроенный служебный метод String.valueOf(num), который преобразует число num в строку «num».

Sample Input 1:

41000

Sample Output 1:

11:23:20

Sample Input 2:

3600

Sample Output 2:

01:00:00

Программа:

Java 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import java.util.Scanner;
class MySolution {
    public static void main(String[] args)
    {
     Scanner sr = new Scanner(System.in);             
int a = sr.nextInt();       
 int a1 = sr.nextInt();
 a = a%86400;       
 a1 = a1%86400;       
int h = (a /3600);
int m = ((a % 3600)/60);        
int s =((a % 3600)%60);        
int h1 = (a /3600);
int m1 = ((a % 3600)/60);        
int s1 =((a % 3600)%60);         
System.out.format ("%02d"+":"+"%02d"+":"+"%02d", h,m,s);   
System.out.format ("%02d"+":"+"%02d"+":"+"%02d", h1,m1,s1);                            
}
}

резюме компилятора:
Exception in thread «main» java.util.NoSuchElementException
at java.util.Scanner.throwFor(Scanner.java:911)
at java.util.Scanner.next(Scanner.java:1534)
at java.util.Scanner.nextInt(Scanner.java:2164)
at java.util.Scanner.nextInt(Scanner.java:2123)
at MySolution.main(Main.java:8)

Вопросы:
1.8,9 строки списала с комментариев, смысла не понимаю. Почему остаток?Логичнее, кажется, a<=(меньше или равно)86400
2.Если сделать только Sample Input 1, выводит правильный ответ.
3. Зачем менять формат, если там и там числа?

__________________
Помощь в написании контрольных, курсовых и дипломных работ, диссертаций здесь

Источник

Разработка виджетов для платформы Android включает несколько иной набор задач, чем разработка стандартных приложений. В этой серии руководств мы будем работать над процессом разработки настраиваемого виджета аналоговых часов. Часы будут основаны на классе Android AnalogClock и настроены с вашей собственной графикой.

Обзор серии

В этой серии руководств мы разрабатываем настраиваемый виджет аналоговых часов для Android с использованием класса AnalogClock и пользовательской графики. В первой части серии мы создаем проект, готовим файл Manifest и другие ресурсы. В этой части мы будем работать над дизайном виджета. Это будет включать создание графики для часового циферблата и стрелок, а также реализацию макета в XML. Мы будем создавать графику для устройств различной плотности. В заключительной части серии мы собираемся реализовать возможность предоставления пользователю выбора из набора дизайнов для часов, поэтому мы создадим три варианта дизайна здесь.

Это вторая часть нашей серии статей о создании настраиваемого виджета аналоговых часов для Android в течение четырех уроков:

  • Настройка проекта виджета Android
  • Проектирование часов
  • Получение обновлений и запуск
  • Реализация конфигурации пользователя

Виджет Android AnalogClock использует три изображения: циферблат часов, минутную стрелку и часовую стрелку. Поэтому мы создадим три элемента дизайна для каждой версии виджета часов, которую мы хотим, чтобы пользователи могли выбирать между. Мы также создадим альтернативные варианты оформления с помощью циферблата, часовой и минутной стрелок. Для этого проекта нам нужно настроить таргетинг на разные плотности экрана устройства, для чего мы будем создавать файлы изображений в четырех разных масштабах.

Шаг 1. Создание изображений для циферблата часов

Мы собираемся создать три дизайна часов, каждый с циферблатом, минутной стрелкой и часовой стрелкой. Вы, конечно, можете использовать свои собственные дизайны вместо этого, но не стесняйтесь использовать файлы изображений, которые мы используем здесь, чтобы начать. Файлы изображений для каждого дизайна в каждой плотности включены в ссылку для загрузки этого учебного пособия, а также будут включены в загрузку для части 4.

Сначала идет циферблат часов. Помните, что мы указали виджет в виде двух ячеек шириной и двух ячеек, что привело к максимальному размеру 146 dp (пикселей, не зависящих от плотности). Для этой серии уроков мы создадим четыре версии каждого изображения в соответствии с четырьмя категориями плотности.

Вместо того, чтобы создавать изображения для каждой плотности, вы можете альтернативно использовать графику NinePatch, которая является растровым изображением, которое можно масштабировать вверх и вниз в соответствии с плотностью устройства, что позволяет вам создавать одно изображение для каждого дизайна. Возможность использования NinePatch частично зависит от содержания используемых вами дизайнов, но есть инструменты, которые помогут вам создать их, если вы пожелаете.

Проще всего начать со средней плотности, которая должна составлять максимум 146 пикселей на обеих осях. Вот часовой циферблат по умолчанию, который мы используем при средней плотности, который вы можете использовать либо в качестве справочного материала для ваших собственных дизайнов, либо, если вы не хотите создавать свой собственный позже.

В этом случае размер изображения составляет 146 пикселей по обеим осям, но вы можете уменьшить его, если хотите. Мы будем указывать запас для устройств с API-интерфейсами Android менее 14, но не будем указывать запас для устройств с более чем 14-ю версиями, поскольку на более поздних уровнях API между виджетами устанавливается автоматический запас. Вы можете использовать практически любой понравившийся вам дизайн — ваши часы даже не должны быть круглыми. Включение либо меток, либо цифр, обозначающих часы на циферблате, целесообразно с точки зрения удобства использования, хотя это и не обязательно.

Вот две альтернативные конструкции циферблата часов, которые мы будем использовать: каменная и другая металлическая, которые представлены здесь со средней плотностью:

Создав циферблат часов, вы можете создавать альтернативные версии каждого изображения для разных плотностей. В зависимости от ваших дизайнов это может не потребоваться, но мы будем включать индивидуальные версии каждого изображения для дизайнов в этом руководстве. Ниже указан максимальный размер, который мы используем для нашего виджета по осям X и Y при каждой плотности:

  • Низкая плотность: 110px
  • Средняя плотность: 146 пикселей
  • Высокая плотность: 220px
  • Очень высокая плотность: 292px

Если у вас есть файлы изображений для каждого дизайна циферблата, который вы хотите использовать (и версии для каждой плотности, если необходимо), скопируйте их в доступные для рисования папки в рабочей области проекта виджета Android. Eclipse обычно создает папку для каждой категории плотности автоматически, но, если вы используете только одно изображение для всех плотностей, вы можете создать папку просто с именем «drawable» и поместить туда изображение. Папки для каждого уровня плотности:

  • Низкий: drawable-lpdi
  • Средний: drawable-mpdi
  • Высокий: drawable-hpdi
  • Очень высокий: drawable-xhpdi

Android AVD Manager позволит вам протестировать готовый проект виджета на каждой из этих плотностей. После того, как ваши изображения будут сохранены в различные папки для рисования, убедитесь, что вы использовали одинаковые имена в каждой из них. Например, один из дизайнов циферблата, который мы используем, называется «clock_dial_stone» — это имя файла изображения для каменного циферблата в каждой папке плотности, хотя содержимое каждой версии отличается, если только по размеру. Если вы все еще сомневаетесь в том, как это должно работать, просто загрузите файлы изображений, используя ссылку для загрузки в верхней части этого руководства, и просмотрите папки, чтобы получить представление о них.

Шаг 2: создайте изображения стрелки часов

Затем создайте изображение для часовой и минутной стрелок виджета часов, включая изображения для каждого дизайна и каждой целевой плотности. Вот наши минутные стрелки средней плотности для каждого дизайна:

Опять же, не стесняйтесь использовать их, чтобы начать или работать самостоятельно. Обратите внимание, что эти файлы изображений содержат прозрачное пространство вокруг руки. Вам необходимо создать каждое из ваших изображений рук с полной высотой циферблата, с которым они будут использоваться. Каждая стрелка должна быть в точном положении, в котором она была бы, если указывать на двенадцать, положить поверх изображения циферблата и на полпути через него. Стрелка также должна находиться в центре файла изображения по горизонтали, поскольку при отображении времени она будет поворачиваться от своей центральной точки. Длина стрелок в файле изображения действительно зависит от вас, если полная высота изображения равна высоте изображения циферблата.

Следующая диаграмма показывает полную шкалу изображений стрелок с минутной стрелкой в двенадцать и часовой стрелкой в три (часовая стрелка была повернута на 90 градусов по часовой стрелке в ее центральной точке):

После того, как у вас отсортированы дизайны минутных стрелок, снова сохраните один для каждой плотности, масштабируя их вверх и вниз, чтобы соответствовать высоте циферблата в каждом случае. Скопируйте их снова в свои папки для рисования, используя одно и то же имя для каждого дизайна в папках плотности, как и в изображениях набора.

Затем выполните тот же процесс для ваших часовых стрелок. Вот часовые стрелки для трех конструкций, которые мы используем:

Принцип здесь тот же, что и для минутных стрелок, за исключением того, что часовые стрелки обычно должны быть короче. Создайте свои часовые стрелки, указывающие на 12 часов, и подготовьте версии для каждой плотности, скопировав их в свои папки для рисования, как вы делали для минутных стрелок.

Шаг 3: Определите поля виджета

В дизайне виджета будут использоваться некоторые данные, которые мы включим в папки «значений» нашего проекта. В Android API 14 и более поздних версиях система автоматически включает поля между виджетами, когда они отображаются на домашнем экране пользователя. Однако в предыдущих версиях API это было не так. По этой причине мы хотим указать поле для включения круглосуточного виджета на устройствах с уровнями Android ниже 14. Это случай, когда мы можем использовать тот факт, что у нас есть папки значений, предназначенные для этих двух категорий уровней пользовательского API.

Мы определим поля в нашем файле макета XML, ссылаясь на ресурс измерения. В каталоге «values» создайте новый файл с именем «sizes.xml» — выберите папку «values» в Eclipse и щелкните правой кнопкой мыши или выберите «Файл», затем «Новый», «Файл» и введите имя файла.

Когда вы нажмете кнопку «Готово», Eclipse создаст и откроет файл. Выберите вкладку «sizes.xml» для редактирования кода. Введите следующее:

 
<resources> 
<dimen name="clock_margin">8dp</dimen> 
</resources>

Этот код просто перечисляет значение измерения с использованием независимых от плотности пикселей вместе с именем, чтобы мы могли ссылаться на него в другом месте.

Сохраните файл. Теперь скопируйте его, щелкнув правой кнопкой мыши в папке «values» или выбрав его и выбрав «Edit» — затем выберите «Copy». Вставьте его в папку «values-v14», которую мы создали в прошлый раз — щелкните правой кнопкой мыши или выберите папку и выберите «Изменить», затем выберите «Вставить». Файл появится в папке «values-v14», которая предназначена для уровней API начиная с 14. Откройте эту новую копию файла и отредактируйте значение измерения, чтобы указать нулевое поле следующим образом:

 
<resources> 
<dimen name="clock_margin">0dp</dimen> 
</resources>

Теперь, когда компоновка XML ссылается на это значение измерения с использованием его имени, нулевое значение будет использоваться на устройствах, работающих под управлением API 14 плюс, а значение 8dp будет использоваться в противном случае.

Шаг 4. Реализация макета виджета

Теперь давайте определим наш виджет в XML. Помните, что мы указали начальный макет для виджета в файле XML, в котором мы определили его основные свойства. Макет, на который мы ссылались, был «clock_widget_layout», поэтому создайте этот файл сейчас. Щелкните правой кнопкой мыши или выберите папку с «макетом» и выберите «Файл», затем «Новый», «Файл». Введите «clock_widget_layout.xml» в качестве имени файла и нажмите «Готово».

Выберите вкладку «clock_widget_layout.xml», когда Eclipse откроет файл, чтобы вы могли редактировать XML. Мы используем относительную компоновку для нашего виджета — если вы хотите использовать другой дизайн, вы можете альтернативно использовать либо линейную, либо рамочную компоновку, так как они являются единственными поддерживаемыми виджетами. Чтобы использовать Относительный макет, добавьте следующую схему в файл XML-макета:

 
<RelativeLayout  
  xmlns:android="http://schemas.android.com/apk/res/android"  
	android:id="@+id/custom_clock_widget"  
	android:layout_width="fill_parent"  
	android:layout_height="fill_parent" 
	android:padding="@dimen/clock_margin" 
	android:gravity="center">	 
 
</RelativeLayout>

Здесь мы указываем идентификатор для виджета, который мы будем использовать для реализации кликов по нему в нашем Java-коде в части 4. Обратите внимание, что код также ссылается на значение измерения, которое мы создали, используя стандартный синтаксис — имя «измерений» .xml » файл на самом деле не имеет значения, вам просто нужно перечислить элемент» измерения «в файле значений, чтобы ссылаться на него таким образом.

Внутри Относительного макета добавьте свой виджет AnalogClock следующим образом:

 
<AnalogClock  
	android:id="@+id/AnalogClock0"  
	android:layout_width="wrap_content"  
	android:layout_height="wrap_content"  
	android:dial="@drawable/clock_dial"  
	android:hand_hour="@drawable/clock_hour_hand"  
	android:hand_minute="@drawable/clock_minute_hand" 
/>

Это стандартный элемент Android Analog Clock, который позволяет настроить дисплей. Мы используем атрибут ID, чтобы мы могли ссылаться на виджет в Java. Последние три атрибута определяют доступные для рисования ресурсы, которые мы создали для циферблата, минутной и часовой стрелок. Если вы сохранили свои файлы с разными именами, измените этот код, чтобы отразить их. Android выберет файл для рисования из соответствующей папки плотности на каждом пользовательском устройстве.

Поскольку мы разрешаем пользователям выбирать дизайн, мы фактически собираемся включить все три дизайна в наш XML, установив все, кроме одного, изначально невидимыми. Убедитесь, что вы включили первый дизайн, который вы хотите отобразить по умолчанию, а затем добавьте остальные следующим образом:

 
<AnalogClock  
	android:id="@+id/AnalogClock1"  
	android:layout_width="wrap_content"  
	android:layout_height="wrap_content"  
	android:dial="@drawable/clock_dial_stone"  
	android:hand_hour="@drawable/clock_hour_hand_stone"  
	android:hand_minute="@drawable/clock_minute_hand_stone" 
	android:visibility="invisible" 
/> 
<AnalogClock  
	android:id="@+id/AnalogClock2"  
	android:layout_width="wrap_content"  
	android:layout_height="wrap_content"  
	android:dial="@drawable/clock_dial_metal"  
	android:hand_hour="@drawable/clock_hour_hand_metal"  
	android:hand_minute="@drawable/clock_minute_hand_metal" 
	android:visibility="invisible" 
/>

Опять же, измените отображаемые имена, чтобы они отражали названия циферблатов, минут и часовых стрелок для каждого из ваших дизайнов. Вы можете включить более трех дизайнов, если хотите — убедитесь, что все, кроме одного, имеют видимость, установленную как невидимую, чтобы изначально отображался только один дизайн (опция по умолчанию). Мы сможем реализовать выбор пользователя между этими проектами в Java, используя атрибуты идентификатора элемента Analog Clock, которые заканчиваются целыми числами, начинающимися с нуля и увеличивающимися с каждым проектом. Сохраните файл макета.

Вот скриншоты того, как каждый из наших дизайнов будет выглядеть, когда виджет будет завершен:

В следующий раз

На этом процесс разработки нашего виджета часов завершен. Если вы не хотите создавать свои собственные изображения дизайна на этом этапе, просто сначала используйте изображения в папке загрузки. В следующем уроке мы будем использовать класс AppWidgetProvider для реализации нашего виджета на Java. В заключительной части серии мы будем реализовывать пользовательские клики на виджете, представляя выбор между дизайнами и обновляя пользовательские настройки, чтобы непрерывно отображать выбранную ими опцию.

Источник

Понравилась статья? Поделить с друзьями:
  • Как написать чем понравилась картина
  • Как написать чем занят
  • Как написать чем занимаешься оригинально
  • Как написать чем занимаешься на английском языке
  • Как написать человеку я тебя люблю чтобы он не понял