javabasic-day03

luoyiang

于 2024-07-23 19:46:11 发布

阅读量438

点赞数 15

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_64370841/article/details/140644522

版权

symbal_AssignSymbolDemo01

package com.basic.day03.symbol;   //

/**
 * 注释，有三种， 文档注释，多行注释，单行注释
 *    文档注释: /**   *\/    一般用于类体上面或者是方法上面
 *    单行注释: //.....      一般用于方法里，或者变量附近
 *    多行注释: /*    *\/     一般用于方法里
 * */

/**
 *  运算符之赋值运算符
 *  =：   最简单的赋值运算符,  将等号后的表达式的结果或者变量的值赋值给等号前面的变量
 *  +=：  如： a+=b   相当于  a = a + b
 *  -=：  如： a-=b   相当于  a = a - b
 *  *=：  如： a*=b   相当于  a = a * b
 *  /=:  如： a/=b   相当于  a = a / b
 *  %=:  如： a%=b   相当于  a = a % b
 */
public class AssignSymbolDemo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b;  // 相当于 a = a + b
        System.out.println(a);// 30
        System.out.println(b);// 20
        a -= b; // 相当于 a = a - b
        System.out.println(a); // 10

        int c = 3;
        int d = 6;
        c *= d;
        System.out.println(c);//18

        c = 15;
        c /=d;  // 注意： 两个整数做除法运算，是取整操作
        System.out.println(c); //2

        int x = 15;
        int y = 6;
        x %= y;
        System.out.println(x);// 3

    }
}

symbal_LogicSymbolDemo01

package com.basic.day03.symbol;

/**
 * 运算符之逻辑运算符：
 *      在java中，一般研究的是短路逻辑运算符
 *       特点： 第一个条件如果已经可以确定最终结果，那么第二个条件就不再执行，节省时间。
 *
 *
 *      &&:  短路与   :    一假则假，全真为真
 *           true&&true ==>  true
 *           true&&false ==> false
 *           false&&true ==> false
 *           false&&false ==> false
 *
 *           针对于短路与来说： 第一个是false时，不再执行第二个条件，管它是true还是false.
 *
 *      ||   短路或   :    一真则真，全假为假
 *           true||true ==>  true
 *           true||false ==> true
 *           false||true ==> true
 *           false||false ==> false
 *
 *           针对于短路或来说： 第一个是true时，不再执行第二个条件，管它是true还是false.
 *
 *      !    非真既假，非假既真
 */
public class LogicSymbolDemo01 {
    public static void main(String[] args) {
        //验证短路&&
        int a = 1,b = 2,c = 3,d = 4;
        boolean f = a < b && c < d;
        System.out.println("f的值: "+f);  // true
        f = a < b && c > d;
        System.out.println("f的值: "+f);  // false
        f = a > b && c++ < d;
        System.out.println("f的值："+f);  // false
        System.out.println("c的值："+c);  //如果c是3，表示第二个条件根本没有执行。
        f = a > b && c > d++;
        System.out.println("f的值："+f); // false
        System.out.println("d的值："+d);  // 如果d是4，表示第二个条件根本没有执行

        // 验证短路||

        int m = 1,n = 2,x = 3,y = 4;
        f = m < n || x < y;
        System.out.println("f的值："+f); // true
        f = m < n || x > y++;
        System.out.println("f的值："+f); // true
        System.out.println("y的值："+y); // 4  , 第一个条件为true,就可以确定最终答案， 因此没有执行自增运算，可以证明短路了。
        f = m > n || x < y;
        System.out.println("f的值："+f); // true
        f = m > n || x > y++;
        System.out.println("f的值："+f); // false
        System.out.println("y的值："+y); // 5  , 因为第一个条件式false,不能立即决定最终结果，所以会执行第二个条件，

        //  !   非真既假，非假既真
        f =  !(1 > 2);
        System.out.println("f的值："+f); //true
        f = !f;
        System.out.println("f的值："+f); //false
    }
}

symbal_RelationSymbolDemo01

