第二周Java课堂作业

演示一：

public class EnumTest {
    public static void main(String[] args) {
        Size s=Size.SMALL;
        Size t=Size.LARGE;
        //s和t引用同一个对象？
        System.out.println(s==t);  
        //是原始数据类型吗？
        System.out.println(s.getClass().isPrimitive());//getClass()返回对象时的运行类  
        //class .isPrimitive()确定指定的Class对象表示一个基本类型(此方法返回true，当且仅当这个类表示一个基本类型。)
        //从字符串中转换
        Size u=Size.valueOf("SMALL");
        System.out.println(s==u);  //true
        //列出它的所有值
        for(Size value:Size.values()){
            System.out.println(value);
        }
    }
}
 enum Size{SMALL,MEDIUM,LARGE};

结果与分析：

 Size枚举类型定义的s，t对象引用的是Size里不同的元素，故不为同一对象，故第一个输出为false。

第二个判断对象s的所属类类型是否是一般类型，得到false输出，所以s所属的类并不是一般类型。

然后定义对象u引用SMALL，与s引用同一元素，故为同一对象。

然后循环打印Size里的元素，即得到输出结果。

结论：

枚举类型是一种特殊的类。

枚举类型是引用类型。

枚举类型可用于switch语句中。

枚举类型中实例化不同元素的对象不是同一对象，枚举不属于原始数据类型，他的每个具体值都引用一个特定的对象，相同的值则引用相同的对象。

使用枚举可以很方便的定义常量。

从字符串中转化的枚举类型可以与原枚举类型进行比较，且可以地址相同。可以使用“==”和“equal()”方法直接对比枚举常量的值。　

演示二：

实现两数相加，用两个文本框输入数据，一个文本框输出。

// An addition program 
import javax.swing.JOptionPane;  // import class JOptionPane
public class Addition {
   public static void main( String args[] )
   {
      String firstNumber,   // first string entered by user
             secondNumber;  // second string entered by user
      int number1,          // first number to add
          number2,          // second number to add
          sum;              // sum of number1 and number2

      // read in first number from user as a string
      firstNumber =
         JOptionPane.showInputDialog( "Enter first integer" );

      // read in second number from user as a string
      secondNumber =
         JOptionPane.showInputDialog( "Enter second integer" );

      // convert numbers from type String to type int
      number1 = Integer.parseInt( firstNumber ); 
      number2 = Integer.parseInt( secondNumber );

      // add the numbers
      sum = number1 + number2;

      // display the results
      JOptionPane.showMessageDialog(
         null, "The sum is " + sum, "Results",
         JOptionPane.PLAIN_MESSAGE );

      System.exit( 0 );   // terminate the program
   }
}

运行结果：

演示三：

验证如下代码的输出结果。

import java.util.*;

public class InputTest
{  
   public static void main(String[] args)
   {  
      Scanner in = new Scanner(System.in);

      // get first input
      System.out.print("What is your name? ");
      String name = in.nextLine();

      // get second input
      System.out.print("How old are you? ");
      int age = in.nextInt();
      
     int i,j;
     String value="100";
     i=Integer.parseInt(value);//Integer.parseInt()return a int value
     j=200;
     String s=String.valueOf(j);//String.valueOf() return a String object
     
      // display output on console
      System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));
      System.out.println("i="+i+",s="+s);
  
      
   }
}

运行结果：

演示四：

验证精度不准。

public class TestDouble {

    public static void main(String args[]) {
        System.out.println("0.05 + 0.01 = " + (0.05 + 0.01));
        System.out.println("1.0 - 0.42 = " + (1.0 - 0.42));
        System.out.println("4.015 * 100 = " + (4.015 * 100));
        System.out.println("123.3 / 100 = " + (123.3 / 100));
    }
}

运行结果：

结论：使用double类型的数值进行计算，结果是不准确的。

归根结底，这个问题涉及到二进制与十进制的转换。而N进制可以理解为：数值×基数的幂。Double类型的数值占用64bit，即64个二进制数，除去最高位表示正负符号的位，在最低位上一定会与实际数据存在误差（除非实际数据恰好是2的n次方）。

所以几乎都会存在误差。

演示五：

精度不准的处理方法。

import java.math.BigDecimal;

public class TestBigDecimal
{
    public static void main(String[] args) 
    {
        BigDecimal f1 = new BigDecimal("0.05");
        BigDecimal f2 = BigDecimal.valueOf(0.01);
        BigDecimal f3 = new BigDecimal(0.05);
        System.out.println("下面使用String作为BigDecimal构造器参数的计算结果：");
        System.out.println("0.05 + 0.01 = " + f1.add(f2));
        System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
        System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
        System.out.println("0.05 / 0.01 = " + f1.divide(f2));
        System.out.println("下面使用double作为BigDecimal构造器参数的计算结果：");
        System.out.println("0.05 + 0.01 = " + f3.add(f2));
        System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
        System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
        System.out.println("0.05 / 0.01 = " + f3.divide(f2));
    }
}

运行结果：

结论：

在构建BigDecimal对象时应使用字符串而不是double数值，否则，仍有可能引发计算精度问题。

演示六：

字符串连接

public class Test {
    public static void main(String[] args) {
        int X=100;
        int Y=200;
        System.out.println("X+Y="+X+Y);
        System.out.println(X+Y+"=X+Y");
    }
}

运行结果：

分析原因：

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-uffff’

⑧boolean（布尔型）：1bits，数值范围为true/false

结论：

java中的基本数据类型转换分为自动类型转换和强制类型转换。自动数据类型转换是由优先级别低的数据赋值给优先级别高的变量。强制类型转换是由优先级别高的数据赋值给优先级别低的变量。强制类型转换通常都会有存在精度的损失，特别是比较大的整数类型转换成小数类型时，由于存储方式不同，精度损失则很容易发生。

演示八：

使用类型转换生成六位验证字符串，示例程序每次运行时，都会生成不同的字符串。

public class RandomStr
{
    public static void main(String[] args) 
    {
        //定义一个空字符串
        String result = "";
        //进行6次循环
        for(int i = 0 ; i < 6 ; i ++)
        {
            //生成一个97～122的int型的整数
            int intVal = (int)(Math.random() * 26 + 97);
            //将intValue强制转换为char后连接到result后面
            System.out.println(intVal+"--"+(char)intVal);
            result = result + (char)intVal;
        }
        //输出随机字符串
        System.out.println(result);
     }
}

运行结果：