您现在的位置是：首页 > Java

当前栏目

Java-笔记3

JAVA 笔记执行

2023-03-02 11:00:45 时间

![1604514-20190502193805363-1142421945.png][]

![1604514-20190502193817083-1378104374.png][]

/*
    运算符之一：算术运算符
    + - + - * / % (前)++ (后)++ (前)-- (后)-- +
    
    
    */
    class AriTest {
        public static void main(String[] args) {
            
            //除号：/
            int num1 = 12;
            int num2 = 5;
            int result1 = num1 / num2;
            System.out.println(result1);//2
    
            int result2 = num1 / num2 * num2;
            System.out.println(result2);//10
    
            double result3 = num1 / num2;
            System.out.println(result3);//2.0
    
            double result4 = num1 / num2 + 0.0;//2.0
            double result5 = num1 / (num2 + 0.0);//2.4
            double result6 = (double)num1 / num2;//2.4
            double result7 = (double)(num1 / num2);//2.0
            System.out.println(result5);
            System.out.println(result6);
    
            // %:取余运算
            //结果的符号与被模数的符号相同
            //开发中，经常使用%来判断能否被除尽的情况。
            int m1 = 12;
            int n1 = 5;
            System.out.println("m1 % n1 = " + m1 % n1);
    
            int m2 = -12;
            int n2 = 5;
            System.out.println("m2 % n2 = " + m2 % n2);
    
            int m3 = 12;
            int n3 = -5;
            System.out.println("m3 % n3 = " + m3 % n3);
    
            int m4 = -12;
            int n4 = -5;
            System.out.println("m4 % n4 = " + m4 % n4);
            
            
            //(前)++ :先自增1，后运算
            //(后)++ :先运算，后自增1
            int a1 = 10;
            int b1 = ++a1;
            System.out.println("a1 = " + a1 + ",b1 = " + b1);
            
            int a2 = 10;
            int b2 = a2++;
            System.out.println("a2 = " + a2 + ",b2 = " + b2);
            
            int a3 = 10;
            ++a3;//a3++;
            int b3 = a3;
            
            //注意点：
            short s1 = 10;
            //s1 = s1 + 1;//编译失败
            //s1 = (short)(s1 + 1);//正确的
            s1++;//自增1不会改变本身变量的数据类型
            System.out.println(s1);
    
            //问题：
            byte bb1 =127;
            bb1++;
            System.out.println("bb1 = " + bb1);
    
            //(前)-- :先自减1，后运算
            //(后)-- :先运算，后自减1
            
            int a4 = 10;
            int b4 = a4--;//int b4 = --a4;
            System.out.println("a4 = " + a4 + ",b4 = " + b4);
    
        }
    }
    
    /* 结果：
    -------------------------
    2
    10
    2.0
    2.4
    2.4
    m1 % n1 = 2
    m2 % n2 = -2
    m3 % n3 = 2
    m4 % n4 = -2
    a1 = 11,b1 = 11
    a2 = 11,b2 = 10
    11
    bb1 = -128
    a4 = 9,b4 = 10
    -------------------------
    */

![1604514-20190502204442892-1440544212.png][]

/*
    练习：随意给出一个三位数的整数，打印显示它的个位数，十位数，百位数的值。
    格式如下：
    数字xxx的情况如下：
    个位数：
    十位数：
    百位数：
    
    例如：
    数字153的情况如下：
    个位数：3
    十位数：5
    百位数：1
    
    */
    class AriExer {
        public static void main(String[] args) {
            
            int num = 187;
            
            int bai = num / 100;
            int shi = num % 100 / 10;//int shi = num / 10 % 10;
            int ge = num % 10;
            
            System.out.println("百位为：" + bai);
            System.out.println("十位为：" + shi);
            System.out.println("个位为：" + ge);
    
        }
    }
    
    /* 结果
    ---------------------------
    百位为：1
    十位为：8
    个位为：7
    ---------------------------
    */

![1604514-20190502212553486-1184446297.png][]

![1604514-20190502212610257-11511034.png][]

