二、第二章——标识符、关键字、变量、数据类型、运算符

1 标识符

关于java语言当中的标识符
    1、什么是标识符？
        - 在java源程序当中凡是程序员有权利自己命名的单词都是标识符。
        - 标识符在EditPlus编辑器当中以黑色高亮显示 【不同编辑器中显示的可能不一样】
        - 标识符可以标识什么元素呢？
            * 类名
            * 方法名
            * 变量名
            * 接口名
            * 常量名
            
    2、标识符的命名规则？【不按照这个规则来，编译器会报错，这是语法】
        * 标识符只能由数字、字母、下划线、美元符号组成，不能含有其他特殊符号
        * 不能以数字开头
        * 严格区分大小写
        * 关键字不能做标识符
        * 理论上无长度限制，但最好不要太长
        
    3、标识符的命名规范？【只是一种规范，不属于语法，不遵守规范编译器不会报错】
        * 最好见名知意
            public class UserService{
                public void login(String username, String password){    
                }
            }
        * 遵守驼峰命名方式
            SystemService
            UserService
            CustomerService
        * 类名、接口名：首字母大写，后面每个单词首字母大写。
        * 变量名、方法名：首字母小写，后面每个单词首字母大写。
        * 常量名：全部字母大写

 

2 关键字

在Java中关键字都是小写的
        public 
        class
        static
        void
        if
        for
        while
        do
        default
        byte
        short
        int
        long
        float
        double
        boolean
        char
        private
        protected
        switch
        true
        false
        throw
        throws
        try
        catch
        ...

 

3、字面值

* 值：
    - 10、100
    - 3.14
    - "abc"
    - 'a'
    - true、false
    
* 字面值就是数据
​
* 字面值是java源程序的组成部分之一。包括标识符和关键字都是java源程序的组成部分。
​
* 数据在现实世界当中是分门别类的，所以数据在计算机编程当中也是有类型的：【数据类型】
    - 10、100        属于整数型字面值
    - 3.14          属于浮点型字面值
    - true、false    属于布尔型字面值
    - "abc"         属于字符串型字面值
    - 'A'、'人'       属于字符型字面值
    
* 注意
    java语言当中所有的字符串型字面值必须使用双引号括起来，双引号是半角
    java语言当中所有的字符型字面值必须使用单引号括起来，单引号是半角
​
​
public class ConstTest01
{
    public static void main(String[] args){
        System.out.println("abc");
        System.out.println(false);
        System.out.println(3.14);
        System.out.println('A');
        System.out.println(100);
        //编译错误，单引号中只能放单个字符
        System.out.println('abc')
    }
}

 

4、变量

1、什么是变量？
    * 变量本质上来说是内存中的一块空间，这块空间有“数据类型”、“有名字”、“有字面值”。
    * 变量包含三部分：数据类型、名称、字面值【数据】
    * 变量是内存中存储数据的最基本的单元。
    
2、数据类型的作用？
    * 不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间。
    * 数据类型是指导程序在运行阶段应该分配多大的内存空间
    
3、变量要求：变量中存储的具体的“数据”必须和变量的“数据类型”一致，当不一致时会编译报错
​
4、声明/定义变量的语法格式：
    数据类型 变量名;   
        * 数据类型：目前我们还没有学习数据类型，但是提前告诉大家有一种数据类型是整数型，叫做int
        * 变量名：
            只要是合法的标识符就行。规范中要求：首字母小写，后面的每个单词的首字母大写。
        * 例如：
            int i;
            int age;
            int num;
            其中int是数据类型，i,age,num都是变量名。
            
5、变量声明之后怎么赋值？
    语法格式：
        变量名 = 字面值;
        要求：字面值的数据类型必须和变量的数据类型一致。
        = 是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋值给左边的变量。
        
6、声明和赋值可以放到一起完成。
    int i = 10;
​
7、变量赋值之后，重新赋值，变量的值可变化：
    int i = 10;
    System.out.println(i);  //10
    i = 100;
    System.out.println(i);  //100
​
8、有了变量的概念之后，内存空间得到了重复的使用：
    int i = 10;
    System.out.println(i);
    ...
    ...
    System.out.println(i);
​
9、通常访问一个变量包括两种访问形式：
    * 第一种：读取变量中保存的具体数据 get/获取
    * 第二种：修改变量中保存的具体数据 set/设置
    i = 20; //set
    System.out.println(i); //get
    
10、变量在一行上可以声明多个
    int a,b,c;
​
11、java中的变量必须先声明，再赋值，才能访问。
    int i; 程序执行到这里，内存空间并没有开辟出来，变量i并没有初始化。所以没有赋值之前不无法访问的