package com.basic.day03.symbol;

/**
 * 运算符之关系运算符：
 *   >,  >=,  <,  <=,   ==,  !=
 *  作用：用于判断两边的大小关系。
 *  返回值： boolean类型
 */
public class RelationSymbolDemo01 {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        System.out.println(x>y);  // false
        System.out.println(x>=y);  //false
        System.out.println(x<y);  // true
        System.out.println(x<=y); // true
        System.out.println(x==y);  // false
        System.out.println(x!=y);  // true
    }
}

symbal_ThreeEyeSymbolDemo01

package com.basic.day03.symbol;

/**
 * 运算符之三目运算符(三元运算符,条件运算符)
 * 语法格式：
 *         boolean类型的变量或者表达式?值1:值2
 * 执行逻辑：
 *      当?前的式子或变量返回true, 则使用值1，
 *      当?前的式子或变量返回false，则使用值2
 * 注意：
 *     1.  该运算，依然遵守混合运算时转成取值范围最大的那种类型
 *     2.  值1和值2，可以是变量，也可以是具有返回值的表达式。
 *     3.  值1和值2的最终类型，需要能自动类型转换。
 *     4. 通常三目运算的最终结果，需要使用一个变量来接受，该变量的类型应该是值1或值2中的一个。
 */
public class ThreeEyeSymbolDemo01 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        String str = a > b ? "是a大于b" : "a不大于b";
        System.out.println(str);

        int m = 10;
        long n = 15;
        long result =  n%m==1?n:m; // 注意，需要考虑m和n在三目运算里都已经是long类型了。
        System.out.println("result:"+result);
    }
}

scanner_RandomDemo01

package com.basic.day03.random;

import java.util.Random;

/**
 * Random: 该类型一般用于产生随机数。比如随机一个范围的整数，或者小数。
 * 使用步骤：
 *      1. 导包操作，   import java.util.Random;
 *      2. 创建对象，   Random r = new Random();
 *      3. 调用相关功能
 *                    r.nextInt(number):  产生一个[0,number)范围内的任意一个整数
 *                    r.nextDouble():   产生一个[0,1)范围内的任意一个小数。
 */
public class RandomDemo01 {
    public static void main(String[] args) {
        Random r = new Random();
        //产生一个[0,10)区间内的一个整数。    生成等号前面的变量快捷键： alt+enter
        int i = r.nextInt(10);
        System.out.println("i=" + i);

        //产生一个[0,10]区间内的一个整数
        int i1 = r.nextInt(11);
        System.out.println("i1=" + i1);

        //产生一个[-5,5]区间内的一个整数
        int i2 = r.nextInt(11)-5;
        System.out.println("i2=" + i2);

        //产生一个[0,1)区间内的任意一个小数
        double v = r.nextDouble();
        System.out.println("v=" + v);


    }
}

scanner_RandomDemo02

package com.basic.day03.random;

import java.util.Random;

/**
 * 练习Random的nextDouble方法
 */
public class RandomDemo02 {
    public static void main(String[] args) {
        Random rd = new Random();
        //随机[0,10)以内的任意小数     [0,1)*10=====>[0,10)
        double num = rd.nextDouble()*10;
        //随机[0,10)以内的任意整数
        int n1 = (int)(rd.nextDouble()*10);
        System.out.println("n1 = " + n1);

        //随机[-6,6]以内的任意整数
        int n2 = (int)(rd.nextDouble()*13-6);
        System.out.println("n2 = " + n2);

        // 随机[5,15]以内的任意整数  [5,16)    [0,11)
        //
        int n3 = (int)((rd.nextDouble()*11)+5);
        /**
         * 通过上述练习：可以总结一个公式
         *   闭区间[n,m]的公式     r.nextDouble()*(m+1-n)+n
         *   开区间[n,m)的公式     r.nextDouble()*(m-n)+n
         */
        // 随机[98,155]以内的任意整数
        int n4 = (int)(rd.nextDouble()*58+98);
        System.out.println("n4:"+n4);
    }
}

math_MathDemo01

