第2章 Java基本语法

1、标识符：凡是可以自己命名的地方，都叫标识符。如：类名、方法名、变量名、接口名等。

（1）标识符命名的规则：(要求严格遵守，否则会报编译性的错误)
由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。

（2）Java中的名称命名规范：(如果不遵守，也不会报错)
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

2、变量：基本数据类型（8个） vs 引用数据类型（类、接口、数组）
（1）java中的变量定义的格式：数据类型 变量名 = 初始化值
如：int i = 10;
（2）变量需先定义，后使用
（3）整型：byte(-128~+127) short int（默认类型） long
long l1 = 3136546548987465L;
注：定义long型变量，值的末尾需加“L”或“l”
（4）浮点型（带小数点的数值）：float double（默认类型）
float f1 = 12.3F;
注：声明float类型的浮点型数据，末尾要加“F”或者“f”
（5）字符型（=两个字节）：char 只能表示一个字符（英文、中文、标点符号、日 文等）
如：char c1 = 'a';
String str = "ab";
char c3 = '中';
String str1 = "中国";
可以表示转义字符
char c4 = '\t';
char c5 = '\n';
（6）布尔类型：boolean 只能够取值为true 或 false 。不能取值null

3、变量之间的运算

（1）

/*
变量之间的运算：(char byte short int long float double，boolean类型除外)
1.自动类型转换
2.强制类型转换
*/
class TestVeriable1{
public static void main(String[] args){
//1.自动类型转换:当容量小的数据类型与容量大的数据类型做运算时，容量小的会自动转换为
//容量大的数据类型:char,byte,short ===>int ===>long ===>float===double
int i1 = 12;
short s1 = 2;
int i2 = i1 + s1;
float f1 = 12.3F;
float f2 = f1 + i2;
double d1 = f2 + 12.3;
System.out.println(i2);
System.out.println(f2);

char c1 = 'a';//97
c1 = 'A';//65
int i3 = c1 + 1;
System.out.println(i3);

//需要注意的：当char、byte、short之间做运算时，默认的结果为int类型
short ss1 = 12;
byte bb1 = 1;
char cc1 = 'a';
int ii1 = ss1 + bb1;
int ii2 = cc1 + bb1;

//2.强制类型转换：容量大转换为容量小的.要使用强制类型转换符：()
//强制类型转换的问题：导致精度的损失
long l1 = 12345L;
int m1 = (int)l1;
System.out.println(m1);

byte by1 = (byte)m1;
System.out.println(by1);

//平时常用的字符串,也是一种数据类型：String
String nation = "我是一个中国人";
System.out.println(nation);
//字符串与基本数据类型之间的运算:只能是连接运算：+。得到的结果仍为一个字符串
String str = "abc";
String str1 = str + m1;//abc12345
System.out.println(str1);

//题目：
String str1 = "hello";
int myInt1 = 12;
char ch1 = 'a';//97
System.out.println(str1 + myInt1 + ch1);//hello12a
System.out.println(myInt1 + ch1 + str1);//109hello
System.out.println(ch1 + str1 + myInt1);//ahello12

String str2 = "12";
str2 = 12 + "";
}
}

4、进制

（1）对于整数，有四种表示方式：
二进制：0,1 ，满2进1.以0b或0B开头。
十进制：0-9 ，满10进1.
八进制：0-7 ，满8进1. 以数字0开头表示。
十六进制：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
如：0x21AF +1= 0X21B0

（2）进制的基本转换

十进制 二进制互转
      二进制转成十进制 乘以2的幂数
      十进制转成二进制 除以2取余数
二进制 八进制互转
二进制 十六进制互转
十进制 八进制互转
十进制 十六进制互转

 

5、原码、反码、补码

所有数字在计算机底层都以二进制形式存在。
计算机以补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码加1。
原码：直接将一个数值换成二进制数。
反码：是对原码按位取反，只是最高位（符号位）确定为1。
Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位。

 6、测试算术运算符

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

