⑴ java arraylist問題
/**
* 學生類
*/
package com.tool;
public class Student {
//學生學號
private String student_no;
//學生姓名
private String student_name;
//學生性別
private String student_sex;
//學生年齡
private String student_age;
public String getStudent_no() {
return student_no;
}
public void setStudent_no(String student_no) {
this.student_no = student_no;
}
public String getStudent_name() {
return student_name;
}
public void setStudent_name(String student_name) {
this.student_name = student_name;
}
public String getStudent_sex() {
return student_sex;
}
public void setStudent_sex(String student_sex) {
this.student_sex = student_sex;
}
public String getStudent_age() {
return student_age;
}
public void setStudent_age(String student_age) {
this.student_age = student_age;
}
}
/**
* 班級類
*/
package com.tool;
import java.util.ArrayList;
public class Class {
private String class_no;
private ArrayList<Student> students;
public String getClass_no() {
return class_no;
}
public void setClass_no(String class_no) {
this.class_no = class_no;
}
public ArrayList<Student> getStudents() {
return students;
}
public void setStudents(ArrayList<Student> students) {
this.students = students;
}
}
/**
* 主類
*/
package com.tool;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
//獲取Student數據,此處先自己new幾個
Student st1 = new Student();
Student st2 = new Student();
Student st3 = new Student();
st1.setStudent_no("001");
st1.setStudent_name("張三");
st1.setStudent_sex("男");
st1.setStudent_age("16");
st2.setStudent_no("002");
st2.setStudent_name("李四");
st2.setStudent_sex("女");
st2.setStudent_age("15");
st3.setStudent_no("003");
st3.setStudent_name("王五");
st3.setStudent_sex("男");
st3.setStudent_age("16");
//...
//將學生添加到集合
ArrayList<Student> sts = new ArrayList<Student>();
sts.add(st1);
sts.add(st2);
sts.add(st3);
//創建班級信息
Class cl = new Class();
cl.setClass_no("1班");
cl.setStudents(sts);
//輸出信息
System.out.println(cl.getClass_no());
for(int i = 0; i < cl.getStudents().size(); i ++ ){
System.out.println("學生信息:");
System.out.println("學號:"+cl.getStudents().get(i).getStudent_no());
System.out.println("姓名:"+cl.getStudents().get(i).getStudent_name());
System.out.println("性別:"+cl.getStudents().get(i).getStudent_sex());
System.out.println("年齡:"+cl.getStudents().get(i).getStudent_age());
}
}
}
⑵ Java TCP socket通信，如何實現發送十六進制值，並在數據接收窗口中顯示這些數據對應的字元串，非常感謝！
我自己的電腦上有一段源代碼，就是基於TCP聊天小代碼，能進行相互之間的消息接受。我的代碼是直接傳輸字元串的,不是16進制滴。嗯，也貼出來看看吧！
運行伺服器，c1,c2就可以了，c1與c2可進行通信。
Client.java
import java.net.*;
public class Client{
static byte num=1;
private int portNum;
public Client(int portnum){
this.portNum=portnum;
System.out.println("您是第"+num+"位客服端");
num++;
}
public void sentMessage(String me){
//都是向伺服器發信息埠號1999
try{
DatagramSocket ds=new DatagramSocket();
DatagramPacket dp=new DatagramPacket(me.getBytes(),me.length(),InetAddress.getByName("127.0.0.1"),1999);
ds.send(dp);
ds.close();
}catch(Exception e){
e.printStackTrace();
}
}
public String receiveMessage(){
String str="";
try{
DatagramSocket ds=new DatagramSocket(this.portNum);//表示哦自己的接收埠號是1999
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf,1024);
ds.receive(dp);
str=new String(dp.getData(),0,dp.getLength());
ds.close();
}catch(Exception e){
e.printStackTrace();
}
return str;
}
}
c1.java
import java.util.*;
public class c1 implements Runnable{
Client cl;
boolean goon=true;
Scanner sc=new Scanner(System.in);
public c1(){
cl=new Client(2000);
System.out.println("這里是2000客戶端\n你可以發送信息。請輸入要發送的信息。out退出");
new Thread(this).start();
while(this.goon==true){
say();
}
if(goon==false){
System.exit(0);
}
}
public static void main(String[] args){
new c1();
}
public void say(){
String mess=sc.nextLine();
System.out.println("是否發送y/n");
String key=sc.nextLine();
if(key.equals("y")){
System.out.println("信息信息發送中……");
try{
cl.sentMessage(mess);
}catch(Exception e){
e.printStackTrace();
}
}
else if(key.equals("out")){
goon=false;
}
}
public void run(){
while(this.goon==true){
String sst="";
try{
sst=cl.receiveMessage();
}catch(Exception e){
e.printStackTrace();
}
if(sst.length()>0){
System.out.println(sst);
}
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println("程序結束！");
}
}
c2.java
import java.util.*;
public class c2 implements Runnable{
Client cl;
boolean goon=true;
Scanner sc=new Scanner(System.in);
public c2(){
cl=new Client(2001);
System.out.println("這里是2001客戶端\n你可以發送信息。請輸入要發送的信息。out退出");
new Thread(this).start();
while(goon==true){
say();
}
if(goon==false){
System.exit(0);
}
}
public static void main(String[] args){
new c2();
}
public void say(){
String mess=sc.nextLine();
System.out.println("是否發送y/n");
String key=sc.nextLine();
if(key.equals("y")){
System.out.println("信息信息發送中……");
try{
cl.sentMessage(mess);
}catch(Exception e){
e.printStackTrace();
}
}
else if(key.equals("out")){
this.goon=false;
}
}
public void run(){
while(this.goon==true){
String sst="";
try{
sst=cl.receiveMessage();
}catch(Exception e){
e.printStackTrace();
}
if(sst.length()>0){
System.out.println(sst);
}
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println("聊天關閉！");
}
}
Server.java
import java.net.*;
import java.util.*;
public class Server implements Runnable{
private String message;
boolean work=true;
byte tm=10;
String[] clomessage={"信息：正在斷開網路連接.",".",".\n","信息：設置保存中……","","","完成\n","信息：歡迎下次使用\n","信息：完成\n","Goodbye!"};
public Server(){
new Thread(this).start();
System.out.println("本程序為服務端Server");
Scanner sc=new Scanner(System.in);
System.out.println("輸入命令out關閉伺服器");
String clo=sc.nextLine();
if(clo.equals("out")){
System.out.println("正在關閉伺服器……");
setwork(false);
System.exit(0);
}
}
public static void main(String[] args){
new Server();
}
public void setwork(boolean bo)
{
this.work=bo;
}
public void setMessage(String str){
this.message=str;
}
public String getMessage(){
return this.message;
}
public void sentMessage(){
String mes=this.getMessage();
try{
DatagramSocket ds=new DatagramSocket();
DatagramPacket dp=new DatagramPacket(mes.getBytes(),mes.length(),InetAddress.getByName("127.0.0.1"),2000);
DatagramPacket dp2=new DatagramPacket(mes.getBytes(),mes.length(),InetAddress.getByName("127.0.0.1"),2001);
ds.send(dp);
ds.send(dp2);
ds.close();
System.out.println("信息發送至：127.0.0.1：2000 & 127.0.0.1：2001");
this.setMessage("");
}catch(Exception e){
e.printStackTrace();
}
}
public void receiveMessage() throws Exception{
try{
DatagramSocket ds=new DatagramSocket(1999);//表示哦自己的接收埠號是1999
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf,1024);
ds.receive(dp);
String str=new String(dp.getData(),0,dp.getLength());
if(str.length()>0){
this.setMessage(str);
System.out.println("信息：Server從"+dp.getAddress().getHostAddress()+"主機(埠號："+dp.getPort()+")收到信息:"+this.getMessage());
}
ds.close();
}catch(Exception e){
e.printStackTrace();
}
}
public void run(){
while(tm>0){
if(work==false){
tm--;
System.out.print(clomessage[9-tm]);
}
try{
receiveMessage();//時刻接受信息
}catch(Exception e){
e.printStackTrace();
}
if(this.getMessage().length()>0){//如果接收到信息則發送信息
try{
sentMessage();
}catch(Exception e){
e.printStackTrace();
}
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
}
呵呵，請指教啊！
⑶ 20寸JAVA碟剎輪組
哈哈我給老婆裝的就是20寸的JAVA CL！這個架子除了後剎不能走油管和前變需轉換座以外，別的方面都不錯的。我的輪組是久鈺4軸承+太陽CR18，比較皮實，圈的話也可選擇DA16，非常騷~~~600元的輪組相當給力了，又是20寸的，堅固耐用程度可完全放心！
自編輪組是車店用花鼓、圈和輻條自編的，總價不貴，性價比高，選擇性較廣，與自編輪組相對的是成品輪組，馬維克、西馬諾等許多品牌都有成品輪組，成品輪組屬於較高端的配件，性能好重量輕，但是普遍價格較高，大牌的成品輪組一般安裝在萬元以上的整車上....
⑷ myeclipse運行代碼時出現如下問題。求解決。
問題可能的原因：如果hibernate用的userLibrary, 並且該user Library設置為system library，有可能出現這個問題。
解決方法：將system library設置項去掉即可
⑸ java靜態變數怎麼聲明
個人的總結
1 靜態變數只有一份被類的所有實例共享
2 靜態變數的聲明在編譯時已經明確了內存的位置
3 延遲初始化是改變靜態變數的值
引用
Java靜態變數的初始化（static塊的本質）
在網上看到了下面的一段代碼：
1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }
public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }
上述代碼會列印出什麼結果來呢？10還是20？本文將以此代碼為引子，著重討論一下靜態變數的初始化問題。 樓主可以找組織先記下175再來記下161最後填寫984就會出現扣裙問題1：靜態變數如何初始化
Java類中可以定義一個static塊，用於靜態變數的初始化。如：
1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6. }
public class Test { public static int _i; static { _i = 10; } }
當然最常用的初始化靜態變數的操作是在聲明變數時直接進行賦值操作。如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
那麼上述兩例在本質上有什麼區別嗎？回答是沒有區別。兩例代碼編譯之後的位元組碼完全一致，通過 「javap -c」查看到的位元組碼如下：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
}
通過位元組碼還可以看出，當類的定義中不含有static塊時，編譯器會為該類提供一個默認的static塊。當然這是在含有靜態變數初始化操作的前 提下。如果靜態變數沒有初始化操作，則編譯器不會為之提供默認的static塊。如：
1. public class Test {
2. public static int _i;
3. }
public class Test { public static int _i; }
其位元組碼的表現形式為：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
}
由於靜態變數是通過賦值操作進行初始化的，因此可以通過靜態函數返回值的方式為其初始化。如：
1. public class Test {
2. public static int _i = init();
3.
4. private static int init() {
5. return 10;
6. }
7. }
public class Test { public static int _i = init(); private static int init() { return 10; } }
其本質與下面的代碼相同：
1. public class Test {
2. public static int _i;
3. static {
4. _i = init();
5. }
6.
7. private static int init() {
8. return 10;
9. }
10. }
public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }
問題2：JDK如何處理static塊
類定義中可以存在多個static塊嗎？回答是可以。如：
1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6.
7. public static void main(String[] args) {
8. }
9.
10. static {
11. _i = 20;
12. }
13. }
public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }
此類編譯之後的位元組碼為：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: return
static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return
}
觀察static{}部分可以看出，上例的代碼與下面的代碼效果一致：
1. public class Test {
2. public static int _i;
3.
4. public static void main(String[] args) {
5. }
6.
7. static {
8. _i = 10;
9. _i = 20;
10. }
11. }
public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }
此例可以證明，不僅類定義中可以有多個static塊，而且在編譯時編譯器會將多個static塊按照代碼的前後位置重新組合成一個static 塊。
問題3：如何看待靜態變數的聲明
靜態變數存放在常量池之中。如何證明呢？如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
使用「javap -c -verbose」查看其位元組碼的內容如下：
public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."<init>":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "<init>":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;
{
public static int _i;
public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 2: 0
static {};
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable:
line 3: 0
}
我們看到，常量池中const #2指向的就是Test._i，也就是靜態變數。靜態變數被保存到常量池中的工作原理這里不深入討論。在此需要注意的是：
* 靜態變數的聲明與初始化是兩個不同的操作；
* 靜態變數的聲明在編譯時已經明確了內存的位置。
如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
上述代碼的本質可以視為：
1. public class Test {
2. // 靜態變數的聲明
3. public static int _i;
4.
5. // 靜態變數的初始化
6. static {
7. _i = 10;
8. }
9. }
public class Test { // 靜態變數的聲明 public static int _i; // 靜態變數的初始化 static { _i = 10; } }
由於靜態變數的聲明在編譯時已經明確，所以靜態變數的聲明與初始化在編碼順序上可以顛倒。也就是說可以先編寫初始化的代碼，再編寫聲明代碼。如：
1. public class Test {
2. // 靜態變數的初始化
3. static {
4. _i = 10;
5. }
6.
7. // 靜態變數的聲明
8. public static int _i;
9. }
public class Test { // 靜態變數的初始化 static { _i = 10; } // 靜態變數的聲明 public static int _i; }
對初始問題的解答
解答了上述三個問題，讓我們再來看看開篇提到的問題。代碼如下：
1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }
public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }
其本質可以用下面的代碼表示：
1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i;
6. static {
7. _i = 10;
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(_i);
12. }
13. }
public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }
再簡化一下，可以表示為：
1. public class Test {
2. public static int _i;
3.
4. static {
5. _i = 20;
6. _i = 10;
7. }
8.
9. public static void main(String[] args) {
10. System.out.println(_i);
11. }
12. }
public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }
至此，代碼已經明確告訴我們列印結果是什麼了！
⑹ 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讀取properties文件
InputStream in = getProperties.class.getClassLoader().getResourceAsStream(
"config.properties");
這一句換個寫法試試：
Properties props = new Properties();
String url = this.getClass().getClassLoader().getResource(
"config.properties").toString().substring(6);
String empUrl = url.replace("%20", " ");// 如果你的文件路徑中包含空格，是必定會報錯的
System.out.println(empUrl);
InputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(empUrl));
props.load(in);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e1) {
e1.printStackTrace();
}
我就是一直這么寫的，沒問題。
我猜你讀取文件為空的原因，是你的文件路徑有空格。
⑻ 衢州哪有賣JAVA小輪車16速CL！高分。。。
小輪車還是到能組裝的單車店訂，如果自己動手能力強，就從網上買散件組裝。
⑼ 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程序的初始化
樓上的 ,人家是新手,不要這么打擊人么. 要鼓勵呀,本來很簡單的問題為什麼要說得這么復雜呢.你著有可能在毀掉一個優秀的java 程序員.
初始化是指 你定義一個成員變數,或局部變數.8種基本類型都有默認的初始值,你查書可以找到.比如,int 類型的 你可以這么定義 int i=0;意思就是把i的值賦為0.要是一個成員變數你對他 不進行初始化則系統對其參照默認初始化表進行賦值.