javadate初始化_java中的初始化具体是什么意思

❶ 请问java中怎样给data类型赋初值

在java中Data不是类型是接口，所以你不能建立Data的实例。不知道你其实是不是想说Date类型吧。
Date类型有好几种构造函数可以赋予初值。如：
Date(int year, int month, int date)
Date(int year, int month, int date, int hrs, int min)
Date(int year, int month, int date, int hrs, int min, int sec)
Date(long date)
Date(String s)
详细的你可以参考java的jdk api文档。建议你去下载个java的jdk api文档方便学习。

❷ java编程问题:如何使用构造的方法进行初始化

private String key;

private String value;

KeyValueBean() {
}
KeyValueBean (String key,String value) {
this.key = key;
this.value = value;
}

public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}

public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}

❸ java中date类型如何初始化

1、使用Date类代表当前系统时间
Date d = new Date();

2、使用Date类代表指定的时间
Date d1 = new Date(2015,7,6);

❹ java中的初始化具体是什么意思

关于Java初始化，有多文章都用了很大篇幅的介绍。经典的>更是用了专门的
一章来介绍Java初始化。但在大量有代码实例后面，感觉上仍然没有真正深入到初始化的本质。

本文以作者对JVM的理解和自己的经验，对Java的初始化做一个比深入的说明，由于作者有水平限制，
以及JDK各实现版本的变化，可能仍然有不少错误和缺点。欢迎行家高手赐教。

要深入了解Java初始化，我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行
机制和堆栈跟踪是有效的手段。可惜的是，到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在
着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况（但我可以证明那确实是一个BUG）

>(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:
以下译文原文:
可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸
的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的
特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来
不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。

我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字""
和""。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化
内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?

""和""方法在哪里？
这两个方法是实际存在而你又找不到的方法，也许正是这样才使得一些大师都犯晕。加上jdk实现上的一
些BUG，如果没有深入了解，真的让人摸不着北。

现在科学体系有一个奇怪的现象，那么庞大的体系最初都是建立在一个假设的基础是，假设1是正确的，
由此推导出2，再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都
是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设，我要确实证明""
和""方法是真真实实的存在的：

packagedebug;
publicclassMyTest{
staticinti=100/0;
publicstaticvoidmain(String[]args){
Ssytem.out.println("Hello,World!");
}
}

执行一下看看,这是jdk1.5的输出：

java.lang.ExceptionInInitializerError
Causedby:java.lang.ArithmeticException:/byzero
atdebug.MyTest.(Test.java:3)
Exceptioninthread"main"

请注意，和其它方法调用时产生的异常一样，异常被定位于debug.MyTest的.

再来看：

packagedebug;
publicclassTest{
Test(){
inti=100/0;
}
publicstaticvoidmain(String[]args){
newTest();
}
}

jdk1.5输入：
Exceptioninthread"main"java.lang.ArithmeticException:/byzero
atdebug.Test.(Test.java:4)
atdebug.Test.main(Test.java:7)

JVM并没有把异常定位在Test()构造方法中，而是在debug.Test.。

当我们看到了这两个方法以后，我们再来详细讨论这两个“内置初始化方法”（我并不喜欢生造一些
非标准的术语，但我确实不知道如何规范地称呼他们）。

内置初始化方法是JVM在内部专门用于初始化的特有方法，而不是提供给程序员调用的方法，事实上
“>”这样的语法在源程序中你连编译都无法通过。这就说明，初始化是由JVM控制而不是让程序员
来控制的。

类初始化方法：
我没有从任何地方了解到的cl是不是class的简写，但这个方法确实是用来对“类”进行初
始化的。换句话说它是用来初始化static上下文的。

在类装载（load）时，JVM会调用内置的方法对类成员和静态初始化块进行初始化调用。它们
的顺序按照源文件的原文顺序。
我们稍微增加两行static语句：
packagedebug;
publicclassTest{
staticintx=0;
staticStrings="123";
static{
Strings1="456";
if(1==1)
thrownewRuntimeException();
}
publicstaticvoidmain(String[]args){
newTest();
}
}
然后进行反编译：
javap-cdebug.Test

Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
staticintx;

staticjava.lang.Strings;

publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:return

publicstaticvoidmain(java.lang.String[]);
Code:
0:new#2;//classdebug/Test
3:p
4:invokespecial#3;//Method"":()V
7:pop
8:return

static{};
Code:
0:iconst_0
1:putstatic#4;//Fieldx:I
4:ldc#5;//String123
6:putstatic#6;//Fields:Ljava/lang/String;
9:ldc#7;//String456
11:astore_0
12:new#8;//classjava/lang/RuntimeException
15:p
16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
19:athrow

}
这里，我们不得不说，JDK在javap功能上的实现有一个BUG。static段的16标号，那里标识了异常
的位置发生在""方法中，而实际上这段程序运行时的输出却是：

