第二章 JAVA编程基础

第二章 JAVA编程基础

2.1 java 的基本语法

1. 代码的基本格式

修饰符 class 类名 {
	程序代码
	}

• 程序代码中分为结构定义语句和功能执行语句
  结构定义语句用于声明一个类或方法
  功能执行语句用于实现具体的目标
• 每条功能执行语句最后都必须用分号结束
• java语言严格区分大小写
• java程序中的一句连续的字符串不能分开在两行中书写
  如想将一个太长的字符串分在两行中书写，可以将这个字符串分成两个字符串，然后用“+”将两个字符串连起来。在“+”处断行。

eg:  System.out.println("这是一个" +
  				"java程序")；
  相等于：System.out.println("这是一个java程序");

2. JAVA中的注释类型

1. 单行注释(符号"//")
   eg： int c=10； // 定义一个整型变量
2. 多行注释(符号以"/ * "开头，"* /"结尾)
   eg： /** int c=10；int b=5； **/
3. 文档注释: 以"/ * * "开头，并在注释末尾以"* * / "结尾

3. JAVA中的标识符

编程过程中，需要在程序中定义一些符号来标记一些名称。

如：包名，类名，方法名，参数名，变量名

• 标识符可由任意的大小写字母、数字、下划线(_)和美元符号($)组成。
• 但不能以数字开头，不能是java中的关键字。

定义标识符需建立的规则

1. 包名所有字母一律小写。 eg：cn.itcast.test
2. 类名与接口名每个单词的首字母要大写。 eg：ArrayList Lterator
3. 常量名中所有的字母都大写，单词之间用下划线链接。 eg:DAY_OF_MONTH
4. 变量名与方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。
   eg：lineNumber getLineNumeber
5. 在程序中，应尽量使用有意义的英文单词来定义标识符。

4. JAVA中的关键字

关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。

5. JAVA中的常量

常量就是在程序中固定不变的值，是不能改变的数据。

1. 整型常量

整型常量是整数类型的数据，表现形式有四种。
    二进制:由数字0和1组成的数字序列组成的数字序列
    八进制:以0开头并且其后由0~7(包括0,7)的数字
    十进制:（第一位不能为0）由数字0~9(包括0,9)的整数组成的数字序列
    十六进制:由0X或0x开头并由其后由0~9，A~F组成的数字序列

2. 浮点数常量—小数

分为float单精度浮点数（以f或F结尾）和double双精度浮点数（以D或d结尾）。

3. 字符常量

- 定义：用于表示一个字符，要用一对英文半角格式的单引号（’ '）引出来。
可以是英文字母，数字，标点符号，以及由转义序列表示的特殊字符。
eg: ‘a’, ‘1’, ‘＆’, ‘
’, ‘u0000’

‘u0000’表示一个空白字符，即单引号之间无任何字符。
because ：Java采用得是Unicode字符集，以U开头，空白字符对应’u0000’

4. 字符串常量

- 用于表示一串连续的字符，要用（" "）引起来。 
    eg：“HelloWorld” “123” " "
- 一个字符串可包含一个字符或多个字符，也可不包含任何字符，即长度为0.

5. 布尔常量

即布尔型的两个值 true和false，用于区别事物的真或假。

6. null常量

只有一个值null，表示对象的引用为空。

2.2JAVA中的变量

1.变量的定义

• 在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元用一个标识符来标识，这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。

2.变量的数据类型

• 注：在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一类型的值，否则程序会报错。

1. 整数类型变量

   • 用来存储整数数值，即没有小数部分的值。

   • 整数类型分为4种不同的类型：字节型（byte）、短整型（short）、整型（int）和长整型（long）。

     类型名	占用空间	取值范围
     byte	8位(1个字节)	-2^7 ~ 2^7 -1
     short	16位(2个字节)	-2^15 ~ 2^15 -1
     int	32位(4个字节)	-2^31 ~ 2^31 -1
     long	64位(8节)	-2^64 ~ 2^64 -1

   • 占用空间指的是不同类型的变量分别占用的内存大小

   • 取值范围是变量存储的值不能超出的范围

   • 为一个long类型的变量赋值时需要注意一点，所赋值的后面要加上一个字母“L”（或小写“l”），说明赋值为long类型。如果赋的值未超出int型的取值范围，则可以省略字母“L”（或小写“l”）

