Java-day-03

package com.ly.java.Main03;

@SuppressWarnings("all")
/**
 * 关于Java中的数据类型：
 * 1、数据类型的作用是什么？
 * 程序当中有很多数据，每一个数据都是相关类型的，不同数据类型的数据占用空间大小不同。
 * 数据类型的作用随时知道JVM在运行程序的时候给该数据分配多大的内存空间
 * 2、Java中的数据类型包括两种：
 * * 基本数据类型
 * * 引用数据类型
 * 3、关于基本数据类型：
 * * 基本数据类型包括四大类八小种：
 * 第一类：整数型、byte,short,int,long
 * 第二类：浮点型、float,double
 * 第三类：布尔型、boolean
 * 第四类：字符型、char
 * 4、字符串”abc“不属于基本数据类型，属于引用数据类型，字符属于基本数据类型：
 * * 字符串使用双引号"abc"
 * * 字符使用单引号’a‘
 * 5、八种基本数据类型各自占用空间大小是多少？
 * 基本数据类型   占用空间大小
 * -----------------------------------------------------------
 *      byte        1
 *      short       2
 *      int         4
 *      long        8
 *      float       4
 *      double      8
 *      boolean     1
 *      char        2
 * 6、计算机在任何情况下都只能识别二进制。0 or 1 ： 断开 or 接通
 * 7、什么是二进制？
 *      * 数据的一种表现形式。十进制表示满十进一原则。二进制表示满二进一原则。
 * 8、字节(byte) ：
 *      1 Byte = 1024 bit【1哥字节 = 8个比特位】1个比特位表示一个二进制位：1/0
 *      1 KB = 1024 Byte
 *      1 MB = 1024 KB
 *      1 GB = 1024 MB
 *      1 TB = 1024 GB
 *      1 TB = 1024 * 1024 * 1024 * 1024 * 8
 * 9、整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个Byte
 *      * 关于Java当中的数字类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制位被称为符号位。并且这个符号位在所有二进制位的最左边，0表示正数，1表示负数。
 *      * byte类型最大值：01111111【10000000（2）- 1 】
 * 10、计算机只认识二进制，那么计算机怎么表示现实世界的文字的？
 *      * 八种数字类型数据当中，byte、short、int、long、float、double、boolean这7种数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和二进制之间“默认”情况下是不存在任何转换关系的。
 *      * 为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制定好"文字"和"二进制"之间的对照关系。这种对照关系被称为：字符编码。
 *      * 计算机最初只支持英文，最先出现的字符编码是ASXII码，当编码和节码的时候采用同一套/对照表，不会出现乱码。当时解码和编码的时候采用的不是同一套对照表，会出现乱码问题。
 *      * 随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO指定的，这种编码方式支持西欧语言，向上兼容ASCII吗，任然不支持中文。这种编码方是：ISO-8859-1，又被称为latin-1
 *      * 随着计算机得向亚洲发展，计算机开始支持中文，日文，韩文等国家文字，其中支持简体中文的编码方式：GB1212 < GBK < GB18030
 *      * 支持繁体中文：大五码 <big5>
 *      * 后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码，unicode编码方式有多种具体的实现：
 *          - UTF - 8
 *          - UTF - 16
 *          - UTF - 32
 *      * Java语言源代码采用unicode编码方式，所以“标识符”可以用中文。
 *      * 现在是实际开发中，一般使用UTF-8编码方式较多，
 * 11、八种基本数据类型的取值范围：
 *      类型                      取值范围
 *      -----------------------------------
 *      byte                    [-128 ` 127]
 *      short                   [-32768 ` 32767]
 *      int                     [-2147483648 ` 2147483647]
 *      long
 *      float
 *      double
 *      boolean                 [true , false]
 *      char                    [0 ` 65535]
 *      注意：shorthechar所表示的种类总数是一样的，只不过char可以表示更大的正整数，因为char没有负数
 *
 */

/**
 * 对于八种基本数据类型的默认值
 */

public class DataTypeTest01 {
    public static void main(String[] args) {
/**
 * 定义一个char类型的变量，起名c，同时赋值字符'a'
 */
        char c = 'a';
        System.out.println(c);
        /**
         * 一个中文占用2个字节，char类型正好是2个字节
         * 所有Java中的char类型可以存储一个中文字符
         */
        char x = '国';
        System.out.println(x);
        /**
         * "a" 是字符串类型
         * k变量是char类型
         * 类型不兼容，编译错误
         * char k = "a";
         */

    }
}

package com.ly.java.Main03;

/**
 * 关于八种基本数据类型的默认值
 * 数据类型                             默认值
 * ------------------------------------------
 * byte，short，int，long               0
 * float，double                        0.0
 * Boolean                             false
 * char                                \u0000
 */
