作业总结

`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};`
运行结果：

结论：枚举不属于原始数据类型，它的每个具体值都引用一个特定的对象。相同的值则引用同一个对象。
可以使用“”和equals()方法直接比对枚举变量的值，换句话说，对于枚举类型的变量，“”和equals()方法执行的结果是等价的。
2.
一、什么是补码
计算机中的有符号数有三种表示方法，即原码、反码和补码。三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位，三种表示方法各不相同 。

在计算机系统中，数值一律用补码来表示和存储。它的定义如下：

对于一个n位二进制数，如果它为正数，他的补码等于原码本身，如果它为负数，它的补码为将这个数除符号位以外的所有位取反（0变成1，1变成0），然后加1所得到的结果。

例如，对于一个8位的二进制数10011010，它的补码为11100101 + 1 = 11100110。

其中11100101是10011010除第一位符号位以外的所有位取反得到的。

补码有以下几个特点：

补码能够表示正数和负数，而且在计算机中，通常只采用补码进行运算。

正数的补码与原码相同，而负数则采用补码表示。

在补码中，一个数的绝对值与它的反码相同。

二、什么是反码
反码是另一种用来表示负数的二进制数的方法。它的定义如下：

对于一个n位二进制数，如果它是负数，则它的反码为将这个数的所有位取反（0变成1，1变成0）所得到的结果；如果它是非负数，则它的反码与原码相同。

例如，对于一个8位的二进制数（第一位为符号位）10011010，它的反码为11100101。

反码有以下几个特点：

反码能够表示整数和负数，但在计算机中并不常用。

在反码中，一个数的绝对值与它的补码相同。

三、原码与补码之间的转换
对于一个原码，可以将它转换成补码，然后再进行运算。转换的方法如下：

如果原码为正数，则它的补码与原码相同。

如果原码为负数，则将原码的绝对值转换成二进制数，然后将这个二进制数除符号位外的所有位取反，最后加1，得到的结果即为它的补码。

例如，将-6转换成补码的过程如下：

将-6转换成二进制数：10000110。

将-6的二进制数除符号位的所有位取反：11111001。

将取反后的结果加1：11111010，这就是-6的补码。

四、补码与原码之间的转换
补码和原码之间的转换也是十分重要的。当我们需要将补码转换成原码时，可以按照以下步骤进行：

如果补码的最高位是1，说明这个补码所代表的数是负数。将补码除符号位外的所有位取反（0变成1，1变成0），得到反码。

在反码的基础上，将所有位加1，得到原码。

例如，将补码11100111转换成原码的过程如下：

最高位是1，说明这是一个负数。将补码除符号位外的所有位取反得到反码：10011000。

在反码的基础上，将所有位加1，得到原码：10011001，即-25。

当需要将原码转换成补码时，也可以按照以上步骤进行，反向转换即可。
public class BitwiseOperations {
public static void main(String[] args) {
int a = 5; // 0000 0101
int b = -5; // 1111 1011

    System.out.println("正数: " + a);
    System.out.println("负数: " + b);

    // 位与操作
    System.out.println("位与操作 (a & b): " + (a & b)); // 0000 0001

    // 位或操作
    System.out.println("位或操作 (a | b): " + (a | b)); // 1111 1111

    // 位异或操作
    System.out.println("位异或操作 (a ^ b): " + (a ^ b)); // 1111 1010

    // 位取反操作
    System.out.println("位取反操作 (~a): " + (~a)); // 1111 1010
    System.out.println("位取反操作 (~b): " + (~b)); // 0000 0100

    // 左移操作
    System.out.println("左移操作 (a << 1): " + (a << 1)); // 0000 1010
    System.out.println("左移操作 (b << 1): " + (b << 1)); // 1111 0110

    // 右移操作
    System.out.println("右移操作 (a >> 1): " + (a >> 1)); // 0000 0010
    System.out.println("右移操作 (b >> 1): " + (b >> 1)); // 1111 1101

    // 无符号右移操作
    System.out.println("无符号右移操作 (b >>> 1): " + (b >>> 1)); // 0111 1101
}

}
运行结果：