​
​
public class VarTest01
{
    public static void main(String[] args){
        //声明一个int类型的变量，起名i
        int i;
        //编译报错：变量i并没有初始化
        // System.out.println(i);
​
        //给i变量赋值，i变量在这里完成初始化，内存开辟
        i = 100;
        System.out.println(i);
​
        //i再次重新赋值
        i = 200;
        System.out.println(i);
​
        //一行上可以同时声明多个变量
        //a和b尚未初始化，c赋值300
        int a,b,c = 300;
        //编译错误
        //System.out.println(a);
        //编译错误
        // System.out.println(b);
        System.out.println(c);
        a = 0;
        b = 1;
        System.out.println(a);
        System.out.println(b);
​
    }
}
​

/*
    关于java语言当中的变量：
        1.在方法体当中的java代码， 遵守自上而下的顺序依次执行的。逐行执行。
        2.在同一个“作用域”当中，变量名不能重名，但是变量可以重新赋值。
*/
​
pulic class VarTest02
{
    public static void main(String[] args){
        int i = 100;
        System.out.println(i);
        i = 200
        System.out.println(i);
        
        //以下代码在编译时有错误，先声明然后复制再访问
        /*
        System.out.println(k);
        int k = 100;
        */
    }
}
​

/*
    关于变量的分类：
        根据变量声明的位置分类：
            * 局部变量
                - 在方法体当中声明的变量叫做局部变量
            * 成员变量
                - 在方法体外【类体之内】声明的变量叫做成员变量
​
    在不同的作用域当中，变量名是可以相同的。
    在同一个作用域当中，变量名是不可以重名的。
*/
​
public class VarTest04
{
    public static void main(String[] args){
        //i变量就是局部变量 
        int i = 10;
​
        //java遵循“就近原则”
        System.out.println(i);
    }
​
    //成员变量
    int i = 100;  //声明变量
​
    //类体中不能直接编写java语句【除声明变量之外】
    //System.out.println(i);
​
    //doSome方法
    public static void doSome(){
        //局部变量
        int i = 90;
    }
}

 

5、数据类型

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、计算机在任何情况下都只能识别二进行。例如：只认识10001010010...
    【现代的计算机底层采用交流电的方式，接通和断开就两种状态，计算机只识别和0，其它不认识】
​
7、什么是二进行？
    * 数据的一种表示形式。十进行表示满十进一原则。二进行表示满二进一原则。
    例如：十进行
        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
    例如：二进行
        0 1 10 11 100 101 110 111 1000 1001 ...
        0 1 2   3   4   5   6   7   8   9
​
8、字节(byte)：
    1 byte = 8 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 (bit);
​
9、整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个比特位。那么byte类型的取值范围是什么？
    * 关于java中数字类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制位被称为“符号位”。并且这个“符号位”在所有二进制位的最左边，0表示正数，1表示负数。
    * byte类型最大值：01111111 【10000000(二进制) - 1】
    * byte最大值：2的7次方 - 1，结果是：127
    * byte类型最小值：-128【具体的怎么用二进制表示，这个和原码、反码、补码有头】
    * byte类型取值范围：[-128 ~ 127]
    * byte类型可以表示256个不同的数字【256个不同的二进制】
​
10、二进制和十进制之间的转换规则：
    * 二进制转换成十进制
    * 十进制转换成二进制
​
11、计算机只认识二进制，那么计算机是怎么表示现实世界当中的文字的呢？
    * 八种基本数据类型当中，byte,short,int,long,float,double,boolean这7种数据类型计算机在表示的时候比较容易，因为底层都是数字，十/八/十六进制的数字和二进制之间存在一种固定的转换规则。
    * 但是八种基本数据类型当中char类型表示的是现实世界中的文字，文字和计算机二进制之间默念情况下是不存在任何转换关系的。
    * 为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制定好 “文字” 和 “二进行” 之间的对照关系。这种对照关系被称为：字符编码。
    * 计算机最初只支持英文，最先出现的字符编码是：ASCII码 【采用一个字节编码】
        'a' --> 97  【01100001】
        'A' --> 65
        '0' --> 48
        'a' --(编码)--> 01100001  
        01100001 --(解码)--> 'a'
        编码和解码的时候采用同一套字典/对照表，不会出现乱码。
        当解码和编码的时候采用的不是同一套对照表，会出现乱码问题
    * 随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，这种编码方式支持西欧语言，向上兼容ASCII码，仍然不支持中文。这种编码方式是：ISO-8859-1，又被称为latin-1
    * 随着计算机向亚洲发展，计算机开始支持中文、日文、韩文等国家文字，其中支持简体中文的编码方式：
        GB2312 < GBK < GB18030
    * 支持繁体中文：大五码 <big5>
    * 后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码，unicode编码方式有多种具体的实现：
        - UTF-8
        - UTF-16
