JAVA编程基础

一、java的基本语法

1.java代码的基本格式

​ java中程序代码都必须放在一个勒种。类需要使用class关键字定义，在class前面可以有一些修饰符，如下：

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

2.在编写java代码时，需要特备的关键点：

• java中的程序代码可分为结构定义语句和功能执行语句，其中，结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功能执行语句的最后都必须用分号（；）结束。

   System.out.println("Hello World")
  

• java语句严格区分大小写。例如，定义一个类是，Computer和computer是两个完全不同的符号，在使用时务必注意

• 虽然Java没有严格要求用什么样的格式来编排程序代码，但是，出于可读性考虑，应该让自己编写的程序代码整齐美观、层次清晰。

• Java程序中第一句连续的字符串不能分开在两行中书写，如果实在太长可以利用+号将两个字符串进行连接

二、java中的注释

在编写程序时，为了时代吗易于阅读。通常会在实现风能的同事为代码加一些注释

注释是对程序的某个狗能或者某行代码的解释说明，它旨在Java源文件中有效，在编译程序时编译器会忽略掉这些注释信息，不会将其编译到class字节码文件中去。

java的注释分为三种：

1.单行注释

通常用于程序中的某一行代码进行解释，用符号“//”表示，“//”后面为被注释的内容，具体如下

int c=10 //定义一个整型变量

2.多行注释

多行注释中可以出现单行注释，但是不能再次出现多行注释

/*
hello
这是注释
*/

3.文档注释

以/**开头，并且在注释内容末尾以*/结尾。

三、Java中的标识符

在编译过程中，经常需要在程序定义一些符号来标记一些名称，如：包名，类名，方法名，参数名，变量名等，这些符号成为标识符。

标识符可以由仍以顺序的大小写字母、数字、下划线和美元符号组成，但不能以数字开头，不能是Java中的关键字。

建议初学者在定义标识符时还应该遵循以下规则：

• 包名所有字母一律小写
• 类名和接口名每个单词的字母要大写
• 常量名所有字母都要大写
• 变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写
• 在程序中，应该尽量使用有意义的英文的单词来定义标识符，使得程序便于阅读。

四、Java中的关键字

关键字时编辑语言里实现定义好并赋予特殊含义的单词，也称做保留字。

abstract	boolean	break	byte	case	catch	char
const	class	continue	default	do	double	else
extend	false	final	finallly	float	for	goto
if	implements	import	instanceof	int	interface	long
native	new	static	package	private	protected	public
return	short	transient	strictfp	super	switch	this
throw	throws	null	true	try	void	volatile
while	synchronized

五、java中的常量

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

在java中包括整型常量、浮点型常量、布尔常量、字符常量等

1.整型常量

整型常量是帧数类型的数据，它的表现形式有四种，具体如下：

• 二进制
• 八进制
• 十进制
• 十六进制

2.浮点常量

浮点数长了两就是数学中用到的小数，分为float和double。单精度浮点数后面以F或f结尾，双精度后面以D或d结尾，也可以不加，则默认为双精度。

3.字符常量

字符串常量用于表示一个字符，一个字符串常量要用一对英文半角格式单引号（’’）引起来，它可以是英文字母、数字、标点符号、以及由转移序列来表示的特殊字符。'a' '1' '&' '\u11000'

注：java采用unicode字符集。

4.字符串常量

字符串常量用一连串的字符，一个字符串常量要用一对英文半角格式的双引号("")引起来。

一个字符串可以包含一个或多个字符，也可以不包含任何字符，即长度为零。

5.布尔常量

布尔常量即布尔型的两个值true和false，该常量用于区分一个事物的真与假。

6.null常量

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

六、变量的定义

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

