2.java基本语法(变量)

回顾

Java语言应用领域

Java web开发：后台开发
大数据开发
Android应用程序开发：客户端开发

Java语言的特点

面向对象性：

• 两个因素：类、对象
• 三个特性：封装、继承、多态
  健壮性：①去除C语言中的指针②自动垃圾回收机制（仍会出现内存溢出，内存泄露）
  跨平台性：一次编译，多平台运行（归功于JVM）

基本语法

关键字与保留字

关键字的定义和特点

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

保留字

• java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字（goto、const）

1.标识符

• java对各种变量、方法和类等要素命名时使用的字符序列成为标识符
• 技巧：凡是自己可以起名字的地方都叫标识符

2.标识符的命名规则：（必须遵守）

• 由26个英文字母大小写，0-9，_或$组成
• 数字不能开头
• 不能使用关键字和保留字但是可以包含
• Java中严格区分大小写，长度无限制
• 标识符不能包含空格

3.Java中名称命名规范：（建议遵守）

• 包名：多组单词组成时所有字字母都小写
• 类名、接口名：多单词组成时，所有单词的首字母大写
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个字母首字母大写
• 常量名：所有字母都大写。多单词使用时每个单词用下划线连接

4.注意

• 在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
• java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

变量

变量的概念：

• 内存中的一个存储区域
• 该区域的数据可以在同一类型范围内不断变化
• 变量是程序中最基本的存储单元。包含变量类型、变量名和存储值

变量的作用：

• 用于在内存中保存数据

变量的使用：
1.java定义变量的格式：数据类型 变量名 = 变量值
2.说明：

• java中每个变量必须先声明，后使用
• 使用变量名来访问这块区域的数据
• 变量的作用域：其定义所在的一对{}内
• 变量只能在其作用域内才有效
• 同一个作用域内，不嗯呢该定义重名的变量

Java定义的数据类型：
1.变量按照数据类型来分：
  基本数据类型：
    整形：byte\short\int\long
    浮点型：float\double
    字符型：char
    布尔型：boolean

  引用数据类型：
    类（class）
    接口（interface）
    数组（array）

2.变量在类中声明的位置：
  成员变量&局部变量

public class VariableTest1{
    public static void main(String[] args){
        //1.整形：byte（1字节=8bit）\ short（2字节）\ int（4字节）\ long（8字节）
        //① byte范围：-128 ~ 127
        byte b1 = 12;
        byte b2 = -128;
        //b2 = 128;//编译不通过
        System.out.println(b1);
        System.out.println(b2);
        //② 声明龙型变量，必须以"l"或"L"结尾
        //③ 通常，定义整形变量时，使用int型
        short s1 = 128;
        int i1 = 1234;
        long l1 = 1234321234L;
        System.out.println(l1);

        //2.浮点型：float（4字节） \ double（8字节）
        //① 浮点型，表示带小数点的数值
        //② float表示数值的范围比long还大
        double d1 = 123.4;
        System.out.println(d1 + 1);
        //③ 定义float类型变量时，变量要以"f"或"F"结尾
        float f1 = 12.3F;
        System.out.println(f1);
        //④ 通常，定义浮点型变量时，使用double型

        //3.字符型：char（1字符=2字节）
        //① 定义char型变量，通常使用一对'',内部只能写一个字符
        char c1 = 'a';
        System.out.println(c1);

        char c2 = '1';
        char c3 = '中';
        System.out.println(c2);
        System.out.println(c3);

        //② 表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符型常量
        char c4 = '\n';
        System.out.println("hello" + c4 + "World!");
        char c5 = '\u0041';
        System.out.println(c5);
        
        //4.布尔型：boolean
        //① 只能取两个值之一：true 、 false
        //② 常常在条件判断、循环结构中使用
        boolean bl = true;
        System.out.println(true);
        
        boolean haveGirlfriend = false;
        if(haveGirlfriend){
            System.out.println("我酸了，emmm");
        }else{
            System.out.println("给，狗粮！");
        }
    }
}

基本数据类型之间的运算规则：
前提：这里只讨论7种基本数据类型变量间的运算。不包含boolean类型。
1.自动类型提升：

• 当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型

• byte、 char、short --> int --> long --> float --> double

• 特别的：当byte、char、short三种类型的变量做运算时，结果为int型
  2.强制类型转换：自动类型提升运算的逆运算。

• 需要使用强转符：()

• 注意点：强制类型转换，可能导致精度损失。

说明：

• 容量大小指表示数的范围的大小。比如：float容量要大于long的容量
• 整型常量，默认类型为int型
• 浮点型常量，默认类型为double型

