第二周Java课堂作业
演示一：
1 public class enumtest {
2 public static void main(string[] args) {
3 size s=size.small;
4 size t=size.large;
5 //s和t引用同一个对象？
6 system.out.println(s==t);
7 //是原始数据类型吗？
8 system.out.println(s.getclass().isprimitive());//getclass()返回对象时的运行类
9 //class .isprimitive()确定指定的class对象表示一个基本类型(此方法返回true，当且仅当这个类表示一个基本类型。)
10 //从字符串中转换
11 size u=size.valueof("small");
12 system.out.println(s==u); //true
13 //列出它的所有值
14 for(size value:size.values()){
15 system.out.println(value);
16 }
17 }
18 }
19 enum size{small,medium,large};
结果与分析：
size枚举类型定义的s，t对象引用的是size里不同的元素，故不为同一对象，故第一个输出为false。
第二个判断对象s的所属类类型是否是一般类型，得到false输出，所以s所属的类并不是一般类型。
然后定义对象u引用small，与s引用同一元素，故为同一对象。
然后循环打印size里的元素，即得到输出结果。
结论：
枚举类型是一种特殊的类。
枚举类型是引用类型。
枚举类型可用于switch语句中。
枚举类型中实例化不同元素的对象不是同一对象，枚举不属于原始数据类型，他的每个具体值都引用一个特定的对象，相同的值则引用相同的对象。
使用枚举可以很方便的定义常量。
从字符串中转化的枚举类型可以与原枚举类型进行比较，且可以地址相同。可以使用“==”和“equal()”方法直接对比枚举常量的值。
演示二：
实现两数相加，用两个文本框输入数据，一个文本框输出。
1 // an addition program
2 import javax.swing.joptionpane; // import class joptionpane
3 public class addition {
4 public static void main( string args[] )
5 {
6 string firstnumber, // first string entered by user
7 secondnumber; // second string entered by user
8 int number1, // first number to add
9 number2, // second number to add
10 sum; // sum of number1 and number2
11
12 // read in first number from user as a string
13 firstnumber =
14 joptionpane.showinputdialog( "enter first integer" );
15
16 // read in second number from user as a string
17 secondnumber =
18 joptionpane.showinputdialog( "enter second integer" );
19
20 // convert numbers from type string to type int
21 number1 = integer.parseint( firstnumber );
22 number2 = integer.parseint( secondnumber );
23
24 // add the numbers
25 sum = number1 + number2;
26
27 // display the results
28 joptionpane.showmessagedialog(
29 null, "the sum is " + sum, "results",
30 joptionpane.plain_message );
31
32 system.exit( 0 ); // terminate the program
33 }
34 }
运行结果：
演示三：
验证如下代码的输出结果。
1 import java.util.*;
2
3 public class inputtest
4 {
5 public static void main(string[] args)
6 {
7 scanner in = new scanner(system.in);
8
9 // get first input
10 system.out.print("what is your name? ");
11 string name = in.nextline();
12
13 // get second input
14 system.out.print("how old are you? ");
15 int age = in.nextint();
16
17 int i,j;
18 string value="100";
19 i=integer.parseint(value);//integer.parseint()return a int value
20 j=200;
21 string s=string.valueof(j);//string.valueof() return a string object
22
23 // display output on console
24 system.out.println("hello, " + name + ". next year, you'll be " + (age + 1));
25 system.out.println("i="+i+",s="+s);
26
27
28 }
29 }
运行结果：
演示四：
验证精度不准。
1 public class testdouble {
2
3 public static void main(string args[]) {
4 system.out.println("0.05 + 0.01 = " + (0.05 + 0.01));
5 system.out.println("1.0 - 0.42 = " + (1.0 - 0.42));
6 system.out.println("4.015 * 100 = " + (4.015 * 100));
7 system.out.println("123.3 / 100 = " + (123.3 / 100));
8 }
9 }
运行结果：
结论：使用double类型的数值进行计算，结果是不准确的。
归根结底，这个问题涉及到二进制与十进制的转换。而n进制可以理解为：数值×基数的幂。double类型的数值占用64bit，即64个二进制数，除去最高位表示正负符号的位，在最低位上一定会与实际数据存在误差（除非实际数据恰好是2的n次方）。
所以几乎都会存在误差。
演示五：
精度不准的处理方法。
1 import java.math.bigdecimal;
2
3 public class testbigdecimal
4 {
5 public static void main(string[] args)
6 {
7 bigdecimal f1 = new bigdecimal("0.05");
8 bigdecimal f2 = bigdecimal.valueof(0.01);
9 bigdecimal f3 = new bigdecimal(0.05);
10 system.out.println("下面使用string作为bigdecimal构造器参数的计算结果：");
11 system.out.println("0.05 + 0.01 = " + f1.add(f2));
12 system.out.println("0.05 - 0.01 = " + f1.subtract(f2));
13 system.out.println("0.05 * 0.01 = " + f1.multiply(f2));
14 system.out.println("0.05 / 0.01 = " + f1.divide(f2));
15 system.out.println("下面使用double作为bigdecimal构造器参数的计算结果：");
16 system.out.println("0.05 + 0.01 = " + f3.add(f2));
17 system.out.println("0.05 - 0.01 = " + f3.subtract(f2));
18 system.out.println("0.05 * 0.01 = " + f3.multiply(f2));
19 system.out.println("0.05 / 0.01 = " + f3.divide(f2));
20 }
21 }
运行结果：
结论：
在构建bigdecimal对象时应使用字符串而不是double数值，否则，仍有可能引发计算精度问题。
演示六：
字符串连接
1 public class test {
2 public static void main(string[] args) {
3 int x=100;
4 int y=200;
5 system.out.println("x+y="+x+y);
6 system.out.println(x+y+"=x+y");
7 }
8 }
运行结果：
分析原因：
1、在第一个输出语句中，第一个遇到的是字符串，所以后面的x，y也转换成字符串输出。此时“+”被理解为连接符。
2、而第二个语句中，第一个遇到的x与第二个遇到的y是int型，而第三个是字符串，所以连接输出了运算结果和字符串。此时“+”则被理解为运算符。
演示七：
每个数据类型所占的位数和取值范围：
①byte（字节）：8bits，数值范围为-128-127
②short（短整型）：16bits，数值范围为-32768-32768
③int（整型）：32bits，数值范围为-2147483648-2147483648
④long（长整型）：64bits，数值范围为-9233372036854477808-9233372036854477808
⑤float（浮点型）：32bits，数值范围为-3.40292347e+38-3.40292347e+38
⑥double（双精度）：64bits，数值范围为-1.7976931486231570e+308-1.7976931486231570e+308
⑦char（字符型）：16bits，数值范围为‘\u0000-u\ffff’
⑧boolean（布尔型）：1bits，数值范围为true/false
结论：
java中的基本数据类型转换分为自动类型转换和强制类型转换。自动数据类型转换是由优先级别低的数据赋值给优先级别高的变量。强制类型转换是由优先级别高的数据赋值给优先级别低的变量。强制类型转换通常都会有存在精度的损失，特别是比较大的整数类型转换成小数类型时，由于存储方式不同，精度损失则很容易发生。