// 除：/
int i = 12;
int j = i/5;
double d = i / 5;
double d1 = i/5.0;
System.out.println(j);//2
System.out.println(d);//2.0
System.out.println(d1);//2.4
//取模：%：取余数. 结果的符号取决于被模数
int i1 = 12 % 5;
int i2 = -12 % 5;
int i3 = 12 % (-5);
int i4 = -12 % (-5);
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
System.out.println(i4);
//前++:先自增1，后做运算
//后++:先做运算，后自增1
int myInt1 = 10;
int myInt2 = ++myInt1;//前++
System.out.println(myInt1);//11
System.out.println(myInt2);//11

int myInt3 = 10;
int myInt4 = myInt3++;//后++
System.out.println(myInt3);//11
System.out.println(myInt4);//10

//前--:先自减1，后做运算
//后--:先做运算，后自减1
int myInt5 = 10;
int myInt6 =--myInt5;//前--
System.out.println(myInt5);//9
System.out.println(myInt6);//9

int myInt7= 10;
int myInt8 = myInt7--;//后--
System.out.println(myInt7);//9
System.out.println(myInt8);//10

}
}

注：前++，前--：表示先进行自增或自减的操作再使用变量；后++，后--：表示先使用变量之后再进行自增或自减的操作。

7、逻辑运算符

&—逻辑与 | —逻辑或 ！—逻辑非
&& —短路与 || —短路或 ^ —逻辑异或

理解：异或，追求的是“异”!

//逻辑运算符：  &  && | || ! ^
class TestLogic{
    public static void main(String[] args){
        boolean a = true;
        boolean b = false;

        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);

        //& 与 && 的区别：&:不管左边是true还是false，右端都会进行运算。
        //               &&:当左端为false时，右端不再进行运算
        //以后使用时，建议使用 &&
        int i1 = 10;
        if(b & (i1++) > 0){
            System.out.println("今天天气很晴朗！");
        }else{
            System.out.println("今天下雨！");
        }
        System.out.println(i1);//11

        int i2 = 10;
        if(b && (i2++) > 0){
            System.out.println("今天天气很晴朗");
        }else{
            System.out.println("今天下雨！");
        }
        System.out.println(i2);//10


        //| 与 || 的区别：|：当左端为true时，右端照样做运算。
        // ||:当左端为true时，右端不再进行运算。
        //我们在使用时，选择：||
        int i3 = 10;
        if(a | i3++ > 0){
            System.out.println("今天天气很晴朗！");
        }else{
            System.out.println("今天下雨！");
        }
        System.out.println(i3);//11

        int i4 = 10;
        if(a || i4++ > 0){
            System.out.println("今天天气很晴朗！");
        }else{
            System.out.println("今天下雨！");
        }
        System.out.println(i4);//10

    }
}

 8、位运算符和三元运算符

8.1 位运算符

注：位运算是直接对二进制进行运算。

练习一：

//位运算符：<<  >>   >>>  | & ~ ^
class TestBit{
    public static void main(String[] args){
        int i1 = 31;
        
        System.out.println(i1<<3);//248(每右移一位乘以2，即：31*2*2*2＝248)
        System.out.println(i1<<28);
        
        System.out.println(i1>>2);//7
        System.out.println(i1>>>2);//7

        int i2 = -31;
        System.out.println(i2>>2);//-8
        System.out.println(i2>>>2);//1073741816
        
        System.out.println(12 & 5);//4
        System.out.println(12 | 5);//13
        System.out.println(12 ^ 5);//9
        System.out.println(~12);//-13(~表示取反)

    }
}

 8.2 三元运算符

格式:
(条件表达式)? 表达式1：表达式2；
        为true，运算后的结果是表达式1；
        为false，运算后的结果是表达式2；

表达式1和表达式2为同种类型。
三元运算符与if-else的联系与区别：
1）三元运算符可简化if-else语句
2）三元运算符要求必须返回一个结果。
3）if后的代码块可有多个语句

练习一：