java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。
$$数据类型\{\begin{array}{l}基本数据类型\{\begin{array}{l}数值型\{\begin{array}{l}整数类型(byte,short,int,long)\\ 浮点类型(float,double)\end{array}\\ 字符型(char)\\ 布尔型(boolean)\end{array}\\ 引用数据类型\{\begin{array}{l}类(class)\\ 接口(interface)\\ 数组\\ 枚举(enum)\\ 注解(Annotation)\end{array}\end{array}$$

1.整数类型变量

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

整数类型分为以下四种

类型名	占空间	取值范围
byte	8位（1个字节）	-27~27-1
short	16位（2个字节）	-215~215-1
int	32位（4个字节）	-231~231-1
long	64位（8个字节）	-263~263-1

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

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

2.浮点类型

浮点数类型变量用来存储小数数值

浮点数类型分为两种：单精度浮点数和双精度浮点数。

类型名	占用空间
float	32位（4个字节）
double	64位（8个字节）

3.字符类型变量

用于存储一个单一字符，在java中用char表示

每个char类型的字符串变量都会占用2个字节

复制时，要用英文半角格式的单引号（’’）吧字符串括起来。也可以赋值0~65535范围内的整数，计算机会自动讲这些整数转化为所对应的字符。

4.布尔类型变量

布尔类型变量用来存储布尔值，在java中用boolean表示，该类型变量只有两个值：true和false。

七、变量的类型转化

当把一种数据类型的值赋值给另一种数据类型的变量时，需要进行数据转化。

根据转化的方式不同，数据类型转化可分为两种：自动类型转化和强制类型转化。

1.自动类型转化

也叫作隐式类型转化，指的是两种数据类型在转化的过程中不需要显示的进行声明。

要实现自动类型转化，必须同时满足两个条件：

• 一是两种数据彼此兼容
• 而是目标类型的取值范围大于源类型的取值范围。

byte b=3;
int x=b; // 程序把byte类型的变量b转化成了int类型，无需特殊声明

1.整数类型之间可以实现转化，如byte类型的数据合一赋值给short，int，long类型的变量等。

2.整数类型转化成float类型，如byte，char，short，int类型的数据可以赋值给float类型的变量。

3.其它类型的转化为double类型，如byte，char，short，int，long，float类型的数据可以复制给double类型的变量。

2.强制类型转化

强制类型转化也叫显式类型转化，指的是两种数据类型之间的转化需要进行显式的声明

当两种类型彼此不兼容，或者目标类型取值范围小于原类型时，自动类型转化无法进行，这是就需要强制类型转换。

目标类型 变量 = （目标类型）值

int num = 4;
byte b = (byte)num;

所谓表达式是指由变量和运算符组成的一个算式。变量在表达式中进行运算时，也有可能发生自动类型转化，这就是表达式数据类型的自动提升。

八、变量的作用域

变量需要在它的作用范围内才可以被使用，这个作用范围成为变量的作用域。

在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。

九、算数运算符

与c语言类似，其中将取模改为%

%，++i,i++,--i,i--

并且在取模运算时，运算结果的正负取决于被模数的符号，与模数的符号无关。7%(-3)==1

十、赋值运算符

=,+=,-=,*=,/=,%=

1.在赋值运算中，需要注意以下几点:在java中可以通过一条赋值语句对多个变量进行赋值

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

2.除了“=”，其他都是特殊的赋值运算符。

3.在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，需要进行强制类型转化。然而在使用特殊赋值运算符时，强制类型转化会自动完成，程序不需要做任何显示声明。

short s = 3;
int i = 5;
s = (short)i;
s += i;//以上两种都是强制转化

十一、比较运算符

==,!=,<,>,<=,>=

比较运算符在使用时需要注意一个问题，不能将比较运算符“==”携程赋值运算符“=”

十二、逻辑运算符

&,|,^,!,&&,||依次为与，或，异或，非，短路与，短路或

短路与：只有左右两边同时为t时才返回t，但是如果左边为true时，右边就不在运算。

短路或：只有左右两边同时为f时才返回f，但是如果左边为f时，右边就不进行运算。

^：当两边的布尔值相同时，结果为t，否则为f。

在使用逻辑运算符过程中，需要注意逻辑运算符可以针对结果为布尔值的表达式进行运算。如：x>3 && y!=0

int x=0;
int y=0;
int z=0;
boolean a,b;
a=x>0&y++>1 //整个为f,此时a为false，y为1
a=x>0&&z++>1 //整个为f，此时a为false，z为0

十三、运算符优先级

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

十四、if条件语句

if条件语句分为三种语法格式，具体如下：

• if语句
• if……else语句
• if……else if……if语句

1.if语句

if语句指如果满足某种条件，就进行某种处理，其语法格式如下：

if (条件语句)
{
	代码块
}

2.if……else语句

if （判断条件）{
	执行语句1
}else{
	执行语句2
}

3.特殊的三元运算

判断条件 ？ 表达式1 ： 表达式2

4.if……else if……else语句

if （判断条件）{
	执行语句1
}else if(判断条件){
	执行语句2
	……
}else{
	执行语句3
}

十五、switch语句

switch语句也是一种常见的选择语句，和id条件语句不同，它只能正对某个表达式的值做出判断，从而决定执行哪一段代码。

switch(表达式){
	case 目标值1:
		执行语句1
		break;
	case 目标值2:
		执行语句2
		break;
	……
	case 目标值n:
		执行语句n
		break;
	default:
		执行语句n+1
		break;
}

在switch语句中，使用switch关键字来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句。

需要注意：switch语句中的表达式只能是byte，short，char，int，枚举（1.5引入），String（1.7引入）的值，否则传入其他值，会报错。

在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句中需书写一次即可。

十六、while循环语句

while（循环条件）{
	执行语句
	……
}

例：

int x=1;
while(x<=4){
	Systemm.out.println(x);
	x++;
}

十七、do……while循环语句

do{
	执行语句
	……
}while（循环条件）;

例：

int x=1;
do{
	Systemm.out.println(x);
	x++;
}while(x<=4);

十八、for循环语句

for （初始化表达式；循环条件；操作表达式）{
	执行语句
	……
}

例：

for(int i=0;i<=4;i++){
	System.out.println(i);
}

二十、循环嵌套

循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do……while、for循环语句都可以进行嵌套，并且他们之间也可以互相嵌套，最常见的是for循环中嵌套for循环。

二十一、跳转语句（break、continue）

跳转语句用于实现循环执行过程中流程的跳转。

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

二十二、方法

为了解决代码重新股编写的问题，可以将重复使用的代码取出放入{}中，并未这段代码取个名字，这样每次想执行这些代码就可以调用这个名字来运行。

修饰符 返回值类型 方法名（[参数类型 参数名1，参数类型 参数名2，.....]）{
	执行语句
	……
	return 返回值;
}

修饰符：是对访问权限的限定，例如public、static都是修饰符

返回值类型：用于限定方法返回值的数据类型

参数类型：用于限定调用方法时传入参数的数据类型

参数名：是一个变量，用于接收调用方法是传入的数据

return关键字：用于结束方法以及返回方法指定类型的值

返回值：被return语句返回的值，该值会返回调用者

二十三、重载

定义：函数名相同，但是参数不同（参数个数，参数类型不同）

public static int sum(int a,int b)
{
	return a+b
}
public ststic int sum(int a,int b,int c)
{
	return a+b+c
}

二十四、数组

数组是一组数据的集合，数组中的每个元素被称为元素，在数组中可以存放仍以类型的元素，但同一个数组中存放的元素类型必须一致。

在Java中，可以使用下列各式定义一个数组，具体实例如下：

int[] x=new int[100]；

上述语句就相当于内存中定义了100个int类型的变量，第一个变量的名称为x[0]，依次往后推，这些变量的初始值为0.

上述代码换为2行进行解释

int[] x;         	//声明一个int[]类型的变量
x = new int[100];	//创建一个长度为100的数组

在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获取数组的长度，即元素的个数。

1.各种不同类型的数组的默认值

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

初始化还有另一种方式叫做静态初始化，就是定义数组的同事就维数组的每个元素赋值。数组的静态初始化有两种方式。

1.类型[] 数组名=new 类型[]{元素，元素，……}；
2.类型[] 数组名={元素，元素，元素，……}；

• 每个数组的索引都有一个范围，即0~length-1.在访问元素时，索引不能超出这个范围，否则程序报错。
• 在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问的元素会出现空指针异常。

2.数组常见操作

1.数组遍历

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

索引思想，操作数组中的元素，赋值还是获取值，都是依赖索引值。

int[] arr=new int[5];
for (int i=0;i<arr.length;i++)
	System.out.println(arr[i]);

2.数值最值

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

public class Example{
	public static void main(String[] args){
		int[] arr={1,2,43,5,2,3,56,321,1,9,2};
		int max = getMax(arr);
		System.out.println("最大值为："+max);
	}
	public static int getMax(int[] arr){
		int max=arr[0];//定义变量x，用于记录数组中的最大值
		for(int i = 1;i<arr.length;i++){
			if (max < arr[i]) max = arr[i];
		}
		return max;
	}
}

3.数组排序

在操作数组时，经常需要对数组中元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者向下沉。

// 冒泡排序
public class Example{
	public static void main(String[] args){
		int[] arr={9,6,3,1,7,3};//定义数组，赋值无序
		printArr(arr);
		buddleSort(arr);
		printArr(arr);
	}
	// 打印数组的方法
	public static void printArr(int[] arr){
		// 循环遍历数组的元素
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.print("\n");
	}
	public static void buddleSort(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;
				}
				System.out.println("第"+ (i+1)+"伦排序");
				printArr(arr);
			}
		}
	}
}

4.多维数组

多维数组可以简单的理解为在数组中嵌套数组。在程序中最常见的数组就是二维数组。

方式一：

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]

public class test{
	public static void main(String[] args){
		int[][] arr = new int[3][];//定义一个长度为3的二维数组
		arr[0] = new int[]{11,12};
		arr[1] = new int[]{14,25,15};
		arr[2] = new int[]{51,125,124};
		int sum = 0;//定义变量记录总销售额
		for(int i=0;i<arr.length;i++){
			int groupSum = 0;//记录每小组的销售额
			for(int j=0;j<arr[i].length;j++){
				groupSum+=arr[i][j];
			}
			sum+=groupSum;
		}
		System.out.println("总销售额为："+sum+"万元");
	}
}