1、1. 編寫程序，用數組實現乘法小九九的存儲和輸出。【提示：采用多個一維數組。】 public class Multipation public static void main(String args) 定義一個類Student，屬性為學號、姓名和成績；方法為增加記錄SetRecord和得到記錄GetRecord。SetRecord給出學號、姓名和成績的賦值，GetRecord通過學號得到考生的成績。public class Student /* * param args */private int ID;private String name;private float score;publ

2、ic void SetRecord(int ID,String name,float score)=ID;=name;=score;public float getRecord(int ID)if(ID=return ;elsereturn -1;public static void main(String args) 編寫程序，測試字符串“你好，歡迎來到Java世界”的長度，將字符串的長度轉換成字符串進行輸出，并對其中的“Java”四個字母進行截取，輸出截取字母以及它在字符串中的位置。public class StringTest /* * param args */public stati

3、c void main(String args) 自己設計一個坐標類，能提供以下方法如求當前坐標和其他坐標之間的距離等方法，要求所有變量為私有變量，并提供兩個構造函數。public class XYdistance private int x;private int y;XYdistance()setX(0);setY(0);public void setX(int x) = x;public int getX() return x;public void setY(int y) = y;public int getY() return y;public static void main(St

4、ring args) lass文件中的一些數據。JVM虛擬機為每個被裝載的類型維護一個常量池。常量池就是該類型所用到常量的一個有序集和，包括直接常量（String,Integer和 Floating point常量）和對其他類型，字段和方法的符號引用。對于String常量，它的值是在常量池中的。而JVM中的常量池在內存當中是以表的形式存在的， 對于String類型，有一張固定長度的CONSTANT_String_info表用來存儲文字字符串值，注意：該表只存儲文字字符串值，不存儲符號引用。 1、String s = "abc" 創建過程分析：在class文件被JVM裝載到內

5、存中，JVM會創建一塊String Pool（String緩沖池）。當執行String s = “abc”;時，JVM首先在String Pool中查看是否存在字符串對象“abc”（如何查看呢用equals()方法判斷），如果已存在該對象，則不用創建新的字符串對象“abc”，而直接使用String Pool中已存在的對象“abc”，然后將引用s指向該對象；如果不存在該對象，則先在String Pool中創建一個新的字符串對象“abc”，然后將引用s指向String Pool中創建的新對象。 注意：使用“字符串常量”引號創建的字符串對象時，在編譯期就已經確定將該對象存儲到String Pool中

6、了。因此，String s = “abc”只會在編譯期，在String Pool中創建一個對象。 例如： Java代碼  1. String s1 = "abc"   2. String s2 = "abc"    = s2);返回了一個String對象，也就是說在堆中創建了對象。這時候會不會在池中出現"abc"這個對象呢（question還沒解決） 生成String s的過程中，編譯器使用sb執行的過程：

7、創建一個StringBuffer對象，使用append()向此StringBuffer對象直接添加新的字符串（而不是每次制作一個新的副本）。 對于String c = "c"String s = "a" + "b" + c;，編譯器將會先將"a" + "b"作為編譯時常量，優化生成成字面常量"ab" ，然后生成一個StringBuilder對象，接著調用兩次 append()方法，即: String s = new Builder().append("ab"

8、;).append(c) .toString(); 對于String a = "a"String s = a + "b" + "c"，編譯器分析a為引用變量，后面的"b" + "c"就不會作為編譯時常量來運算了。相當于執行： String s = new Builder().append(a).append("b") .append("c") .toString(); 對于String b = "b"String s = "a

9、" + b + "c"，這種形式的就沒辦法優化了，直接生成StringBuilder對象，然后調用三次 append()方法，即： String s = new Builder().append("a").append(b) .append("c") .toString(); 接著，我們再看以下代碼： Java代碼  String str1 = "abc".，只要在java里面有關鍵字new存在，不管內容是否相同，都表示它將生成一個新的對象，new多少次，就生成多少

10、個對象，而且新生成的對象都是在Heap里面，所以它會在Heap里面生成一個內容為abc的對象，并且將它的地址賦給了引用s3，s3就指向剛在Heap里面生成的內容為abc的對象。所以，當執行完語句(3)時，內存里面一共有3個對象，其中包含了在String Pool里面一個內容為abc的字符串對象和在Heap里面包含了兩個內容為abc的字符串對象。 問題4：當執行完語句(4)(5)(6)后，它們的結果分別是什么 在java里面，對象用"="永遠比較的是兩個對象的內存地址，換句話說，是比較"="左右兩邊的兩個引用是否指向同一個對象。對于java里面的8種原生數