/*
    运算符之二：赋值运算符
    =  +=  -=  *=  /=  %= 
    
    
    */
    class SetValueTest {
        public static void main(String[] args) {
            //赋值符号：=
            int i1 = 10;
            int j1 = 10;
    
            int i2,j2;
            //连续赋值
            i2 = j2 = 10;
    
            int i3 = 10,j3 = 20;
            
            //*********************
            int num1 = 10;
            num1 += 2;//num1 = num1 + 2;
            System.out.println(num1);//12
    
            int num2 = 12;
            num2 %= 5;//num2 = num2 % 5;
            System.out.println(num2);
    
            short s1 = 10;
            //s1 = s1 + 2;//编译失败
            s1 += 2;//结论：不会改变变量本身的数据类型
            System.out.println(s1);
    
            //开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
            //方式一：num = num + 2;
            //方式二：num += 2; (推荐)
            
            //开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
            //方式一：num = num + 1;
            //方式二：num += 1; 
            //方式三：num++; (推荐)
            
            //练习1
            int i = 1;
            i *= 0.1;
            System.out.println(i);//0
            i++;
            System.out.println(i);//1
    
            //练习2
            int m = 2;
            int n = 3;
            n *= m++; //n = n * m++;    
            System.out.println("m=" + m);//3
            System.out.println("n=" + n);//6
            
            //练习3
            int n1 = 10;
            n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);
            System.out.println(n1);//32
    
        }
    }
    
    /* 结果：
    -------------------------
    12
    2
    12
    0
    1
    m=3
    n=6
    32
    -------------------------
    */

![1604514-20190502212452191-811812487.png][]

![1604514-20190502212502828-1372962864.png][]

![1604514-20190502212516529-998867626.png][]

/*
    运算符之三：比较运算符
    ==  !=  >  <  >= <=  instanceof
    
    结论：
    1.比较运算符的结果是boolean类型
    2.区分 ==  和  = 
    */
    class CompareTest {
        public static void main(String[] args) {
            int i = 10;
            int j = 20;
    
            System.out.println(i == j);//false
            System.out.println(i = j);//20
    
            boolean b1 = true;
            boolean b2 = false;
            System.out.println(b2 == b1);//false
            System.out.println(b2 = b1);//true
        }
    }
    
    /* 结果：
    -------------------------
    false
    20
    false
    true
    -------------------------
    */

![1604514-20190502213055358-723121123.png][]

![1604514-20190502213105007-29888678.png][]

/*
    运算符之四：逻辑运算符
    
    &  && |  || ! ^
    
    说明：
    1.逻辑运算符操作的都是boolean类型的变量
    
    
    */
    class LogicTest {
        public static void main(String[] args) {
            
            //区分& 与 &&
            //相同点1：& 与  && 的运算结果相同
            //相同点2：当符号左边是true时，二者都会执行符号右边的运算
            //不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
            //开发中，推荐使用&&
            boolean b1 = true;
            b1 = false;
            int num1 = 10;
            if(b1 & (num1++ > 0)){
                System.out.println("我现在在北京");
            }else{
                System.out.println("我现在在南京");
            }
    
            System.out.println("num1 = " + num1);
            
    
            boolean b2 = true;
            b2 = false;
            int num2 = 10;
            if(b2 && (num2++ > 0)){
                System.out.println("我现在在北京");
            }else{
                System.out.println("我现在在南京");
            }
    
            System.out.println("num2 = " + num2);
    
            // 区分：| 与 || 
            //相同点1：| 与  || 的运算结果相同
            //相同点2：当符号左边是false时，二者都会执行符号右边的运算
            //不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
            //开发中，推荐使用||
            boolean b3 = false;
            b3 = true;
            int num3 = 10;
            if(b3 | (num3++ > 0)){
                System.out.println("我现在在北京");
            }else{
                System.out.println("我现在在南京");
            }
            System.out.println("num3 = " + num3);
    
    
            boolean b4 = false;
            b4 = true;
            int num4 = 10;
            if(b4 || (num4++ > 0)){
                System.out.println("我现在在北京");
            }else{
                System.out.println("我现在在南京");
            }
            System.out.println("num4 = " + num4);
        }
    }
    
    /* 结果：
    ------------------------
    我现在在南京
    num1 = 11
    我现在在南京
    num2 = 10
    我现在在北京
    num3 = 11
    我现在在北京
    num4 = 10
    ------------------------
    */

![1604514-20190502215249888-1698062677.png][]

![1604514-20190502215302867-722106395.png][]

![1604514-20190502215441090-1635564099.png][]

![1604514-20190502215502467-1536232279.png][]

![1604514-20190502220832703-961070035.png][]