package com.basic.day03.math;

/**
 * Math: 数学工具类，里面提供了很多关于数学方面的功能方式。
 * 使用方式： 直接使用类名.具体方法名
 * 里面的内容分类：
 *   静态常量：  E  自然对数   PI  圆周率
 *   常用函数：
 *      max(): 取最大的数
 *      min(): 取最小的数
 *      random(): 随机数，范围[0,1)       与Random的nextDouble()效果一样
 *      abs(): 取绝对值
 *   取整函数：
 *        ceil():  向上取整（大于等于某一个数的最小整数）    比如 ceil(3.4)  得到 4
 *        floor(): 向下取整(小于等于该数的最大整数)     比如floor(3.4)  得到3
 *        rint()： 最近的整数          比如  rint(3.7)   得到4
 *                                 比如 3.5 距离两边一样近，则返回偶数的整数
 *        round()： 四舍五入
 *   指数函数：
 *          pow(): 幂函数
 *          sqrt(): 平方根
 *          cbrt(): 立方根
 *   三角函数：
 *          sin()
 *          cos()
 *          asin()
 *          acose()
 *          tan()
 *          atan()
 *
 *
 */
public class MathDemo01 {
    public static void main(String[] args) {
        System.out.println("自然对数:"+Math.E);  //double类型
        System.out.println("圆周率："+Math.PI);  //double类型

        System.out.println("3和5比较，其中最大值: "+Math.max(3,5));
        System.out.println("3和5比较，其中最小值: "+Math.min(3,5));
        System.out.println("-3的绝对值: "+Math.abs(-3));

        //使用Math.random()产生一个随机数， 默认是[0,1)区间内的小数
        // [5,10]
        int i = (int) (Math.random() * 6 + 5);
        System.out.println("产生的随机整数："+i);

        System.out.println("3.4向上取整: "+Math.ceil(3.4));
        System.out.println("3.4向下取整: "+Math.floor(3.4));
        System.out.println("离3.4最近的整数: "+Math.rint(3.4));
        System.out.println("3.4四舍五入后: "+Math.round(3));

        System.out.println("3的4次方："+Math.pow(3,4));
        System.out.println("8的平方根："+Math.sqrt(8));
        System.out.println("8的立方根："+Math.cbrt(8));


    }
}

branch_01IfDemo

package com.basic.day03.branch;

/**
 * 分支结构之if的学习：
 *
 * 基本语法：
 *      if(boolean表达式){
 *          //code1：   表达式返回true,执行code1
 *      }else{
 *          //code2:   表达式返回false,执行code2
 *      }
 */
public class _01IfDemo {
    public static void main(String[] args) {
        //三目运算
        int a = 10;
        int b = 20;
        String str = a<b?"正确":"错误";
        System.out.println(" a<b?  "+str);

        //将上述代码转成if-else分支结构的写法。
        if(a<b){
            System.out.println("正确");
        }else{
            System.out.println("错误");
        }

        System.out.println("---main方法结束---");
    }
}

branch_02IfDemo

package com.basic.day03.branch;

/**
 * if多分支结构：
 *
 *   if(表达式1){
 *       //code1
 *   }else if(表达式2){
 *      //code2
 *   }else if(表达式3){
 *      //code3
 *   }
 *   ......
 *   else{
 *
 *   }
 *   //...后续代码
 *  执行逻辑：
 */
public class _02IfDemo {
    public static void main(String[] args) {
        /*
         * 随机一个整数num：范围[0,100],作为一个分数。
         * 请输入num这个分数的等级
         *  不及格： <60
         *  及格:   <80
         *  良好    <90
         *  优秀：  <100
         *  满分：  =100
         */
        int num = (int) (Math.random()*101);
        System.out.println("偷偷的看一下成绩："+num);
        if(num<60){
            System.out.println("不及格");
        }else if(num < 80){
            System.out.println("及格");
        }else if(num < 90){
            System.out.println("良好");
        }else if(num < 100){
            System.out.println("优秀");
        }else{
            System.out.println("满分");
        }
        System.out.println("---main方法结束---");
    }
}

