Java变量及运算符

如何声明使用常量

Java语言声明常量使用final。程序开发中，常量名一般规则全部大写，并且多个单词之间使用下划线分隔，以提高可读性，例如 MAX_VALUE、PI_VALUE 等等。声明常量时必须赋 值，以后只能使用，不能再赋值。

如何声明使用成员属性（变量）、局部变量

成员属性（变量）声明和使用：

    在类的作用域中声明成员属性（变量）。

    可以选择不同的访问修饰符（如 public、private）来控制成员属性（变量）的可访问性。

    成员属性（变量）的声明通常发生在类的开始部分。

    需要在对象创建后通过对象引用来访问成员属性（变量）。

public class Example {
    public int memberVariable; // 公开的成员变量
    private String privateVariable; // 私有的成员变量
    protected boolean protectedVariable; // 受保护的成员变量

    public static void main(String[] args) {
        Example obj = new Example();
        obj.memberVariable = 10; // 访问和修改成员变量的值
        String value = obj.privateVariable; // 访问成员变量的值
    }
}

局部变量声明和使用：

    在方法、代码块或构造函数的作用域中声明局部变量。

    局部变量通常在声明时进行初始化，并且只在声明它们的作用域内可见。

    局部变量不可以使用访问修饰符。

    局部变量只在其所在的方法、代码块或构造函数的执行过程中可用。

public class Example {
    public void method() {
        int localVar = 20; // 声明和初始化局部变量
        System.out.println(localVar); // 使用局部变量
    }

    public static void main(String[] args) {
        Example obj = new Example();
        obj.method(); // 调用方法，局部变量在方法内部可见
    }
}

数据的8大基本类型

整数类型： byte 、 short 、 int 、 long

浮点类型： float 、 double

字符型： char

布尔型： boolean

java 八种基本数据类型的字节数 :1 字节 (byte 、 boolean) 、 2 字节 (short 、 char) 、 4 字节 (int 、 float)、 8 字节 (long 、 double)

浮点数的默认类型为 double （如果需要声明一个常量为 float 型，则必须要在末尾加上 f 或 F ）

整数的默认类型为 int （声明 Long 型在末尾加上 l 或者 L ）

八种基本数据类型的包装类：除了 char 的是 Character 、 int 类型的是 Integer ，其他都是首字母大写

char类型是无符号的，不能为负，所以是 0 开始的

float 和 double 的最小值和最大值都是以科学记数法的形式输出的，结尾的 “E+ 数字 ” 表示 E 之前的数字要乘以10 的多少倍。比如 3.14E3 就是 3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。

类型转换

1.隐式类型转换（自动类型转换）：
隐式类型转换是指当一种数据类型的范围小于另一种数据类型时，Java会自动进行类型转换。例如，将一个字节赋值给一个整数，这是安全的，因为整数的范围大于字节。具体规则为：byte→short(char)→int→long→float→double

int num = 10;
double decimalNum = num; // int类型隐式转换为double类型

2.显式类型转换（强制类型转换）：
显式类型转换是指将一种数据类型强制转换为另一种数据类型。这种转换可能会丢失精度或导致数据溢出，因此需要使用强制类型转换运算符(type)。

double decimalNum = 3.14;
int num = (int) decimalNum; // double类型显式转换为int类型

注意：在进行强制类型转换时，如果目标类型无法容纳源类型的值，则可能会导致数据丢失或溢出。因此，需要确保转换是安全的。

3.字符串类型转换：

将字符串转换为数值类型：使用相应的包装类的静态方法，如Integer.parseInt()、Double.parseDouble()。

将数值类型转换为字符串：使用 String.valueOf()方法或将数据类型与空字符串进行连接。

String strNumber = "10";
int number = Integer.parseInt(strNumber); // 将字符串转换为整数

int num = 5;
String str = String.valueOf(num); // 将整数转换为字符串

注意，在进行类型转换时，需要小心数据类型的范围和精度，以确保转换的正确性和安全性。、

算术运算符 + - * / % ++ --

1. 加法运算符 +：用于将两个操作数相加。
   示例：int sum = a + b;

2. 减法运算符 -：用于将第一个操作数减去第二个操作数。
   示例：int difference = a - b;

3. 乘法运算符 *：用于将两个操作数相乘。
   示例：int product = a * b;

4. 除法运算符 /：用于将第一个操作数除以第二个操作数（注意，如果两个操作数都是整数，则结果为整数除法，即去除小数部分）。
   示例：double quotient = a / b;

5. 取余运算符 %：用于计算两个操作数相除的余数。
   示例：int remainder = a % b;

6. 自增运算符 ++：用于将操作数的值增加1。
   示例：a++; 或 ++a;

7. 自减运算符 --：用于将操作数的值减少1。
   示例：a--; 或 --a;

int a = 5;
int b = 2;

int sum = a + b; // 7
int difference = a - b; // 3
int product = a * b; // 10
double quotient = (double) a / b; // 2.5
int remainder = a % b; // 1

int c = 10;
int result1 = c++; // 先将 c 的值赋给 result1，再将 c 的值增加1
int result2 = ++c; // 先将 c 的值增加1，再将 c 的值赋给 result2