@SuppressWarnings("all")
public class DataTypeTest02 {
    static int k = 1000;
    /**
     * 变量还是遵守这个语法，必须先声明，再赋值，才能访问。
     * 成员变量没有手动赋值系统会默认赋值【局部变量不会】
     */
    static int f;//成员变量

    public static void main(String[] args) {
        /*
        int i ;//局部变量
        System.out.println(i);
        */
        System.out.println(k);
        System.out.println(f);//0
    }
}

package com.ly.java.Main03;

/**
 * 关于Java语言当中的char类型：转义字符\
 * 转义字符出现在特殊字符之前，后将之变为字面意义上的普通字符
 * \n 换行符
 * \t 制表符
 * \' 普通的单引号
 * \\ 普通的反斜杠
 * \" 普通的双引号
 */
@SuppressWarnings("all")
public class DataTypeTest03 {
    public static void main(String[] args) {
        //普通的n字符
        char c1 = 'n';
        System.out.println(c1);
        /**
         * 属于char，作用为代表一个换行符
         * 反斜杠在Java语言当中具有转义功能。
         */
        char c2 = '\n';
        System.out.println(c2);

        char x = 't';
        System.out.println(x);
        /**
         * 在控制台上输出“反斜杠字符”
         */
        char k = '\'';
        System.out.println(k);
        /**
         * 负负得正
         * 第一个反斜杠具有转移功能，将后面的反斜杠转义为普通的反斜杠字符。
         * 结论：在Java当中两个反斜杠代表一个普通的反斜杠字符
         */
        char s = '\\';
        System.out.println(s);

        /**
         * 在控制台上输出一个普通的单引号字符
         * cahr a = '';//Java中不允许这样编写程序，编译报错
         * char a = ''';
         */
        /**
         * JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
         * 在命令行输入native2ascii，回车，然后输入文字之后回车就可以得到native2ascii编码
         *
         */
        char z = '中';
        System.out.println(z);
    }
}

package com.ly.java.Main03;

/**
 * 关于Java语言当中的整数型：
 * 数据类型                 占用空间大小             默认值             取值范围
 * ---------------------------------------------------------------------------------
 * byte                        1                      0                【-128 · 127】
 * short                       2                      0                【-32768 · 32767】
 * int                         4                      0                【-2147483648 · 2147483647】
 * long                        8                      0L
 * 1、Java语言当中的”整数型字面值“被默认当作int类型来处理。要让这个”整数型字面值“被当做long类型来处理的话，需要在”整数型字面值“后面添加1/L，建议使用大写的L
 * 2、Java语言当中的整数型字面值有三种表示方式：
 * 第一种方式：十进制【是一种缺省默认的方式】
 * 第二种方式：八进制【在白那些八进制整数型字面值的时候需要以0开始】
 * 第三种方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】
 */
@SuppressWarnings("all")
public class DataTypeTest04 {
    public static void main(String[] args) {
        int a = 10; // 十进制
        int b = 010; //八进制
        int c = 0x10;//十六进制
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(a + b + c);//34
        System.out.println("And:" + a+"/t"+ b + c);
        /**
         * 123这个整数型字面值时int类型
         * i变量声明的时候也是int类型
         * int类型的123赋值给int类型的变量i，不存在类型转换
         */
        int i = 123;
        System.out.println(i);
        /**
         * 456整数型字面值被当作int类型，占用4个字节
         * x变量在声明的时候是long类型，占用8个字节
         * int类型的字面值456赋值给long类型的bianlx，存在类型转换
         * int类型是小容量
         * long类型是大容量
         * 小容量可以自动转换成大容量，称为自动类型转换机制。
         */
        long x = 456;
        System.out.println(x);
        /**
         * 2147483647字面值是int类型，占用4个字节
         * y是long类型，占用8个字符，自动类型转换
         */
        long y = 2147483647;
        System.out.println(y);
        /**
         * 在Java语言当中，等号的右边的数字会被默认为int类型范围
         * 2147483648被当作int类型4个字节处理，但是这个字面值超出int类型范围
         * long z = 2147483648;
         * 解决以上问题只需要在数据后添加一个L
         * z是long类型变量，以下程序不存在类型转换
         */
        long z = 2147483648L;
        System.out.println(z);
    }
}

package com.ly.java.Main03;

@SuppressWarnings("all")
/**
 * 关于Java中的整数型
 * byte
 * shor
 * int
 * long
 */
