JavaSE——二、Java语言基础

一、Java基本语法

输出语句：

System.out.println(); 先输出数据，然后换行
System.out.print(); 只输出数据

1.1、关键字（keyword）与保留字

关键字

• 定义：

被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

• 特点：

关键字中所有字母都为小写

保留字

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

goto、const

1.2、标识符（Identifier）

• 定义：

Java对各种变量、方法和类等要素命名时使用的字符序列
技巧：凡是自己可以起名字的地方都叫标识符
eg：类名、变量名、方法名、接口名、包名…

• 定义合法标识符规则：

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

Java中的名称命名规则

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

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

1.3、注释

• //单行注释,多种计算机语言适用
• /* */多行注释
• 文档注释

/**
	@author 指定java程序的作者
	@version 指定源文件的版本
*/
注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档

1.4、常量

• 定义：

表示不能改变的数值，Java中常量有整数常量、小数常量、布尔型常量、字符常量、null常量（只有null）。
对于整数有四种表现形式：二进制（满2进1）、八进制（满8进1，0开头）、十进制（满10进1），十六进制（满16进1，0X开头）。

1.5、变量

• 定义：

内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在该数据类型范围内不断变化。是程序中最基本的存储单元

• 使用：

数据类型 变量名 = 初始化值; 例如 int a = 0;

• 使用注意事项：

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

eg：

class VariableTest {
    public static void main(String[] args) {
        int myAge = 12;
        System.out.println(myAge);
        
        //编译错误：使用myNumber之前并未定义过myNumber
        //System.out.println(myNumber);

        //编译不通过
        //System.out.println(myClass);
    }
    public void method(){
        int myClass = 1;
    }
}

• 变量的分类—按数据类型
  对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间
  

1.5.1、整数类型（byte、short、int、long）

byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性
java的整型常量默认为int型，声明long型常量须后加"l"或”L“
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

1MB=1024KB 1KB=1024B B=byte或bit
bit是计算机中的最小存储单元，byte是计算机中基本存储单元

public class VariableTest1 {
    public static void main(String[] args) {
        //byte范围：-128 ~ 127
        byte b1 = 12;
        byte b2 = -128;
        //b2 = 128;//编译不通过
        System.out.println(b1);
        System.out.println(b2);

        short s1 = 128;
        int i1 = 1234;
        long l1 = 341234124L;
        System.out.println(l1);
    }
}

1.5.2、浮点类型（float、double）

float、double

• 浮点型常量有两种表示形式：

十进制数形式：如：5.12、512.0f、0.512
科学计数法形式：如：5.12e2、512E2、100E-2

• float：

单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求

• double：

双精度，精度是float的两倍。通常采用此类型。

Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’

        //float表示数值的范围比long还大
        double d1 = 123.3;
        System.out.println(d1 + 1);
        //定义float类型变量时，变量要以“f”或“F”结尾
        float f1 = 12.3F;
        //定义浮点型变量时，通常使用double型

1.5.3、字符类型（char）

char

char型数据用来表示通常意义上“字符”（2字节）

Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母、一个汉字或其他书面语的一一个字符。

• 字符型变量的三种表现形式:

➢字符常量是用单引号(’ ')括起来的单个字符.
eg：

char c1='a'；
char c2= '中'; 
char c3= '9';

➢Java中还允许使用转义字符‘\’ 来将其后的字符转变为特殊字符型常量。

eg:

char c3= '\n'; // '\n'表示换行符

➢直接使用unicode值来表示字符型常量：'\uXXXX'。其中，XXXX代表一个十六进制整数。

eg：

\u000a 表示\n。

        //定义char型变量，通常使用一堆''，内部只能写一个字符
        char c1 = 'a';
        //编译不通过
        //c1 = 'AB';

        char c2 = '1';
        char c3 = '中';

        char c4 = '\n'; //换行符
        char c5 = '\t'; //制表符Tab

• char类型是可以进行运算的。因为它都对应有Unicode码。

基本数据类型之间的运算规则：

前提：不包含布尔类型，只讨论7种基本数据类型
1、自动类型提升：
当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

	byte、char、short —>  int —>   long —>   float —>   double

特别的：当byte、char、short三种类型的变量做运算时，结果为int型

eg：

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

        byte b1 = 2;
        int i1 = 129;
        //编译不通过，结果为int类型，不可用byte接受
        //byte b2 = b1 + i1;
        int i2 = b1 + i1;
        long l1 = b1 + i1;
        System.out.println(i2);
        System.out.println(l1); //结果一样131
        
        float f = b1 + i1;
        System.out.println(f);
        
        short s1 = 123;
        double d1 = s1;
        System.out.println(d1);  //123.0
        
        //*********特别的*************
        char c1 = 'a'; //97
        int i3 = 10;
        int i4 = c1 + i3;
        System.out.println(i4);
        
        short s2 = 10;
        //char c2 = c1 +s2;//编译不通过 c1+s2结果为int型
        
        byte b2 = 10;
        //char c3 = c1 +b2;//编译不通过 c1+b2结果为int型
        
    }
}