![1604514-20190502221004776-1861559787.png][]

![1604514-20190502222720238-1078520995.png][]

/*
    运算符之五：位运算符 （了解）
    
    结论：
    1. 位运算符操作的都是整型的数据
    2. << ：在一定范围内，每向左移1位，相当于 * 2
       >> :在一定范围内，每向右移1位，相当于 / 2
    
    
    
    面试题：最高效方式的计算2 * 8 ？  2 << 3  或 8 << 1
    */
    class BitTest {
        public static void main(String[] args) {
            int i = 21;
            i = -21;
            System.out.println("i << 2 :" + (i << 2));
            System.out.println("i << 3 :" + (i << 3));
            System.out.println("i << 27 :" + (i << 27));
    
            int m = 12;
            int n = 5;
            System.out.println("m & n :" + (m & n));
            System.out.println("m | n :" + (m | n));
            System.out.println("m ^ n :" + (m ^ n));
    
            //练习：交换两个变量的值
            int num1 = 10;
            int num2 = 20;
            System.out.println("num1 = " + num1 + ",num2 = " + num2);
    
            //方式一：定义临时变量的方式
            //推荐的方式
            int temp = num1;
            num1 = num2;
            num2 = temp;
    
            //方式二：好处：不用定义临时变量  
            //弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
            //num1 = num1 + num2;
            //num2 = num1 - num2;
            //num1 = num1 - num2;
    
            //方式三：使用位运算符
            //有局限性：只能适用于数值类型
            //num1 = num1 ^ num2;
            //num2 = num1 ^ num2;
            //num1 = num1 ^ num2;
    
            System.out.println("num1 = " + num1 + ",num2 = " + num2);
    
        }
    }
    
    /* 结果：
    ---------------------------
    i << 2 :-84
    i << 3 :-168
    i << 27 :1476395008
    m & n :4
    m | n :13
    m ^ n :9
    num1 = 10,num2 = 20
    num1 = 20,num2 = 10
    ---------------------------
    */

![1604514-20190502222748346-89304636.png][]

![1604514-20190502222756103-165074418.png][]

![1604514-20190502222814647-553019736.png][]

![1604514-20190502225756402-1054293384.png][]

![1604514-20190502225818709-1969775816.png][]

![1604514-20190502225936545-2050416807.png][]

![1604514-20190502225859426-742975995.png][]

![1604514-20190502225920004-1017547475.png][]

![1604514-20190502230003284-865974718.png][]

![1604514-20190502230011387-1283702352.png][]

![1604514-20190502230020401-2008022994.png][]

/*
    分支结构中的if-else（条件判断结构）
    
    
    一、三种结构
    
    第一种：
    if(条件表达式){
        执行表达式
    }
    
    第二种：二选一
    if(条件表达式){
        执行表达式1
    }else{
        执行表达式2
    }
    
    第三种：n选一
    if(条件表达式){
        执行表达式1
    }else if(条件表达式){
        执行表达式2
    }else if(条件表达式){
        执行表达式3
    }
    ...
    else{
        执行表达式n
    }
    
    
    
    */
    class IfTest {
        public static void main(String[] args) {
            
            //举例1
            int heartBeats = 79;
            if(heartBeats < 60 || heartBeats > 100){
                System.out.println("需要做进一步检查");
            }
    
            System.out.println("检查结束");
            
            //举例2
            int age = 23;
            if(age < 18){
                System.out.println("你还可以看动画片");
            }else{
                System.out.println("你可以看成人*电影了");
            }
    
            //举例3
            if(age < 0){
                System.out.println("您输入的数据非法");
            }else if(age < 18){
                System.out.println("青少年时期");
            }else if(age < 35){
                System.out.println("青壮年时期");
            }else if(age < 60){
                System.out.println("中年时期");
            }else if(age < 120){
                System.out.println("老年时期");
            }else{
                System.out.println("你是要成仙啊~~");
            }
        }
    }
    
    /* 结果：
    --------------------------
    检查结束
    你可以看成人*电影了
    青壮年时期
    --------------------------
    */

转载于:https://www.cnblogs.com/LXL616/p/10803824.html