- UTF-32
    ...
* java语言采用的是哪一种编码方式呢？
- java语言源代码采用的是unicode编码方式，所以“标识符”可以写中文，也可以写各种语言
* 现在在实际开发中，一般使用UTF-8编码方式较多。
​
12、八种基本数据类型的取值范围：
类型取值范围
---------------------------------
byte    [-128~127]
short    [-32768~32767]
int    [-2147483648~2147483647]
long
float
double
boolean    [true, false]
char    [0 ~ 65535]
注意：short和char所表示的种类总数是一样的，只不过char能表示更大的正整数。因为char没有符号位，也就没有负数。
​
13、以下java程序主要讲解的是数据类型之：char类型
public class DataTypeTest01
{
public static void main(String[] args){
//定义一个char类型的变量，起名c，同时赋值字符'a'
char c = 'a';
System.out.println(c);
​
char x = '国';
System.out.println(x);
​
//编译错误
//ab是字符串不能使用单引号括起来
//char y = 'ab';
​
//"a"是字符串类型
//k变量是char类型
//类型不兼容，编译错误
// char k = "a";
​
//声明
char e;
​
//赋值
e = 'e'
​
//再次赋值
e = 'f';
System.out.println(e);
    }
}
​
​
14、关于八种基本数据类型的默认值
数据类型 默认值
---------------------------------
byte,short,int,long 0
float,double 0.0
boolean false  【true是0，false是0】
char \u0000
八种基本数据类型的默认值是一切向0看齐

public class DataTypeTest02
{
// 这里的static必须加
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
    }
}
​
​
ps:
java源代码在编译的时候如果出现乱码，可以这样编译：
javac -encoding=UTF-8 xxx.java

 

 

5.1 数据类型char

public class DataTypeTest01
{
    public static void main(String[] args){
        //定义一个char类型的变量，起名c，同时赋值字符'a'
        char c = 'a';
        System.out.println(c);
​
        char x = '国';
        System.out.println(x);
​
        //编译错误
        //ab是字符串不能使用单引号括起来
        //char y = 'ab';
​
        //"a"是字符串类型
        //k变量是char类型
        //类型不兼容，编译错误
        // char k = "a";
​
        //声明
        char e;
​
        //赋值
        e = 'e'
​
        //再次赋值
        e = 'f';
        System.out.println(e);
    }
}
​
​
ps:
java源代码在编译的时候如果出现乱码，可以这样编译：
    javac -encoding UTF-8 xxx.java

 

5.2 java语言当中的char类型

/*
    关于java语言当中的char类型:
        转义字符 \ 【反斜杠】
    转义字符出现在特殊字符之前，会将特殊字符转换成普通字符。
​
    \n  换行符
    \t  制表符
    \'  普通的单引号
    \\  普通的反斜杠
    \"  普通的双引号
*/
    
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("hello");
        System.out.println("world");
        */
​
        //System.out.printn()和System.out.print()区别：println输出之后换行，print表示输出但不换行
​
        /*
        System.out.print("Hello");
        System.out.println("world");
        */
​
        //普通的t字符
        char x = 't';
        System.out.println(x);
​
        //制表符tab键
        //强调：制表符和空格不同，他们的ASCII不一样，体现在键盘上两个不同的按键
        char y = '\t';
        System.out.print("A");
        System.out.print(y);
        System.out.println("B");
​
        //要求在控制台上输出“反斜杠字符”
        //反斜杠将后面的单引号转义成不具备特殊含义的普通单引号字符，左边的单引号少了结束的单引号字符，编译报错
        /*
        char k = '\';
        Systemout.println(k);
        */
​
        /*
            解释：第一个反斜杠具有转义功能将后面的反斜杠转义成普通反斜杠字符。
            结论：在java当中两个反斜杠代表一个普通的字符
        */
        char k = '\\';
        System.out.println(k);
​
        //在控制台上输出一个普通的单引号字符
        //char a = '';  //java中不允许这样编写程序，编译报错
        //以下编译报错：第一个单引号和第二个单引号配对，最后的单引号找不到另一来了
        //char a = ''';
        //反斜杠具有转义功能，将每二个单引号转义成普通的单引号字符，第一个单引号和最后一个单引号配对。
        char a = '\'';
        System.out.println(a);
        char f = '"';
        System.out.println(f);
        System.out.println("HelloWorld");
        System.out.println("“HelloWorld!”");
        //编译错误
        //System.out.println(""HelloWorld!"");
        //纠正
        System.out.println("\"HelloWorld!\"");