public class DataTypeTest05 {
    public static void main(String[] args) {
        /**
         * 100L是long类型字面值
         * x是long类型变量
         * 不存在类型转换，直接赋值
         */
        long x = 100L;
        /**
         * x变量是long类型，8个字节
         * y变量是int类型，4ge字节
         * 大容量不能直接赋值给小容量
         * int y = x;
         */
        /**
         * 大容量转换还曾小容量，需要强制类型转换
         * 强制类型转换需要加强制类型转换符
         * 加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度。
         * 所以强制类型转换谨慎使用，应为损失精度之后可能损失很严重
         * 强制转换原理：
         *      原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
         *      强制转换之后的数据： 00000000 00000000 00000000 01100100
         *      将左边的二进制砍掉【所有的数据强制转换的时候都是这样完成的】
         */
        int y = (int) x;
        System.out.println(y);
        /**
         * 原始数据：00000000  00000000  00000000  10000000  00000000  00000000  00000000  00000000
         * 强制转换之后的数据：10000000  00000000  00000000  00000000
         * 10000000  00000000  00000000  00000000目前这个数据存储在计算机内部，计算机存储数据都是采用补码的形式存储在计算机当中
         * 所以10000000  00000000  00000000  00000000现在是一个补码形式
         * 将以上的补码转换到原码就是最终的结果
         */
        long k = 2147483648L;
        int e = (int) k;
        System.out.println(e);//损失精度非常严重，结果是负数
        /**
         * byte b = 50;是无法编译成功的；50是int类型的字面值，bshibyte的变量，显然是大容量转换成小容量byte
         * 大容量转换成小容量是需要添加强制类型转换符的，以下程序没有添加强转符号，所以编译报错
         */
        byte b = 50;

        byte c = 127;
        /**
         * byte b = 50;
         * byte c = 127;
         * 编译通过的原因，但是在实际编译的时候，以下代码编译通过了，这说明在Java语言当中，当一个整数型字面值没有超过byte类型取值范围的话，该字面值可以直接赋值给byte类型的变量
         * byte b1 = 128;
         * 编译报错：128这个int类型的字面值已经超出了byte类型的取值范围，不能直接赋值给byte类型的变量
         * 纠正错误，需要使用强制类型转换符
         * 但是一定会损失精度
         *
         */
        byte b1 = (byte) 128;//-128
        /**
         * 当一个证书字面值没有超出byte，short，char的取值范围，这个字面值可以直接赋值给byte，short，char类型的变量。这种机制sun允许了，目的就是为了方便程序员的编程。
         */
    }
}

package com.ly.java.Main03;

/**
 * 关于浮点型数据类型：
 * float单精度【4个字节】
 * double双精度【8个字节，精度较高】
 * <p>
 * double的精度太低【相对来说】，不适合做财务软件。
 * 财务设计到钱的问题，要求精度较高，所以SUN在基础SE类库当中为程序员准备了精确度更高的类型，它是：Java.math.BigDecimal
 * 其实Java程序中SUN提供了一套庞大 的类库，Java程序员是基于这套基础的类库进行开发的。所以要知道Java的Se类库的字节码在哪里，要知道Java的SE类库的源码在哪儿？
 * * SE类库字节码：
 * * SE类库源码
 * 例如：String.Java和String.class
 * 我们的(String[] args) 中的 String 使用的就是String.class字节码文件
 * 注意：double和float在计算机内部二进制存储的时候存储的都是近似值。
 * 在Java语言当中，所有的浮点型字面值【3.0】，默认被当作double类型来处理，想要该字面值当作float类型来处理，需要在字面值后面添加F/f
 */
@SuppressWarnings("all")
public class DataTypeTest06 {
    public static void main(String[] args) {
        /**
         * 3.0是double类型 的字面值
         * d是double类型的变量
         * 不存在类型转换
         */
        double d = 3.0;
        System.out.println(d);
        /**
         * 5.1是doubke类型的字面值
         * f是float类型的变量
         * 大容量转换成小容量需要强制类型转换符，所以以下编译错误。
         * float f = 5.4；
         * 解决方案：
         * 第一种方式：强制类型转换
         * float f = (float)5.4;
         * 第二种方式：没有类型转换
         */
        float f = 5.4f;
    }
}

package com.ly.java.Main03;

/**
 * 关于布尔型数据类型：
 * boolean
 * 在Java数据类型当中boolean类型自由两个值：true，false，没有别的值。
 * 不像C语言当中，0和1可以表示假和真。
 * 在底层存储的时候boolean类型占用1个字节，因为实际存储的时候false底层是0，true底层是1.
 * 布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。
 */
@SuppressWarnings("all")
public class DataTypeTest07 {
    public static void main(String[] args) {
        /**
         * boolean flag = 1;
         * 编译错误，不兼容的类型
         * boolean loginSuccess = true;
         */

        boolean loginSuccess = false;
        if (loginSuccess){
            System.out.println(0);
        }else {
            System.out.println(1);
        }
    }
}

package com.ly.java.Main03;

