java练习题含答案.docx

1、java练习题含答案1. 编写程序，用数组实现乘法小九九的存储和输出。【提示：采用多个一维数组。】 public class Multipation public static void main(String args) / TODO Auto-generated method stub int x=new int99; for(int i=0;i9;i+) for(int j=0;j=j) int m=i+1; int n=j+1; xij=m*n; System.out.print(m+*+n+=+xij); System.out.println(); 2. 定义一个类Student，属

2、性为学号、姓名和成绩；方法为增加记录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) this.ID=ID; this.name=name; this.score=score; public float get

3、Record(int ID) if(ID=this.ID) return this.score; else return -1; public static void main(String args) / TODO Auto-generated method stub Student s=new Student(); s.SetRecord(0,alex,100); float Sco=s.getRecord(0); System.out.print(Sco); 3. 给出上题中设计类的构造函数，要求初始化一条记录(学号、姓名、成绩)。4. public class Student 5. /

4、*6. * param args7. */8. private int ID;9. private String name;10. private float score;11. Student(int ID,String name,float score)12. this.ID=0;13. this.name=666;14. this.score=65;15. 16. public void SetRecord(int ID,String name,float score) 17. this.ID=ID;18. this.name=name;19. this.score=score;20.

5、21. public float getRecord(int ID)22. if(ID=this.ID)23. return this.score;24. else25. return -1;26. 27. public static void main(String args) 28. / TODO Auto-generated method stub29. Student s=new Student(0,sdfs,12);30. /s.SetRecord(0,alex,100);31. float Sco=s.getRecord(0);32. System.out.print(Sco);3

6、3. 34. 4. 编写程序，测试字符串“你好，欢迎来到Java世界”的长度，将字符串的长度转换成字符串进行输出，并对其中的“Java”四个字母进行截取，输出截取字母以及它在字符串中的位置。public class StringTest /* * param args */ public static void main(String args) / TODO Auto-generated method stub String str=你好，欢迎来到Java世界; int length=str.length(); char stringArr = str.toCharArray(); /Sys

7、tem.out.print(stringArr); for(int i=0;ilength;i+) /System.out.print(stringArri); /System.out.print(stringArr0); if(J=stringArri) System.out.print(i); 1. 自己设计一个坐标类，能提供以下方法如求当前坐标和其他坐标之间的距离等方法，要求所有变量为私有变量，并提供两个构造函数。public class XYdistance private int x; private int y; XYdistance() setX(0); setY(0); pub

8、lic void setX(int x) this.x = x; public int getX() return x; public void setY(int y) this.y = y; public int getY() return y; public static void main(String args) / TODO Auto-generated method stub XYdistance m_1= new XYdistance(); m_1.setX(10); m_1.setY(10); XYdistance m_2= new XYdistance(); double d