​
        char m = '中';
        System.out.println(m);
​
        //JDK中自带的native2ascii.exe命令，可以将文件转换成unicode编码形式
        char n = '\u4e2d';  //‘中’对应的unicode编码是：4e2d
        System.out.println(n);
        //编译错误
        //char g = '4e2d';
        //编译错误
        //char g = 'u4e2d';
        //通过：反斜杠u联合起来后面的一串数字是某个文字的unicode编码
        char g = '\u4e2d';
        System.out.println(g);
​
        //char类型的默认值
        char c = '\u0000'; 
​
    }
}
​
​
/*
    十进制：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 
    二进制：0 1 10 11 100 101
    十六进制：0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12
    八进制：0 1 2 3 4 5 6 7 10 11 12 13 14
*/

 

5.3 数据类型整数型

/*
    关于java语言当中的整数型：
        数据类型                    占用空间大小       默认值            取值范围
        -----------------------------------------------------------------
        byte                        1               0           [-128~127]
        short                       2               0           [-32768~32767]
        int                         4               0           [-2147483648~2147483647]
        long                        8               0L
​
1、java语言当中的“整数型字面值”被默认当做int类型来处理。要让这个“整数型字面值”被long类型来处理的话，需要在“整数型字面值”后面添加l/L，建议使用大写的L   
​
2、java语言当中的整数类型字面值有三种表示方式：
    第一种方式：十进制 【是一种缺省默认的方式】
    第二种方式：八进制 【在编写八进制字面值的时候需要以0开始
    第三种方式：十六进制 【在编写十六进制整数型字面值的时候需要以0x开始】
*/
​
public class DataTypeTest04
{
    public static void main(String[] args){
        int a = 10;
        int b = 010;  //整数型字面值以0开头的，后面那一串数字就是八进制形式
        int c = 0x10;  //整数型字面值以0x开头的，后面那一串数字就是十六进制形式
​
        System.out.println(a);  //10
        System.out.println(b);  //8
        System.out.println(c);  //16
​
        System.out.println(a + 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类型的变量值x，存在类型转换
        //int类型转换在long类型
        //int类型是小容量
        //long类型是大容量
        //小容量可以自动转换成大容量，称为自动类型转换机制。
        long x = 456;
        System.out.println(x);
​
        //2147483647字面值是int类型，占用4个字节
        //y是long类型，占用8个字节，自动类型转换
        long y = 2147483647;
        System.out.println(y);
​
        //编译错误：过大的整数：2147483648
        //2147483648被当做int类型4个字节处理，但是这个字面值超出int类型范围
        // long z = 2147483648;
        //解决错误
        //2147483648字面值一上来就当做long类型来处理，在字面值后面添加L
        //2147483648L是8个字节的long类型，以下程序不存在类型转换
        long z = 2147483648L;
        System.out.println(z);
​
    }
}

 

5.4 数据类型精度损失

/*
    关于java中的整数型
        byte
        short
        int
        long    
*/
​
public class DataTypeTest05
{
    public static void main(String[] args){
        //100L是long类型字面值
        //x是long类型变量
        //不存在类型转换，直接赋值
        long x = 100L;
​
        //x变量是long类型，8个字节
        //y变量是int类型，4个字节
        //以下程序可以编译通过吗？
        //编译报错，大容量不能直接赋值给小容量
        // 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 00000000 10000000 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);  //损失精度严重，结果是负数
​
        //分析以下程序是否可以编译通过？
        //依据目前所党内容，以下程序是无法编译通过的
        //理由：50是int类型的字面值，b是byte类型的变量，显然是大容量int转换成小容量byte
        //大容量转换成小容量是需要添加强制类型转换符的，以下程序没有添加强制符号，所以编译报错。
        //但是，在实际编译的时候，以下代码编译通过了，这说明：在java语法当中，当一个整数型字面值没有超出byte类型取值范围的话，该字面值可以直接赋给byte类型的变量
        byte b = 50;  //可以
        byte c = 127;  //可以
        //编译报错，128这个int类型的字面值已经超出了byte类型的取值范围地，不能直接赋值给byte类型的变量
        // byte b1 = 128;  
​
        //纠正错误，需要使用强制类型转换
        //但是一定会损失精度
        //原始数据：00000000 00000000 00000000 10000000
        //强转之后：10000000 【这是存储在计算机内部的，这是一个补码，它的原码是什么？】
        byte b1 = (byte)128;  //-128
        System.out.println(b1);
​
        /*
            计算机二进制有三种表示形式：
                原码
                反码
                补码
            计算机在任何情况下底层表示存储数据的时候采用了补码形式
            正数的补码：和原码相同
            负数的补码：负数的绝对值对应的二进制码所有二进制位取反，再加1
            补码：10000000
            原码计算过程：
                * 10000000 - 1 --> 01111111
                * 10000000 --> 128
        */
​
        //原始数据：00000000 00000000 00000000 11000110
        //强制类型转换之后：11000110
        //11000110现在在计算机当中存储，它是一个补码，将补码转换成原码就是该数据
        //11000110 - 1 --> 11000101
        //取反：00111010 【2 + 8 + 16 + 32】 --> 58
        byte m = (byte)198;
        System.out.println(m);  //-58
​
        // short s = 32767;  //通过
        // short s1 = 32768;  //编译报错
​
        //65535是int类型，4个，
        //cc是char类型，2个字节
        //按照以前所学知识点来说，以下程序是编译报错的。
        char cc = 65535;  //通过
        cc = 65536;  //编译报错
​
        /*
            当一个整数字面值没有超出byte,short,char的取值范围，这个字面值可以直接赋值给byte,short,char类型的变量。
            这种机制SUN允许了，目的是为了方便程序员的编程。
        */
​
​
​
    }
}

 

5.5 数据类型-浮点型

/*
    关于浮点型数据类型：
        float 单精度 【4个字节】
        double 双精度 【8个字节，精度较高、  
​
    double的精度太低 【相对来说的】，不适合做财务软件。
    财务涉及到钱的问题，要求精度较高，所以SUN在基础SE类库当中为程序员准备了精确度更高的类型，只不过各种类型是一种引用数据类型，不属于基本妖魔鬼怪类型，它是：java.math.BigDecimal
    其实java程序中SUN提供了一套庞大的类库，java程序员是基于这套基础的类库来进行开发的。所以要知道java的SE类库的源码在哪儿？
        * SE类库字节码: ...\Java\jdk.x.x.x\jre\lib\rt.jar
        * SE类库源码：...\Java\jdk.x.x.x\src.zip
​
    例如：String.java和String.class
    我们的(String[] args)中的String使用的就是String.class字节码文件
​
    在java语言当中，所有的浮点型字面值，默认被当做double类型来处理，
    要想该字面值当做float类型来处理，需要在字面值后面添加F/f
​
    注意：
        double和float在计算机内部二进行存储的进修存储的都是近似值。
        在现实世界当中有上引起数字是无限循环的，例如：3.3333333333....
        计算机的资源是有限的，用有限的资源存储无限的数据只能存储近似值
​
*/
​
public class DataTypeTest06
{
    public static void main(String[] args){
        //3.0是double类型的字面值
        //d是double类型的变量
        //不存在类型转换
        double d = 3.0;
        System.out.println(d);
​
        //5.1是double类型的字面值
        //f是float类型的变量
        //大容量转换成小容量需要加强制转换符，所以以下程序编译会报错
        //float f = 5.1;
​
        //解决方案
        //第一种方式：强制类型转换
        float f = (float)5.1;
​
        //第二种方式：没有类型转换
        float f = 5.1f;
    }
}

 

5.6 数据类型-布尔型

/*
    关于布尔型数据类型：
        boolean
​
    在java语言当中boolean类型只有两个值：true,false，没有其他值。
    不像c语言当中，0和1可以表示假和真。
​
    在底层存储的时候boolean类型占用1个字节，因为实际存储false底层是0，true底层是1。
​
    布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。
*/
​
public class DataTypeTest07
{
    public static void main(String[] args){
        //编译错误：不兼容的类型
        //boolean flag = 1;
​
        boolean loginSuccess = true;
        //if语句以后讲 【条件控制语句】
        if(loginSuccess){
            System.out.println("恭喜你，登录成功");
        }else{
            System.out.println("对不起，用户名不存在或者密码错误");
        }
​
​
    }
}

 

5.7 数据类型-类型转换

/*
    关于基本数据类型之间的互相转换：转换规则
        * 八种基本数据类型当中除了布尔类型之外剩下的7种类型之间都可以互相转换
        * 小容量向大容量转换，称为自动类型转换，容量从小到大排序
            byte < short < int < long < float < double
                    char <
            注：
                任何浮点类型不管占用个字节，都比整数型容量大。
                char和short可表示的种类数量相同，但是char可以取更大的正整数
                char c = 97;
        * 大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以要谨慎使用
        * 当整数字面值没有超出byte,short,char的取值范围，可以直接赋值给byte,short,char类型的变量
        * byte,short,char混合运行的时候，各自先转换成int类型再做运算
        * 多种数据类型混合运算，先转换成容量最大的那种类型再做运算
​
        注意：         
            byte b = 3;  可以编译通过，3没有超出byte类型取值范围
​
            int i = 10;
            byte b = i / 3;  编译报错，编译器只检查语法，不会“运算” i / 3
​
            分析代码的时候要把“编译期”和“运行期”分开考虑
*/
​
public class DataTypeTest08
{
    public static void main(String[] args){
        //出现错误，1000超出了byte的范围
        //byte a = 1000;
​
        //正确，因为20没有超出byte范围
        //所以赋值
        byte a = 20;
​
        //变量不能重名
        //short a = 1000;
​
        //正确，因为数值1000没有超出short类型的范围
        //所以赋值正确
        short b = 1000;
​
        //正确，因为默认就是int，并且没有超出int范围
        int c = 1000;
​
        //正确，可以自动转换
        long d = c;
​
        //错误，出现精度丢失问题，大类型-->小类型会出现问题
        // int e = d;
​
        //将long强制转换成int顾炎武
        //因为值1000，没有超出int范围，所以是正确的
        int e = (int)d;
​
        //因为java中的运算会转成最大类型
        //而10和3默认为int，所以运算后的最大类型也是int
        //所以是正确的
        int f = 10/3;  //3
​
        //声明10为long类型
        long g = 10;
​
        //出现错误，多个数值在运算过程中，会转换成容量最大的类型
        //以下示例最大的类型为double，而h为int，所以就会出现大类型(long)到小类型(int)的转换，将会出现精度丢失问题
        //int h = g/3;
        //可以强制转换，先把g转换成int类型，因为运算结果没有超出int范围
        //int h = (int)g/3;
        //可以采用long类型来接收运算结果
        //long h = g/3;
​
        //出现精度损失问题，以下问题主要是优先级的问题
        //将g转换成int，然后又将int类型g转换成byte，最后byte类型的g和3运算，那么它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题
        //byte h = (byte)(int)g/3;  //javac 编译期间只检测语法不进行运算
​
        //正确
        //byte h = (byte)(int)(g/3);
​
        //不能转换，还有因为优先级的问题
        byte h = (byte)g/3;
​
        //可以转换，因为运算结果没有超出byte范围
        byte h = (byte)(g/3);
​
        //可以转换，因为运算结果没有超出short范围
        short h = (short)(g/3);
        short i = 10;
        byte j = 5;
        //错误，short和byte运算，首先会各自转换成int再运算
        //所以运算结果为int，int赋值给short就会出现精度丢失问题
        //short k = i + j
        //可以将运算结果强制转换成short
        //short k = (short)(i + j);
        //因为运算结果为int，所以可以采用int类型接收
        int k = i + j;
​
        char l = 'a';
        //输出结果为a
        System.out.println(l);
​
        //输出结果为97，也就是a的ascii值
        System.out.println((byte)l);
        int m = 1 + 100;
        //输出结果为197，取得a的ascii码值，然后与100进行相加运算
        System.out.println(m);
​
        //它的原理是先算出3，再反3转换成3.0
        double dd = 10 / 3;  
        System.out.println(dd);  //3.0
​
        //它的原理是先把3变成3.0，然后10.0除以3.0算了最后的结果
        dd = 10.0 / 3;
        System.out.println(dd);  //3.3333333333333335
    }
}

6 运算符

* 算术运算符
* 关系运算符
* 逻辑运算符
* 赋值类运算符
* 字符串连接运算符
* 三元运算符

 

6.1 算术运算符

/*
    关于java编程中运算符之：算术运算符
        +       求和
        -       相减
        *       乘积
        /       商
        %       求余数 【取模】
        ++      自加1
        --      处减1
​
    注意：
        一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升
        没有必要支专门记忆运算符的优先级。
​
    ps:
        sublime_text文本编辑器中的快捷键
            复制当前行到下一行是：ctrl+shift+d
            删除当前行：ctrl+shift+k
*/
​
public class OperatorTest01
{
    public static void main(String[] args){
        int i = 10;
        int j = 3;
        System.out.println(i + j);
        System.out.println(i - j);
        System.out.println(i * j);
        System.out.println(i / j);
        System.out.println(i % j);
​
        //以下以++为例，--运算符自学！
        //关于++运算符 【自加1】
        int k = 10;
​
        //++运算符可以出现在变量后面【单目运算符】
        k++;
        System.out.println(k);  //11
​
        int y = 10;
        //++运算符可以出现在变量的前面 【单目运算符】
        ++ y;
        System.out.println(y);  //11
​
        //小结：
        //++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后
        //只要++运算符结束，该变量中的值一定会自加1
​
        //++ 出现在变量后
        //规则：先进行赋值运算，再对变量中保存的值进行自加1
        int a = 10;
        int b = a ++;
        System.out.println(a);  //101
        System.out.println(b);  //100
​
        //++ 出现在变量前
        //规则：先进行自加1运算，然后再进行赋值操作。
        int m = 20;
        int n = ++ m;
        System.out.println(m);  //21
        System.out.println(n);  //21
​
        int xx = 500;
        System.out.println(xx);
​
        int e = 100;
        System.out.println(e ++);  //100
        System.out.println(e);  //101
​
        int s = 100;
        System.out.println(++s);  //101
        System.out.println(s);  //101
​
        System.out.println(--s);  //100
        System.out.println(s++);  //100
        System.out.println(s--);  //101
        System.out.println(s--);  //100
        System.out.println(s--);  //99
        System.out.println(s);  //98
​
    }
}

 

6.2 关系运算符

/*
    关系运算符
        >       大于
        >=      大于等于
        <       小于
        <=      小于等于
        ==      等于
        !=      不等于
​
    = 是赋值运算符
    == 是关系运算符
​
    关系运算符的运算结果一定是布尔类型：true/false
​
    关系运算符的运算原理：
        int a = 10;
        int b = 10;
        a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。
        a == b 也是如此
*/
​
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);
    }
}

 