[1604514-20190502193805363-1142421945.png]: /images/20211220/d913869833a94cc0af991661e948d5bd.png
[1604514-20190502193817083-1378104374.png]: /images/20211220/fcc1e1d8420449cab0d14083646b1abd.png
[1604514-20190502204442892-1440544212.png]: /images/20211220/471acf5b6acc4164a704fcfd9f025247.png
[1604514-20190502212553486-1184446297.png]: /images/20211220/9a54e5de6ee9443f916dd85963763e17.png
[1604514-20190502212610257-11511034.png]: /images/20211220/bdf72928766242a8a65203f1c546f878.png
[1604514-20190502212452191-811812487.png]: /images/20211220/a9d8462fdba64071bb7f316583ddad18.png
[1604514-20190502212502828-1372962864.png]: /images/20211220/e2305f5501204c4f8c51d79840d189d5.png
[1604514-20190502212516529-998867626.png]: /images/20211220/baba551765ae4d4e836e7c395defae58.png
[1604514-20190502213055358-723121123.png]: /images/20211220/d53ec52d3f1841eb8ca92e97e89b716d.png
[1604514-20190502213105007-29888678.png]: /images/20211220/e9d3c918742643ea95380f39f6a04374.png
[1604514-20190502215249888-1698062677.png]: /images/20211220/0f0633134c2446ebb9970529838731fa.png
[1604514-20190502215302867-722106395.png]: /images/20211220/2394863f49be480ea49954ee831ef17b.png
[1604514-20190502215441090-1635564099.png]: /images/20211220/b418851fc5634cce9d53dc340dccf29e.png
[1604514-20190502215502467-1536232279.png]: /images/20211220/1d5cd76434f849bb875e6e89cb762322.png
[1604514-20190502220832703-961070035.png]: /images/20211220/2c909f60fdbd415fa412334918d54a71.png
[1604514-20190502221004776-1861559787.png]: /images/20211220/99d35301d1b74e7cbdc817397eab13fd.png
[1604514-20190502222720238-1078520995.png]: /images/20211220/fe51bee10bdf4fb58e9e433eaed5d324.png
[1604514-20190502222748346-89304636.png]: /images/20211220/ca1d4c6a5c1648978753399960bdbef8.png
[1604514-20190502222756103-165074418.png]: /images/20211220/7b94209a710548db8f403f89760a7fca.png
[1604514-20190502222814647-553019736.png]: /images/20211220/8381c430e1fb4250a8b36dffad86023a.png
[1604514-20190502225756402-1054293384.png]: /images/20211220/53e0444a2f454eb6936d8867deb16c7c.png
[1604514-20190502225818709-1969775816.png]: /images/20211220/9009501a6722476ba0deaa6db2aecf1b.png
[1604514-20190502225936545-2050416807.png]: /images/20211220/e56a10cb0b084de1806b194b75f8b9c8.png
[1604514-20190502225859426-742975995.png]: /images/20211220/9c7a4340db264e90a1a183e7eab723dd.png
[1604514-20190502225920004-1017547475.png]: /images/20211220/9644214aecb1450082d49ffc7f70fb3f.png
[1604514-20190502230003284-865974718.png]: /images/20211220/68d475ff3a90408da2aa0fc6d0e3ed4c.png
[1604514-20190502230011387-1283702352.png]: /images/20211220/1a5d96eebef7434e8d095fbe41f0e0bb.png
[1604514-20190502230020401-2008022994.png]: /images/20211220/fb1447ebd4a24b7485c489348797add2.png

猜你喜欢

利用X-ui搭建多协议多用户面板
ReactJS学习(四)
gget：一款强大的基因组参考数据库的高效查询工具
构建 Web3 应用程序所需的技术堆栈
网速慢、搞不定，照老网工说得做就行
MTIC工业大脑，海量接入网关！
第一弹！华为设备命令最全大合集（2022新版）
第二弹！思科设备命令最全大合集（2022新版）
第三弹！华三设备命令最全大合集（2022新版）
比较CPU和GPU中的矩阵计算
15 种TypeScript最常用的实用程序类型
老网工就是厉害，设备存在MAC漂移告警，访问VM业务异常都能解决！
服务计算的思考
超详细的Wireshark使用教程
我像“小马过河”一样升级了我的开源系统
Python 中的 Map 函数处理可迭代对象
ESLint 配置入门，你学会了吗？
通过实战总结的使用GoFrame小技巧
Wi-Fi满格，网速却快不起来，咋整啊？
先聊聊「内存分配」，再聊聊Go的「逃逸分析」

zl程序教程

当前栏目

Java-笔记3

相关文章