添砖加瓦（java）之java基本语法

添砖加瓦（java）

java基本语法

前言：

大家好我是kdy丶

---

一丶关键字和标识符

1丶关键字的使用

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）。
特点：关键字中所字母都为小写。

2.标识符的使用

定义：凡是自己可以起名字的地方都叫标识符。
涉及到的结构：
包名、类名、接口名、变量名、方法名、常量名
规则：(必须要遵守。否则，编译不通过)
1丶java中标识符由26个英文字符大小写，数字0-9，符号_ $。注意：数字不能开头
2丶不可以是关键字和保留字。
3丶严重区分大小写，长度限制
4丶不可以有空格

规范：（可以不遵守，不影响编译和运行。但是要求大家遵守）

1丶类名首字母大写，变量名和方法名采用驼峰标志法，常量全大写，多个单词之间用“_”隔开，包名全小写；

二、变量

1丶按数据类型分类

1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
   ① byte范围：-128 ~ 127
   ② 声明long型变量，必须以"l"或"L"结尾
   ③ 通常，定义整型变量时，使用int型。
   ④整型的常量，默认类型是：int型
2. 浮点型：float(4字节) \ double(8字节)
   ① 浮点型，表示带小数点的数值
   ② float表示数值的范围比long还大
   ③ 定义float类型变量时，变量要以"f"或"F"结尾
   ④ 通常，定义浮点型变量时，使用double型。
   ⑤ 浮点型的常量，默认类型为：double
3. 字符型：char (1字符=2字节)
   ① 定义char型变量，通常使用一对’’,内部只能写一个字符
   ② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
   4.布尔型：boolean
   ① 只能取两个值之一：true 、 false
   ② 常常在条件判断、循环结构中使用

2丶定义的格式

数据类型 变量名 = 变量值;
或者
数据类型 变量名;
变量名 = 变量值;

3丶自动类型转换和强制类型转换

1丶自动类型转换(只涉及7种基本数据类型）
结论：当数的范围小的数据类型的变量与数的范围大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
例1：

public class demo02 {
   
    public static void main(String[] args) {
   
        int a=8;
        double d=a;

        System.out.println(d);

    }
}

运行结果：

例2：
我么可以看到次编译是不通过的

public class demo02 {
   
    public static void main(String[] args) {
   
        byte b=4;
        char c='a';
     /* short cc=b+c; 编译不通过
        byte cc=b+c;编译不通过
        char cc=b+c;编译不通过
        */
        int cc=b+c;
        System.out.println(cc);

    }
}

运行结构：

2丶 强制类型转换(只涉及7种基本数据类型）：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。

public class demo02 {
   
    public static void main(String[] args) {
   
       int a;
       double d=8.9;
       a=(int)d;
       System.out.println(a);

    }
}

运行结果：

我们可以看出来，在这里d是有精度损失的，这也是强转的缺点。

三丶运算符

1丶算术运算符

算术运算符： + - + - * / % (前)++ (后)++ (前)-- (后)-- +：
1.(前)++ :先自增1，后运算
(后)++ :先运算，后自增1
2.(前)-- :先自减1，后运算
(后)-- :先运算，后自减1
（加号在前面就先加，加号在后面就后加）
3.连接符：+：只能使用在String与其他数据类型变量之间使用。

例1：

public class demo1 {
   
    public static void main(String[] args) {
   
        //除号：/
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        System.out.println(result1);//2
        // %:取余运算
        //结果的符号与被除数的符号相同（和上面的数的符号相同）
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);
        //(前)++ :先自增1，后运算
        //(后)++ :先运算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + ",b1 = " + b1);

        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + ",b2 = " + b2);

        int a3 = 10;
        ++a3;//a3++;
        int b3 = a3;
        //(前)-- :先自减1，后运算
        //(后)-- :先运算，后自减1

        int a4 = 10;
        int b4 = a4--;//int b4 = --a4;
        System.out.println("a4 = " + a4 + ",b4 = " + b4);
    }
}

运行结果：

2丶赋值运算符

赋值运算符：= += -= *= /= %=
例1：

public class demo03 {
   
    public static void main(String[] args) {
   
        int num1 = 10;
        num1 += 2;//num1 = num1 + 2;
        System.out.println(num1);//12

        int num2 = 12;
        num2 %= 5;//num2 = num2 % 5;
        System.out.println(num2);

    }

我们来看这一段代码，
int num1 = 10;
num1 += 2;
这个num1+= ;其实
相当于
num=num+ ;
所以
num1 += 2其实就是num1 = num1 + 2;
同样的+= -= *= /= %= 他们的规则都一样。
但我们在这时候会次考一个问题：
竟然都一样，为什么还有这种方式，难不成
是为了少敲几个代码？？
其实不然，他俩又一个很明显的区别，我们上代码：
例2：

在这里一定会想到，这个编译时通过不了的。因为s1他是short类型，而2他是int类型所以我们要么用int类型的变量来接受，要么进行强转：
s1 = (short) (s1 +2);（可能会有精度损失）
这时候，我们用+=来进行编译
例3：

没有显示编译错误！

运行结果：

所以我们可以得出结论：
+=会自动转型，不会改变变量本身的数据类型。

3丶比较运算符

比较运算符（关系运算符）: == != > < >= <= instanceof
例1：

public class demo04 {
   
    public static void main(String[] args) {
   

        int i = 10;
        int j = 20;

        System.out.println(i == j);//false
        System.out.println(i = j);//20

        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b2 == b1);//false
        System.out.println(b2 = b1);//true

        int m=12;
        int n=11;
        System.out.println(m