01

package com.taidu.test.demo1;


/**
 * @Description 第一个类
 * @Date 2023/1/5 11:45
 * @Created by FanShiXiang
 */


import org.junit.Test;
import org.springframework.stereotype.Component;

/**
 * 这里的类名是Demo1，大小写敏感，class用来定义一个类，public表示这个类是公开的，
 * public、class都是Java的关键字，必须小写，Hello是类的名字，按照习惯，首字母H要大写。而花括号{}中间则是类的定义。
 */
public class Demo1 {

    /**
     * 方法
     * 可执行的代码块，一个方法除了方法名main，还有用（）括起来的方法参数，这里的main方法有一个参数,参数类型是 String[],参数名是args
     * public static 用来修饰方法，这里表示它是一个公开的静态方法，
     * void 是方法的返回类型
     * {}中间的就是方法的代码
     * 方法的代码每一行用；结束，这里只有一行代码
     *
     * @param args
     */
    public static void main(String[] args) {
        //代码块
        //System.out.println("hello!!!");
        /**
         * 在Java中，变量必须先定义后使用，在定义变量的时候，可以给他一个初始值
         */
        int x = 100;
        /**
         * 上述语句定义一个整型 int 类型的变量，
         * 名称为 x ，初始值为 100
         * 不写初始值，就相当于给他指定了默认值，默认值总为 0
         */
        System.out.println("100>>>>" + x);
        /**
         * 变量的一个重要特点是可以重新赋值，例如，对变量 x ，先赋值 100 在赋值 200
         * 观察两次打印的结果
         */
        x = 200;
        System.out.println("200>>>>" + x);
        /**
         * 注意到第一次定义变量 x 的时候，需要指定变量类型 int，因此使用语句 int x = 100;
         * 而第二次重新赋值的时候，变量 x 已经存在，不需要重复定义，因此不能指定变量类型 int,必须使用语句 x = 200
         */
        int n = x;
        System.out.println("n>>>>" + n);
        /**
         * 变量不但可以重新赋值，还可以赋值给其他变量
         * 注意，等号 = 是赋值语句，不是数学意义上的相等，否则无法解释 x = x + 100
         *
         */

        /**
         * 基本数据类型
         * 基本数据类型是CPU可以直接进行运算的类型。java定义了以下几种基本数据类型
         *
         * 整数类型：byte，short，int，long
         *
         * 浮点数类型：float，double
         *
         * 字符类型：char
         *
         * 布尔类型：boolean
         */


    }

    /**
     * java程序运行过程
     * java源码本质上是一个文本文件，我们需要先用javac把Demo1.java编译成字节码文件，然后，用Java命令执行这个字节码文件
     * <p>
     * Demo1.java      --- source code
     * |
     * Demo1.class     --- byte code
     * |
     * run on jvm
     */


    @Test
    public  void panDuan() {
        int i = 0; // 变量i从这里开始定义
        {
            int x = 1; // 变量x从这里开始定义
            {
                String s = "hello"; // 变量s从这里开始定义
                System.out.println(s);
            } // 变量s作用域到此结束
            // 注意，这是一个新的变量s，它和上面的变量同名，
            // 但是因为作用域不同，它们是两个不同的变量:
            String s = "hi";
            System.out.println(x);
        } // 变量x和s作用域到此结束
        System.out.println(i);
    } // 变量i作用域到此结束  定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名


    /**
     * Java的整数运算遵循四则运算规则，可以使用任意嵌套的小括号。四则运算规则和初等数学一致
     * 整数的数值表示不但是精确的，而且整数运算永远是精确的，即使是除法也是精确的，因为两个整数相除只能得到结果的整数部分
     */
    @Test
    public  void szys() {
        int i = (100 + 200) * (99 - 88); // 3300
        int n = 7 * (5 + (i - 9)); // 23072
        //特别注意：整数的除法对于除数为0时运行时将报错，但编译不会报错。
        //要特别注意，整数由于存在范围限制，如果计算结果超出了范围，就会产生溢出，而溢出不会出错，却会得到一个奇怪的结果：
        int x = 12345 / 67; // 184
        int y = 12345 % 67; // 12345÷67的余数是17
        System.out.println(i);
        System.out.println(n);
        System.out.println(x);
        System.out.println(y);
    }

