twotwo

//注意: 有小数参加运算,结果一定是小数
System.out.println(a*1.0 / b);//30.0/20: 1.5

%(取余数)运算符

//定义int变量num,并初始化
int num = 1234;
//计算个位赋值int变量ge
int ge = num % 10;
//计算十位赋值int变量shi
int shi = num / 10 % 10;
//计算百位赋值int变量bai
int bai = num / 100 % 10;
//计算千位赋值int变量qian
int qian = num / 1000 % 10;

+的作用
    1.完成数学中的加法运算: +左右两边都是数字或者字符
    2.完成字符串的连接(拼接): 如果+的左右两边出现字符串

/*
    表达式"5+5=" + 5 + 5: 从左向右计算
    先计算表达式"5+5=" + 5: +号左侧是字符串"5+5=",右侧是数字5,此时+号代表字符串的拼接
    表达式"5+5=" + 5的结果: "5+5=5"
    再计算表达式"5+5=5" + 5: +号左侧是字符串"5+5=5",右侧是数字5,此时+号代表字符串的拼接
    最终结果: "5+5=55"
 */
System.out.println("5+5=" + 5 + 5);//5+5=55
/*
    表达式"5+5=" + (5 + 5):从左向右计算,但是有()要先计算()
    先计算表达式(5 + 5): +号左侧是数字5,右侧是数字5,此时+号代表加法运算,结果是10
    再计算"5+5=" + 10: +号左侧是字符串"5+5=",右侧是数字10,此时+号代表字符串的拼接
    最终结果: "5+5=10"
 */
System.out.println("5+5=" + (5 + 5));//5+5=10

System.out.println(5 + "Hello" + 5);//5Hello5

自增++,自减--运算符

public class Demo04ZiZeng {
    public static void main(String[] args) {
        int a = 1;
        //单独使用: 只有++,没有别的运算
        ++a;//a = a + 1
        System.out.println("a = " + a);//2

        int b = 1;
        //单独使用: 只有++,没有别的运算
        b++;//b = b + 1
        System.out.println("b = " + b);//2
        System.out.println("----------");

        int c = 3;
        //单独使用: 只有--,没有别的运算
        --c;//c = c - 1
        System.out.println("c = " + c);//2

        int d = 3;
        //单独使用: 只有--,没有别的运算
        d--;//d = d - 1
        System.out.println("d = " + d);//2
    }
}

public class Demo05ZiZeng {
    public static void main(String[] args) {
        int a = 1;
        /*
            a++: 变量a的值增加1
            a--: 变量a的值减少1
            混合运算: 有++和=
            因为++在变量a的前面,先把变量a的值增加1,变量a的值变成2,
            然后再使用变量a增加1之后的结果2赋值给变量b,所以变量b的值是2
         */
        int b = ++a;
        System.out.println("a = " + a);//2
        System.out.println("b = " + b);//2

        int c = 1;
        /*
            混合运算: 有++和=
            因为++在变量c的后面,先使用c的值1,赋值给左侧变量d,
            所以d的值是1,然后c的值增加1,c变成2
         */
        int d = c++;
        System.out.println("c = " + c);//2
        System.out.println("d = " + d);//1

        int e = 1;
        //++在e的前面,e的值先增加1,变成2,然后输出e的值,结果是2
        System.out.println(++e);//2
        System.out.println(e);//2

        int f = 1;
        //++在f的后面,先使用f的值1,进行输出,输出结果是1,然后f的值增加1,f变成2
        System.out.println(f++);//1
        System.out.println(f);//2
    }
}

