Java学习记录（基础语法）

Java基础语法

变量

变量就是系统为程序分配的一块内存单元，用于存储各种类型的数据，由于该存储单元的数据可以发生变化，所以被称为变量
变量分类
按所属的数据类型分类：　　　
　　　基本数据类型　　　
　　　引用数据类型
　　　
　按被声明的位置划分：　　　
　　　局部变量：　　　
　　　成员变量：
Tips：类的外面不能有变量的声明

数据类型

类型	占用内存（字节）	取值范围	默认值
布尔（boolean)	1	true or false	false
字节（byte)	1	-128 ~ 127	0
短整型（short）	2	-32768 ~ 32767	0
字符（char）	2	‘ \u0000 - u\ffff ’	‘\u0000 ’
整形（int）	4	-2,147,483,648 ~ 2,147,483,647	0
长整型（long）	8	-9,223,372,036,854,775,808L ~ 9,223,372,036,854,775,807L	0
单精度浮点型（float）	4	-3.40292347E+38~3.40292347E+38	0.0f
双精度浮点型（double）	8	-1.79769313486231570E+308-1.79769313486231570E+308	0.0d

标识符

Java对对包，类，方法，参数和变量等要素命名时使用的字符序列称为标识符。
规则
（1）不能以数字开头
（2）由数字，字母，下划线_和美元符号$构成
（3）长度无限制
（4）不能是Java中的关键保留字
（5）区分大小写
Tips：标识符命名习惯：见名知意

类型转换

boolean类型不能转化成任何其他数据类型

自动转换类型：容量小的类型自动转换成容量大的类型
Byte，short，int>float>long>double

Byte,short,int不会互相转化，他们三者在计算时会转化成int类型

强制类型转换：容量大的类型转换成容量小的数据类型时，要加上牵制转换符
. Example：

	llong i = 100L;
	int i = (int)t;

强制类型转换与变量的具体数值无关，只与变量的类型有关

方法

概念：
方法用于封装一段特定的逻辑功能。
方法的主要要素有：前线修饰符，方法名，参数列表和返回值。
. 格式

• 权限修饰符 返回值声明 方法名称 （参数列表）{
  - 方法中封装的逻辑功能：
  - return 返回值；
  }
  权限修饰符

权限修饰符\访问权限	类	包	子类	全部
public	v	v	v	v
protected	v	v	v	x
friendly（默认（default））	v	v	x	x
private	v	x	x	x

返回值详解：

• 方法调用结束后可以返回一个数值，称之为返回值。
• 方法在声明时必须指定返回值的类型。
• 通过return语句返回，return语句的作用在于结束方法且将数据返回。
• 如果方法没有返回值（即方法不需要返回数值），需将返回值类型声明为void。

参数列表详解：

• 方法的参数列表：在调用时传递给方法，需要被方法处理的数据。
• 在方法定义时，需要声明该方法所需要的参数变量。
• 在方法调用时，会将实际参数值传递给方法的参数变量。必须保证传递参数的类型和个数符合方法的声明。

运算符

算术运算符

自增和自减

	int i = 8;
	i = i++;
	System.out.println(i);	
		结果：i = 8;

int i = 8;
	i = ++i;
	System.out.println(i);	
		结果：i = 9;

当自增运算在前时，程序会先进行自增运算，并将结果赋值给变量，然后再读取变量中的内容进行操作，此时程序操作的变量的值是自增后的值。
当自增运算在后时，程序会先读取变量的值，再进行自增运算，此时程序操作的变量的值是自增前的值

赋值运算符

赋值运算符作用是将一个值赋给一个变量，运算顺序从右到左。

关系运算符

关系运算符作用是比较两边的操作数，结果总是 boolean 型的。

逻辑运算符

逻辑运算符用于对 boolean型结果的表达式进行运算，运算结果总是 boolean 型。

字符串连接符

当“+”链接的是字符串时，他就成了字符串连接符
当“+”连接的一端有字符串时，就会自动将结果变为字符串

int i = 10;;
String s = "10";
System.out.println(i + s);
	结果为：（String）1010

三目运算符

X ? Y : Z

• X 为 boolean 类型表达式，先计算 x 的值，若为true，整个三目运算的结果为表达式 y 的值，否则整个运算结果为表达式z 的值。

执行结构

• 基础执行结构：顺序结构，分支结构和循环结构

任何简单或复杂的算法都可以由顺序结构，分支结构和循环结构三种基本结构组成-
他们的共同点是都包含一个入口和出口，他们的每个代码都有机会被执行不会出现死循环。

顺序结构

顺序结构是一种基本的控制结构，他按照 语句出现的顺序 执行操作

分支结构（选择结构）

分支结构又被称为选择结构，根据条件成立与否 来执行操作

if条件语句

If条件结构是根据条件判断之后在进行处理

if(输入返回值为boolean类型的判断语句){
}else if{
}else {
}

if-else语句可以嵌套和连续使用
if语句适用于取值不确定的判定（即有关范围的判断）

switch条件语句

