Java基础语法测试

class EnumTest {
public static void main(String[] args) {
Size s=Size.SMALL;
Size t=Size.LARGE;

    System.out.println(s==t);  //false

    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};

import javax.swing.JOptionPane; // import class JOptionPane

class Addition {
public static void main( String args[] )
{
String firstNumber, // 用户输入第一个数字
secondNumber; //用户输入第二个数字
int number1, // 第一个数字
number2, // 第二个数字
sum; // 两个数字和

    // 以string类型读入第一个数字
    firstNumber =
            JOptionPane.showInputDialog( "Enter first integer" );

    // 以string类型读入第二个数字
    secondNumber =
            JOptionPane.showInputDialog( "Enter second integer" );

    // 将string类型转化为Int类型
    number1 = Integer.parseInt( firstNumber );
    number2 = Integer.parseInt( secondNumber );

    // 相加
    sum = number1 + number2;

    // 输出结果
    JOptionPane.showMessageDialog(
            null, "The sum is " + sum, "Results",
            JOptionPane.PLAIN_MESSAGE );

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

}

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

}

import java.math.BigDecimal;

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

class Sum
{
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");
}
}

class Test
{
private static int value=1;
public static void main(String[] args) {
int value = 2;
System.out.println("value的值为：" + value);
}
}

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;
String value="100";
i=Integer.parseInt(value);
i=200;
String s=String.valueOf(i);

    // display output on console
    System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));


}

}

class RandomStr
{
public static void main(String[] args)
{
String result = "";
for(int i = 0 ; i < 6 ; i ++)
{
int intVal = (int)(Math.random() * 26 + 97);
result = result + (char)intVal;
}
System.out.println(result);
}
}

class RandomMath
{
public static void main(String[] args)
{
Random r = new Random();
String[] arr = new String[]{"+","-","*","/"};
for (int i = 1; i < 31; i++)
{
int number1 = r.nextInt(21);
int number2 = r.nextInt(21);
int number3 = r.nextInt(21);
int c1;
int c2;
if(number2 == 0)
c1 = r.nextInt(3);
else
c1 = r.nextInt(4);

        if (number3 ==0)
            c2 = r.nextInt(3);
        else
            c2 = r.nextInt(4);
        System.out.println(i + "、 " + number1 + " "+arr[c1] +" "+ number2 + " " + arr[c2] + " " + number3+ " = ");
    }
}

}

原码是直接用二进制表示数值的符号和大小。
反码是对原码的符号位不变，其余位取反。对于负数，反码是将原码的其他位取反，正数的反码与原码相同负数的反码是原码除符号位外所有位取反。
补码是反码加1。正数的补码与原码相同,负数的补码是其反码加1。

在 Java 中，同名变量的屏蔽原则指的是在不同的作用域中定义相同名称的变量时，内层作用域的变量会隐藏或屏蔽外层作用域中同名的变量。这意味着在内层作用域中访问该变量时，会优先使用内层作用域的变量，而不是外层作用域的变量。

Java中每个数据类型所占的位数和表示数值的范围：

对于类型转换时精度的损失，依据Java中每个数据类型所占的位数和表示数值的范围所得，当所占位数小的数据类型向所占位数大的数据类型转换时，没有精度损失，例如short→int；当所占位数大的数据类型向所占位数相等或小于的数据类型转换时，有精度损失，例如int→double，int→float。
在 Java 中，double 类型使用双精度浮点数表示，它遵循 IEEE 754 标准。这种表示方法虽然在很多情况下非常有效，但由于其内部实现方式，进行运算时可能得不到“数学上精确”的结果。以下是一些关键原因：

1. 二进制表示的限制
   浮点数的表示：double类型在内存中以二进制形式存储。这意味着某些十进制数无法被准确表示为二进制数。例如，数字 0.1 和 0.2 在二进制中无法精确表示，计算它们的和 0.1 + 0.2 可能会得到一个非常接近 0.3 的数，但不是完全等于 0.3。
2. 舍入误差
   舍入误差：在进行浮点运算时，计算结果可能会因为舍入而略有误差。IEEE 754 标准定义了一种舍入模式，以决定在进行运算时如何处理无法精确表示的数。这种舍入误差可能在多个运算中逐渐累积，导致最终结果与数学上预期的值存在差异。
3. 精度限制
   有效位数的限制：double 类型大约可以提供 15 到 16 位的有效数字。对于特别大的或特别小的数，可能会因为这个限制而失去精度。在进行多次运算时，精度的丢失会变得更加明显。