public class Demo02FuZhi {
    public static void main(String[] args) {
        
/*
    赋值运算符
    += 	加后赋值    a+=b，将a+b的值给a 	a = a + b
    -= 	减后赋值    a-=b，将a-b的值给a 	a = a - b
    *= 	乘后赋值    a*=b，将a×b的值给a 	a = a * b
    /= 	除后赋值    a/=b，将a÷b的商给a    a = a / b
    %= 	取余后赋值  a%=b，将a÷b的余数给a  a = a % b
    注意:
        1.=: 表示的是赋值运算
        2.==: 表示的是判断是否相同
 */
        int a = 10, b = 20;
        a += b;//a = a + b
        System.out.println("a = " + a);//30
        System.out.println("b = " + b);//20

        int c = 100, d = 30;
        c /= d;//c = c / d
        System.out.println("c = " + c);//3
        System.out.println("d = " + d);//30

        int e = 20, f = 6;
        e %= f;//e = e % f
        System.out.println("e = " + e);//2
        System.out.println("f = " + f);//6
    }
}

package com.itheima.d2_qita;
 
public class Demo03GuanXi {
    /*
    关系运算符
    1.作用:
        用来比较两个数据之间的大小关系,结果是boolean类型的数据
    2.特点:
        关系表达式不管写的多么复杂,或者多么简单,最终结果要么是true(成立),要么是false(不成立)
    3.分类:
        == 	a==b，	判断a和b的值是否相等，成立为true，不成立为false
        > 	a>b，	判断a是否大于b，成立为true，不成立为false
        >= 	a>=b，	判断a是否大于或者等于b，成立为true，不成立为false
        < 	a<b，	判断a是否小于b，成立为true，不成立为false
        <= 	a<=b，	判断a是否小于或者等于b，成立为true，不成立为false
        ！= 	a!=b，	判断a和b的值是否不相等，成立为true，不成立为false
    4.注意:
        1.=: 表示的是赋值运算
        2.==: 表示的是判断是否相同
 */
    public static void main(String[] args) {
        //定义两个int变量并初始化
        int a = 10, b = 20;
        System.out.println(a > b);//false
        System.out.println(a >= b);//false
        System.out.println(a < b);//true
        System.out.println(a <= b);//true
        System.out.println(a != b);//true
        System.out.println(a == b);//false
        //把变量b的值赋值给变量a,然后再输出a的值
        System.out.println(a = b);//20
    }
}

public class Demo04LuoJi {
    /*
    逻辑运算符
        1.作用:
            用来连接多个布尔表达式的,结果也是布尔类型
        2.分类:
            (1)逻辑与(&:shift+7)【有false，则false】:
                表示并且的意思,同时成立的意思
                多个条件都为true,结果才为true
                多个条件只要有一个为false,结果就是false
            (2)逻辑或(|:shift+\)【有true，则true】:
                表示或者的意思
                多个条件只要有一个为true,结果就是true
                多个条件都是false,结果就是false
            (3)逻辑异或(^:shift+6):			目前暂时不用
                相同为false,不同为true
            (4)逻辑非(!:shift+1):
                !true: 就是false
                !false: 就是true
 */
    public static void main(String[] args) {
        int a = 10, b = 20, c = 30;
        //&运算: 有false,则false
        System.out.println((a > b) & (a > c));//false & false ---> false
        System.out.println((a < b) & (a < c));//true  & true  ---> true
        System.out.println((a > b) & (a < c));//false & true  ---> false
        System.out.println((a < b) & (a > c));//true  & false ---> false
        System.out.println("----------------");
        //|运算: 有true,则true
        System.out.println((a > b) | (a > c));//false | false ---> false
        System.out.println((a < b) | (a < c));//true  | true  ---> true
        System.out.println((a > b) | (a < c));//false | true  ---> true
        System.out.println((a < b) | (a > c));//true  | false ---> true
        System.out.println("----------------");
        //^运算: 相同为false,不同为true    目前用不到
        System.out.println((a > b) ^ (a > c));//false ^ false ---> false
        System.out.println((a < b) ^ (a < c));//true  ^ true  ---> false
        System.out.println((a > b) ^ (a < c));//false ^ true  ---> true
        System.out.println((a < b) ^ (a > c));//true  ^ false ---> true
        System.out.println("----------------");
        //!运算: !true就是false,!false就是true
        System.out.println(!true);//false
        System.out.println(!false);//true

        //输出变量的值是否不等于变量b的值
        System.out.println(a != b);//true
        System.out.println(!(a == b));//!false --> true 
    }
}