long num = 20000000L;//所赋的值超出了int型的取值范围，后面必须加上字母L

long num = 198L;//所赋的值未超出int型的取值范围，后面可以加上字母L

long num = 198;//所赋的值未超出int型的取值范围，后面可以省略字母L

2. 浮点数类型变量
   • 浮点数类型变量用来存储小数数值。
   • 浮点数类型分为两种：单精度浮点数（float）、双精度浮点数（double），double型所表示的浮点数比float型更精确。

     类型名	占用空间	取值范围
     float	32位(4个字节)	1.4E-45 ~ 3.4E+38,-1.4E-45 ~ -3.4E+38
     double	64位(8个字节)	4.9E-324 ~ 1.7E+308,-1.7E+328 ~ -4.9E-324

   • 在取值范围中，E表示以10为底的指数，E后面的“+”号和“-”号代表正指数和负指数，例如1.4E-45表示1.4*10-45。
   • 在为一个float类型的变量赋值时需要注意一点，所赋值的后面一定要加上字母“F”（或“f”），而为double类型的变量赋值时，可以在所赋值的后面加上字符“D”（或“d”），也可不加。
   • 在程序中也可以为一个浮点数类型变量赋予一个整数数值。

float f = 123.4f;//为一个float类型的变里赋值，后面必须加上字母f

double dl = 100.1;//为一个double类型的变里赋值，后面可以省略字母d

double d2 = 199.3d;//为一个double类型的变里赋值，后面可以加上字母d

3. 字符类型变量
   • 用于存储一个单一字符，在Java中用char表示。
   • 每个char类型的字符变量都会占用2个字节。
   • 赋值时，要用英文半角格式的单引号（''）把字符括起来，如'a'，
   • 也可以赋值为0~65535范围内的整数，计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。

char c = 'a';//为一个char类型的变量赋值字符a
char ch = 97 ;//为一个char类型的变量赋值整数97，相当于赋值字符a

4. 布尔类型变量
   布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。具体示例如下：

boolean flag = false;//声明一个boolean类型的变里，初始值为falser
flag = true;//改变flag变里的值为truet

3.变量的类型转换

• 当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
• 根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。

1. 自动类型转换
   • 也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。
   • 要实现自动类型转换，必须同时满足两个条件，
     • 第一是两种数据类型彼此兼容，
     • 第二是目标类型的取值范围大于源类型的取值范围。

   1. 整数类型之间可实现转换。如：short，char类型可赋给int，long。
   2. 整数类型转float类型，如：byte，char，short，int可赋给float。
   3. 其他类型转double，如：byte，char，short，int，long，float可赋给double。

2. 强制类型转换
   • 强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。
   • 当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
   • 强制类型转换的格式如下所示：

   目标类型 变量 = (目标类型)值
   

   • 大类型转小类型会出现数据精度丢失的问题

4.变量的作用域

• 变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
• 在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。

5.算术运算符

• 在进行自增（++）和自减（--）的运算时，如果运算符放在操作数的前面则是先进行自增或自减运算，再进行其它运算。反之，如果运算符放在操作数的后面则是先进行其它运算再进行自增或自减运算。
• 在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数。
• 在进行取模（%）运算时，运算结果的正负取决于被模数(%左边的数)的符号，与模数(%右边的数)的符号无关。
• 赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量，表中列出了Java中的赋值运算符及用法。

6.赋值运算符

• 一条赋值语句对多个变量进行赋值

int x,y,z;
x = y = z = 5;   //为三个变量同时赋值
int x = y = z = 5;  //这样写是错误的

• 除了“=”，其它的都是特殊的赋值运算符，以“+=”为例，x += 3就相当于x = x +3，首先会进行加法运算x+3，再将运算结果赋值给变量x。- -=、*=、/=、%=赋值运算符都可依此类推
• 在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，需要进行强制类型转换。然而在使用+=、-=、*=、/=、%= 运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式地声明。

7.比较运算符

• 比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。
• == 表示 相等于； = 表赋值