/*
三元运算符：(条件表达式)?  表达式1 : 表达式2;
要求：表达式1与表达式2为同种数据类型。
     既然是运算符，就一定会有运算的结果,结果的数据类型与表达式1,2的类型一致。
三元运算符在一定程度上可以与if-else互换。（三元运算符一定可以转换为if-else，反之不成立。）
*/

class TestSanYuan{
    public static void main(String[] args){
        int i = 20;
        int j = 20;
        //此时max记录了i与j的较大值
        int max = (i > j)? i : j;

        //String str = (i > j)? "i大" : "j大";
        String str = (i > j)? "i大" : (i == j)? "相等" : "j大";

        //String str1 = (i > j)? i : "j大";
        System.out.println(max);
        System.out.println(str);

        //互换
        if(i >= j){
            System.out.println("较大值为：" + i);
        }else{
            System.out.println("较大值为：" + j);
        }

        //练习：如何使用三元运算符，输出三个数中的较大值。
        int m = 12;
        int n = 23;
        int k = -9;
        int max1 = (m > n)? m : n;
        int max2 = (max1 > k)? max1 : k;
        System.out.println(max2);
    }
}

练习二：

class TestExer1{
    public static void main(String[] args){
        int m = 12;
        int n = 5;
        System.out.println("m:" + m + " n:" + n);
//        方法一：提供一个临时变量。
//        int temp = m;
//               m = n;
//               n = temp;
//        System.out.println("m:" + m + " n:" + n);

        //方法二：当m和n较大时，有可能出现精度损失
        //m = m + n;//m = 12 + 5;
        //n = m - n;//n = 17 - 5;
        //m = m - n;//m = 17- 12
        //System.out.println("m:" + m + " n:" + n);

        //方法三：优点：没有上面两种方法的缺点。 缺点：难！
        m = m ^ n;
        n = m ^ n;//(m ^ n) ^ n == m
        m = m ^ n;//(m ^ n) ^ m == n
        System.out.println("m:" + m + " n:" + n);
        
        //问题：
        //60  手动的方式，从控制台输出60的十六进制。
        int i = 60;
        //自动调用Integer类现成的方法
        String binary = Integer.toBinaryString(i);
        
        System.out.println(binary);//二进制

        String hex = Integer.toHexString(i);
        System.out.println(hex);//十六进制
        
    
//        char c1 = 'a';
//        char c2 = (char)(c1 + 2);
//        System.out.println(c2);//c
    

        int j = i & 15;//获取到i的最低4位对应的值。
        String k1 = (j <= 9)? j + "" : (char)(j - 10 + 'a') + ""; //转为字符串
        //System.out.println(k1);

        i = i >> 4;
        int z = i & 15;//获取到i的最高4位对应的值。
        String k2 = (z <= 9)? z + "" : (char)(z - 10 + 'a') + "";
//        System.out.println(z);
        System.out.println(k2 + k1);
    }
}

 9、程序流程控制

顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。

分支结构
根据条件，选择性地执行某段代码。
有if…else和switch两种分支语句。

循环结构
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

9.1 分支语句1： if-else语句

if语句三种格式：

1. if(true){
执行代码块；
}

2. if(条件表达式){
执行代码块；
}
else{
执行代码块；
}

3. if(条件表达式){
执行代码块；
}
else if (条件表达式){
执行代码块；
}
……
else{
执行代码块；
}

举例：

//流程控制：顺序结构；分支结构（if-else；switch-case）；循环结构(while;do...while;for(;;))
class TestSortStruc{
    public static void main(String[] args) {
        int i = 12;
        int j = i + 1;
        
        System.out.println(j);//13

        int m = 10;
        int n = m + 1;
        System.out.println(n);
    }
}