/**
 * 关于基本数据类型之间的互相转换：
 *      1、八种基本数据类型当中除布尔类型之外，剩下的7种类型之间都可可以互相转换
 *      2、小容量向大容量转换，称为自动类型转换，容量从大到小排序：
 *          byte < short < int < long < float < double < char <
 *          注：任何浮点型类型不管占用多少个字节，都比整数型容量大。
 *          char和short可表示的种类数量相同，但是char可以取更大的正整数
 *      3、大容量转换成小容量，必须加强制类型转换符，才能进行强制类型转换，程序才能编译通过，但是有可能还会损失精度
 *      4、当整数字面值没有超出byte，short，char的取值范围，额可以赋值给byte，short，char类型的变量。
 *      5、byte，short，char混合运算的时候，各种先转换成int类型再运算。
 *      6、多种数据类型混合运算，先转换成容量最大的那种类型再做运算。
 *      注意：
 *          byte b = 3;可以编译通过，3没有超出byte的取值范围
 *          int i = 10;
 *          byte b = i / 3;编译报错，编译器只检查语法，不会“运算”i / 3
 *          编译器只检查语法，在实际编译过程中不会运算，不要在编译器参杂运行
 */
@SuppressWarnings("all")
public class DataTypeTest08 {
    public static void main(String[] args) {

    }
}

package com.ly.java.Main03;

/**
 * 关于Java编辑器中运算符之：算术运算符
 * + - * / % -- ++
 * 注意：
 * 一个表达式当中，有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。
 * 没必要可以去记运算符的优先级
 */
@SuppressWarnings("all")
public class OperatorTest01 {
    public static void main(String[] args) {
        int i = 10;
        int j = 5;
        System.out.println(i + j);//15
        System.out.println(i / j);//2
        System.out.println(i * j);//50
        System.out.println(i - j);//5
        System.out.println(i % j);//0
        /**
         * 关于Java++运算符
         * ++运算符就是让变量加1，可以出现在变量的前面，++无论出现在变量前还是变量后
         * 只要++运算结束，该变量中的值一定会自加1
         */
        for (int k = 1; k < 10; k++) {
            for (int l = 10; l < 21; l++) {
                System.out.println(l);
            }
            System.out.println(k);
        }
    }
}

package com.ly.java.Main03;

/**
 * 关系运算符：
 * >   >=  <   <=  ==  !=
 * = 是赋值运算符
 * == 是关系运算符
 * 关系运算符的运算结果一定是布尔类型：true/false
 * 变量中保存的值之间的比较
 */
@SuppressWarnings("all")
public class OperatorTest02 {
    public static void main(String[] args) {

        int a = 10;
        int b = 10;

        System.out.println(a > b);
        System.out.println(a >= b);
        System.out.println(a < b);
        System.out.println(a <= b);
        System.out.println(a == b);
        System.out.println(a != b);


    }
}

package com.ly.java.Main03;

/**
 * 逻辑运算符：
 * &    |    !    ^      &&       ||
 * 与   或   非   异或    短路与    短路或
 * 1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型
 * 2、短路与和逻辑与的最终结果是相同的，只不过短路与存在短路现象。
 * 3、短路或和逻辑或的最终结果是相同的，只不过短路或存在短路现象。
 * 4、什么时候发生短路现象？
 * 5、什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？
 */
@SuppressWarnings("all")
public class OperatorTest03 {
    public static void main(String[] args) {
        System.out.println(5 > 3 & 5 > 2);
        System.out.println(5 > 3 & 5 > 6);
        System.out.println(5 > 3 | 5 > 6);

        System.out.println(true & true);
        System.out.println(true & false);
        System.out.println(true & true);
        System.out.println(true & false);

        System.out.println(true | false);
        System.out.println(true | false);

        System.out.println(!false);
        System.out.println(!true);

        System.out.println(true ^ false);
        System.out.println(false ^ true);

        /**
         * 逻辑与和短路与
         */
        int x = 10;
        int y = 8;
        System.out.println(x < y & ++x < y);
        System.out.println(x);
        /**
         * 由于&&前面的判定结果已经是false，所以后续都得执行程序就不会再执行了
         * x < y 结果是false，整个表达式结果已经确定是false，所以后面的表达式没有再执行，从某个角度看，短路与更智能。由于后面都得表达式可能不执行
         * 所以执行效率较高，这种方式在实际的开发中使用较多。短路与比逻辑与使用的多。短路与更常用。
         * 在某些特殊的业务逻辑当中，要求两边的算子必须全部执行，此时必须使用逻辑与，不能使用逻辑与，
         * 使用短路与可能导致右边的表达式不执行。
         */
        int x1 = 10;
        int y1 = 8;
        System.out.println(x1);
        System.out.println(x1 < y1 && ++x1 < y1);
    }
}