6.3 逻辑运算符

/*
    逻辑运算符:
        &       逻辑与     (两边的算子都是true，结果才是true)
        |       逻辑或         (两边的算子只要有一个是true，结果就是true)
        !       逻辑非         (取反，!false就是true，!true就是false，这是一个单目运算符)
        ^       逻辑异或    (两边的算子只要不一样，结果就是true)
​
        &&      短路与
        ||      短路或
​
    1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
    2、短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象
    3、短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象
    4、什么情况下发生短路现象呢？
    5、什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？ 
​
*/
​
public class OperatorTest03
{
    public static void main(String[] args){
        //运算符优先级不确定，加小括号
        System.out.println(5 > 3 & 5 > 2);  //true
        System.out.println(5 > 3 & 5 > 8);  //false
        System.out.println(5 > 3 | 5 > 8);  //true
​
        System.out.print(true & true);  //true
        System.out.print(true & false);  //false
        System.out.print(false & false);  //false
        System.out.print(false & true);  //false
​
        System.out.println(true | true);  //true
        System.out.println(true | false);  //true
        System.out.println(false | false);  //false
​
        System.out.println(!false);  //true
        System.out.println(!true);  //false
​
        System.out.println(true ^ true);  //false
        System.out.println(true ^ false);  //true
        System.out.println(false ^ false);  //false
        System.out.println(false ^ true);  //true
​
        //逻辑与和短路与
        // int x = 10;
        // int y = 12;
        //逻辑与
        // System.out.println(x < y & ++x < y);
        // System.out.println(x);  //11
        
        int x = 10;
        int y = 12;
        //短路与
        //x < y 结果是false，整个表达式结果已经确定是false
        //所有后面的表达式没有再执行，这种现象被称为短路现象
        //短路与才会有短路现象，逻辑与是不会存在短路现象的。
        System.out.println(x < y && ++x < y);
        System.out.println(x);  //10
​
        /*
            从某个角度来看，短路与更智能。由于后面的表达式可能不执行，所以执行的效率较高。这种方式在实际的开发中使用较多，短路与比逻辑与使用的多。短路与更常用。
            但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的表壳式不执行。
        */
​
        /*
            什么情况下发生短路或？
                - 第一个表达式执行结果是true，会发生短路或。
            什么情况下会发生短路与？
                - 第一个表达式执行结果是false，会发生短路或。
        */
    }
​
}

 