/*
注：执行if-else语句时，一定会选择其中的一个路径执行，而且也仅会选择一条路径。
*/
class TestIf1 {
    public static void main(String[] args){
        int age = 28;

        if(age > 18){
            System.out.println("你已经成年了！");
        }else{
            System.out.println("你还未成年！");
        }

        if(age > 130 || age < 0){
            System.out.println("估计你不是人！");
        }else if(age < 30){
            System.out.println("人家还很年轻，只有" + age + "岁啦！");
        }else{
            System.out.println("别追我了，我都有两个娃了！");
        }

        if(age < 30){//如果age<30，只执行第一个就跳出整个循环。
            //1.
        }else if(age < 60){
            //2.
        }else if(age < 100){
            //3.
        }else{
            //4.
        }

    }
}

//1.导包
import java.util.Scanner;
class TestScanner{
    public static void main(String[] args){
        //2.创建一个Scanner类的对象
        Scanner s = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        //3.调用此对象的相应的方法，完成键盘输入的值的获取
        //next():表示从键盘获取一个字符串
        String str = s.next();
        
        System.out.println(str);
    }
}

/*
从键盘输入小明的期末成绩。
当成绩为100分时，奖励一辆汽车；
当成绩为（80，99]时，奖励一个台iphone7s；
当成绩为[60,80]时，奖励一本参考书；
其它时，什么奖励也没有。

1.条件判断之间可以嵌套
2. ①如果多个条件之间是“互斥”关系，多个条件语句上下顺序是自由的。
   ②如果多个条件之间存在“包含”关系，要求范围小的写在范围大的上面。
*/
import java.util.Scanner;
class TestIf2{
    public static void main(String[] args) {
        
        Scanner s = new Scanner(System.in);
        System.out.println("请输入小明的期末成绩：（分）");
        int score = s.nextInt();
        
        if(score >100 || score < 0){
            System.out.println("你输入的数值有误！");
        }else{//if-else语句可以嵌套
            if(score == 100){
                System.out.println("奖励一辆汽车");
            }else if(score > 80){
                System.out.println("奖励一个iphone7s");
            }else if(score >= 60){
                System.out.println("奖励一本参考书");
            }else{
                System.out.println("什么奖励也没有");
            }
        }

    }
}

 练习一：编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else),并且从小到大输出。

/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。

说明：如果if-else if-else条件的执行语句块{}只有一条语句的话，那么这一对{}可以省略
建议：不要省略{}
*/
import java.util.Scanner;
class TestIf3{
    public static void main(String[] args) {
        //1.从键盘获取三个整数
        Scanner s = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int num1 = s.nextInt();
        System.out.println("请输入第二个整数：");
        int num2 = s.nextInt();
        System.out.println("请输入第三个整数：");
        int num3 = s.nextInt();

        //2.对num1，num2，num3从小到大排序
        System.out.println("从小到大的排序为：");
        if(num1 > num2){
            if(num3 > num1)
                System.out.println(num2 + "," + num1 + "," + num3);
            //System.out.println("helloworld");
            else if(num3 < num2)
                System.out.println(num3 + "," + num2 + "," + num1);
            else
                System.out.println(num2 + "," + num3 + "," + num1);
            
        }else{
            if(num3 > num2)
                System.out.println(num1 + "," + num2 + "," + num3);
            else if(num3 < num1)
                System.out.println(num3 + "," + num1 + "," + num2);
            else
                System.out.println(num1 + "," + num3 + "," + num2);
            
        }
    
    }
}

 9.2 分支结构2：switch语句

 

switch(变量){
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
… …
case 常量N:
语句N;
break;
default:
语句;
break;
}

举例：

/*
switch(变量){
    case 值1:

    case 值2:

    case 值3:

    default:

}
1.根据变量的值，选择相应的case去判断，一旦满足case条件，就执行case的相应语句。如果没有break或者已经
到结尾的话，会继续执行其下的case语句。
2.default:是可选的，而且位置是灵活的。
3.变量可以是哪些类型？char byte short int 枚举 String(jdk1.7)
4.case 条件:其中条件只能是值，不能是取值范围！
*/
class TestSwitch1 {
    public static void main(String[] args) {
        int i = 2;
        switch(i){
            
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");
                break;
        }
        /*
        switch(i){//case后面只能写值，不能写范围。
            case (i > 2):
                System.out.println("a");
                break;
            case (i > 5):
                System.out.println("b");
                break;
            default:
                System.out.println("c");
                break;
        }
        */
    }
}

