第一章 数据类型转换

java程序中要求参与计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换

1.1自动转换

自动转换：将取值范围小的类型自动提升为取值范围大的类型

转换原理图解

转换规则

/*
当数据类型不一样时，将会发生数据类型转换
自动类型转换 （隐式）
    1，特点：代码不需要进行特殊处理，自动完成
    2，规则数据范围从小到大
强制类型转换 （显式）
*/
public class Demo01DataType {
    public static void main(String[] args) {
        System.out.println(1024); // 这是一个整数，默认为int类型
        System.out.println(3.14); // 这是一个浮点数，默认为double类型
        // 左边为long类型，右边为默认int类型，左右不一样
        // 一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
        // int --> long，符合数据范围从小到大的要求
        // 这一行代码发生了自动类型转换
        long num1 = 100;
        System.out.println(num1); // 100
        // 左边是double类型，右边是float类型，左右不一样
        // float --> double, 符合从小到大的规则
        // 发生了自动类型转换
        double num2 = 2.5F;
        System.out.println(num2); // 2.5
        // 左边是float类型，右边是long类型，左右不一样
        // long --> float , 范围是float更大一些，符合从小到大的规则
        // 发生了自动类型转换
        float num3 = 30L;
        System.out.println(num3); // 30.0
    }
}

1.2强制转换

转换原理图解

转换规则

/*
强制类型转换
    1，特点：代码需要进行特殊的格式处理，不能自动完成
    2，格式：范围小的类型 范围小的变量名 = (范围大的类型) 原本范围打的数据;
*/
public class Demo02DataType {
    public static void main(String[] args) {
        // 左边是int类型，右边是long类型，不一样
        // long --> int，不是从小到大
        // 不能发生自动类型转换！
        // 格式：范围小的类型 范围小的变量名 = (范围大的类型) 原本范围打的数据;
        int num1 = (int) 100L;
        System.out.println(num1);
        // 左边是int类型，右边是float类型，不一样
        // float --> int，不是从小到大
        // 不能发生自动类型转换！
        // 格式：范围小的类型 范围小的变量名 = (范围大的类型) 原本范围打的数据;
        int num2 = (int) 3.9999999F;
        System.out.println(num2); // 结果为4
        int num3 = (int) 3.9999998F;
        System.out.println(num3); // 结果为3
    }
}

强烈注意

/*
强制类型转换
    1，特点：代码需要进行特殊的格式处理，不能自动完成
    2，格式：范围小的类型 范围小的变量名 = (范围大的类型) 原本范围打的数据;
注意事项：
    1，强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出。
    2，byte/short/char这三种类型都可以发生数学运算，例如加法“+”
    3，byte/short/char这三种类型在运算的时候，都会被首先提升为int类型，然后计算
    4，boolean类型不能发生数据类型转换
*/
public class Demo021DataType {
    public static void main(String[] args) {
        // 左边是int类型，右边是long类型，不一样
        // long --> int，不是从小到大
        // 不能发生自动类型转换！
        // 格式：范围小的类型 范围小的变量名 = (范围大的类型) 原本范围打的数据;
        int num1 = (int) 100L;
        System.out.println(num1);
        // long强制转换为int类型，会发生数据溢出
        int num2 = (int)6000000000L;
        System.out.println(num2); //1705032704
        // double --> int ,强制类型转换，会发生精度损失
        int num3 = (int)3.99;
        System.out.println(num3); //3，这里不是四舍五入，所有的小数位都会被舍弃掉
        char zifu1 = 'A'; //这是一个字符变量，里面是大写的字母A
        System.out.println(zifu1 + 1); // 66，也就是大写字母A被当作65进行处理
        // 计算机底部会用一个数字（二进制）来代表字符A，就是65
        // 一旦char类型进行了数学计算，那么字符就会按照一定的规则翻译成为一个数字
        byte num4 = 40; // 注意右侧的数值大小不能超过左侧的类型范围
        byte num5 = 50;
        // 错误，由于byte类型运算会先转换为int，
        // byte + byte --> int + int --> int -->byte(可能会出现数据溢出)
        // byte result1 = num4 + num5;
        // byte + byte --> int + int --> int 
        int result1 = num4 + num5;
        System.out.println(result1); //90
        short num6 = 60;
        //byte + short --> int +int --> int
        // int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
        short result2 = (short)(num4 + num6);
        System.out.println(result2); //100
    }
}

数据溢出

1.3 ASCII编码表