6.4 赋值类运算符

赋值类运算符包括两种：
    * 基本的赋值运算符
        =
    * 扩展的赋值运算符
        +=
        -=
        *=
        /= 
        %=
​
1、赋值类的运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量
​
2、注意以下代码：
    byte i = 10;
    i += 5; 等同于 i = (byte)(i + 5);
    int k = 10;
    k += 5; 等同于 k = (int)(k + 5);
    long x = 10L;
    int y = 20;
    y += x; 等同于 y = (int)(y + x)
​
3、重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型。
​
public class OperatorTest01
{
    public static void main(String[] args){
        //基本的赋值运算符
        int i = 10;
        System.out.println(i);
        i = i + 5;
        System.out.println(i);
​
        //扩展的赋值运算符 【 += 运算符可以翻译为“追加/累加”】
        i += 5;  //等同于：i = i + 5;
        System.out.println(i);
​
        i -= 5;  //等同于：i = i - 5;
        System.out.println(i);
​
        i *= 5;  //等同于：i = i * 5;
        System.out.println(i);
​
        i /= 2;  //等同于：i = i / 2;
        System.out.println(i);
​
        i %= 2;  //等同于：i = i % 2;
        System.out.println(i);
​
        //-------------------------------
        //10没有超出byte取值范围，可以直接赋值
        byte b = 10;
        //b = 15;  //可以，编译通过，15没有超出byte取值范围
        //编译错误，为什么？
        //编译器只检查语法，不运行程序，编译器发现b+5的类型是int类型，b变量的数据类型是byte
        //大容量向小容量转换需要加强制类型转换符，所以以下程序编译报错
        // b = b + 5;
​
        //纠正错误
        b = (byte)(b + 5);
        System.out.println(b);  //15
​
        byte x = 10;
        x += 5;  //等同于x = (byte)(x + 5)，其实并不等同于：x = x + 5 
        System.out.println(x);
​
        byte z = 0;
        z += 128;  //损失精度了
        System.out.println(z);  //-128
    }
​
}

 