public class Demo05DuanLu {
    public static void main(String[] args) {
        /*
    逻辑运算符的短路效果
        1.基本使用
            (1)短路逻辑与(&&): 左侧为false,右侧不进行计算
            (2)短路逻辑或(||): 左侧为true,右侧不进行计算

        2.使用区别):
            (1)&&和&: 最终的结果是相同的,但是&&具有短路的效果,效率高
            (2)||和|: 最终的结果是相同的,但是||具有短路的效果,效率高

        3.注意:
            以后实际学习/开发过程中,需要连接多个条件时,强烈建议使用&& 或者 ||
 */
        int a = 1;
        /*
            表达式(3 < 2) & (++a > 1): 从左向右执行
            先计算表达式(3 < 2)的结果为false,但是对于&而言,虽然左侧为false,
            已经决定了最终的结果为false,仍然会计算右侧的表达式(++a > 1)的结果为true,
            导致a的值增加1
         */
        System.out.println((3 < 2) & (++a > 1));//false
        System.out.println(a);//2 说明 对于&而言,左侧为false,右侧仍然需要计算

        int b = 1;
        /*
            表达式(3 < 2) && (++b > 1): 从左向右执行
            先计算表达式(3 < 2)的结果为false,但是对于&&而言,
            左侧为false已经决定了最终的结果为false,
            右侧的表达式(++b > 1)不再计算了,所以b的值没有变化
         */
        System.out.println((3 < 2) && (++b > 1));//false
        System.out.println(b);//1 说明 对于&&而言,左侧为false,右侧不计算

        int c = 1;
        /*
            表达式(3 > 2) | (++c > 2): 从左向右执行
            先计算表达式(3 > 2)的结果为true,但是对于|而言,虽然左侧为true,
            已经决定了最终的结果为true,仍然会计算右侧的表达式(++c > 1)的结果为true,
            导致c的值增加1
         */
        System.out.println((3 > 2) | (++c > 1));//true
        System.out.println(c);//2说明 对于|而言,左侧为true,右侧仍然需要计算

        int d = 1;
        /*
            表达式(3 > 2) || (++d > 1): 从左向右执行
            先计算表达式(3 > 2)的结果为true,但是对于||而言,
            左侧为true已经决定了最终的结果为true,
            右侧的表达式(++d > 1)不再计算了,所以d的值没有变化
         */
        System.out.println((3 > 2) || (++d > 1));//true
        System.out.println(d);//1 说明 对于||而言,左侧为true,右侧不计算
    }
}

public class Demo06SanYuan {
    /*
    三元运算符
        1.格式:
            数据类型 变量名称 = 布尔表达式1 ？ 表达式2 ： 表达式3；
            注意：
                ？号前面的式子的结果必须是布尔类型

        2.执行流程:
            （1）计算布尔表达式1的结果，看是true，还是false
            （2）如果布尔表达式1的结果是true，取表达式2的结果赋值给左侧的变量
            （3）如果布尔表达式1的结果是false，取表达式3的结果赋值给左侧的变量
    需求：
        一座寺庙里住着两个和尚，已知他们的身高分别为150cm、210cm，请用程序实现获取这两个和尚的最高身高。

    实现步骤:
        1.定义两个int变量h1和h2,代表两个和尚的身高,并根据题目需求进行初始化
        2.使用三元运算符计算h1和h2的最大值,保存int变量max中
        3.输出结果数据max

    注意:
        判断h1和h2的大小的表达式可以写出好多种
        根据表达式的不同,三元运算符?和:后面的式子就有可能不一样
        int max = h1 > h2 ? h1 : h2;
        int max = h2 > h1 ? h2 : h1;
 */
    public static void main(String[] args) {
        //1.定义两个int变量h1和h2,代表两个和尚的身高,并根据题目需求进行初始化
        int h1 = 250, h2 = 210;
        //2.使用三元运算符计算h1和h2的最大值,保存int变量max中
        //int max = h1 > h2 ? h1 : h2;
        int max = h2 > h1 ? h2 : h1;
        //3.输出结果数据max
        System.out.println("最大身高: " + max);
    }
}

