零基础学Java笔记一

常量

1.常量的概念

常量：在程序运行期间，固定不变的量

2.常量的分类

1.字符串常量，凡是双引号引起来的部分叫做字符串常量，如"ABC"
2.整数常量：直接写上的数字，没有小数，如8，9
3.浮点数常量：直接写上的数字，由小数，如6.3
4.字符常量：凡是用单引号引起来的单个字符，叫做字符常量，如'b','中'，'8'（单引号里面有且只有一个字符，可以是一个空字符！！）
5.布尔常量：只有两种取值，true和false
6.空常量：null，代表没有任何数据（空常量不能直接打印输出）

数据类型

1.基本数据类型

1.整数型
2.浮点型
3.字符型
4.布尔型

2.引用数据类型

1.字符串
2.数组
3.类
4.Lambda

注意事项

1.字符串不是基本类型，而是引用类型
2.浮点型可能只是一个近似值，并非精确值
3.数据范围与字节数不一定相关，例如float的数据范围比long更广泛，但是float是4字节，long是8字节
4.浮点数当中默认类型是double。如果一定要使用float类型，需要加上后缀F或f(推荐使用大写字母)
如果是整数，默认是int类型。如果一定要使用long类型，需要在其值后加上后缀L或l(推荐使用大写字母)

变量

1.变量的概念

变量：在程序运行的过程中，值会发生变化的量

2.变量定义的格式

1.定义一个变量
数据类型 变量名；
如 int a ;
2.定义一个变量并给它赋初值
数据类型 变量名 = 初始值
如：int a = 8

3.使用变量的注意事项

1.对于float和long类型来说，后缀F和L要记得带上
2.如果使用byte或者short，要注意右侧的值不能超过左侧类型的范围
3.只是定义但没有进行赋值的变量，不能直接使用
4.变量使用不能超过作用域的范围
【作用域】：从定义变量的一行开始一致到该变量所属的大括号结束

数据类型转换

当数据类型不一样时，将会发生数据类型转换

1.自动类型转换（隐式）

1.特点：代码不需要进行特殊处理，自动完成
2.规则：数据范围从小到大
【所谓"从小到大规则":就是小的数据范围的类型转换成大的数据范围的类型！！】

package com.company.dataTypeConversion;

/**
 * 数据类型转换
 * 自动类型转换
 */
public class DataTypeConversion1 {
    public static void main(String[] args) {
        /*
         *  在整数类型中，默认100是int类型，而赋值符号左侧的又是long类型
         *  即赋值号左右两侧的值类型不一致，这时需要进行类型转换
         *  由于此例中数据类型符合从小到大的规则，所以可以进行自动转换
         * 【所谓"从小到大规则":就是小的数据范围的类型转换成大的数据范围的类型！！】
         */
        long num1 = 100;
        System.out.println(num1); //100

        /*
         * float的字节数虽然是4，小于字节数为8的long类型，但是float所能表示的范围比long的数据范围大，
         * 即此例符合从小到大规则，可以进行自动转换
         */

        float num2 = 1000L;
        System.out.println(num2); //1000.0


    }

}

2.强制类型转换（显式）

1.特点：代码需要进行特殊格式处理，不能自动完成
2.格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据

package com.company.dataTypeConversion;

/**
 * 数据类型转换
 * 强制类型转换
 */
public class DataTypeConversion2 {
    public static void main(String[] args) {
        /*
         *  此例要将类型为long的数100赋值给类型为int的变量num1
         *  由于long的数据范围比int的数据范围大，不遵循从小到大规则，明显是从大到小规则
         * 【所谓"从大到小规则":就是指将大范围的数赋值给小范围的变量！！】
         * 因此需要本例需要强制类型转换
         * 注意：强制类型转换有时候会造成数据精度损失、数据溢出！
         */
        int num1 = (int) 100L;
        System.out.println(num1); //100 ,安然无恙，数据没有出现精度损失也没有出现溢出

        int num2 = (int) 3.99;
        System.out.println(num2); //3，数据出现了及精度损失！
    }
}

3.注意事项

1.强制类型一般不推荐使用，因为有可能发生精度损失、数据溢出
2.byte、short、char这三种类型都可以发生数学运算，如加法
3.byte、short、char这三种类型在运算的时候，都会首先提升为int类型，然后再计算！！
4.布尔类型不能完成数据类型转换！

package com.company.dataTypeConversion;