3.
同名变量的屏蔽原则
同名变量的屏蔽原则是 Java 编程中的一个重要概念，指的是在不同作用域中可以定义同名变量，而局部作用域中的变量会遮蔽外层作用域中的同名变量。具体来说：

作用域：变量的可见范围。Java 的作用域包括类级别、方法级别和块级作用域。

遮蔽：当局部变量（如方法内或块内定义的变量）与外层作用域的同名变量存在时，局部变量会优先被访问。

示例代码
public class ShadowingExample {
static int value = 10; // 类级别变量

public static void main(String[] args) {
    int value = 20; // 方法级别变量
    System.out.println("在 main 方法中，value = " + value); // 输出 20

    testMethod(); // 调用另一个方法
}

public static void testMethod() {
    int value = 30; // 块级作用域变量
    System.out.println("在 testMethod 方法中，value = " + value); // 输出 30

    // 访问类级别变量
    System.out.println("在 testMethod 方法中，类级别的 value = " + ShadowingExample.value); // 输出 10
}

}
输出结果
在 main 方法中，value = 20
在 testMethod 方法中，value = 30
在 testMethod 方法中，类级别的 value = 10
总结
在 main 方法中定义的 value 遮蔽了类级别的 value，所以输出的是 20。
在 testMethod 中又定义了一个 value，遮蔽了 testMethod 外层的 value，输出 30。
如果需要访问被遮蔽的变量，可以通过类名来引用（如 ShadowingExample.value）。
测试所给结果发现，输出顺序按照就近原则，先在本方法内查找，如果没有，去到本类中查找，如果也没有，再去到上一级的接口或者父类中查找。
4.
一. 浮点数表示
Java 中的浮点数（float 和 double）是近似值，并不能精确表示所有小数。例如：

public class PrecisionLoss {
public static void main(String[] args) {
double a = 0.1;
double b = 0.2;
double sum = a + b; // 期望结果是 0.3

    System.out.println("Sum: " + sum); // 可能输出 0.30000000000000004
}

}
二. 整数溢出
当整数计算结果超出其类型范围时，会导致溢出。例如：

public class IntegerOverflow {
public static void main(String[] args) {
int maxInt = Integer.MAX_VALUE;
int result = maxInt + 1; // 期望结果是 Integer.MIN_VALUE

    System.out.println("Result: " + result); // 可能输出 -2147483648
}

}
三. 类型转换
在将浮点数转换为整数时，小数部分会被截断，可能导致数据损失。例如：

public class TypeConversion {
public static void main(String[] args) {
double value = 5.99;
int intValue = (int) value; // 小数部分被丢弃

    System.out.println("Converted Value: " + intValue); // 输出 5
}

}
四. 使用 BigDecimal 解决精度问题
为了处理浮点数的精度问题，可以使用 BigDecimal 类，它提供高精度的计算。示例：

import java.math.BigDecimal;

public class BigDecimalExample {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal sum = a.add(b);

    System.out.println("Sum: " + sum); // 输出 0.3
}

}
5.
public class Main {
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");
}
}
运行结果：

结论：
第一行 System.out.println("x+y=" + x + y);

首先，"x+y=" 是一个字符串。
然后，Java 会执行字符串与整数的连接。此时会先计算 "x+y=" + x，结果是 "x+y=100"。
接着，再将这个结果与 y 进行连接，最终结果是 "x+y=100200"。
第二行 System.out.println(x + y + "=x+y");

这里 x + y 会先被计算，因为整数的加法优先于字符串连接。
x + y 的结果是 300。
然后，再将 300 与 "=x+y" 进行连接，最终结果是 "300=x+y"。
6.
随机出题代码
import java.util.Random;

public class Main {
public static void main(String[] args) {
Random random = new Random();
for(int i=0;i<30;i++){
int num1 = random.nextInt(101)+1;
int num2 = random.nextInt(101)+1;
int change = random.nextInt(5)+1;
if(change1){
System.out.println(num1+"+"+num2+"=");
}
else if(change2){
System.out.println(num1+"-"+num2+"=");
}
else if(change3){
System.out.println(num1+"*"+num2+"=");
}
else if(change4){
System.out.println(num1+"/"+num2+"=");
}
}
}
}
使用 java.util.Random 类
Random 类提供了多种方法用于生成不同类型和范围的随机数。