java.lang.ExceptionInInitializerError
Causedby:java.lang.RuntimeException
atdebug.Test.(Test.java:8)
Exceptioninthread"main"

但我们总可以明白，类初始化正是按照源文件中定义的原文顺序进行。先是声明

staticintx;

staticjava.lang.Strings;

然后对intx和Strings进行赋值：
0:iconst_0
1:putstatic#4;//Fieldx:I
4:ldc#5;//String123
6:putstatic#6;//Fields:Ljava/lang/String;
执行初始化块的Strings1="456";生成一个RuntimeException抛
9:ldc#7;//String456
11:astore_0
12:new#8;//classjava/lang/RuntimeException
15:p
16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
19:athrow

要明白的是，""方法不仅是类初始化方法，而且也是接口初始化方法。并不是所以接口
的属性都是内联的，只有直接赋常量值的接口常量才会内联。而

[publicstaticfinal]doubled=Math.random()*100;

这样的表达式是需要计算的，在接口中就要由""方法来初始化。

下面我们再来看看实例初始化方法""

""用于对象创建时对对象进行初始化，当在HEAP中创建对象时，一旦在HEAP分配了空间。最
先就会调用""方法。这个方法包括实例变量的赋值（声明不在其中）和初始化块，以及构造
方法调用。如果有多个重载的构造方法，每个构造方法都会有一个对应的""方法。

同样，实例变量和初始化块的顺序也是按源文件的原文顺序执行，构造方法中的代码在最后执行：

packagedebug;
publicclassTest{
intx=0;
Strings="123";
{
Strings1="456";
//if(1==1)
//thrownewRuntimeException();
}

publicTest(){
Stringss="789";
}

publicstaticvoidmain(String[]args){
newTest();
}
}

javap-cdebug.Test的结果：

Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
intx;

java.lang.Strings;

publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:iconst_0
6:putfield#2;//Fieldx:I
9:aload_0
10:ldc#3;//String123
12:putfield#4;//Fields:Ljava/lang/String;
15:ldc#5;//String456
17:astore_1
18:ldc#6;//String789
20:astore_1
21:return

publicstaticvoidmain(java.lang.String[]);
Code:
0:new#7;//classdebug/Test
3:p
4:invokespecial#8;//Method"":()V
7:pop
8:return
}

如果在同一个类中，一个构造方法调用了另一个构造方法，那么对应的""方法就会调用另一
个""，但是实例变量和初始化块会被忽略，否则它们就会被多次执行。

packagedebug;
publicclassTest{
Strings1=rt("s1");
Strings2="s2";

publicTest(){
s1="s1";
}
publicTest(Strings){
this();
if(1==1)thrownewRuntime();
}
Stringrt(Strings){
returns;
}
publicstaticvoidmain(String[]args){
newTest("");
}
}

反编译的结果：
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
java.lang.Strings1;

java.lang.Strings2;

publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:aload_0
21:ldc#2;//Strings1
23:putfield#4;//Fields1:Ljava/lang/String;
26:return

publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#7;//Method"":()V
4:new#8;//classjava/lang/RuntimeException
7:p
8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
11:athrow

java.lang.Stringrt(java.lang.String);
Code:
0:aload_1
1:areturn

publicstaticvoidmain(java.lang.String[]);
Code:
0:new#10;//classdebug/Test
3:p
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return

}

我们再一次看到了javap实现的bug，虽然有一个"":(Ljava/lang/String;)V签名可以说明
每个构造方法对应一个不同,但Runtime异常仍然被定位到了""()V的方法中：
invokespecial#8;//Methodjava/lang/RuntimeException."":()V,而在main方法中的
调用却明明是"":(Ljava/lang/String;)V.

但是我们看到，由于Test(Strings)调用了Test();所以"":(Ljava/lang/String;)V不再对
实例变量和初始化块进次初始化：

publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#7;//Method"":()V
4:new#8;//classjava/lang/RuntimeException
7:p
8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
11:athrow

而如果两个构造方法是相互独立的，则每个构造方法调用前都会执行实例变量和初始化块的调用：

packagedebug;
publicclassTest{
Strings1=rt("s1");
Strings2="s2";
{
Strings3="s3";
}
publicTest(){
s1="s1";
}

publicTest(Strings){
if(1==1)
thrownewRuntimeException();
}

Stringrt(Strings){
returns;
}

publicstaticvoidmain(String[]args){
newTest("");
}
}

反编译的结果：

Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
java.lang.Strings1;

java.lang.Strings2;

publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:ldc#7;//Strings3
22:astore_1
23:aload_0
24:ldc#2;//Strings1
26:putfield#4;//Fields1:Ljava/lang/String;
29:return

publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:ldc#7;//Strings3
22:astore_2
23:new#8;//classjava/lang/RuntimeException
26:p
27:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
30:athrow

java.lang.Stringrt(java.lang.String);
Code:
0:aload_1
1:areturn

publicstaticvoidmain(java.lang.String[]);
Code:
0:new#10;//classdebug/Test
3:p
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return

}

❺ java数组中的一点问题

Date不是关键字，按照Java命名规范，首字母大写的是类名。

JDK API中有Date这个类，不过是在java.util包和java.sql包中，使用时必须用import语句导入，如果没导入的话，也可以把自己的类命名为Date的。

Datedays;
days=newDate[3];
......

因此上面这几句是定义了一个Date类的对象数组，days[0]=new Date(2008,4,5);这句是用Date类的构造函数进行初始化，这下清楚了吧。

❻ java初始化MM/dd/yyyy格式的时间Date

要把date转为指定格式的话只能用format
初始化可以
//Date(int year, int month, int date)
Date date = new Date(2000,4,23);
DateFormat dt1 = new SimpleDateFormat("MM/dd/yyyy");
String s = dt1.format(date);

❼ 用JAVA设计一个时间类MyDate，其中的属性包括year、month、day，其构造方法可以初始化其三个属性

http://hi..com/shy2850/blog/item/3b5d3145f7d25641510ffec3.html

❽ java里怎样用时间初始化calendar对象

Calendar rightNow = Calendar.getInstance();
static Calendar getInstance()
//使用默认时区和语言环境获得一个日历。
static Calendar getInstance(Locale aLocale)
//使用默认时区和指定语言环境获得一个日历。
static Calendar getInstance(TimeZone zone)
//使用指定时区和默认语言环境获得一个日历。

❾ java中想要将字符串类型的201827的日期格式初始化成为yyyyMMdd的日期格式有什么方法

importjava.text.*;
classtest
{
	publicstaticvoidmain(String[]args)throwsException
	{
	SimpleDateFormatsdf1=newSimpleDateFormat("yyyyMd");
	SimpleDateFormatsdf2=newSimpleDateFormat("yyyyMMdd");
	System.out.println(sdf2.format(sdf1.parse("201827")));
	}
}

导航:首页 > 编程语言 > javadate初始化

javadate初始化

与javadate初始化相关的资料