class TestSwitch2{
    public static void main(String[] args) {
        
        String season = "SPRING";

        switch(season){
            case "SPRING":
                System.out.println("春天");
                break;
            case "SUMMER":
                System.out.println("夏天");
                break;
            case "AUTUMN":
                System.out.println("秋天");
                break;
            case "WINTER":
                System.out.println("冬天");
                break;
            default:
                System.out.println("输入有误");
                break;
        
        }
        
        
        
    }
}

 练习一：

/*
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

说明：
1.当多个case语句处理的语句块一致时，可以统一来书写
2.一定情况下switch-case与if-else之间可以相互转换。
*/
class TestSwitch3 {
    public static void main(String[] args){
        int score = 69;
        if(score >= 60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        /*
        switch(score){
            case 100:
            ...
            case 0:
            default:
        }
        */
        switch(score / 10){
            case 10:
            case 9:
            case 8:
            case 7:
            case 6:
                System.out.println("及格");
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                System.out.println("不及格");
                break;
            default:
                System.out.println("输入有误");
                break;
        
        }

    }
}

练习二：

/*
编写程序：从键盘上输入2014年的“month”和“day”，要求通过程序输出输入的日期为2014年的第几天
*/
import java.util.Scanner;
class TestSwitch4{
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入月份：");
        int month = s.nextInt();
        System.out.println("请输入日期：");
        int day = s.nextInt();

        int sum = 0;//用来记录month月day日是2014年第几天
        //使用switch-case
        switch(month){
        
        case 12:
            sum += 30;//30:十一月份的总天数
        case 11:
            sum += 31;
        case 10:
            sum += 30;
        case 9:
            sum += 31;
        case 8:
            sum += 31;
        case 7:
            sum += 30;
        case 6:
            sum += 31;
        case 5:
            sum += 30;
        case 4:
            sum += 31;
        case 3:
            sum += 28;
        case 2:
            sum += 31;//31:是一月份的天数
        case 1:
            sum += day;
    
        }

        System.out.println(sum);
    }
}

 练习三：

/*
编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级：

score>=90        等级：A
70<=score<90     等级: B
60=<score<70     等级: C
score<60         等级：D

*/
import java.util.Scanner;
class TestScore{
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入学生的成绩：");
        int score = s.nextInt();
        char level;
        /*
        if(score >= 90){
            level = 'A';
        }else if(score >= 70){
            level = 'B';
        }else if(score >= 60){
            level = 'C';
        }else{
            level = 'D';
        }
        */
        switch(score / 10){
            case 10:
            case 9:
                level = 'A';
                break;
            case 8:
            case 7:
                level = 'B';
                break;
            case 6:
                level = 'C';
                break;
            default:
                level = 'D';
                break;
        }

        System.out.println("score:" + score + ",level:" + level);
    }
}

练习四：

//从键盘分别输入年、月、日，判断这一天是当年的第几天
import java.util.Scanner;
class TestYearMonthDay{
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = s.nextInt();
        System.out.println("请输入月份：");
        int month = s.nextInt();
        System.out.println("请输入日期：");
        int day = s.nextInt();

        int sum = 0;//用来记录year年month月day日是year年第几天
        //使用switch-case
        switch(month){
        
        case 12:
            sum += 30;//30:十一月份的总天数
        case 11:
            sum += 31;
        case 10:
            sum += 30;
        case 9:
            sum += 31;
        case 8:
            sum += 31;
        case 7:
            sum += 30;
        case 6:
            sum += 31;
        case 5:
            sum += 30;
        case 4:
            sum += 31;
        case 3:
            if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
                sum += 29;
            }else{
                sum += 28;
            }
        case 2:
            sum += 31;//31:是一月份的天数
        case 1:
            sum += day;
    
        }
        System.out.println(sum);
    }
}

 9.3 for循环