public class Demo07SanYuan {
    /*
    需求：
        一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
        请用程序实现获取这三个和尚的最高身高。

    实现步骤:
        1.定义三个int变量h1,h2和h3,代表三个和尚的身高,并根据题目需求进行初始化
        2.使用三元运算符计算h1和h2的最大值,保存int变量temp中
        3.使用三元运算符计算temp和h3的最大值,保存int变量max中
        4.输出结果数据max
 */
    public static void main(String[] args) {
        //1.定义三个int变量h1,h2和h3,代表三个和尚的身高,并根据题目需求进行初始化
        int h1 = 150, h2 = 210, h3 = 165;
        //2.使用三元运算符计算h1和h2的最大值,保存int变量temp中
        int temp = h1 > h2 ? h1 : h2;
        //3.使用三元运算符计算temp和h3的最大值,保存int变量max中
        int max = temp > h3 ? temp : h3;
        //4.输出结果数据max
        System.out.println("最大身高: " + max + "cm");
    }
}

public class Demo03Scanner {
    /*
    键盘录入Scanner类的使用:
        1.导包(找到我们要使用的东西) import 引入
            格式: import 包名.类名;
            Scanner类的导包: import java.util.Scanner;
        2.创建对象
            格式: 类名 对象名 = new 类名(参数列表...);
            解释:
                (1)类名: class关键字后面指定的名字
                (2)对象名: 就是我们前面用的变量名,是一个标识符(符合命名规则)
                (3)=: 赋值的过程
                (4)new: 开辟内存空间创建对象的过程
                (5)参数列表: 根据需求指定
            创建Scanner类的对象:
                Scanner sc = new Scanner(System.in);
                注意: ()中的System.in目前是固定写法,就业班详细学习
        3.使用对象:
            sc.nextInt(): 获取键盘录入的整数数字(int范围)
            sc.nextDouble(): 获取键盘录入的小数数字(double范围)

        注意事项:
        不用自己手动导包,自己写import java.util.Scanner;
        (1)正确的写出Scanner类的前几个字母,根据提示,选择Scanner类,会自动导包        建议使用
        (2)正确的写出Scanner类的名字,如果没有提示: 快捷键alt + 回车
 */
    public static void main(String[] args) {
        //1.在最上面完成导包
        //2.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //3.获取键盘录入的数字
        System.out.println("请输入第一个整数数字: ");
        int a = sc.nextInt();
        System.out.println("您输入的第一个整数数字: " + a);
        System.out.println("请输入第二个整数数字: ");
        int b = sc.nextInt();
        System.out.println("您输入的第二个整数数字: " + b);
    }
}

public class Demo04ScannerSum {
    /*
    键盘录入练习
    需求:
        获取键盘录入的两个整数(int类型)数字,在控制台输出求和的结果。
    实现步骤:
        1.创建键盘录入Scanner类的对象sc
        2.获取键盘录入的两个整数数字,分别保存int变量a和b中
        3.计算a和b的数据和保存int变量sum中
        4.输出求和结果数据sum
 */
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象sc
        Scanner sc = new Scanner(System.in);
        //2.获取键盘录入的两个整数数字,分别保存int变量a和b中
        System.out.println("请输入第一个整数数字: ");
        int a = sc.nextInt();
        System.out.println("请输入第二个整数数字: ");
        int b = sc.nextInt();
        //3.计算a和b的数据和保存int变量sum中
        int sum = a + b;
        //4.输出求和结果数据sum
        System.out.println("求和结果: " + sum);
    }
}