java double 计算除法

Java中的运算符分为以下几种

1. 算术运算符：用于执行基本数学计算，例如加法(+)、减法(-)、乘法(*)、除法(/)和取模(%)。这些运算符的操作方式与数学中的操作类似。在进行除法和取模运算时，需要注意除数不能为0，否则会抛出异常。
2. 关系运算符：用于比较两个值之间的关系，包括等于(==)、不等于(!=)、大于(>)、小于(<)、大于等于(>=)和小于等于(<=)。这些运算符返回一个布尔值，即true或false。
3. 逻辑运算符：用于连接多个布尔表达式，包括逻辑与(&&)、逻辑或(||)和逻辑非(!)。逻辑与和逻辑或运算符可以用于组合多个条件，而逻辑非用于反转布尔值。
4. 位运算符：在二进制级别上操作数值，包括按位与(&)、按位或(|)、按位异或(^)、按位取反(~)、左移(<<)和右移(>>)。位运算符在进行底层编程或优化时非常有用。例如，右移运算符可以将数字除以2的n次方。
5. 赋值运算符：用于给变量赋值，包括基本的赋值运算符(=)和复合赋值运算符(+=, -=, *=, /=等)。复合赋值运算符将运算和赋值结合在一起，使代码更加简洁。
6. 其他运算符：包括条件运算符(?:)、类型比较运算符(instanceof)和类型转换运算符等。

算术运算符

算术运算符包含：加法(+)、减法(-)、乘法(*)、除法(/)和取模(%)；

• 加法（+）

对于生活中我们最常见的算法就是1+2等于多少？我们是很快速得计算出结果，当时如果使用java编写的话，要怎么编写这个1+2的结果，接下来我们使用个示例来说明。

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
       int one=1;
       //声明2
       int two =2;

       //1+2的结果值
       int three = one+two;

       //1+2 输出结果是3
       System.out.println(three);
    }
}

• 减法(-)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
       int one=1;
       //声明2
       int two =2;

       //2-1的结果值
       int result = two+one;

       //2-1 输出结果是1
       System.out.println(result);
    }
}

• 乘法(*)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
       int one=1;
       //声明2
       int two =2;

       //2 * 1的结果值
       int result = two * one;

       //2 * 1 输出结果是2
       System.out.println(result);
    }

}

• 除法(/)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
       int one=1;
       //声明2
       int two =2;

       //2 / 1的结果值
       int result = two / one;

       //2 / 1 输出结果是2
       System.out.println(result);
    }

}

• 取模(%)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
        int number = 10;
        //2 % 1的结果值
        int result = number % 100;

        //10 取模 100 输出结果是10
        System.out.println(result);
    }

}

关系运算符

关系运算符执行后返回一个布尔值，即true或false。

• 等于(==)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
        int number = 10;

        //声明另外一个数字
        int otherNumber = 10;
        //10 == 10的结果值
        boolean result = number == otherNumber;

        //输出结果是true
        System.out.println(result);
    }
}

• 不等于(!=)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
        int number = 10;

        //声明另外一个数字
        int otherNumber = 10;
        //10 不等于 10的结果值是false
        boolean result = number != otherNumber;

        //输出结果是false
        System.out.println(result);
    }
}

• 大于(>)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
        int number = 10;

        //声明另外一个数字
        int otherNumber = 10;
        //10 大于 10的结果值是false
        boolean result = number > otherNumber;

        //输出结果是false
        System.out.println(result);
    }
}

• 小于(<)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
        int number = 10;

        //声明另外一个数字
        int otherNumber = 10;
        //10 小于 10的结果值是false
        boolean result = number < otherNumber;

        //输出结果是false
        System.out.println(result);
    }
}

• 大于等于(>=)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
        int number = 10;

        //声明另外一个数字
        int otherNumber = 10;
        //10 大于等于 10的结果值是true
        boolean result = number >= otherNumber;

        //输出结果是true
        System.out.println(result);
    }

}

• 小于等于(<=)

public class OperatorDemo {
    public static void main(String[] args) {
        //声明1
        int number = 10;

        //声明另外一个数字
        int otherNumber = 10;
        //10 小于等于 10的结果值是true
        boolean result = number <= otherNumber;

        //输出结果是true
        System.out.println(result);
    }

}

逻辑运算符

