数据类型和运算符

ArithmeticOperators

// 算术运算符
public class ArithmeticOperatorsDemo {
    public static void main(String[] args) {
        char c = 'A';
        char i = (char) (c + 12);
        System.out.println(i);
        System.out.println("AAA" + 7 + 3); // AAA73
        // 算术异常: / by zero
        // System.out.println(1 / 0);
        System.out.println(1.0 / 0); // 等价于1/0.0:Infinity正无穷大
        System.out.println(0.0 / 0.0); // NaN:Not a Number
        double x = 0.0 / 0.0;
        System.out.println(x == x); // false
        // 需求:求出10除以3的余数,1
        System.out.println(10 % 3); // 取模
        System.out.println("=================================");
        // 自增操作
        int a = 10;
        a++;// ++在变量之后,后缀
        int b = 10;
        ++b;// ++在表里之前,前缀
        System.out.println(a);
        System.out.println(b);
        System.out.println("=================================");
        /**
         * 当int y1 = ++x1;
         *         ++前缀时:表示x1先递增1,此时--->x1==11
         *         再把11赋值给y1;
         */
        int x1 = 10;
        int y1 = ++x1;
        System.out.println("x1=" + x1); // 11
        System.out.println("y1=" + y1); // 11
        System.out.println("=================================");
        /**
         * 当int y2 = x2 ++;
         *             ++后缀时:表示x2先递增,此时x2 == 11
         *             但是,取出x2的原始值(10),再去做运算.
         */
        int x2 = 10;
        int y2 = x2++;
        System.out.println("x2=" + x2); // 11
        System.out.println("y2=" + y2); // 10

        int num2 = 1;
        num2 = num2++;
        System.out.println(num2);
    }
}

AssigningOperator

// 赋值运算符
public class AssigningOperatorDemo {
    public static void main(String[] args) {
        int age;
        age = 17; // 赋值运算符,从右往左运算
        //int age = 17;

        int x = 10;
        x += 5; // 等价于: x = x + 5;
        System.out.println(x);

        /**
         *错误: 不兼容的类型: 从int转换到short可能会有损失
         *             short s = 123;
         *             s = (short)(s + 10);
         */
        short s = 123;
        s += 10;
        System.out.println(s);
    }
}

BitOperator

// 二进制的位运算符
public class BitOperatorDemo {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        /**
         *             a:0b00000101
         *         &   b:0b00000011
         *         -------------------------
         *               0b00000001
         */
        System.out.println(a & b); // 1

        /**
         *             a:0b00000101
         *         |   b:0b00000011
         *         -------------------------
         *               0b00000111
         */
        System.out.println(a | b); // 7

        /**
         *            a:0b00000101
         *         ^  b:0b00000011
         *         -------------------------
         *              0b00000110
         */
        System.out.println(a ^ b); // 6
        /**
         *            a:0b00000101
         *         ~
         *         -------------------------
         *              0b11111010
         */
        System.out.println(~5); // -6
        // 操作负数: 得到原码-->反码-->补码-->操作
        System.out.println(~-5); // 4

        System.out.println("=========================");
        // 交换两个变量值练习
        int x = 10;
        int y = 20;
        System.out.println("x=" + x + ",y=" + y); // x=10,y=20
        // 操作
        /**
         *     int temp = x;
         *         x = y;
         *         y = temp;
         */
        // 作图
        x = x ^ y;
        y = x ^ y;
        x = x ^ y;
        System.out.println("x=" + x + ",y=" + y); // x=20,y=10
        System.out.println("=========================");
        int num = 2;
        /**
         *         2的二进制:
         *                 0b000_00010
         *                 0b00010_000
         *         -------------------------
         */
        System.out.println(num << 3); // 16
        /**
         *         0b00000010
         */
        // 操作负数:原码,反码,补码-->操作--->取反>取补
        System.out.println(-16 >> 3); // -2
    }
}

Boolean

// boolean数据类型
public class BooleanDemo {
    public static void main(String[] args) {
        /**
         *     boolean类型：通常用于逻辑运算和程序流程控制。
         *             该类型的值只能是true 或 false，表示真或假。
         *             不可以使用0或非0的整数来代替false和true，区分于C语言。
         *             （其实在JVM中对boolean的处理也是用0表示false，非0表示true的。）
         *             false和true是boolean的常量。
         */
        // boolean的常量
        System.out.println(true); // true
        System.out.println(false); // false
        // boolean的变量
        boolean isMan = true;
        System.out.println(isMan); // true
        isMan = false;
        System.out.println(false); // false
    }
}

Char

 // 字符符号类型(char)