/*
数字和字符的对照关系表（编码表）：
ASCII码表：American Standard Code for Information Interchange 美国信息交换标准代码
Unicode码表：万国码。也是数字和符号的对照关系，开头0 - 127部分和ASCII完全一样，但是从128开始包含有更多字符
48 - '0'
65 - 'A'
97 - 'a'
*/
public class Demo03DataTypeChar{
    public static void main(String[] args) {
        char zifu1 = '1';
        System.out.println(zifu1 + 0); // 49
        char zifu2 = 'A'; // 其实底层保存的数字是65
        char zifu3 = 'c';
        // 左侧是int类型，右侧是char类型，
        // char --> int ,确实是从小到大
        // 发生了自动类型转换
        int num = zifu3;
        System.out.println(num); //99
        char zifu4 = '中';
        System.out.println(zifu4 + 0); // 20013
    }
}

第二章运算符

2.1算数运算符

加减乘除取模

/*
运算符：进行特定操作的符号。例如：+
表达式：用运算符连起来的式子叫做表达式。例如：20 + 5。又例如：a + b
四则运算
加: +
减: -
乘: *
除: /
取模（取余数）：%
首先计算得到表达式的结果，然后再打印输出这个结果
复习一下小学一年级的除法公式：
被除数 / 除数 = 商 …… 余数
对于一个整数的表达式来说，除法用的式整除，整数除以整数，结果还是整数。只看商，不看余数
之对于除法来说，取模运算符才有意义
注意事项：
    1. 一旦运算中有不同类型的数据，那么结果将会是数据类型范围大的那种。
*/
public class Demo04peralor{
    public static void main(String[] args){
        // 两个常量之间可以进行数学运算
        System.out.println(7 + 5);
        // 两个变量之间可以也进行数学运算
        int a = 10, b = 20;
        System.out.println(a - b);
        // 常量与变量之间可以混合运算
        System.out.println(a * 5);
        System.out.println(7 / 5); // 1
        System.out.println(5 / 7); // 0
        System.out.println(7 % 5); // 2
        System.out.println(5 % 7); // 5
        System.out.println(7.0 / 5.0); // 1.4
        System.out.println(5.0 / 7.0); // 0.7142857142857143
        System.out.println(7.0 % 5.0); // 2.0 余数由整型变为浮点型
        System.out.println(5.0 % 7.0); // 5.0 余数由整型变为浮点型
        // int + double --> double + double --> double
        System.out.println(7 + 5.0);
        double result1 = a + 2.5;
        System.out.println(result1);
        // b = a + 1.2; //当运算中含有多种数据类型时，需注意结果变量的数据
        // System.out.println(b); 
    }
}

加法多种用法

/*
四则运算当中的“+”有常见的三种用法：
1，对于数值来说，是加法
2，对于字符char来说，在计算之前，char会被提升成为int，然后计算
    char类型字符，和int类型字符，之间的对照关系表：ASSCII，Unicode
3，对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作
    任何数据类型和字符串进行连接的时候，结果都会变成字符串
*/
public class Demo05Plus {
    public static void main(String[] args){
        // 字符串类型的变量的基本使用
        // 数据类型 变量名称 = 数据值
        String String = "Hello";
        System.out.println(String); // String 不是关键字
        String str1 = "Hello";
        System.out.println(str1); // Hello
        String str2 = "java";
        // String + int --> String
        System.out.println(str2 + 20); // java20
        // 优先级问题
        // String + int + int
        // String          + int
        // String
        System.out.println(str2 + 20 + 30); // java2030
        System.out.println(str2 + (20 + 30)); // java50
    }
}

自增自减

/*
自增运算符：++
自减运算符：--
基本含义：让一个变量涨一个数值1，或者让一个变量降一个数值1
使用格式：写在变量名称之前，或者之后。例如：++num，也可以num++
使用方式：
    1，单独使用：不与其他任何操作混搭，自己独立成为一个步骤
    2，混合使用：和其他操作混搭，例如与赋值混搭，或者与打印操作混搭，等
使用区别：
    1，在单独使用时，前++与后++没有任何区别。也就是：++num;和num++;是完全一样的
    2，在混合使用时，有【重大区别】
        A，如果是【前++】，那么【立刻马上+1】，然后拿着结果进行使用。        【先加后用】
        B，如果是【后++】，那么首先使用变量本来的值，【然后再让变量+1】        【先用后加】
注意事项：
    只有变量才能使用自增，自减运算符，常量不可发生改变，所以不能用
*/
public class Demo06perator{
    public static void main(String[] args) {
        // 单独使用
        int num1 = 10;
        System.out.println(num1);
        System.out.println(num1); // 10
        ++num1; // 单独使用 前++
        System.out.println(num1); // 11
        num1++; // 单独使用 后++
        System.out.println(num1); // 12
        System.out.println("================");
        // 与打印操作混合使用时
        int num2 = 20;
        // 混合使用，前++，变量立刻马上变成21，然后打印结果21
        System.out.println(++num2); // 21
        System.out.println(num2); // 21
        System.out.println("================");
        int num3 = 30;
        // 混合使用，后++，首先使用变量原本的30，然后再让变量+1得到31
        System.out.println(num3++); // 30
        System.out.println(num3); // 31
        System.out.println("=================");
        // 和赋值操作混合
        int num4 = 40;
        // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量
        int result1 = --num4; 
        System.out.println(result1);
        System.out.println(num4);
        System.out.println("==================");
        int num5 = 50;
        // 混合使用，后--，首先把本来的数字50交给result2，然后自己再-1变成49
        int result2 = num5--;
        System.out.println(result2);
        System.out.println(num5);
        System.out.println("=================");
        int x = 10;
        int y = 20;
        // 11 * 20 + 11 - 18
        int result3 = ++x * y-- + x++ - --y; //213
        System.out.println(result3);
        System.out.println(x); // 12
        System.out.println(y); // 18
        // 60++; // 语法错误！常量不可以使用++或--
    }
}

