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;public 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 static 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(String[] args) {lass文件中的一些数据。

JVM虚拟机为每个被装载的类型维护一个常量池。

常量池就是该类型所用到常量的一个有序集和，包括直接常量（String,Integer和 Floating point常量）和对其他类型，字段和方法的符号引用。

对于String常量，它的值是在常量池中的。

而JVM中的常量池在内存当中是以表的形式存在的，对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。

1、String s = "abc";创建过程分析：在class文件被JVM装载到内存中，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中了。

因此，String s = “abc”只会在编译期，在String Pool中创建一个对象。

例如：Java代码1.String s1 = "abc";2.String s2 = "abc";== s2);返回了一个String对象，也就是说在堆中创建了对象。

这时候会不会在池中出现"abc"这个对象呢？（question还没解决）生成String s的过程中，编译器使用sb执行的过程：创建一个StringBuffer对象，使用append()向此StringBuffer对象直接添加新的字符串（而不是每次制作一个新的副本）。

对于String c = "c";String s = "a" + "b" + c;，编译器将会先将"a" + "b"作为编译时常量，优化生成成字面常量"ab" ，然后生成一个StringBuilder对象，接着调用两次 append()方法，即:String s = new Builder().append("ab").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" + b + "c";]，这种形式的就没办法优化了，直接生成StringBuilder对象，然后调用三次 append()方法，即：String s = new Builder().append("a").append(b) .append("c") .toString();接着，我们再看以下代码：Java代码String str1 = "abc";.，只要在java里面有关键字new存在，不管内容是否相同，都表示它将生成一个新的对象，new多少次，就生成多少个对象，而且新生成的对象都是在Heap里面，所以它会在Heap里面生成一个内容为abc的对象，并且将它的地址赋给了引用s3，s3就指向刚在Heap里面生成的内容为abc 的对象。

所以，当执行完语句(3)时，内存里面一共有3个对象，其中包含了在String Pool里面一个内容为abc的字符串对象和在Heap里面包含了两个内容为abc的字符串对象。

问题4：当执行完语句(4)(5)(6)后，它们的结果分别是什么?在java里面，对象用"=="永远比较的是两个对象的内存地址，换句话说，是比较"=="左右两边的两个引用是否指向同一个对象。

对于java里面的8种原生数据类型来说，"=="比较的是它们的字面值是不是一样的；对应用类型来说，比较的是它们的内存地址是不是一样的。

在语句(1)(2)(3)中，由于s1、s2、s3指向不同的对象，它们的内存地址就不一样，因此可以说当执行完语句(4)(5)(6),它们返回的结果都是false。

问题5：当执行完语句(7)(8)(9)后，它们的结果分别是什么?首先，s1这个对象指向的是堆中第一次new...生成的对象，当调用 intern 方法时，如果String Pool已经包含一个等于此 String 对象的字符串(该对象由equals(Object)方法确定），则返回指向String Pool中的字符串对象的引用。

因为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 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"引用hello指向的对象就是String Pool中的“hello”，即语句(13)的结果为true。

hello == "hel" + "lo"当加号两边都是常量值时，就会组成一个新的常量值"hello"在String Pool里面，如果String Pool已经有相同内容的就不会再创建，则直接返回String Pool里面的内容为"hello"的字符串对象的内存地址，所以，hello == "hel" + "lo"结果为true。

hello =="hel" + 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");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(new String("b")).append("c").toString()，会在String Pool中产生"a"、"b"、"c"三个对象，在Heap中产生"b"、"abc"两个个对象。