2、强制类型转换：
自动类型提升运算的逆运算。

1、需要使用强转符：（）
2、强制类型转换，可能导致精度损失

eg1：

public class VariableTest3 {
    public static void main(String[] args) {
        double d1 = 12.9;
        //精度损失1
        int i1 = (int)d1;//截断操作
        System.out.println(i1); //12

        //没有精度损失
        long l1 = 123;
        short s2 = (short)l1;
        System.out.println(s2);//123

        //精度损失2
        int i2 = 128;
        byte b = (byte)i2;
        System.out.println(b); //-128
    }
}

eg2：

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

        long l = 123213;
        System.out.println(l);
        //编译失败：过大的整数
        //long l1 = 12323123123123123;
        long l1 = 12323123123123123L;

        //编译失败：float类型要么加f结尾，要么加强转符
        //float f1 = 12.3;
        float f1 = (float) 12.3;
        float f2 = 12.3f;
        System.out.println(f1);
        System.out.println(f2);
        
        byte b = 12;
        //编译失败,整型常量，默认类型为int型
        //byte b1 = b + 1;
        //编译失败,浮点型常量，默认类型为double型
        //float f1 = b+12.3;

    }
}

1.5.4、字符串类型（String）

String 不是基本数据类型，属于引用数据类型
使用方式与基本数据类型一致。

eg：

String str = "abcd";

一个字符串可以串接另一个字符串，也可以和8种基本数据类型变量做运算，且运算只能是连接运算，运算的结果仍然是Strig类型。

eg：

public class Test {
    public static void main(String[] args){
        String str = "abcd";
        str = str + "xyz";
        int n = 100;
        str = str + n;
        System.out.println(str); //abcdxyz100
    }
}

练习

强制类型转换练习

int与String之间的转换

public class Test {
    public static void main(String[] args){
        String str = 123 + "";
        System.out.println(str); //123

        //int num1 = str; 不通过
        //int num1 = (int)str; 不通过

        int num1 = Integer.parseInt(str);
        System.out.println(num1);  //123
    }
}

1.6、运算符

运算符（Java共六种）是一种特殊的符号，用以表示数据的运算、赋值和比较等。

1.6.1、算术运算符

自增（自减一样）：

public class Test {
    public static void main(String[] args){
       //前++：先自增1，后运算
       //后++：先运算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = "+ a1 + ",b1 = "+ b1);//a1 = 11,b1 = 11

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

        int a3 = 10;
        ++a3; //代码从上往下执行，此时前++和后++一样，结果都会先加1
        int b3 = a3;

        //自增自减都不会改变本身变量的数据类型
        short s1 = 10;
        //s1 = s1 + 1 ; 此时short类型变为int类型
        s1++;
        System.out.println(s1);//11

        //**********不改变数据类型***********
        byte bb1 = 127;
        bb1++;
        System.out.println(bb1);//-128 
    }
}

1.6.2、赋值运算符

public class Test {
    public static void main(String[] args){
  
  		 //运算不会改变变量本身的数据类型
        short s1 = 1;
        s1 += 2;
        System.out.println(s1);//3，数据类型还是short型
    }
}

1.6.3、比较运算符（关系运算符）

比较运算符的结果都是boolean型（true 或 false）

1.6.4、逻辑运算符

&与&&的区别

• 相同点
  运算结果相同；当符号左边是true时，二者都会执行符号右边的运算
• 不同点
  当符号左边是false时，&继续执行符号右边的运算，&&不再执行符号右边的运算

eg：

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

        boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)){
            System.out.println("我现在在广东");
        }else{
            System.out.println("我现在在广广西");
        }

        System.out.println("num1 = " + num1);

        boolean b2 = true;
        b2 = false;
        int num2 = 10;
        if (b2 && (num2++ > 0)){
            System.out.println("我现在在广东");
        }else{
            System.out.println("我现在在广广西");
        }

        System.out.println("num2 = " + num2);
    }
}

|与||的区别

• 相同点
  运算结果相同；当符号左边是true时，二者都会执行符号右边的运算
• 不同点
  当符号左边是false时，|继续执行符号右边的运算，||不再执行符号右边的运算

1.6.5、位运算符

位运算是直接对整数的二进制进行的运算

1.6.6、三元运算符