branch_03IfDemo

package com.basic.day03.branch;

/**
 * if多分支结构：
 *
 *   if(表达式1){
 *       //code1
 *   }else if(表达式2){
 *      //code2
 *   }else if(表达式3){
 *      //code3
 *   }
 *   ......
 *   else{
 *
 *   }
 *   //...后续代码
 *  执行逻辑：
 */
public class _02IfDemo {
    public static void main(String[] args) {
        /*
         * 随机一个整数num：范围[0,100],作为一个分数。
         * 请输入num这个分数的等级
         *  不及格： <60
         *  及格:   <80
         *  良好    <90
         *  优秀：  <100
         *  满分：  =100
         */
        int num = (int) (Math.random()*101);
        System.out.println("偷偷的看一下成绩："+num);
        if(num<60){
            System.out.println("不及格");
        }else if(num < 80){
            System.out.println("及格");
        }else if(num < 90){
            System.out.println("良好");
        }else if(num < 100){
            System.out.println("优秀");
        }else{
            System.out.println("满分");
        }
        System.out.println("---main方法结束---");
    }
}

branch_04IfDemo

package com.basic.day03.branch;

/**
 * if多分支结构：
 *
 *   if(表达式1){
 *       //code1
 *   }else if(表达式2){
 *      //code2
 *   }else if(表达式3){
 *      //code3
 *   }
 *   ......
 *   else{
 *
 *   }
 *   //...后续代码
 *  执行逻辑：
 */
public class _02IfDemo {
    public static void main(String[] args) {
        /*
         * 随机一个整数num：范围[0,100],作为一个分数。
         * 请输入num这个分数的等级
         *  不及格： <60
         *  及格:   <80
         *  良好    <90
         *  优秀：  <100
         *  满分：  =100
         */
        int num = (int) (Math.random()*101);
        System.out.println("偷偷的看一下成绩："+num);
        if(num<60){
            System.out.println("不及格");
        }else if(num < 80){
            System.out.println("及格");
        }else if(num < 90){
            System.out.println("良好");
        }else if(num < 100){
            System.out.println("优秀");
        }else{
            System.out.println("满分");
        }
        System.out.println("---main方法结束---");
    }
}

branch_05IfDemo

package com.basic.day03.branch;

/**
 * if分支语句中，可以没有else语句块。
 *
 * 总结：
 *    1. 带有else语句块的分支结构，一定会执行某一条分支。
 *    2. 不带else语句块的分支结构，可能一条分支都不执行。
 *    3. if分支结构不可能执行多条分支。
 */
public class _05IfDemo {
    public static void main(String[] args) {
        //年满18岁，才可以单独进入澡堂子洗澡
        int age = 16;
        if (age > 18) {
            System.out.println("可以单独进入澡堂子了");
        }
        System.out.println("-----------------------------");

        int answer = (int)(Math.random()*10);
        if(answer>6){
            System.out.println("随机出来的数字大于6");
        }else if (answer>3){
            System.out.println("随机出来的数字大于3");
        }


        System.out.println("---main方法结束---");
    }
}

branch_06SwitchCaseDemo

package com.basic.day03.branch;

/**
 * if分支语句中，可以没有else语句块。
 *
 * 总结：
 *    1. 带有else语句块的分支结构，一定会执行某一条分支。
 *    2. 不带else语句块的分支结构，可能一条分支都不执行。
 *    3. if分支结构不可能执行多条分支。
 */
public class _05IfDemo {
    public static void main(String[] args) {
        //年满18岁，才可以单独进入澡堂子洗澡
        int age = 16;
        if (age > 18) {
            System.out.println("可以单独进入澡堂子了");
        }
        System.out.println("-----------------------------");

        int answer = (int)(Math.random()*10);
        if(answer>6){
            System.out.println("随机出来的数字大于6");
        }else if (answer>3){
            System.out.println("随机出来的数字大于3");
        }


        System.out.println("---main方法结束---");
    }
}