2.2赋值运算符

/*
赋值运算符分为：
基本运算符：就是等号 ”=“，代表将右侧的数据交给左侧的变量
    int a = 10;
复合赋值运算符：
    +=        a += 5        相当于        a = a + 5
    -=        b -= 6        相当于        b = b - 6
    *=        c *= 7        相当于        c = c * 7
    /=        d /= 8        相当于        d = d / 8
    %=        e %= 9        相当于        e = e % 9
注意事项：
    1，只有变量才能使用赋值运算符，常量不能进行赋值
    2，复合赋值运算其中隐含了一个强制类型转换
*/
public class Demo07perator{
    public static void main(String[] args){
        int a = 10;
        // 按照公式进行翻译：a = a + 5
        // a = 10 + 5
        // a = 15
        // a本来是10，现在重新赋值得到15
        a += 5;
        System.out.println(a); // 15
        int b = 10;
        // // 按照公式进行翻译：b = b + 5
        // b = 10 % 3
        // b = 1
        // a本来是10，现在重新赋值得到1
        b %= 3;
        System.out.println(b);
        // 50 = 30 // 常量不能进行赋值
        byte c = 100;
        // c = c + 5
        // c = byte + int
        // c = int + int
        // c = int
        // c = (byte) int
        c += 30;
        System.out.println(c); // -126 出错了，因为发生了强制类型转换
    }
}

2.3比较运算符

/*
比较运算符
大于：        >
小于：        <
大于等于：    >=
小于等于：    <=
相等：        ==    【两个等号连写，才是相等，一个等号是赋值】
不相等：    !=
注意事项：
1，比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2，如果进行多次判断不能连着写
数学中的写法：例如：1 < x < 3
Java程序中【不允许】这种写法
*/
public class Demo08perator{
    public static void main(String[] args){
        System.out.println(10 > 5); // true
        int num1 = 10;
        int num2 = 20;
        System.out.println(num1 > num2); // flase
        System.out.println(num1 >= 5); // true
        System.out.println(num2 <= 11); // flase
        System.out.println(num1 >= 20); // true
        System.out.println("====================");
        System.out.println(10 == 10); // true
        System.out.println(10 != 5); // true
        System.out.println(10 != 10); // flase
        int x = 2;
        // System.out.println(1 < x < 3); // 错误写法，编译报错，不能连着写
    }
}

2.4逻辑运算符

/*
逻辑运算符：
与    （并且）    &&    全真则真，有假则假
或    （或者）    ||    有真则真，全假则假
非    （取反）    !    是真则假，是假则真
与"&&", 或"||"，具有短路效果，如果根据左边已经可以判断得到最终结果，那么右边的代码将不会执行，从而节省一定的性能
注意事项:
1，逻辑运算符只能用于boolean值
2，与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可
3，与、或两种运算符，如果有多个条件，可以连续写
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C
TIPS：
对于1 < x < 3的情况应该拆成两个部分，然后使用与运算符连接起来
int x = 2
1 < x && x < 3
*/
public class Demo09Logio{
    public static void main(String[] args){
        System.out.println(true && true); // true
        System.out.println(true && false); // false
        System.out.println(false && false); // false
        System.out.println("========================="); 
        System.out.println(true || true); // true
        System.out.println(true || false); // true
        System.out.println(false || false); // false
        System.out.println("========================="); 
        System.out.println(true); // true
        System.out.println(!true); // false 
        System.out.println("========================="); 
        int a = 10;
        // false && ...
        System.out.println(3 > 4 && a++ < 100); // false
        System.out.println(a); // 10，触发短路，a++没有执行
        System.out.println("========================="); 
        int b = 20;
        // true || ...
        System.out.println(5 > 3 || b++ < 100); // true
        System.out.println(b); // 20，触发短路，b++没有执行
    }
}

2.5三元运算符