利用入口方法String[] args，编写一个求两个数商和余数的案例程序，并运行出结果

public class T4 {

            public static void main(String[] args) {
                //int a = Integer.parseInt(args[0]);
                //int b = Integer.parseInt(args[1]);
                //实例化对象 Scanner接收键盘输入
                Scanner sc = new Scanner(System.in);
                while (true) {
                    System.out.print("请输入两个非零整数：");
                    int a = sc.nextInt();
                    int b = sc.nextInt();
                    if(a==0 || b==0) break;
                    if (a % b == 0) {
                        System.out.printf("%d ÷ %d = %d%n", a, b, a / b);
                    } else {
                        System.out.printf("%d ÷ %d = %d ... %d%n", a, b, a / b, a % b);
                    }
                }
                System.out.println("程序结束");
            }

    }

赋值运算符 += = *=

赋值运算符是用于将右侧的操作数的值赋给左侧的操作数。

+= 赋值运算符：
+= 赋值运算符用于将左操作数与右操作数相加，并将结果赋给左操作数.

int num = 5;
num += 3; // 等同于 num = num + 3;
// num 的值现在为 8

= 赋值运算符：
= 赋值运算符用于将右操作数的值赋给左操作数。

int a = 5;
int b = a; // 将 a 的值赋给 b

*= 赋值运算符：
*= 赋值运算符用于将左操作数与右操作数相乘，并将结果赋给左操作数。 

int a = 5;
int b = a; // 将 a 的值赋给 b

关系运算符 > >= < <= == !=

关系运算符用于比较两个操作数之间的关系，并返回布尔值（true或false）。在Java中，常见的关系运算符包括：大于（`>`）、大于等于（`>=`）、小于（`<`）、小于等于（`<=`）、等于（`==`）和不等于（`!=`）。

1. 大于（`>`）：用于检查左侧操作数是否大于右侧操作数。

   示例：`a > b`，如果a大于b，则表达式的结果为true，否则为false。

2. 大于等于（`>=`）：用于检查左侧操作数是否大于或等于右侧操作数。

   示例：`a >= b`，如果a大于或等于b，则表达式的结果为true，否则为false。

3. 小于（`<`）：用于检查左侧操作数是否小于右侧操作数。

   示例：`a < b`，如果a小于b，则表达式的结果为true，否则为false。

4. 小于等于（`<=`）：用于检查左侧操作数是否小于或等于右侧操作数。

   示例：`a <= b`，如果a小于或等于b，则表达式的结果为true，否则为false。

5. 等于（`==`）：用于检查左侧操作数是否等于右侧操作数。

   示例：`a == b`，如果a等于b，则表达式的结果为true，否则为false。

6. 不等于（`!=`）：用于检查左侧操作数是否不等于右侧操作数。

   示例：`a != b`，如果a不等于b，则表达式的结果为true，否则为false。

这些关系运算符通常用于条件语句和循环结构中，用于根据不同的条件或关系来控制程序的执行流程。

请注意，关系运算符返回的是一个布尔值，因此可以直接用于条件判断或赋值给布尔类型的变量。在比较两个操作数时，操作数的类型必须是兼容的（例如，两个操作数都是数值类型、字符类型或引用类型）。

逻辑运算符 &&与 ||或 !非

逻辑运算符用于组合和操作布尔值（true或false）。在Java中，常见的逻辑运算符包括：与（&&）、或（||）和非（!）

1. 与（&&）：用于判断同时满足两个条件。

   示例：`a && b`，如果a和b都为true，则表达式的结果为true，否则为false。

2. 或（||）：用于判断满足任意一个条件。

   示例：`a || b`，如果a或b为true，则表达式的结果为true，否则为false。

3. 非（!）：用于对条件的结果取反。

   示例：`!a`，如果a为true，则表达式的结果为false，如果a为false，则结果为true。

这些逻辑运算符通常用于条件语句、循环结构和布尔表达式中，用于对不同的条件进行组合和判断。

需要注意的是，逻辑运算符具有短路特性。当使用逻辑与（&&）时，如果第一个操作数为false，则不会对第二个操作数进行求值。当使用逻辑或（||）时，如果第一个操作数为true，则不会对第二个操作数进行求值。这种短路特性可用于提高效率并避免不必要的计算。

三元运算符 条件 ?  值1 : 值2

三元运算符是一种简洁的条件表达式，也称为条件运算符。它由一个条件、一个问号（？）、一个值1和一个冒号（:）、一个值2组成。其语法形式为：条件 ? 值1 : 值2。

三元运算符的作用是根据条件的真假，返回值1或值2。如果条件为true，则表达式的结果为值1；如果条件为false，则结果为值2。

int age = 18;
String message = (age >= 18) ? "成年人" : "未成年人";
System.out.println(message);

在上述语句中，我们根据变量age的值判断一个人是否成年。如果age大于或等于18，则将message赋值为"成年人"；否则将message赋值为"未成年人"。最后，我们打印出message的值为"成年人"，因为age的值是18，满足条件age >= 18。

三元运算符可以代替简单的if-else语句，使代码更加简洁和易读。但请注意，当需要进行更复杂的条件判断时，应使用if-else语句来取代三元运算符，以提高代码的可读性。