8.逻辑运算符

• 逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型。

& 与： 全真才真，一假则假，
| 或：一真全真， 一假则假，
^ 异或：两边全为真/假，则假。两边不一样，则真。
&& 短路与，|| 短路或：如果第一个已经足够证明式子的真假，则直接进行判断，不考虑后面的式子。

• 在使用逻辑运算符的过程中，需要注意以下几个细节：
  • 逻辑运算符可以针对结果为布尔值的表达式进行运算。如：x > 3 && y != 0。
  • 运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。
  • 运算符“|”和“||”都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false。同与操作类似，“||”表示短路或，当运算符“||”的左边为true时，右边的表达式不会进行运算。
  • 运算符“^”表示异或操作，当运算符两边的布尔值相同时（都为true或都为false），其结果为false。当两边布尔值不相同时，其结果为true。

9.运算符的优先级

优先级	运算符	优先级	运算符
1	. [] ()	8	&
2	++ -- ~ !	9	^
3	* / %	10	｜
4	+ -	11	&&
5	<< ，>> ， >>>	12	‖
6	<， >， <=， >=	13	？：
7	== ，!=	14	=，*=，/=，+=，-=，<<=, >>=, >>>=, &=, ^=，｜=

2.4 选择结构语句

1. if语句

• 分为三类，if语句，if…else语句，if…else if…else语句
  • if语句

   public class If{
       public static void main(String[] args){
       int x = 5;
       if( x < 10){
       x ++ ;}
       System.out.println("x is " +x);
       }
   }
  

  • if…else语句

  public class IfElse{
      public static void main(String[] args){
      int num = 19;
      if (num % 2 == 0){
        System.out.println("num为偶数")；
      }
      else{
        System.out.println("num为奇数")；
      }
     }
  }
  

  • if…else多级语句

  public class IfElseDuoji{
      public static void main(String[] args){
      int gread = 75;
      if (gread >80){
        System.out.println("成绩为优")；
      }
      else if（gread >70）{
        System.out.println("成绩为良");
      }
      else if(gread >60){
        System.out.println("成绩为中");
      }
      else {
        System.out.println("成绩为差")；}
      }
    }
  }
  

2. switch语句

• 在switch语句中，使用switch语句来描述一个表达式，使用关键字来描述和表达式结果比较的目标值。当表达式的值和某个目标值匹配时，全执行对应case下的语句。
• 需要注意的是，在switch语句中的表达式只能是byte、short、char、int、枚举、String类型的值，如果传入其他值，程序会报错。
• 在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可。

public class Switch{
	public static void main(String[] args){
	int week = 3;
	switch (week){
	case 1: //注意是 冒号，不是分号
		System.out.println("星期一")；
		break;
	case 2:
		System.out.println("星期二");
		break;
	case 3:
		System.out.println("星期三")；
		break;
	case 4:
		System.out.println("星期四")；
		break;
	case 5:
		System.out.println("星期五");
		break;
	case 6:
		System.out.println("星期六");
		break;
	case 7:
		System.out.println("星期日");
		break;
	default :
		System.out.println("您输入的数字错误");
		break;

    }
  }
}

2.5循环结构语句

1.while语句

根据条件判断来决定是否执行后面的代码，while循环语句会反复的进行条件判断。只要条件成立，{}内的执行语句会执行，直到条件不成立，循环结束。
格式：while （循环条件） {执行语句}

public class While{
	public static void main(Srting[] args){
	int x = 1;
	while ( x < 4){
	System.out.println("x = " +x);
	x++;
    }
  }
}

2.do…while语句

格式：do {执行语句} while （循环条件）
先进行一次循环，再判断条件是否满足。

public class DoWhile{
	public static void main(String[] args){
	int x = 1;
	do {
	System.out.println("x = " +x);
	x++;}
    }while(x <= 4);   //注意分号
}

3.for循环

格式：for（初始化表达式 ; 循环条件 ; 操作表达式）{执行语句}
先进行表达式和循环条件，满足则进行执行语句，不满足则无法进入执行语句。执行语句结束后进行操作表达式，再返回循环条件，继续执行语句。直到表达式不满足循环条件。