6.5 字符串连接运算符

1、+运算符在java语言当中有两个作用：
    * 加法运算，求和
    * 字符串的连接运算
​
2、当“+”运算符两边的数据都是数字的话，一定是进行加法运算
​
3、当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串的连接运算。并且，连接运算之后的结果还是一个字符串类型。
    数字 + 数字 ---> 数字 【求和】
    数字 + 数字 ---> “字符串” 【字符串连接】
​
4、在一个表达式当中可以出现多个“+”，在没有添加小括号的前提下，遵循自左向右顺序依次运算。
​
​
public class OperatorTest02
{
    public static void main(String[] args){
        System.out.println(10 + 20);  //30 这里的加号是求和
        System.out.println(10 + 20 + 30);  //60 这里的加号也是求和
        System.out.println(10 + 20 + "30");  //"3030" 第一个加号是求和，第二个加号是字符串连接
        System.out.println(10 + (20 + "30"));  //"102030"
​
        int a = 10;
        int b = 20;
​
        //要求在控制台上输出 "10 + 20 = 30"
        System.out.println("10 + 20 = 30");
​
        //注意：要求以动态的方式输出
        System.out.println("10 + 20 = " + a + b);  //"10 + 20 = 1020"
        System.out.println(a + " + " + b + " = " + (a + b));
​
        //引用类型String
        //String是SUN在JavaSE当中提供的字符串类型
        //String.class字节码文件
        //int是基本数据类型，i是变量名，10是int类型的字面值
        int i = 10;
​
        //String是引用数据类型，s是变量名，"abc"是Sring类型的字面值
        //String s = "abc";
​
        //编译错误，类型不兼容
        //String ss = 10;
​
        //定义一个String类型的变量，起名username，赋值"xiaohong"
        String username = "xiaohong";
        System.out.println("登录成功，欢迎" + username + "回来");
​
    }
}

 