    /**
     * 自增/自减
     * Java还提供了++运算和--运算，它们可以对一个整数进行加1和减1的操作
     * 注意++写在前面和后面计算结果是不同的，++n表示先加1再引用n，n++表示先引用n再加1。不建议把++运算混入到常规运算中，容易自己把自己搞懵了
     */
    @Test
    public  void zzzj() {
        int n = 3300;
        n++; // 3301, 相当于 n = n + 1;
        n--; // 3300, 相当于 n = n - 1;
        int y = 100 + (++n); // 不要这么写
        System.out.println(y);
    }

    /**
     * 浮点数运算和整数运算相比，只能进行加减乘除这些数值计算，不能做位运算和移位运算。
     * 在计算机中，浮点数虽然表示的范围大，但是，浮点数有个非常重要的特点，就是浮点数常常无法精确表示
     * 如果参与运算的两个数其中一个是整型，那么整型可以自动提升到浮点型
     * 由于浮点数存在运算误差，所以比较两个浮点数是否相等常常会出现错误的结果。正确的比较方法是判断两个浮点数之差的绝对值是否小于一个很小的数
     */
    @Test
    public  void fdys() {
        double x = 1.0 / 10;
        double y = 1 - 9.0 / 10;
        // 观察x和y是否相等:
        System.out.println(x);
        System.out.println(y);
        // 比较x和y是否相等，先计算其差的绝对值:
        double r = Math.abs(x - y);
        // 再判断绝对值是否足够小:
        if (r < 0.00001) {
            // 可以认为相等
        } else {
            // 不相等
        }
        int n = 5;
        double d = 1.2 + 24.0 / n; // 6.0
        System.out.println(d);
    }

    /**
     * 如果要进行四舍五入，可以对浮点数加上0.5再强制转型：
     */
    @Test
    public  void sswr() {
        double d = 2.6;
        int n = (int) (d + 0.5);
        System.out.println(n);
    }

    /**
     * 布尔运算是一种关系运算，包括以下几类
     * 比较运算符：>，>=，<，<=，==，!=
     * 与运算 &&
     * 或运算 ||
     * 非运算 !
     * <p>
     * 布尔运算的一个重要特点是短路运算。如果一个布尔运算的表达式能提前确定结果，则后续的计算不再执行，直接返回结果。
     * 因为 false && x 的结果总是 false，无论 x 是 true 还是 false，因此，与运算在确定第一个值为 false 后，不再继续计算，而是直接返回 false。
     * 类似的，对于||运算，只要能确定第一个值为true，后续计算也不再进行，而是直接返回true
     * boolean result = true || (5 / 0 > 0); // true
     * Java还提供一个三元运算符b ? x : y，它根据第一个布尔表达式的结果，分别返回后续两个表达式之一的计算结果
     */
    @Test
    public  void brys() {
        boolean isGreater = 5 > 3; // true
        int age = 12;
        boolean isZero = age == 0; // false
        boolean isNonZero = !isZero; // true
        boolean isAdult = age >= 18; // false
        boolean isTeenager = age > 6 && age < 18; // true
        int n = -100;
        int x = n >= 0 ? n : -n;
        System.out.println(x);
    }

    /**
     * 常见的转义字符包括：
     * \" 表示字符"
     * \' 表示字符'
     * \\ 表示字符\
     * \n 表示换行符
     * \r 表示回车符
     * \t 表示Tab
     */


    public static Integer add(Integer a) {
        a *= a + 1;
        return a;

    }