public class DataTypeConversion3 {
    public static void main(String[] args) {
        /*
         * num1 和 num2都是byte类型，
         * 由于byte/short/char类型的数都会在运算的时候先提升为int类型，再进行计算
         * 所以byte + byte ===> int + int ，所以int + int = int
         * 这就是为什么result是int类型的原因了！！
         */
        byte num1 = 40;
        byte num2 = 50;
        int result = num1 + num2 ;
        System.out.println(result);
    }
}

四则运算与取模运算

1.运算符

+加
-减
*乘
/除
%取模（取余数）

2.注意事项

1.一旦运算当中有不同类型的数据，那么结果将会是两者中数据范围大的那种类型

package com.company.operation;

/**
 * 四则运算
 */
public class Arithmetic {
    public static void main(String[] args) {
        /*
         * 一旦运算当中有不同类型的数据，那么结果将会是两者中数据范围大的那种类型
         * int 类型的范围小于double的范围
         * 所以 int + double ==> double + double
         * 所以两者进行运算，结果的类型是double型！！
         */
        int x = 3;
        double y = 3.4;
        double result = x + y;
        System.out.println(result);
    }
}

运算符加号的多种意思

1.对于数值来说，那就是加法运算
2.对于字符char类型来说，在计算之前，char会被先提升为int类型，再进行计算
3.对于字符串来说，那就是表示字符串之间的连接操作

注意事项：

1.任何数据类型和字符串进行连接的时候，结果都会是变成字符串！
2.字符串和数值进行拼接的时候，注意优先级问题

package com.company.operation;

/**
 * 跟String有关的加法
 */
public class AdditionAboutString {
    public static void main(String[] args) {
        String str = "hello";
        System.out.println(str + 20); // hello20
        System.out.println(str + 20 + 50); // hello2050
        System.out.println(str + (20+30)); // hello50
    }
}

自增自减运算

1.使用格式：写在变量名称之前或之后。如++num 或 num++
2.使用方式：
单独使用：不和其他任何操作混合，自己独立成为一个步骤
混合使用：和其他操作混合，例如与赋值混合，或与打印操作混合等
3.使用区别：
1.在单独使用的时候，前++和后++没有任何区别。即num++和++num是完全一样的！
2.在混合使用的时候有重大区别！
A.如果是【前++】，那么变量立刻马上+1，然后拿着结果进行使用 =>【先加后用】
B.如果是【后++】，那么使用变量本来的数值，【然后再让变量+1】=>【先用后加】

package com.company.operation;

public class AdditionSelf {
    public static void main(String[] args) {
        int num1 = 20;
        //++num1:属于前++，立刻马上+1，然后拿着加了1的值打印出来
        System.out.println(++num1); //21
        System.out.println(num1); //21
        System.out.println("=============");
        int num2 = 10;
        //num2++:属于后++，先将值打印出来，再加1
        System.out.println(num2++); //10
        System.out.println(num2); //11
    }
}

赋值运算符

1.+=
a += 1 相当于 a = a + 1
2.-=
a -= 1 相当于 a = a - 1
3.*=
a *= 1 相当于 a = a * 1
4./=
a /= 1 相当于 a = a / 1
5.%=
a %= 1 相当于 a = a % 1

注意事项

1.赋值运算有时候隐含了类型的转换

package com.company.operation;

/**
 * 赋值运算符 += -= *= /= %=
 */
public class AssignmentOperation {
    public static void main(String[] args) {
        /*
         * num1 += 5相当于num1 = num1 + 5
         * 赋值符号右侧是byte + int ,所以会先将byte提升为int,即变成int + int
         * 所以结果就是int类型
         */
        byte num1 = 20;
        num1 += 5;
        System.out.println(num1);
    }
}

比较运算符

1.== 等于
2.<= 小于等于
3.>= 大于等于
4.< 小于
5.> 大于
6.!= 不等于

注意事项：

1.比较运算符的结果一定是一个布尔值，成立就是true
2.如果需要进行多次比较，两个比较运算符不能连着写！即3 < x < 5这种写法错误！

逻辑运算符

1.与&& 有一个为假，结果为假
2.或|| 全部为假，结果为假，否则结果是真
3.非！ 取反

三元运算符

1.格式：
数据类型 变量名称 = 条件判断 ？ 表达式A： 表达式B
2.流程：
首先判断条件是否成立
如果成立，那么将表达式A的值赋给左侧的变量
如果不成立，那么将表达式B的值赋给左侧的变量
二者选其一
3.注意事项：
1.必须同时保证A和B表达式都符号左侧数据类型的要求【不论最后赋给左侧的是A还是B，都必须让这两个同时满足左侧变量的数据类型】
2.三元运算符的结果必须被使用