用于连接多个布尔表达式，包括逻辑与(&&)、逻辑或(||)和逻辑非(!)。逻辑与和逻辑或运算符可以用于组合多个条件，而逻辑非用于反转布尔值。

• 逻辑与(&&)

Java中的逻辑与运算符是&&，它用于将两个布尔值进行逻辑与运算。逻辑与运算符是一种二元运算符，这意味着它需要两个操作数来完成运算。在Java中，逻辑与运算符将两个布尔值进行比较，如果两个操作数都为true，则结果为true；否则，结果为false。

public class LogicalAndExample {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        boolean result = a && b; // 逻辑与运算符
        System.out.println("Result: " + result); // 输出结果为false
    }
}

• 逻辑或(||)

Java中的逻辑或运算符是两个竖线||。当两个操作数中至少有一个为true时，逻辑或的结果就为true。如果两个操作数都是false，那么结果就是false。

public class LogicalOrExample {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        // 使用逻辑或运算符
        boolean result = a || b;
        System.out.println("Result: " + result); // 输出结果为true
    }
}

• 逻辑非(!)

逻辑非运算符是一种单目运算符，这意味着它只需要一个操作数来完成运算。在Java中，逻辑非运算符会将其操作数的布尔值取反。如果操作数为true，则逻辑非的结果为false；反之，如果操作数为false，则结果为true。

public class LogicalNotExample {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        // 使用逻辑非运算符
        boolean result1 = !a; // 结果为false
        boolean result2 = !b; // 结果为true

        System.out.println("Result 1: " + result1);
        System.out.println("Result 2: " + result2);
    }
}

位运算符

在二进制级别上操作数值，包括按位与(&)、按位或(|)、按位异或(^)、按位取反(~)、左移(<<)和右移(>>)。位运算符在进行底层编程或优化时非常有用。例如，右移运算符可以将数字除以2的n次方。

• 按位与(&)

Java中的按位与运算符是"&"，用于执行二进制位的“与”操作。按位与运算符（&）是一种二元运算符，它对两个数的每一位进行逻辑与操作。按位与的运算规则是：只有当两个相应的二进制位都为1时，结果位才为1；如果任一位为0，则结果位为0。例如，对于数字3和5，它们的二进制表示分别是0000 0011和0000 0101，按位与的结果是0000 0001，即十进制的1。

public class BitwiseAndExample {
    public static void main(String[] args) {
        int a = 5; // 二进制表示为0000 0101
        int b = 3; // 二进制表示为0000 0011

        // 使用按位与运算符进行逻辑与操作
        int result = a & b; // 结果为0000 0001，即十进制的1
        System.out.println("Result: " + result);
    }
}

• 按位或(|)

Java中的按位或运算符是"|"，用于执行二进制位的“或”操作。按位或运算符（|）是一种二元运算符，它对两个数的每一位进行逻辑或操作。按位或的运算规则是：只要两个相应的二进制位中有一个为1，结果位就为1；如果两个位都是0，则结果位为0。例如，对于数字5和3，它们的二进制表示分别是0000 0101和0000 0011，按位或的结果是0000 0111，即十进制的7。

public class BitwiseOrExample {
    public static void main(String[] args) {
        int a = 5; // 二进制表示为0000 0101
        int b = 3; // 二进制表示为0000 0011

        // 使用按位或运算符进行逻辑或操作
        int result = a | b; // 结果为0000 0111，即十进制的7
        System.out.println("Result: " + result);
    }
}

• 按位异或(^)

Java中的按位异或运算符是"^"，用于执行二进制位的“异或”操作。按位异或运算符（^）是一种二元运算符，它对两个数的每一位进行异或操作。异或的运算规则是：如果两个相应的二进制位相同，则结果为0；如果两个相应的二进制位不同，则结果为1。例如，对于数字5和3，它们的二进制表示分别是0000 0101和0000 0011，按位异或的结果是0000 0110，即十进制的6。

public class BitwiseXorExample {
    public static void main(String[] args) {
        int a = 5; // 二进制表示为0000 0101
        int b = 3; // 二进制表示为0000 0011

        // 使用按位异或运算符进行逻辑异或操作
        int result = a ^ b; // 结果为0000 0110，即十进制的6
        System.out.println("Result: " + result);
    }
}

• 左移(<<)

