2019-9-16 java上课知识整理总结（动手动脑，课后实验）

java上课知识整理总结（动手动脑，课后实验）

一，课堂测试

1，题目：课堂测试：像二柱子那样，花二十分钟写一个能自动生成30道小学四则运算题目的 “软件”

      要求：（1）题目避免重复；

                       （2）可定制（数量/打印方式）；

2，设计思路

1），产生两个1-100的随机数作为题目参与运算的数据，产生一个1-100的随机数并对4求余作为运算符（0：‘+’，1：‘-’，2：‘*’，3：‘/’）。

2），用for循环控制出题个数n，用循环变量i对一行出题个数m求余，余数为0换行控制一行中题目的个数。

3），在减法中用while（s1<s3）循环（s1，s3是参与运算的数）循环体是新生成一个随机数赋给s3，保证结果非负。

4），在乘法中用while（s1*s3>100）循环（s1，s3是参与运算的数）循环体是新生成一个随机数赋给s3，保证结果小于100。

5），在除法中用while（s1/s3！=0）循环（s1，s3是参与运算的数）循环体是新生成一个随机数赋给s3，保证结果为正数。

6），用数组存储之前所有输入的操作数和运算符用for循环判断是否重复若重复新生成一个随机数赋给s3，保证出题不重复。

3，代码

import java.util.Random;
import java.util.Scanner;
public class suanshu {
static Scanner sc = null;
public static int s1 = new Random().nextInt(100);
public static int s2 = new Random().nextInt(100);
public static int s3 = new Random().nextInt(100);
public static int a[][]=new int[100000][2] ;//用于从操作数

public static int s[]=new int[100000];//用于存操作符

public static void main(String[] args) {

sc = new Scanner(System.in);
System.out.println("请输入题数：");
int n=sc.nextInt();
System.out.println("请输入每行的题数：");
int m=sc.nextInt();

for(int i=0;i<n;i++) {
if((i)%m==0)
System.out.print(" ");
System.out.print((i+1)+":");

//产生随机数
s1 = new Random().nextInt(100);
System.out.print(s1);
s2 = new Random().nextInt(100);
s3 = new Random().nextInt(100);

//检查重复
a[i][0]=s1;
a[i][1]=s3;
s[i]=s2;
for(int j=0;j<i;j++) {
if(a[j][0]==s1&&a[j][1]==s3&&s[j]==s2) {
s3 = new Random().nextInt(100);
while(s3==a[i][1]) {
s3 = new Random().nextInt(100);
}
s3 = new Random().nextInt(100);
while(s3==a[i][1]) {

}
}}

//判断操作符
if(s2%4==0)
System.out.print("+");
if(s2%4==1) {
System.out.print("-");

while(s1<s3) {
s3 = new Random().nextInt(100);
}

}

if(s2%4==2) {
System.out.print("*");
while(s1*s3>=100) {
//s1 = new Random().nextInt(100);
s3 = new Random().nextInt(100);
}
}

if(s2%4==3) {
System.out.print("/");
while(s3!=0&&s1/s3!=0){
//s1 = new Random().nextInt(100);
s3 = new Random().nextInt(100);
}
}


System.out.print(s3);
System.out.print("=");
System.out.print(" "+' ');
}


}


}

4，运行测试

 二，动手又动脑_1

1，问题：仔细阅读示例: EnumTest.java，运行它，分析运行结果？你能得到什么结论？你掌握了枚举类型的基本用法了吗？

2，代码

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());
        //从字符串中转换
        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};

3，运行测试

 4，结论

1）枚举变量中实例化的对象的不同元素的地址不同

2）枚举变量中实例化的对象的的元素不是java的基本数据类型。

3）从字符串中转换的枚举变量中实例化的对象的的元素赋给新的变量和原变量的地址相同。

4）可以使用“==”直接比对枚举变量的值。

  二，动手又动脑_2

1，问题：以下代码的输出结果是什么？为什么会有这样的输出结果？

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");

}
}

运行测试

 2，答：

首先,可用于System.out.println里面的加号一般情况下有两种意义
第一: 连接字符串 , 假如需要连接的字符串比较长此时也可用加号进行换行连接
例如：System.out.println("X+Y="+X+Y);第一个遇到的是字符串所以后面的X，Y也转换为字符转连接输出了
     X+Y=100200
     而System.out.println(X+Y+"=X+Y");第一个遇到的X与第二个遇到的Y是int型第三个是字符串所以连接输出了运算结果和字符串。
     300=X+Y

第二: 进行运算 , 当然进行运算时 , 需要附加括号 比如:System.outprintln("运算结果:" + (1+2)); 结果:运算结果:3
 二，动手又动脑_3
1，问题：Java变量遵循“同名变量的屏蔽原则”，请课后阅读相关资料弄清楚相关知识，然后自己编写一些测试代码，就象本示例一样，有意识地在不同地方定义一些同名变量，看看输出的到底是哪个值。
2，自测代码：

package ClassAfter;

public class Maskingsamename {
    private static int a=1;
    public static void main(String[] args) {
        int a=10;
        System.out.println(a);
    }

}

运行测试：

二，动手又动脑_4

1问题：

 2，每个数据类型所占的位数和取值范围：

①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

3，结论

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

三，动手实验_1
1，问题：请运行以下代码（TestDouble.java）

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));
        System.out.println(0.1+0.2);
    }
}

你看到了什么样的输出，意外吗？

答：意外！

出现此结果的原因：变量的存储方式不同，不同浮点数在计算机中存的尾数不同：

float 和double类型主要是为科学计算和工程计算而设计的，他们执行二进制浮点运算，这两种类型在计算机中的储存分为三部分：符号位、指数为、尾数部分。数据以二进制存储在计算机时，会出现无线循环系列，在数据转化中会出现错误。十进制不能准确的表示1/3,同样二进制不能精确的表示1/10。

double类型的数值占用64bit，即64个二进制数，除去最高位表示正负符号的位，还有63位，而我们给出的数值，在大多数情况下需要比64bit更多的位数才能准确表示出来（甚至是需要无穷多位），而double类型的数值只有64bit，后面舍去的位数一定会带来误差，无法得到“数学上精确”的结果。