11、據類型來說，"="比較的是它們的字面值是不是一樣的；對應用類型來說，比較的是它們的內存地址是不是一樣的。在語句(1)(2)(3)中，由于s1、s2、s3指向不同的對象，它們的內存地址就不一樣，因此可以說當執行完語句(4)(5)(6),它們返回的結果都是false。 問題5：當執行完語句(7)(8)(9)后，它們的結果分別是什么 首先，s1這個對象指向的是堆中第一次new.生成的對象，當調用 intern 方法時，如果String Pool已經包含一個等于此 String 對象的字符串(該對象由equals(Object)方法確定），則返回指向String Pool中的字符串

12、對象的引用。因為String Pool中有內容為abc的對象，所以()返回的是String Pool中的內容為abc的字符串對象的內存地址，而s1卻是指向Heap上內容為abc的字符串對象的引用。因而，兩個引用指向的對象不同，所以，s1 = () 為false，即語句(7)結果為false。 對于()，它還是會首先檢查String Pool中是否有內容為abc的對象，發現有，則將String Pool中內容為abc的對象的地址賦給()方法的返回值。因為s2和()方法的返回值指向的是同一個對象，所以，s2 = ()的結果為true,，即語句(8)結果為true。 對于()，它首先檢查String

13、 Pool中是否有內容為abc的對象，發現有，則將String Pool中內容為abc的對象的賦給()方法的返回值。對于(),首先檢查String Pool中是否有內容為abc的對象，發現有，則將String Pool中內容為abc的對象的地址賦給()方法的返回值。因為兩者返回的地址都指向同一個對象，所以，() = ()的結果為true,，即是語句(9)結果為true。 因此，當執行完語句(7)(8)(9)后，它們的結果分別是false、true、true。 問題6：當執行完語句(13)(14) (15)(16)后，它們的結果分別是什么 hello = "hello"引用h

14、ello指向的對象就是String Pool中的“hello”，即語句(13)的結果為true。 hello = "hel" + "lo"當加號兩邊都是常量值時，就會組成一個新的常量值"hello"在String Pool里面，如果String Pool已經有相同內容的就不會再創建，則直接返回String Pool里面的內容為"hello"的字符串對象的內存地址，所以，hello = "hel" + "lo"結果為true。 hello ="hel" +

15、lo 當加號兩邊有一個不是常量值，會在堆里面創建一個新的"hello"對象，一個在String Pool中，一個在Heap中，故輸出false 。 hel + lo 同上，輸出false。 因此，當執行完語句(7)(8)(9)后，它們的結果分別是true、true、false、false。 例程7： Java代碼  1. String s1 = "abc"   2. String s2 = new String("abc"); 

16、0; 3. String s3 = new String("abc");   ();ppend("a").append(new String("bc").toString(); 思考：String s = "a" + new String("b") + "c"產生了那幾個對象 解：等價于String s = new StringBuilder().append("a").append(n

17、ew String("b").append("c").toString()，會在String Pool中產生"a"、"b"、"c"三個對象，在Heap中產生"b"、"abc"兩個個對象。一共5個字符串對象。 例程9： Java代碼  1. String s1 = "Hello"   2. s1 = "Java"   3

18、. String s2 = "Hello"   4. String s3 = new String("Hello");   5.  = s2);   6.  = s3);  String s2 = "Hello"String s3 = new String("Hello"); = s2); = s3);運行結果如下： false

19、 false 分析這段程序的執行過程： 首先在加載Java程序時，JVM會創建一片的內存空間（String Pool）專門存入string對象。 String s1 = "Hello"，現在棧中創建一個字符串引用s1，然后JVM會在String Pool中查找是否存在"Hello"，如果存在，則直接使用它，將其地址賦給s1，如果不存在（這時String Pool中顯然不存在"Hello"），則在String Pool中創建"Hello"，并將其地址賦給s1。 s1 = "Java"，JVM會在S

20、tring Pool中查找是否存在"Java"，如果存在，則直接使用它，將其地址賦給s1，如果不存在（這時String Pool中顯然不存在"Java"），則在String Pool中創建"Java"，并將其地址賦給s1。而原來的字符串對象"Hello"仍然在String Pool中，沒有消失，因為String對象的值是不能被修改的。這里只是改變了引用的值即引用指向的對象的地址，而沒有改變它所引用的對象。 String s2 = "Hello"，JVM會在String Pool里查看有沒有字符串

21、"Hello"，若有，則返回它的地址給s2，否則，創建新的String對象"Hello"， 放到String Pool里。這里由于"Hello"對象已經創建，并存在于String Pool中，因而不需要重新創建String對象"Hello"。此時s1指向String Pool中的"Java"，s2指向String Pool中的"Hello"，故s1 = s2的值為false。 String s3=String("Hello")，JVM會在String Po

22、ol里查看有沒有字符串"Hello"，若有，直接執行new操作，若沒有，則先要在String Pool中創建"Hello"，然后執行new操作，由于遇到了new，還會在Heap上（不是String Pool里）創建string對象"Hello"，并將Heap上的"Hello"對象的地址賦給引用s3。所以s2 = s3將返回false，因為s2和s3不是引用同一個對象。 以上小結如理解有誤，希望各位高手指教！ 寫代碼驗證靜態代碼塊被自動執行，就算產生了類的多個實例對象，但其中的靜態代碼塊只被執行了一次。class P

23、arent static String name = "hello""parent block");static "parent static block");public Parent() "parent constructor");class Child extends Parent static String childName = "hello""child block");static "child static block");public Child() "child constructor");public class TextStatic public static void main(String args) / TODO Auto-generated method stubnew Child();/ 語句(*)new Ch