Java中的左移运算符是"<<"，用于将一个数的二进制位向左移动指定的位数。左移运算符（<<）是一种二元运算符，它对一个数进行左移操作。左移的运算规则是：将原数的二进制位向左移动指定的位数，右边空出的位用0填充。例如，对于数字5和3，它们的二进制表示分别是0000 0101和0000 0011，将它们分别左移2位后得到的结果分别为0001 0100和0000 0011，即十进制的20和3。

public class Main {
    public static void main(String[] args) {
        int number = 5; // 二进制表示为0000 0101
        int shift = 2;
        int result = number << shift; // 结果为0001 0100，即十进制的20
        System.out.println("Result: " + result);
    }
}

在这个例子中，我们定义了一个整数变量number，它的值为5。然后，我们使用左移运算符（<<）将number向左移动了2位，并将结果存储在变量result中。最后，我们将结果打印出来。

• 右移(>>)

Java中的右移运算符（>>）用于将二进制数向右移动指定的位数。右移操作相当于将二进制数除以2的指定次方，同时在左侧补0。

public class RightShiftExample {
    public static void main(String[] args) {
        int num = 8; // 二进制表示为 0000 1000
        int result = num >> 1; // 右移一位，结果为 0000 0100，即十进制的4
        System.out.println("右移后的结果为： " + result);
    }
}

赋值运算符

用于给变量赋值，包括基本的赋值运算符(=)和复合赋值运算符(+=, -=, *=, /=等)。复合赋值运算符将运算和赋值结合在一起，使代码更加简洁。

• 赋值运算符（=）

Java中的赋值运算符（=）用于将一个值赋给变量

public class AssignmentOperatorExample {
    public static void main(String[] args) {
        int a = 5; // 将整数5赋值给变量a
        double b = 3.14; // 将浮点数3.14赋值给变量b
        char c = 'A'; // 将字符'A'赋值给变量c
        boolean d = true; // 将布尔值true赋值给变量d
        String str = "Hello, World!"; // 将字符串"Hello, World!"赋值给变量str

        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
        System.out.println("d = " + d);
        System.out.println("str = " + str);
    }
}

在这个例子中，我们使用赋值运算符将不同类型的值分别赋给了变量a、b、c、d和str。然后，我们使用System.out.println()方法输出这些变量的值。

• 复合赋值运算符（+=）

Java中的+=运算符是一个复合赋值运算符，用于将右侧的值加到左侧的变量上，并将结果赋给左侧的变量

public class CompoundAssignmentOperatorExample {
    public static void main(String[] args) {
        int a = 5;
        a += 3; // 等同于 a = a + 3;
        System.out.println(a); // 输出8

        double b = 2.5;
        b += 1.5; // 等同于 b = b + 1.5;
        System.out.println(b); // 输出4.0

        String str = "Hello";
        str += ", World!"; // 等同于 str = str + ", World!";
        System.out.println(str); // 输出"Hello, World!"
    }
}

在这个例子中，我们使用+=运算符将不同的值添加到变量a、b和str上，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

• 复合赋值运算符（-=）

Java中的"-="运算符是一个复合赋值运算符，用于将右侧的值减去左侧的变量，并将结果赋给左侧的变量。

public class CompoundAssignmentOperatorExample {
    public static void main(String[] args) {
        int a = 5;
        a -= 3; // 等同于 a = a - 3;
        System.out.println(a); // 输出2

        double b = 2.5;
        b -= 1.5; // 等同于 b = b - 1.5;
        System.out.println(b); // 输出1.0

        String str = "Hello";
        str -= ", World!"; // 等同于 str = str - ", World!";
        System.out.println(str); // 输出"Hello"
    }
}

在这个例子中，我们使用"-="运算符将不同的值从变量a、b和str中减去，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

• 复合赋值运算符（*=）

Java中的"*="运算符是一个复合赋值运算符，用于将右侧的值乘以左侧的变量，并将结果赋给左侧的变量。

public class CompoundAssignmentOperatorExample {
    public static void main(String[] args) {
        int a = 5;
        a *= 3; // 等同于 a = a * 3;
        System.out.println(a); // 输出15

        double b = 2.5;
        b *= 1.5; // 等同于 b = b * 1.5;
        System.out.println(b); // 输出3.75

        String str = "Hello";
        str *= 2; // 等同于 str = str + str;
        System.out.println(str); // 输出"HelloHello"
    }
}