public class For{
	public static void main(String[] args){
	int sum = 0;
	for ( int i = 1; i <= 4; i++){
	sum += i;
    }
	System.out.println(" sum is " +sum);
  }
}

4.循环嵌套

在一个循环语句的循环体中再定义一个循环语句的语法结构。

// for循环嵌套打印直角三角形
public class ForQianTao{
	public static void main(String[] args){
	int i,j;
	for( i = 1; i <= 9; i++){      //外层循环
		for(j = 1; j <= i; j++){   //内层循环
		System.out.print("*");   //打印*
        }
		System.out.println();
	 }   //换行
  }
}

5.跳转语句（continue，break）

1. break语句：用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。
2. continue语句：用在循环语句中，它的作用是终止本次循环，执行下一次循环。

//break语句（跳出循环）
public class Break{
	public static void main(String[] args){
	int i,j;
	it cast: for( i = 1; i <= 9; i++){
			for( j = 1; j <= i; j++){
			if( i > 4){
			break it cast;}
	}System.out.print("*");
	}System.out.println();
  }
}

2.6 方法

• 为解决代码重复编写的问题，将重复的代码提取出来放在{}中，并取一个名字，这样可通过这个名字来调用这段代码。
• 格式：

修饰符  返回值类型  方法名  ([参数类型  参数名1,参数类型 参数名2]){
	执行语句   
	......
	return 返回值；
}

• 修饰符：是对访问权限的限定，例如，public、static都是修饰符
• 返回值类型：用于限定方法返回值的数据类型
• 参数类型：用于限定调用方法时传入参数的数据类型
• 参数名：是一个变量，用于接收调用方法时传入的数据
• return关键字：用于结束方法以及返回方法指定类型的值
• 返回值：被return语句返回的值，该值会返回调用者

//案例代码 打印不同大小的矩阵
public class Fangfa{	
	public static void main(String[] args){
	printJuzhen(3,4);
	printJuzhen(5,7);
	printJuzhen(10,12);
    }
	public static void printJuzhen(int x , int y){
		for(int i = 0; i < x; i++){
			for(int j; j < y; j++){
			System.out.print("*");}
			System.out.println();
        }
    }
}

//有返回值的方法
public class Fanhui{
	public static void main(String[] args){
	int z = FanHui(5,6);
	System.out.println("z = " +z);
	}
	public static int FanHui(int x, int y){
	return x * y;
	}
}

• Java允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。