6.6 三元运算符

三元运算符/三目运算符/条件运算符
    1、语法规则：
        布尔表达式 ? 表达式1 : 表达式2
​
    2、三元运算符的执行原理
        当布尔表达式的结果是true的时候，选择表达式1作为整个表达式的执行结果
        当布尔表达式的结果是false的进修，选择表达式2作为整个表达式的执行结果
        
​
public class OperatorTest03
{
    public static void main(String[] args){
        //编译错误：不是一个完整的java语句
        //10;
​
        //编译错误：不是一个完整的java语句
        //男;
​
        //布尔类型的变量
        boolean sex = false;
        //分析以下程序是否可以编译通过
        //编译报错，因为它不是一个完整的java语句
        // sex ? '男' : '女';
​
        char c = sex ? '男' : '女';
        System.out.println(c);
​
        sex = true;
        c = (sex ? '男' : '女');
        System.out.println(c);
​
        //语法错误，编译报错，结果可能是String，也可能是char，但是前边不能用char来接收数据。
        //类型不兼容
        char c1 = sex ? "男" : '女';
​
        //编译错误，类型不兼容
        /*
        sex = false;
        char c1 = sex ? "男" : '女';
        */
​
        System.out.println(10);
        System.out.println('10');
        System.out.println("10");
        //可以
        System.out.println(sex ? '男' : "女");
​
    }
}