凡是可以使用三元运算符的地方，都可以改正if-else（反之不成立）
eg：

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

        int m = 10;
        int n = 12;
        String maxStr = (m > n)?"大":((m == n)? "m和n相等": "大" );
        System.out.println(maxStr);

        // 获取三个数的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;

        int max1 = (n1 > n2)? n1 : n2;
        int max2 = (max1 > n3)? max1 : n3;
        System.out.println("三个数中的最大值：" + max2);

        int max3 = (((n1 > n2)? n1 : n2) > n3) ? ((n1 > n2)? n1 : n2) : n3;
        System.out.println("三个数中的最大值：" + max3);

    }
}

运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序.如右表，上–行运算符总优先于下一行

只有单目运算符、三元运算符、赋值运算符是从右向左运算的.

程序流程控制
顺序
分支
if-else
1：
if(条件表达式){ }
2：二选一
if（条件表达式）{
执行表达式1
}else{
执行表达式2
}
3：多选一
if（条件表达式）{
执行表达式1
}else if(条件表达式){
执行表达式2
}
…
else{
执行表达式n
}

循环

• 语句

  • 判断结构
    if、switch
  • 选择结构
  • 循环结构
    while、do while
    break\continue

  break//跳出。应用于选择结构和循环结构。
  continue//继续。 应用于循环结构 。
  这两个语句单独存在下面不可以有语句，因为执行不到，continue语句结束本次循环继续下次循环。

• 函数
  函数是定义在类中的具有特定功能的一段独立小程序，也称为方法。函数的格式一般为：

修饰符 返回值类型 函数名（参数类型 形参1，参数类型 形参2，…）{ 执行语句; return 返回值; }

/*返回值类型：函数运行后结果的数据类型；
参数类型：形参的数据类型；
形参：变量，用于存储调用函数时传递给函数的实参；
实参：传递给形参的具体数值； return 用于结束函数；
返回值：函数运算后的结果，该结果会返回给调用者。没有具体返回值时return后面直接用分号结束，返回值类型为关键字void。
*/

//返回和值的参数 public static int add(int a,int b){ return a+b; }

函数的特点

• 定义函数可以将功能代码进行封装；
• 便于对该功能进行复用；
• 函数只有被调用才会被执行；
• 函数的出现提高了代码的复用性；
• 对于函数没有具体返回值的情况，返回值类型用关键字void表示，该函数中的return语句如果在最后一行可以省略不写；
• 函数中只能调用函数，不可以在函数内部定义函数；
• 定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的重载

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可，重载与返回值类型无关，只看参数列表，重载可以方便阅读，优化程序设计

//返回两个整数的和
int add(int x,int y){ return x+y; }
//返回三个整数的和
int add(int x,int y,int z){ return x+y+z; }
//返回两个小数的和
double add(double x,double y){ return x+y; }

• 数组
  同一种类型数据的集合，数组就是容器。数组可以自动给数组中的元素从0开始编号，方便操作。数组定义有两种格式

//格式1
//元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
int[] arr = new int[5];
//格式2
//元素类型[] 数组名 = new 元素类型[] {元素1,元素2,…}
int[] arr = new int[]{1,3,5,7}; int[] arr = {1,3,5,7};

(2)内存的划分

• 寄存器
• 本地方法区
• 方法区
• 栈内存（存储的都是局部变量，变量所属作用域结束，变量自动释放）
• 堆内存[存储的是数组和对象（数组就是对象）凡是new建立在堆中， 每一个实体都是首地址值；
  堆内存中的每一个变量都有默认初始化值，根据类型不同而不同，整数是0，小数是0.0或者0.0f，boolean是false，char是’\u0000’；
  垃圾回收机制。

(3)二维数组

二维数组的定义方式==

//格式1
int[][] arr = new int[3][2];
//打印二维数组的长度，即一维数组的个数
System.out.println(arr.length);
//打印二维数组中角标为1的一维数组的长度
System.out.println(arr[1].length)
//格式2
int[][] arr = new int[3][];
arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];

(4)数据类型

类型	位数	值域
boolean	(JVM决定)	true/false
char	16 bits	0~65535
byte	8 bits	-128~127
short	16 bits	-32768~32767
int	32 bits	-2147483648~2147483647
long	64 bits	-9,223,372,036,854,775,808~9,223,372,036,854,775,807
float	32 bits	范围规模可变
double	64 bits	范围规模可变

注：

float f = 32.5f 除非加上f，否则所有带小数点的值都会被 Java 当作 double 处理

（5）Java命名规则

• 类名的首字母应大写，方法名的首字母应小写
• 变量名必须以**字母、下划线或$**开头
• 所有的 Java 程序由 public static void main(String[] args) 方法开始执行

源文件声明规则：

• 一个源文件中只能有一个 public 类，可以有多个非public类
• 源文件名须和public类名相同
• 如果一个类定义在某个包中，那么package语句应该在源文件的首行
• 如果源文件包含import语句，那么应该放在package语句和类定义之间；如果没有package语句，那么应该放在最前面
• import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明