public class CharDemo {
    public static void main(String[] args) {
        /**
         * char类型：表示16位的无符号整数或者Unicode字符，Java对字符采用Unicode字符编码。
         *          Unicode收集了世界上所有语言文字中的字符，是一种跨平台的编码方式，Java的字符占两个字节，可以表示一个汉字。
         *          什么是编码？
         *          计算机只能表示0和1两个数，于是人们做规定使用一个数字去表示一个特定的字符，比如a使用97表示。
         *          char前256个字符和ASCII（美国信息交互标准编码）码中的字符重复。
         *          ----------------------------------------------
         *          char常量有4种表示形式：
         *          ①　直接使用单个字符来指定字符常量，格式如'◆'、'A'，'7'；
         *          ②　直接作为整数类型使用，但是数据范围在[0，65535]，格式如97，但是打印出来的值依然是ASCII码表对于的符号,如97打印出来是字符a。
         *          ③　和2一样，只不过表示的是16进制的数值,.....
         *          所以有人说char本质上也是整型，也是有道理的。
         *          char前256个字符和ASCII（美国信息交互标准编码）码中的字符重复，可查表。
         */
        // char的常量表示
        // char的变量表示
        System.out.println('◆'); // ◆
        System.out.println('A'); // A
        System.out.println('7'); // 7

        char a = 97; // a
        System.out.println(a); // 输出65所对应位置的符号

        char aa = 'u0061';
        System.out.println(aa); // a

        char ma = '码';
        System.out.println(ma); // 码
    }
}

ComparisonOperato

// 比较运算符
public class ComparisonOperatorDemo {
    public static void main(String[] args) {
        System.out.println(5 == 5); // true
        System.out.println(5 == 4); // false
        System.out.println(110 != 119); // true
        System.out.println(18 > 17); // true
        System.out.println(17 < 18); // true
        System.out.println(17 >= 17); // true
        int a = 5;
        int b = 10;
        boolean ret = a > b;
        System.out.println(ret); // false
    }
}

Const

// 知识点：常量/字面量
public class ConstDemo {
    // main方法是程序的入口
    public static void main(String[] args) {
        // 系统的输出打印
        System.out.println("hello");
        System.out.println(3.14);
    }
}

Decimal

// 小数类型(float/double)
public class DecimalDemo {
    public static void main(String[] args) {
        /**
         * 小数的常量
         *          方式1:直接使用小数点表示:如3.14
         *          方式2:使用科学计数法: 3.14E2--->3.14 乘以  10 的 二次方
         *       小数的常量,默认是double类型.
         *       表示float类型: 在常量之后跟上F,或者f;
         */
        System.out.println(3.14);
        System.out.println(3.14E2);
        System.out.println("--------------------------");
        // 小数的变量
        float pi = 3.14F;
        System.out.println(pi);
        double  d = 123.456;
        // 注意:无论是float还是double类型,double不能精确的表示一个小数.
        // 在开发中,表示精确的数,比如金钱,在面向对象讲BigDecimal类来解决.
    }
}

int

/**
 * 当要表示的数据超出数据类型的临界范围时，称为溢出。
 * 溢出情况发生时程序并没有做数据范围检查处理，此时会出现数据紊乱情况。
 * int类型的范围:[-2147483648,2147483647]
 */
public class IntDemo {
    public static void main(String[] args) {
        int max = 2147483647;
        max = max + 1;
        System.out.println(max); // -2147483648
        /**
         * 原理:
         *              二进制:0b01111111_11111111_11111111_11111111
         *         +    二进制:0b00000000_00000000_00000000_00000001
         *         ------------------------------------------------------
         *                    0b10000000_00000000_00000000_00000000
         */

        int min = -2147483648;
        min = min - 1;
        System.out.println(min); // 2147483647
    }
}

Integer

// 整数类型(byte,short,int,long)
public class IntegerDemo {
    public static void main(String[] args) {
        /**
         * byte、short、int、long类型(仅仅是容量大小不一样而已)：
         *         整型常量的四种表示形式：
         *         ①　二进制整数：0B或0b开头（Java7的新特性），如：int a = 0B110;
         *         ②　八进制整数：要求以0开头，如 int a = 012;
         *         ③　十进制整数：如：int a = 17;
         *         ④　十六进制整数：要求0X或0x开头，如int a = 0x12;
         *         Java语言的整型常量默认是int型，声明long型变量后加上‘l’或‘L，因小写的l容易和数字1相混淆，建议使用大写L。
         *
         *         默认情况下,一个整型的字面量默认是int类型.
         */
        // 整数的常量表示:250
        System.out.println(250); // 十进制        // 250
        System.out.println(0b11111010); // 二进制 // 250
        System.out.println(0372); // 八进制       // 250
        System.out.println(0xFA); // 十六进制     // 250
        System.out.println("-----------------------------------");
        // 整数的变量表示: 数据类型 变量名 = 值;
        int day = 127;
        long id = 123L;
        System.out.println(day); // 127
        System.out.println(id); // 123
        // int有四个字节,有32位.
        /**
         * 250的二进制表示:
         *         0b00000000000000000000000011111010
         */
        int bin = 0b00000000_000000000_0000000_11111010;
        System.out.println(bin); // 250

        // Java7,运行数字之间使用_分割.
        System.out.println(1_2_3); // 123
    }
}

LogicalOperator