//方法重载（求几个数的和）
public class ChongZai{
	public static void main(String[] args){
	System.out.println("getArr = " +getArr(12,23);
	System.out.println("getArr = " +getArr(45.23,12.56);
	System.out.println("getArr = " +getArr(12,23.78);
}
	public static int getArr(int x, int y){
	return x + y;
	}
	public static double getArr(double x, double y){
	return x + y;
	}
	public static float getArr(int x, float y){
	return x + y;
	}
}

2.7数组

• 数组是指一组数据的集合，数组中的每个元素被称为元素，在数组中可以存放任意类型的元素，但同一个数组中存放的元素类型必须一致。
• 格式：

	int[]x = new int [100];
等价于：
	int[]x;
	x = new int[100];
	
	/*相当于在内存中定义了100个int类型的变量，第一个变量的名称称为x[0]，第二个为x[1]，以此类推，
第100个为x[99]，这些变量的初始值为0.*/

• 在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。
• 当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。

数据类型	默认初始值
byte , short , int , long	0
float , double	0.0
char	一个空字符，即"u0000"
long	0L
boolean	false
引用数据类型	mull，表示变量不引用任何对象

//定义数组及访问数组中的元素
public class Shuzu{
	public static void main(String[] args){
	int arr[];    //定义数组
	arr = new int[100];	//创建数组容量
	System.out.println("arr[0] = " +arrr[0]);
	System.out.println("arr的长度为" +arr.length);
  }
}

//为数组赋值
public class Fuzhi{
	public static void main(String[] args){
	int arr[] = new int[2];		//new之后的[] 一定要写入容量
	arr[0] = 1;
	arr[1] = 2;
	System.out.println("arr[0] = " +arr[0]);
	System.out.println("arr[1] = " +arr[1]); 
  }
}

ps：new之后的[]一定要写入容量，如果没有容量编译是不通过的。
对于没有的赋值的元素，统一都是0.
当然也要注意输出的值不能超过容量的大小。

• 在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式：
  1. 类型[ ] 数组名 = new 类型 [ ] { 元素 }；
  2. 类型[ ] 数组名 = { 元素 }；

//静态初始化、越界
public class Jingtai{
	public static void main(String[] args){
	int [] arr = {1,2,3,4};
	System.out.prinrln("arr[0] = " +arr[0]);
	System.out.println("arr[1] = " +arr[1]);
	System.out.println("arr[2] = " +arr[2]);
	System.out.println("arr[3] = " +arr[3]);
	System.out.println("arr[4] = " +arr[4]);//编译到此处不通过
  }
}

ps：数组的容量是从0开始打得。例如本例中，初始化定义和赋值数组放一起进行，只有四个数字，
所以结果也是从元素0开始，于元素3结束，即0 1 2 3 。出现4之后即为越界。

//空指针异常
public class Kong{
	public static void main(String[] args){
	int arr[] = new int [3];  //定义数组
	arr[0] = 5;	//为第一个元素赋值
	System.out.println("arr[0] = " +arr[0]);
	arr = null; 	//给数组赋空
	System.out.println("arr[0] = " +arr[0]);
  }
}

ps：为整个数组赋空，即这个数组中所有的元素都为空

数组的常见操作

1、数组遍历

• 在操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数组的遍历。

//使用for循环遍历数组
public class BianLi{
	public static void main(String[] args){
	int [] arr = {2,3,4,5,6};   //定义数组
	for(int i = 0; i < arr.length; i++){
	System.out.println(arr[i]);    //通过索引访问元素
	}
  }
}

2、数组最值

• 在操作数组时，经常需要获取数组中元素的最值。

//获取数组中元素的最大值
public class MAX{
	public static void main(String[] args){
	int []arr = {12,45,98,32,65,78};  
	int max = getMax(arr);
	System.out.println("max is " +max);
    }
	static int getMax(int arr[]){
	int max = arr[0];
	for(int x = 1; x < arr.length; x++){
		if(arr[x] > max){
			max = arr[x];
		}
	}
	return max;  //返回最大值
  }
}

3、数组排序

• 在操作数组时，经常需要对数组中的元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程和水中气泡上升的原理相似。
• 数组排序的过程如下所示：
  （1）从第一个元素开始，将相邻的两个元素依次比较，直到最后两个元素完成比较，如果第一个元素比后一个大，则交换位置。整个过程完成后，数组中最后一个元素就是最大值。
  （2）除最后一个元素，将剩余的元素继续进行两两比较，过程与第一步类似，这样数组中第二大的元素放在了倒数第二个位置。
  （3）以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一个元素需要比较为止。

//数组冒泡排序
public class MaoPao{
	public static void main(String[] args){
     	int arr[] = {9，8，3，5，2};
	    System.out.println("排序前的数字是")；
	    printShuZu(arr);  //打印数组元素
	    fangfa(arr);   //调用排序方法
	    System.out.println("排序后的数字是");
	    printShuZu(arr);	  //打印数组元素
    }    
    //打印数组的方法
	public static void printShuZu(int []arr){	
	    for (int i = 0; i < arr.length; i++){
	    System.out.print(a[i] +"   ");
	    }
	    System.out.prinln("
");
    }
    //冒泡排序的方法
	public static void fangfa(int []arr){		
	for(int i = 0; i < arr.length - 1; i++){
		for(int j = 0; j < arr.length -i -1; j++){
			if(arr[j] > arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;}
			}
	    }
    }
}

多维数组

• 多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组。
• 二维数组的定义有很多方式，具体如下：
  • 方式一：int [ ] [ ] arr = new int [3] [4]
  • 方式二：int [ ] [ ] arr = new int [3] [ ]
  • 方式三：int[ ] [ ] arr = { {1,2},{3,4.5,6},{7,8,9}}
• 多维数组对元素的访问时通过角标的方式。
  例如：访问二维数组中第一个元素数组的第二个元素的方式如下： arr [0] [1];