class VariableTest2{
    public static void main(String[] args){
        //自动类型提升
        byte b1 = 2;
        int i1 = 129;
        //编译不通过
        //byte b2 = b1 + i1;
        int i2 = b1 + i1;
        long l1 = b1 + i1;
        System.out.println(i2);

        float f1 = b1 + i1;
        System.out.println(f1);

        short s1 = 123;
        double d1 = s1;
        System.out.println(d1);

        char c1 = 'a';//97
        int i3 = 10;
        int i4 = c1 + i3;
        System.out.println(i4);

        System.out.println("-----------------------------------");
        //**************************************
        //强制类型转换

        double d_1 = 12.5;

        //精度损失示例1
        int i_1 = (int)d_1;//截断操作
        System.out.println(i_1);

        //精度损失示例2
        int i_2 = 128;
        byte b_1 = (byte)i_2;
        System.out.println(b_1);//-128

        //没有精度损失
        long l_1 = 123L;
        short s_2 = (short)l_1;
        System.out.println(s_2);
    }
}

String类型变量的使用
1.String属于引用数据类型
2.声明String类型变量时，使用一对""
3.String可以和8种基本数据类型做运算，且只能是加运算：+
4.运算的结果仍然是String类型

class StringTest{
    public static void main(String[] args){
        String s1 = "Hello World!";

        System.out.println(s1);

        String s2 = "a";
        String s3 = "";

        //*************************
        int number = 1001;
        String numberStr = "学号：";
        String info = numberStr + number;
        boolean b1 = true;
        String info1 = info + b1;
        System.out.println(info1);
        
        //*******************************
        //练习1
        char c = 'a';
        int num = 10;
        String str = "hello";
        System.out.println(c + num + str);//107hello
        System.out.println(c + (num + str));//a10hello
        System.out.println((c + num) + str);//107hello
        System.out.println(c + str + num);//ahello10
        System.out.println(str + num + c);//hello10a
        
        //练习2
        //输出* *
        System.out.println("*   *");//*   *
        System.out.println('*' + '\t' + '*');//93
        System.out.println('*' + "\t" + '*');//*   *
        System.out.println('*' + '\t' + "*");//51*
        System.out.println('*' + ('\t' + "*"));//*   *
        
        //***************************
        String str1 = 123 + "";
        System.out.println(str1);//"123"
        
        int num1 = Integer.parseInt(str1);
        System.out.println(num1);//123
    }
}

进制

二进制（binary）：0,1，满2进1.以0b或0B开头。
十进制（decimal）：0-9，满10进1。
八进制（octal）：0-7，满8进1.以数字0开头。
十六进制（hex）：0-9及A-F，满16进1.以0x或0X开头。此处的A-F不区分大小写。
如：0x21AF +1 = 0X21B0

class BinaryTest{
    public static void main(String[] args){
        int num1 = 0b110;
        int num2 = 110;
        int num3 = 0123;
        int num4 = 0x110A;
        
        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
        System.out.println("num3 = " + num3);
        System.out.println("num4 = " + num4);
    }
}

原码、反码、补码

• 正数的原码、反码、补码一样
• 负数的补码是原码取反码加1
• 计算机底层都是以补码的形式存储

运算符

1.算数运算符：+(正号)、-(负号)、+、-、*、/、%、(前)++、(后)++、(前)–、(后)–、+（连接运算符）

class AriTest1{
    public static void main (String[] args){
        //除号：/
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        System.out.println(result1);//2
        
        int result2 = num1 / num2 * num2;
        System.out.println(result2);//10
        
        double result3 = num1 / num2;
        System.out.println(result3);//2.0
        
        double result4 = 0.0 + num1 / num2;
        double result5 = (double)num1 / num2;
        System.out.println(result4);//2.4
        System.out.println(result5);//2.4
        
        //%:取余运算
        //结果的符号与被模数的符号相同
        //开发中，常用来判断能否被除尽
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);//2
        
        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);//-2
        
        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);//2
        
        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);//-2
        
        //(前)++:加+1再运算
        //(后)++:先运算后+1
        //不会改变本身变量的数据类型
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + ",b1 = "+ b1);//a1=11,b=11
        
        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + ",b2 = " + b2);//a2=11,b2=10
        
        byte bb1 = 127;
        bb1++;
        System.out.println("bb1 = " + bb1);//bb1=-128
        
        //(前)--:先-1后运算
        //(后)--:先运算后-1
    }
}

2.赋值运算符
=、 +=、 -=、 *=、 /=、 %=