switch（表达式）{
case 取值一 : 语句块一； break；
case 取值二 : 语句块二； break；
Default :语句块n+1； break；
}

Switch语句相关规则：

• 表达式的返回值必须是下面几种类型之一：int，byte，string，char，short
  case子句中的取值必须是常量，且所有case子句中的取值应该是不同的
  Default子句是可选的
  Break语句用来在执行完一个case分之后是程序跳出switch语句块，如果case后面没有写break则直接往后面直行
  Case后面的执行体可写{}也可以不写
• switch语句适用于取值确定的情况

Example（判断季节）：
	switch (text) {
		case "1" :
		case "2" :
		case "3" :
			System.out.println("春季");
			break ;
		case "4" :
		case "5" :
		case "6" :
			System.out.println("夏季");
			break ;
		case "7" :
		case "8" :
		case "9" :
			System.out.println("秋季");
			break ;
		case "10" :
		case "11" :
		case "12" :
			System.out.println("冬季");
			break ;
			default :
				System.out.println("你输入的月份不正确，请重新输入");
			break ;
		}

循环结构

循环结构是一种重复结构，如果条件成立他会重复执行某一循环体，直到出现不满足的条件为止

循环语句功能：
在循环条件满足的情况下，反复执行特定代码循环语句分类
常用的循环语句

• for 循环
• while 循环
• do/while 循环

for循环

语法：
	for(初始化参数;判断条件 ;更新循环变量){
		循环体;
	}
应用举例
	public class ForLoop {
		public static void main(String  [] args){
		 	int result = 0;
			for(int i=1; i<=100; i++) { 
				result += i;
			}
		System.out.println("result=" + result);
	}
}

for循环适用于循环次数已经确定时使用

while循环

符合条件，循环继续执行；否则，循环退出特点：先判断，再执行

语法：
while(条件表达式){
	//语句块；
}

while循环适用于循环次数不确定时使用

do-while循环

先执行一遍循环操作，符合条件，循环继续执行；否则，循环退出特点：先执行，再判断

语法：
do {
	循环操作
}while ( 条件表达式 );

do-while循环适用于某些需要提前进行一次操作时使用

while 循环和 do-while 循环的区别？

• while:先判断条件，如果条件满足，再执行循环操作
• do while:先执行一遍循环操作，然后再判读条件，如果条件满足，继续执行循环操作。

退出循环

break和continue都可以退出循环
break和continue的区别：

• break退出当前所在循环，即离break最近的循环，该循环剩余的所有循环都不在执行
• continue是退出正在执行的此次循环，并继续执行下一次循环

for(int i = 0;i<10;i++) {
		for(int j = 0;j<10;j++) {			
			if(j == 9) {
				break;
			}
			System.out.print(i +""+ j + "\t");
		}
		System.out.println();
	}

由于j=9时，内层循环退出，不再打印数字，于是就干掉了个位为9的数

00	01	02	03	04	05	06	07	08	
10	11	12	13	14	15	16	17	18	
20	21	22	23	24	25	26	27	28	
30	31	32	33	34	35	36	37	38	
40	41	42	43	44	45	46	47	48	
50	51	52	53	54	55	56	57	58	
60	61	62	63	64	65	66	67	68	
70	71	72	73	74	75	76	77	78	
80	81	82	83	84	85	86	87	88	
90	91	92	93	94	95	96	97	98	

数组

概念

• 数组是相同数据类型的多个数据的容器
• 这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。

创建格式
	格式 1.  数据类型[] 数组名称 = new 数据类型[数组长度];
	格式 2.  数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3...数组内容 n};
	格式 3.  数据类型[] 数组名;
		格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。
	格式 4.  数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3...内容 n];

Example：
	格式1：int[] nums = new int[10];
	格式2：int[] nums = {1,2,3,4,5,6,7,8,9,0};
	格式3：int[] nums;
	格式4：int[] a = new int[] {1,2,3,4,5,6,7,8,9,0};
	

下标
可以理解为数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0 ~ n-1。可以通过下标的方式访问数组中的每一个元素。

以上述格式2为例：
		nums[0] = 1;
		nums[9] = 1o:

数组长度获取

数组名称.length；

注意
使用数组不当， 会出现如下问题：

• 数组未赋值： 空指针异常
• 超出长度的下标操作：
• 数组越界异常注意：
• 数组的长度在创建时就固定了

数组常用算法

冒泡排序

原理：

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会 是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

名字由来:
是因为最小（或最大）的元素会经由交换慢慢“浮”到数列的顶端（降序或升序），就如同水中的气泡最 终会上浮到顶端一样，故名“冒泡排序”。

升序排列的口诀:
N个数字来排队两两相比小靠前,
外层 循环length-1 内层循环length-i-1

降序排序的口诀:
N个数字来排队两两相比大靠前,
外层 循环length-1 内层循环length-i-1

二分查找 （折半查找）

概念

• 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺序存储结构有序排列。
  原理
• 首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功； 否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数 组，否则进一步查找后子数组。

重复以上过程，直到找到满足条件的数据，则表示查找成功， 直到子数组不存在为止，表示查找不成功。