9、istance=(m_1.getX()-m_2.getX()*(m_1.getX()-m_2.getX()+(m_1.getY()-m_2.getY()*(m_1.getY()-m_2.getY(); double result=Math.sqrt(distance); System.out.println(result); 编写使用静态变量统计一个类产生的实例对象的个数的程序？public class Static private static int number; public Static() /number=number+1; +number; /System.out.println

10、(+number); public static void main(String args) / TODO Auto-generated method stub new Static(); /m_1.Static(); System.out.println(Static.number); 创建string对象过程的内存分配：常量池（Constant Pool）：指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。JVM虚拟机为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（String,Integer和 Floating point常

11、量）和对其他类型，字段和方法的符号引用。对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。 1、String s = abc; 创建过程分析：在class文件被JVM装载到内存中，JVM会创建一块String Pool（String缓冲池）。当执行String s = “abc”;时，JVM首先在String Pool中查看是否存在字符串对象“abc”（如何查看呢？用equals()方法判断），如果已存在

12、该对象，则不用创建新的字符串对象“abc”，而直接使用String Pool中已存在的对象“abc”，然后将引用s指向该对象；如果不存在该对象，则先在String Pool中创建一个新的字符串对象“abc”，然后将引用s指向String Pool中创建的新对象。 注意：使用“字符串常量”引号创建的字符串对象时，在编译期就已经确定将该对象存储到String Pool中了。因此，String s = “abc”只会在编译期，在String Pool中创建一个对象。 例如： Java代码1. Strings1=abc; 2. Strings2=abc; 3. System.out.println(s

13、1=s2);/true结果说明：JVM创建了两个引用str1和str2，但在String Pool中只创建了一个对象，而且两个引用都指向了同一个对象。 2、String s = new String(abc); 创建过程分析：当执行String s = new String(“abc”);时，JVM首先在String Pool中查看是否存在字符串对象“abc”，如果不存在该对象，则先在String Pool中创建一个新的字符串对象“abc”，然后执行new String(“abc”)构造方法，在Heap里又创建一个新的字符串对象“abc”（new出来的对象都放在Heap里面），并将引用s指向H

14、eap中创建的新对象；如果已存在该对象，则不用创建新的字符串对象“abc”，而直接使用String Pool中已存在的对象“abc”， 然后执行new String(“abc”)构造方法，在Heap里又创建一个新的字符串对象“abc”，并将引用s指向Heap中创建的新对象。 注意：使用new String（“”）创建的字符串对象时，会在运行期创建新对象存储到Heap中。因此，new String（“abc”）创建字符串对象时，会创建2个对象，编译期在String Pool中创建一个，运行时Heap中创建一个。 这里使用了 Java代码1. publicString(Stringoriginal

15、)这个构造方法，作用：初始化一个新创建的String对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 由于Sring类是不可变的，因而不必使用该构造方法，除非需要original的显式副本。 例如： Java代码1. Strings1=newString(abc); 2. Strings2=newString(abc); 3. System.out.println(s1=s2);/false结果说明：只要是用new()来新建对象的，都会在堆（Heap）中创建，而且其字符串是单独存值的，即使与String Pool中的数据相同，也不会与String Pool

16、中的数据共享。 例程1： Java代码1. Strings1=abcdef; 2. Strings2=abcdef; 3. Strings3=abc+def;/编译期自动优化为Strings3=abcdef; 4. System.out.println(s1=s2); 5. System.out.println(s1=s3); 6. System.out.println(s2=s3);运行结果： true true true 结果说明：字符串常量生成的字符串对象在String Pool中只有一个拷贝，且它是在编译期就被确定了，所以“s1 = s2”；“abc”和“def”都是字符串常量，当一个

17、字符串由多个字符串常量连接而成时，它自己也肯定是字符串常量（它在编译期就被解析为一个字符串对象了，即class文件中就已经存在“abcdef”），所以在字符串生成字符串对象时，s3也是String Pool中“abcdef”的一个引用。故JVM对于字符串常量的+号连接，在程序编译期，JVM就将常量字符串的+连接优化为连接后的值。 例程2： Java代码1. Strings1=abc; 2. Strings2=def; 3. Strings3=abcdef; 4. Strings4=abc+def; 5. Strings5=s1+def; 6. Strings6=abc+s2; 7. Strin

18、gs7=s1+s2; 8. System.out.println(s3=s4); 9. System.out.println(s3=s5); 10. System.out.println(s3=s6); 11. System.out.println(s3=s7);运行结果如下： true false false false 结果说明：JVM对于有字符串引用存在的字符串+连接中，而引用的值在程序编译期是无法确定的，即s1 + “def”无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给s5。 例程3： Java代码1. finalStrings1=abc; 2. Strings2

19、=def; 3. Strings3=abcdef; 4. Strings4=abc+def; 5. Strings5=s1+def; 6. Strings6=abc+s2; 7. Strings7=s1+s2; 8. System.out.println(s3=s4); 9. System.out.println(s3=s5); 10. System.out.println(s3=s6); 11. System.out.println(s3=s7);运行结果如下： true true false false 例程4： Java代码1. finalStrings1=abc; 2. finalSt

20、rings2=def; 3. Strings3=abcdef; 4. Strings4=abc+def; 5. Strings5=s1+def; 6. Strings6=abc+s2; 7. Strings7=s1+s2; 8. System.out.println(s3=s4); 9. System.out.println(s3=s5); 10. System.out.println(s3=s6); 11. System.out.println(s3=s7);运行结果如下： true true true true 结果说明：例程3和例程4与例程2的区别是，例程3在字符串s1前加了final修

21、饰，例程4在字符串s1和s2前都加了final修饰。对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的s1 + “def”和abc + def效果是一样的。接着后面两个含引用的字符串连接，JVM会进行相同的处理。故上面程序后面三个的结果为true。 例程5： Java代码1. publicstaticvoidmain(Stringargs) 2. Strings1=abc; 3. finalStrings2=getDef(); 4. Strings3=abcdef; 5. Strings4=abc+s2; 6. Strings

22、5=s1+s2; 7. System.out.println(s3=s4); 8. System.out.println(s3=s5); 9. Java代码1. privatestaticStringgetDef() 2. returndef; 3. 程序运行结果如下： false false 结果说明：JVM对于方法调用给字符串引用赋值的情况，引用指向字符串的值在编译期是无法确定的，只有在程序运行调用方法后，将方法的返回值“def”和“abc”动态连接并分配新地址赋值给s4，所以上述程序的结果都为false。 通过以上的例子可知： Java代码1. Strings=a+b+c;等价于： Ja

23、va代码1. Strings=abc;编译期，直接优化，进行常量连接。 对于： Java代码1. Stringa=a; 2. Stringb=b; 3. Stringc=c; 4. Strings=a+b+c;就不等价于：等价于： Java代码1. Strings=abc;最终结果等于： Java代码1. StringBuilderbuilder=newStringBuilder(); 2. builder.append(a); 3. builder.append(b); 4. builder.append(c); 5. Strings=builder.toString();去看StringB

24、uilder的toString()方法： Java代码1. publicStringtoString() 2. /Createacopy,dontsharethearray 3. returnnewString(value,0,count); 4. 可以发现是通过new String(.)返回了一个String对象，也就是说在堆中创建了对象。这时候会不会在池中出现abc这个对象呢？（question还没解决） 生成String s的过程中，编译器使用sb执行的过程：创建一个StringBuffer对象，使用append()向此StringBuffer对象直接添加新的字符串（而不是每次制作一个新

25、的副本）。 对于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

26、) .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代码1. Stringstr1=abc;/是字符串常量，它在编译期被确定，放在常量池中（共享内容值） 2. /newString()创建的字符串不放入常量池中 3. Stringstr2=new

27、String(abc);/不是字符串常量，不在编译期确定（不共享内容值）Java代码1. Stringstr1=newString(abc); 2. Stringstr2=abc; 3. System.out.println(str1=str2);/false创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。 Java代码1. Stringstr1=abc; 2. Stringstr2=newString(abc); 3. System.out.println(str1=str2);/false创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。 接下来我们再来看看intern()方法，它的定义如下： Java代码1. publicnativeStringintern();这是一个本地方法。在调用这个方法时，JAVA虚拟机首先检查String Pool中是否已经存在与该对象值相等对象存在，如果有则返回字符串池中对象的引用；如果没有，则先在String Pool中创建一个相同值的String对象，然后再