/*
一元运算符：只需要一个数据就可以进行操作的运算符。例如；取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算。例如：加法+、减法-、赋值=
三元运算符：需要三个数据才可以进行运算的运算符
格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
流程：
首先判读条件是否成立：
    如果成立 为true，那么将表达式A的值赋给左侧的变量
    如果不成立 weifalse，那么将表达式B的值赋给左侧的变量
二者选其一
注意事项:
1，必须同时保证表达式A和表达式B都符合左侧的变量的数据类型的要求
2，三元运算符的结果必须被使用
*/
public class Demo10Operato{
    public static void main(String[] args){
        int a = 10, b = 20;
        // 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
        // 判断a > b是否成立，如果成立将a的值赋给max；如果不成立将bde值赋给max。二者选其一
        int max = a > b ? a : b; // 最大值 max
        System.out.println("最大值：" + max); //20
        // int result = 3 > 4 ? 2.5 : 11; //错误写法！
        System.out.println(a > b ? a : b); // 正确写法！
        // a > b ? a : b; // 错误写法！
        System.out.println("===========");
        int x = 10;
        // 100 > 1 成立，将表达式A 100 赋给y，表达式B没有执行，x的值不变
        int y = 100 > 1 ? 100 : ++x;
        System.out.println(x); // 100
        System.out.println(y); // 10
    }
}

第三章方法入门

3.1概述

方法：

    就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。 当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

3.2方法的定义

3.3方法的调用

3.4调用练习

3.5注意事项

• 方法定义注意事项：
  • 方法必须定义在一类中方法外
  • 方法不能定义在另一个方法的里面

/*
定义一个方法的格式：
public static void 方法名称() {
    方法体;
}
方法的命名规则采用小驼峰式
方法体：也就是大括号中包含的任意条语句
注意事项：
1，方法定义的先后顺序无所谓
2，方法的定义不能产生嵌套包含关系
3，方法在定义后，不会执行，如果想要执行，一定要进行方法的【调用】。
如何调用方法，格式：
方法名称();
*/
public class Demo11Method{
    public static void main(String[] args){
        farmer(); // 调用农民的方法
        seller(); // 调用小商贩的方法
        cook(); // 调用厨师的方法
        me(); // 调用我自己的方法
    }
    // 厨师
    public static void cook() {
        System.out.println("洗菜");
        System.out.println("切菜");
        System.out.println("炒菜");
        System.out.println("装盘");
        /*public static void me() {
            System.out.println("吃");
        } 错误写法，方法的定义不能嵌套*/
    }
    // 我
    public static void me() {
        System.out.println("吃");
    }
    // 小商贩
    public static void seller() {
        System.out.println("运输到农贸市场");
        System.out.println("抬高价格");
        System.out.println("吆喝");
        System.out.println("卖给厨师");
    }
    // 农民
    public static void farmer() {
        System.out.println("播种");
        System.out.println("浇水");
        System.out.println("施肥");
        System.out.println("除虫");
        System.out.println("收割");
        System.out.println("卖给小商贩");
    }
}

第四章JShell脚本工具

JShell脚本工具是JDK9的新特性

第五章扩展知识点

5.1+=符号的扩展

5.2常量和变量的运算

/*
在给变量赋值时，如果右侧表达式中都是常量，没有任何变量
那么编译器javac将会直接将若干个常量表达式结算得到结果
short result = 5 + 8; // 等号左边全是常量，没有任何变量
编译之后，得到的.class字节码文件当中相当于【直接就是】：
short result = 13;
右侧常量结果数值没有超过左侧范围，所以正确
这称为"编译器的常量优化"。
但是注意：一旦表达式中有变量参加，那么就不能进行这种优化
*/
public class Demo13Notice {
    puvlic ststic void main(String[] args) {
        short num1 = 10; // 正确写法，右侧没有超过左侧范围
        short a = 5;
        short b = 8;
        // short + short --> int + int --> int
        // short result = a + b; // 错误写法！左侧需要是int类型
        // 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
        short result = 5 + 8;
        Systrm.out.println(result);
        // short result1 = 5 + a + 8; // 不全是常量会报错
    }
}

2，

/*
对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过左侧范围
那么java编译器就会自动隐含的为我们补上一个(byte)(short)(char)
1，如果没有超过左侧范围，编译器会补上强转
2，如果超出范围，编译器会直接报错
*/
public class Demo12Notice{
    public static void main(String[] args){
        // 右侧是一个int范围数字，但没有超出左侧范围，是正确的
        byte num1 = /*(byte)由编译器补上*/30; // 右侧没有超出左侧范围
        System.out.println(num1); // 30
        // byte num2 = 128; // 右侧超出左侧范围，报错
        // int --> char, 没有超出范围
        // 编译器会自动补上一个隐含的(char)
        char zifu = /*(char)*/ 65;
        System.out.println(zifu); //A
    }
}