// 逻辑运算符
public class LogicalOperatorDemo {
    public static void main(String[] args) {
        // '&' 操作:都为true的时候,结果才为true.
        System.out.println(true & true); // true
        System.out.println(true & false); // false
        System.out.println(false & true); // false
        System.out.println(false & false); // false
        // System.out.println(false & (1/0==0)); // 报错,说明 (1/0==0)执行了,证明 & 不具有短路效果.
        // '&&' 操作:都为true的时候,结果才为true.
        System.out.println(true && true); // true
        System.out.println(true && false); // false
        System.out.println(false && true); // false
        System.out.println(false && false); // false
        // 没报错,说明(1/0==0)没有执行.  若左边操作数为false,右边操作数不执行.直接返还false.
        System.out.println(false && (1/0==0)); // false 
        System.out.println("-----------------------");
        // '|' :有一个为true,结果就是true.
        System.out.println(true | true); // true
        System.out.println(true | false); // true
        System.out.println(false | true); // true
        System.out.println(false | false); // false
        // '||' :有一个为true,结果就是true
        System.out.println(true || true); // true
        System.out.println(true || false); // true
        System.out.println(false || true); // true
        System.out.println(false || false); // false

        System.out.println(!!!!true); // true
    }
}

StepInVar

// 引出变量
public class StepInVarDemo {
    public static void main(String[] args) {
        // 第一种方法
        // 需求:接到客户的一个需求，求两个操作数6和3的和，差，积，商。
        System.out.println(6 / 3); // 2
        System.out.println(6 * 3); // 18
        System.out.println(6 - 3); // 3
        System.out.println(6 + 3); // 9
        System.out.println("------------------------------");
        // 用户需求改变:操作数变成了  8 和 4
        System.out.println(8 / 4); // 2
        System.out.println(8 * 4); // 32
        System.out.println(8 - 4); // 4
        System.out.println(8 + 4); // 12
        System.out.println("----------------------");
        // 第二种方法
        int x = 6;
        int y = 3;
        System.out.println(x + y); // 9
        System.out.println(x - y); // 3
        System.out.println(x * y); // 18
        System.out.println(x / y); // 2
        System.out.println("-----------------------------");
        x = 8;
        y = 4;
        System.out.println(x + y); // 12
        System.out.println(x - y); // 4
        System.out.println(x * y); // 32
        System.out.println(x / y); // 2
    }
}

String

// 最常用的的引用类型:String类
public class StringDemo {
    public static void main(String[] args) {
        // 表示名字:小明
        String username = "小明";
        System.out.println("名字:" + username); // 名字:小明

        int age= 17;
        System.out.println("年龄=" + age); // 年龄=17

        // 转义符号练习: 输出:  "你好师姐"
        System.out.println(""你好师姐"");

        System.out.println(8 + 7 + "Hello"); // 结果是15Hello
        System.out.println("Hello" + 7 + 8); // 结果是Hello78
        System.out.println(7 + "Hello" + 8); // 结果是7Hello8

        // int xx = "ABC"; // 错误: 不兼容的类型: String无法转换为int
    }
}

TernaryOperator

public class TernaryOperatorDemo {
    public static void main(String[] args) {
        // 现在给一个小数，需要求出其四舍五入之后的结果，怎么完成该功能？
        double num = 4.46;
        // 整数部分
        int iNum = (int)num; // 4
        // 小数部分
        double dNum = num - iNum; // 0.56
        int ret = dNum >= 0.5 ? iNum + 1 : iNum;
        System.out.println(ret);

        int x = 30;
        int y = 50;
        // 求出x,y的最大值;
        int max = x >= y ? x : y;
        System.out.println(max);
        int min = x <= y ? x : y;
        // 判断一个数是奇数或者偶数:陷阱
        // 判断奇偶数.直接判断除以2的余数是否为0.
        int num2 = -101;
        String ret2 =  num2 % 2 == 1 ? "奇数" : "偶数"; // 有问题
        System.out.println(ret2);
    }
}

TypeConvert

public class TypeConvertDemo {
    public static void main(String[] args) {
        // 自动类型转换
        byte b = 17;
        short s = b;
        int i = s;
        float f = i;
        double d = f;
        // byte b2 = d; // 错误: 不兼容的类型: 从double转换到byte可能会有损失
        System.out.println(d);
        // 需求:强制的把double类型的d转换为int类型
        int num = (int)d;
        System.out.println(num);

        int num2 = (int)3.1415926;
        System.out.println(num2); // 损失精度

        byte c = 5; // 内部,隐式转换
        System.out.println("------------------------------");
        double ret = 123 + 1.1F + 99L + 3.14;

        int n = 'A' +  1;
        System.out.println(n);

    }
}

Var

// 变量的分类/作用域/使用注意
public class VarDemo {
    static String name = "will"; // 成员变量：直接定义在类中
    public static void main(String[] args) {
        /**
         * 变量分类:(变量定义的位置不同而已)
         *         成员变量: 直接定义在类中的变量;
         *         局部变量: 变量除了成员变量,就是局部变量.
         */
        String name = "小明"; // 局部变量
        System.out.println(name); // 就近原则

        int    age = 17;
        System.out.println(age);
    }
}