在这个例子中，我们使用"*="运算符将不同的值乘以变量a、b和str，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

• 复合赋值运算符（/=）

Java中的"/="运算符是一个复合赋值运算符，用于将左侧变量除以右侧的值，并将结果赋给左侧的变量。

public class CompoundAssignmentOperatorExample {
    public static void main(String[] args) {
        int a = 10;
        a /= 2; // 等同于 a = a / 2;
        System.out.println(a); // 输出5

        double b = 4.0;
        b /= 2.0; // 等同于 b = b / 2.0;
        System.out.println(b); // 输出2.0

        String str = "Hello";
        str /= " World"; // 等同于 str = str + " World";
        System.out.println(str); // 输出"Hello World"
    }
}

在这个例子中，我们使用"/="运算符将不同的值除以变量a、b和str，并将结果赋回给相应的变量。然后，我们使用System.out.println()方法输出这些变量的值。

其他运算符

包括条件运算符(?:)、类型比较运算符(instanceof)和类型转换运算符等。

• 条件运算符(?:)

Java中的条件运算符（也称为三元运算符）是一种简洁的表示条件语句的方法。它的语法如下：

条件表达式 ? 表达式1 : 表达式2;

public class ConditionalOperatorExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = (a > b) ? a : b;
        System.out.println("The maximum value is: " + max);
    }
}

在这个例子中，我们使用条件运算符来比较变量a和b的值，并将较大的值赋给变量max。如果a大于b，则整个条件运算符的值为a；否则，整个条件运算符的值为b。

• 类型比较运算符(instanceof)

Java中的类型比较运算符（instanceof）用于检查一个对象是否属于某个类或接口的实例。

public class Main {
    public static void main(String[] args) {
        String str = "Hello, world!";
        boolean isString = str instanceof String;
        System.out.println("str 是 String 类型的实例吗？ " + isString); // 输出：str 是 String 类型的实例吗？ true

        Integer num = 42;
        boolean isInteger = num instanceof Integer;
        System.out.println("num 是 Integer 类型的实例吗？ " + isInteger); // 输出：num 是 Integer 类型的实例吗？ true

        double dbl = 3.14;
        boolean isDouble = dbl instanceof Double;
        System.out.println("dbl 是 Double 类型的实例吗？ " + isDouble); // 输出：dbl 是 Double 类型的实例吗？ false
    }
}

类型转换运算符

• 自动类型转换（Implicit Type Conversion）

int a = 10;
double b = a; // 自动类型转换

编译器会自动将较小的数据类型转换为较大的数据类型。例如，将 int 类型的变量转换为 double 类型时，int 类型的值会被转换为 double 类型的值。

• 显式类型转换

需要使用类型转换运算符将一个数据类型转换为另一个数据类型。例如，将 double 类型的变量转换为 int 类型时，可以使用强制类型转换运算符（如 (int)）

double a = 10.5;
int b = (int) a; // 显式类型转换

• 包装类型转换

Java 提供了一些包装类，如 Integer、Double 等，它们分别对应基本数据类型 int、double。通过包装类型转换，可以将基本数据类型转换为对应的包装类对象，或者将包装类对象转换为对应的基本数据类型。

int a = 10;
Integer b = a; // 包装类型转换

double c = 10.5;
Double d = c; // 包装类型转换

• 字符串到数字的转换

使用 Integer.parseInt()、Double.parseDouble() 等方法将字符串转换为数字。

String str1 = "10";
int num1 = Integer.parseInt(str1); // 字符串到数字的转换

String str2 = "10.5";
double num2 = Double.parseDouble(str2); // 字符串到数字的转换

结语

本章节学习了Java中的运算符，

• 1、算术运算符：用于执行基本的数学运算，如加、减、乘、除等；
• 关系运算符：用于比较两个值之间的关系，如等于、不等于、大于、小于等。
• 布尔逻辑运算符：用于连接多个布尔表达式，如与、或、非等。
• 位运算符：用于对整数进行二进制位操作。
• 条件运算符：也称为三元运算符，用于根据一个布尔表达式的值来选择两个值中的一个。
• 赋值运算符：用于将一个值赋给变量。
• 算术运算符：用于执行基本的数学运算，如加、减、乘、除等。
• 类型比较运算符：用于检查一个对象是否属于某个类或接口的实例。