class SetValueTest{
    public static void main(String[] args){
        //赋值符号：=
        int i1 = 10;
        int j1 = 10;
        
        int i2,j2;
        //连续赋值
        i2 = j2 = 10;
        
        int i3 = 10,j3 = 20;
        
        //*******************************
        int num1 = 10;
        num1 +=2;//不会改变变量本身的数据类型
        System.out.println(num1);//12
        
        int num2 = 12;
        num2 %= 5;
        System.out.println(num2);
        
        //练习1
        int i = 1;
        i *= 0.1;
        System.out.println(i);//0
        i++;
        System.out.println(i);//1
        
        //练习2
        int m = 2;
        int n = 3;
        n *= m++;
        System.out.println(m);//3
        System.out.println(n);//6
        
        //练习3
        int n1 = 10;
        n1 += (n1++) + (++n1);
        System.out.print(n1);//32
    }
}

3.比较运算符
==、 !=、>、<、>=、<=、instanceof
结论：

• 比较运算符的运算结果都是boolean型
• 区分==和=

class CompareTest{
    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
    }
}

4.逻辑运算符
&(逻辑与)、&&(短路与)、|(逻辑或)、||(短路或)、!(逻辑非)、^(逻辑亦或)

说明：

• 逻辑运算符操作的都是boolean类型的变量

class LogicTest{
    public static void main(String[] args){
        //区分& 与 &&
        //相同点1：& 和 && 的运算结果相同
        //相同点2：当符号左边是true时，二者都会执行符号右边的运算
        //不同点：当符号左边是false时，&继续执行符号右边的运算。&&不执行符号右边的运算
        boolean b1 = false;
        int num1 = 10;
        if(b1 & (num1++ >0 )){
            System.out.println("今天学习！");
        }else{
            System.out.println("今天休息！");
        }
        System.out.println("num1 = " + num1);//11
        
        boolean b2 = false;
        int num2 = 10;
        if(b2 && (num2++ >0 )){//b2不满足判断结束，num2++ > 0不执行
            System.out.println("今天学习！");
        }else{
            System.out.println("今天休息！");
        }
        System.out.println("num2 = " + num2);//10
        
        //区分：| 与 ||（同理）
    }
}

5.位运算符
<<、>>、>>>(无符号右移)、&、|、^、~
结论：
1.位运算符操作的都是整型数据
2.<<：在一定范围内，每向左移一维，相当于 * 2
 <<：在一定范围内，每向右移一位，相当于 / 2

面试题：计算2 * 8最高效的方式? 2 << 3 或 8 << 1

class BitTest{
    public static void main(String[] args){
        int i = 21;
        System.out.println("i << 2 : " + (i << 2));
        System.out.println("i << 3 : " + (i << 3));
        System.out.println("i << 27 : " + (i << 27));//越界
        
        int m = 12;
        int n = 5;
        //按位计算
        System.out.println("m & n : " + (m & n));
        System.out.println("m | n : " + (m | n));
        System.out.println("m ^ n : " + (m ^ n));
        
        //练习：交换两个变量的值
        int num1 = 11;
        int num2 = 19;
        
        //方式一：
        //int temp = num1;
        //num1 = num2;
        //num2 = temp;
        
        //方式二
        //好处：不用定义临时变量
        //弊端：① 相加操作可能越界 ②有局限性：只能适用于数值类型
        //num1 = num1 + num2;
        //num2 = num1 - num2;
        //num1 = num1 - num2;
        
        //方式三：使用位运算符(局限：只能用于数值类型)
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;
        
        
        System.out.println("num1 = " + num1 + ",num2 = " + num2);
    }
}

6.三元运算符
1.结构：（条件表达式）? 表达式1 : 表达式2
2.说明

• 条件表达式的结果为boolean类型
• 根据表达式真或假，决定执行表达式1，还是表达式2.真则表达式1，反之表达式2.
• 表达式1和表达式2要一致
• 可嵌套使用
• 凡是可以用三元运算符的地方，都可改写为if-else，反之不成立
• 如果程序可以使用三元运算符，有可以使用if-sels结构，那么优先选择三元运算符。原因：简洁、执行效率高。

class SanYuanTest{
    public static void main(String[] args){
        //获取两个整数的较大值
        int m = 12;
        int n = 5;
        int max = (m > n)? m : n;
        System.out.println(max);

        //********************************
        n = 12;
        String maxStr = (m > n)? "m大" : ((m == n)? "一样大" : "n大");
        System.out.println(maxStr);

        //****************************
        //获取三个数的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;
        
        //不建议
        int maxNum = (n1 > n2)? ((n1 > n3)?  n1 : n3) : ((n2 > n3)? n2 : n3);
        System.out.println(maxNum);
    }
}

运算符优先级