    /**
     * 判断引用类型相等
     * 在Java中，判断值类型的变量是否相等，可以使用==运算符。
     * 但是，判断引用类型的变量是否相等，==表示“引用是否相等”，或者说，是否指向同一个对象。
     * 例如，下面的两个String类型，它们的内容是相同的，但是，分别指向不同的对象，用==判断，结果为false：
     */
    @Test
    public  void pdyylxxd() {
        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        System.out.println(s1);
        System.out.println(s2);
        if (s1 == s2) {
            System.out.println("s1 == s2");
        } else {
            System.out.println("s1 != s2");
        }
    }
    /**
     * 要判断引用类型的变量内容是否相等，必须使用equals()方法
     */
    @Test
    public void pdEquals(){
        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        System.out.println(s1);
        System.out.println(s2);
        if (s1.equals(s2)) {
            System.out.println("s1 equals s2");
        } else {
            System.out.println("s1 not equals s2");
        }
    }

    /**
     * 除了if语句外，还有一种条件判断，是根据某个表达式的结果，分别去执行不同的分支。
     *
     * 例如，在游戏中，让用户选择选项：
     *
     * 单人模式
     * 多人模式
     * 退出游戏
     * 这时，switch语句就派上用场了。
     *
     * switch语句根据switch (表达式)计算的结果，跳转到匹配的case结果，然后继续执行后续语句，直到遇到break结束执行
     */
    @Test
    public  void switchMethod() {
        int option = 5;
        switch (option) {
            case 1:
                System.out.println("Selected 1");
                break;
            case 2:
                System.out.println("Selected 2");
                break;
            case 3:
                System.out.println("Selected 3");
                break;
            default:
                System.out.println("没有了");
                break;
        }
    }


    /**
     * while循环
     * 循环语句就是让计算机根据条件做循环计算，在条件满足时继续循环，条件不满足时退出循环。
     * while循环在每次循环开始前，首先判断条件是否成立。如果计算结果为true，就把循环体内的语句执行一遍，如果计算结果为false，那就直接跳到while循环的末尾，继续往下执行
     * 注意到while循环是先判断循环条件，再循环，因此，有可能一次循环都不做。
     * 对于循环条件判断，以及自增变量的处理，要特别注意边界条件。
     */
    @Test
    public void whlieMethod(){
        int sum = 0; // 累加的和，初始化为0
        int n = 1;
        while (n <= 100) { // 循环条件是n <= 100
            sum = sum + n; // 把n累加到sum中
            n ++; // n自身加1
        }
        System.out.println(sum); // 5050
    }
    /**
     * do while循环
     * while循环是先判断循环条件，再执行循环。而另一种do while循环则是先执行循环，再判断条件，条件满足时继续循环，条件不满足时退出
     */
    @Test
    public void doWhileMethod(){
        int sum = 0;
        int n = 1;
        do {
            sum = sum + n;
            n ++;
        } while (n <= 100);
        System.out.println(sum);
    }

    /**
     * break
     * 在循环过程中，可以使用break语句跳出当前循环
     * break语句通常都是配合if语句使用。要特别注意，break语句总是跳出自己所在的那一层循环
     */
    public void breakMethod(){
        int sum = 0;
        for (int i=1; ; i++) {
            sum = sum + i;
            if (i == 100) {
                break;
            }
        }
        System.out.println(sum);
    }

    /**
     * continue
     * break会跳出当前循环，也就是整个循环都不会执行了。而continue则是提前结束本次循环，直接继续执行下次循环
     * break语句可以跳出当前循环；
     * break语句通常配合if，在满足条件时提前结束整个循环；
     * break语句总是跳出最近的一层循环；
     * continue语句可以提前结束本次循环；
     * continue语句通常配合if，在满足条件时提前结束本次循环
     */
    @Test
    public void continueMethod(){
        int sum = 0;
        for (int i=1; i<=10; i++) {
            System.out.println("begin i = " + i);
            if (i % 2 == 0) {
                continue; // continue语句会结束本次循环
            }
            sum = sum + i;
            System.out.println("end i = " + i);
        }
        System.out.println(sum); // 25
    }



}