学习总结

1.枚举类型

举一个简单的例子

 1 public class EnumTest {
 2 
 3     public static void main(String[] args) {
 4         Size s=Size.SMALL;
 5         Size t=Size.LARGE;
 6         //s和t引用同一个对象？
 7         System.out.println(s==t);  //
 8         //是原始数据类型吗？
 9         System.out.println(s.getClass().isPrimitive());
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 }
20  enum Size{SMALL,MEDIUM,LARGE};

 

本例中Size枚举类的成员都是枚举常量，所以不能用new实例化枚举。在此例中s和t引用的是不同的对象，输出第一个为false。第二个输出为false是因为枚举类型不是八大基本类型。第三个true是因为valueOf返回和s相同的枚举常量。之后的for循环是values返回一个包含枚举类型的数组。枚举类型也是一个类，它除了无法实例化之外，其他类能完成的任务它也能完成。

2.浮点数精度

这里引用一个例子

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 }

 

 我们看到输出并不是我们理想的数字，这是因为计算机的二进制存储所致，浮点数的存储有三个结构：符号位，指数位，尾数位。输出有差别主要体现在尾数位上。float的尾数位是23bit，对应7~8位十进制数，所以有效数字有的编译器是7位，也有的是8位；double的尾数位是52bit，对应15~16位十进制数，有效数字位15位或16位；所以最后的输出会有所差别。

3.动手动脑

 1 public class LI {
 2     public static void main(String args[])
 3     {
 4         int X=100;
 5         int Y=200;
 6         System.out.println("X+Y="+X+Y);
 7         System.out.println(X+Y+"=X+Y");
 8         
 9     }
10 }

 

 最后输出结果不同是因为第一个后面的加号是添加数据的作用，而第二个输出加号在前是起运算符的作用。

4.课堂测试

写一个自动打印四则运算程序

（1）能自动打印30道题目

package kiss;


import java.util.Random;

public class ke {
    int temp[]=new int[1000];
    int arr[]=new int[1000];
    int sum=0;
void input()
{

    Random ra =new Random();
 for(int i=0;i<100;i++){
        temp[i]=ra.nextInt(10)+1;
        
        arr[i]=ra.nextInt(10)+1;
    }
}
void jian()
{
    while(temp[sum]-arr[sum]<0)
    {
        sum++;
    }
        
        
        System.out.println(temp[sum]+"-"+arr[sum]+"=");
        sum++;
}
void jia()
{
    
    
    System.out.println(temp[sum]+"+"+arr[sum]+"=");
    sum++;
}
void chen()
{
    
    
    System.out.println(temp[sum]+"*"+arr[sum]+"=");
    sum++;
}
void chu()
{
    while(temp[sum]%arr[sum]!=0||arr[sum]==0)
    {
        sum++;
    }
    System.out.println(temp[sum]+"/"+arr[sum]+"=");
    sum++;
}
}
package kiss;



public class ok {

    public static void main(String args[])
    {
        
        ke sr=new ke();
        sr.input();
        for(int i=1;i<=30;i++)
        {  System.out.print(i+":");
            int a=(int)(1+Math.random()*(4-1+1));
            switch(a)
            {
            case 1:sr.jia();
            break;
            case 2:sr.jian();
            break;
            case 3:sr.chen();
            break;
            case 4:
                sr.chu();
                break;
            }
        }
    }
}

此法比较繁琐，用两个数组在副类中存储随机数，然后执行主类的随机加减运算用switch实现四则运算的随机出现，在副类中用sum进行控制下标运行，实现随机数的遍历.

 

转载于:https://www.cnblogs.com/w669399221/p/11553364.html