java模拟时钟代码讲解,java简单时钟代码及详细解释
java 构造方法重载 模拟电子时钟 5个构造方法，看不懂了，解释下什么意思
java源代码中有几个构造方法，那么class文件中就有几个初始化方法，编译器会把第一部分与第二部分分别复制到每个初始化方法的前端，然后把初始化方法对应参数的构造方法的代码复制到相应初始化方法中(这里说的复制其实应该说是编译，不过为了让你更好理解所以如此说).
创新互联建站是一家集网站建设,孝感企业网站建设,孝感品牌网站建设,网站定制,孝感网站建设报价,网络营销,网络优化,孝感网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。
那么说初始化方法如何追述其父类的，这也关系到初始化方法的结构，初始化方法的执行顺序以及结构就如上所说，但是每个初始化方法的第一个执行指令就是调用另外一个初始化方法，这个初始化方法可能是自身类某个初始化方法，例如你的构造函数中第一句有类似this(...)这种语句，那么初始化方法就会调用自身类的指定构造方法；如果你的构造方法中没有指定构造方法调用，那么初始化方法会默认调用父类无参数初始化方法，如果你的子类第一句为super(....),那么初始化方法会调用父类指定初始化方法。这种调用过程会递归进行调用，直到这个类是java.lang.Object类。
调用初始化方法并不代表会生成对象，你的java代码中出现new关键字加上构造方法的调用，只会生成一个对象，其父类对象不会生成，所以调用父类为抽象类的构造方法完全是合理的。而且初始化方法对于虚拟机来说只是一个名称叫做"init"的普通方法，区别只是生成对象以后调用而已(sun 的jdk私有包中有绕过构造方法生成对象的方式，可以证明之上说法，具体如何我这里不陈述)。
如何用Java中做一个电子时钟
import java.awt.Color;
import java.awt.Font;
import java.util.Date;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class MyTime {
JFrame frame=null;
JLabel label=null;
public MyTime(){
frame=new JFrame("时钟");
label=new JLabel();
label.setFont(new Font("幼圆",1,40));
label.setBackground(Color.BLUE);
frame.add(label);
frame.setSize(200,90);
frame.setLocation(500,300);
frame.setVisible(true);
}
public static void main(String[] args) {
MyTime mt=new MyTime();
new TimeThread(mt).start();
}
}
class TimeThread extends Thread{
private MyTime mt;
public TimeThread(MyTime mt){
this.mt=mt;
}
public void run(){
while(true){
String fullTime=new Date().toString();
String time=fullTime.substring(11, 19);
mt.label.setText(time);
mt.label.repaint();
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
怎样用java 程序写一个时钟程序
面向对象思想写成：
下面是一个显示器类
public class Display {
private int value;//现在的值
private int limit;//上限值
Display( int limit) {
this.limit = limit;
}
public void increase() {
value++;
if(value == limit) {
value = 0;
}
}
public int getValue() {
return value;
}
public static void main(String[] args) {
Display d = new Display(24);
for(;;) {
d.increase();
System.out.println(d.getValue());
}
}
}
下面创建一个时钟对象：
public class Clock {
private Display h = new Display(24);
private Display min = new Display(60);
private Display s = new Display(60);
public void start () {
for(;;) {
s.increase();
if(s.getValue() == 0){//如果分重置，小时+1
min.increase();
if(min.getValue() == 0){//如果分重置，小时+1
h.increase();
}
}
System.out.printf("%02d:%02d:%02d\n",h.getValue(), min.getValue(),s.getValue());//格式输出
}
}
public static void main(String[] args) {
Clock clock = new Clock();
clock.start();
}
这段java代码， 通过一个模拟时钟的程序，熟悉构造方法重载， 可是看不懂啊 麻烦高手帮忙解释下
//这是新建了一个public类，名称为Time
public class Time{
//其中有三个变量，表示时分秒
private int hour;
private int minute;
private int second;
//此处即为空参数的构造函数，即当声明这个类的对象时，怎样初始化这个对象里面的值
//每个对象都表示个时间。
//这个构造函数调用了这个类里面的有三个参数的构造函数。
public Time(){
this(0,0,0);
}
//此处为一个参数的构造函数
public Time(int h){
this(h,0,0);
}
//此处为二个参数的构造函数
public Time(int h,int m){
this(h,m,0);
}
//此处为三个参数的构造函数，即前面的构造函数调用了这个构造函数来初始化对象的时间值
public Time(int h,int m,int s){
setTime(h,m,s);
}
//此处是构造函数，参数为这个类的对象：
//即用一个已经表示一个时间的Time对象来创建一个和它一样的时间对象
public Time(Time time){
this(time.getHour(),time.getMinute(),time.getSecond());
}
//设置时间值
public void setTime(int h,int m,int s){
setHour(h);
setMinute(m);
setSecond(s);
}
//设置时
public void setHour(int h){
hour=((h=0h24)?h:0);
}
//设置分
public void setMinute(int m){
minute=((m=0m60)?m:0);
}
//设置秒
public void setSecong(int s){
second=((s=0s60)?s:0);
}
//获得这个时间对象的时
public int getHour(){
return hour;
}
//获得分
public int getMinute(){
return minute;
}
//获得秒
public int getSecond(){
return second;
}
//格式化时间成为串
public String toUniversalString(){
return String.format("%d:%02d:%02d",getHour(),getMinute(),getSecond());
}
//格式化这个时间成为串
public String toString(){
return String.format("%d:%02d:%02d%s",((getHour()==0||getHour()==12)?12:getHour()%12),getMinute(),getSecond(),(getHour()12?"AM":"PM"));
}
}
构造方法：通过这个程序可以看出，一个时间对象表示一个时间，有时分秒，那么创建对象要给它表示个时间，构造函数就是初始化有关的操作。
比如我创建一个对象Time time0=new Time(8,20,20);那么time0就表示8:20:20。
构造函数通常的格式是：public + 类名称（参数列表）{},记住，它没有返回值。
重载：可以看到里面不只一个构造函数，这就是重载。你可能并不一定要确切的时分秒或其它，这样就可以调用不同的构造函数。
比如：Time time1=new Time(time0);这也创建了对象，此对象表示的时间和time0是一样的。
重载的意思是一个函数，参数列表的不同可以实现不同的功能。
JAVA画时钟代码
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import sun.util.calendar.Gregorian;
import java.util.Calendar;
import java.util.GregorianCalendar;
public class ClockPointer extends JFrame{
int x, y, x0, y0, r, h, olds_x, olds_y, oldm_x, oldm_y, oldh_x, oldh_y,
ss,mm, hh, old_m, old_h, ang;
final double RAD = Math.PI/180;
public ClockPointer(){
super("Java时钟");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Image image = getToolkit().getImage("clock.gif");
setIconImage(image);
setSize(400,400);
setBackground(Color.white);
//setLocation(300,150);
this.setLocationRelativeTo(null);
setResizable(true);
int delay = 1000;
//创建一个监听事件
setVisible(true);
ActionListener drawClock = new ActionListener(){
public void actionPerformed(ActionEvent evt){
repaint();
}
};
//创建一个时间计数器，每一秒触发一次
new Timer(delay, drawClock).start();
}
java.text.SimpleDateFormat fmTime = new java.text.SimpleDateFormat("HH:mm:ss");
//绘制图形
public void paint(Graphics g){
super.paint(g);
g.setFont(null);
Graphics2D g2D = (Graphics2D)g;
Insets insets = getInsets();
int L = insets.left/2, T = insets.top/2;
h = getSize().height;
g.setColor(Color.white);
//画圆
g2D.setStroke(new BasicStroke(2.0f));
g.setColor(Color.gray);
g.drawOval(L+40, T+40, h-80, h-80);
r = h/2 - 40;
x0 = 40 + r - 5 + L;
y0 = 40 + r - 5 - T;
ang = 60;
//绘制时钟上的12个字
for(int i = 1;i = 12;i ++){
x = (int)((r+10)*Math.cos(RAD*ang)+x0);
y = (int)((r+10)*Math.sin(RAD*ang)+y0);
g.setColor(Color.black);
g.drawString(""+i, x, h-y);
ang -=30;
}
//获得现在的时间
Calendar now = new GregorianCalendar();
int nowh = now.get(Calendar.HOUR_OF_DAY);
int nowm = now.get(Calendar.MINUTE);
int nows = now.get(Calendar.SECOND);
String st=fmTime.format(now.getTime());
//在窗体上显示时间
g.setColor(Color.pink);
g.fillRect(L, T, 50, 28);
g.setColor(Color.blue);
g.drawString(st,L+2,T+26);
//计算时间与度数的关系
ss = 90 - nows*6;
mm = 90 - nowm*6;
hh = 90 - nowh*30 - nowm/2;
x0 = r+40+L;
y0 = r+40+T;
g2D.setStroke(new BasicStroke(1.2f));
//擦除秒针
//if(olds_x 0){
// g.setColor(getBackground());
// // g.setColor(Color.gray);
// g.drawLine(x0, y0, olds_x, h-olds_y); // (?)
//}
//绘制秒针
x = (int)(r*0.9*Math.cos(RAD*ss))+x0;
y = (int)(r*0.9*Math.sin(RAD*ss))+y0-2*T;
g.setColor(Color.yellow);
g.drawLine(x0, y0, x, h-y);
olds_x = x;
olds_y = y;
g2D.setStroke(new BasicStroke(2.2f));
//擦除分针
//if(old_m!=mm){
// g.setColor(getBackground());
// g.drawLine(x0,y0,oldm_x,h-oldm_y);
//}
//绘制分针
x = (int)(r*0.7*Math.cos(RAD*mm))+x0;
y = (int)(r*0.7*Math.sin(RAD*mm))+y0-2*T;
g.setColor(Color.green);
g.drawLine(x0,y0,x,h-y);
oldm_x = x;
oldm_y = y;
old_m = mm;
g2D.setStroke(new BasicStroke(3.2f));
//擦除时针
//if(old_h!=hh){
// g.setColor(getBackground());
// g.drawLine(x0,y0,oldh_x,h-oldh_y);
//}
//绘制时针
x = (int)(r*0.5*Math.cos(RAD*hh))+x0;
y = (int)(r*0.5*Math.sin(RAD*hh))+y0-2*T;
g.setColor(Color.red);
g.drawLine(x0,y0,x,h-y);
oldh_x = x;
oldh_y = y;
old_h = hh;
}
public static void main(String[] args){
new ClockPointer();
}
}
//整理一下
分享名称：java模拟时钟代码讲解,java简单时钟代码及详细解释
本文网址：http://azwzsj.com/article/phchgp.html
