JavaSE知识点查漏补缺(1)

1、JavaSE里面最基础、最重要的基本知识就是变量，在这里给出关于变量我们需要掌握的知识。

变量 ：
解决的是单个数据的存储问题.
存数据的一块空间
内存中的一块被命名的有特定类型约束的存储区域, 该区域中可以保存一个数据, 并且这个数据可以无限次地在其范围内被修改.
声明变量：类型 变量名;
初始化赋值, 变量刚声明完后的第一次赋值
变量名 = 值;
普通赋值：变量名 = 值;
变量的使用 ：只需要通过变量名就可以了  不可以加双引号 "变量名"
变量的使用注意事项 :
1) 变量有作用范围 : 变量的声明语句所属的花括号
2) 变量必须有名字
3) 变量必须有类型
4) 保存的数据有其范围
5) 必须要有初始化值
6) 先声明,后使用
7) 变量在其范围内不可以重复定义 
变量的分类 
1) 按照数据类型
1) 基本数据类型 : 变量空间中保存的就是数据本身
1) 数值型
1) 整数
byte 1 -128~127
short 2 -32768~32767
int 4 -20多亿~20多亿
long 8 很大
2) 浮点数
float 4 10的38次方
double 8 10的300多次方
2) 字符型
char 2 0~65535
3) 布尔型
boolean 1 只有true或false
boolean b = true;

2) 引用数据类型 : 保存的是别的数据的地址
2) 按照变量的范围
1) 局部变量 : 在方法中声明的变量 范围小, 寿命短
2) 成员变量 : 在类中方法外声明的变量范围大, 寿命长
class A {
int i = 1; // 成员变量
void m() {
int i = 0; // 局部变量
}
}

2、关于变量就这些比较重要的知识点，接下来就是流程控制，主要包括分支语句和循环语句。

下面是需要掌握的

流程控制 :
分支 : 

<span style="white-space:pre">		</span>/*if 
			if (A) {
				B;			
			} else if (X) {
				Y;			
			} else {
				C;			
			}
		switch
			switch (变量) {
				case 常量1 :
					语句;
					break;
				case 常量2 :
					语句2;
					break;
				...
				default :
					语句N;
					break;
			}*/

循环 :

<span style="white-space:pre">		</span>/*while 循环0-N次
			while(条件) {
				循环体;		
			} 
			while (true) { 死循环
				循环体;		
			}
		do while 循环1-N次
			do {
				循环体;		
			} while (条件);
		
			do {
				语句1;
				语句2;
				条件
					break;
				语句3
				语句4
			} while (false);
			语句5		
		
			do {
			} while (true); 死循环
		
			适用于循环次数不确定的循环.
		
		for 循环
			for (初始化; 条件语句; 迭代语句) {
				循环体;
			}*/

死循环的多种写法:
for (;;) {}
for (初始化;;迭代语句) {}
for (初始化;true;迭代语句) {}
for (初始化; 条件语句;) {}

特殊流程控制语句 :
break 中断它所隶属的某个语句块的执行
break 标签; 中断标签指定的循环体

continue 中断当次循环, 直接进入下一次循环
while (条件) {
continue;
}
continue 标签 中断标签指定的循环的当次循环, 直接进入标签指定的循环的下一次循环.

这里我们还需要知道方法的声明：

<span style="white-space:pre">	</span>/*修饰符 返回值类型 方法名(形参类型1 形参1, 形参类型2 形参2, ....) {
		方法体;
		return 返回值类型的值;	
	}


	API*/
	
	public static Type methodName(Type1 parmeter1, Type2 parameter2, ....) {
		code;
		return value;	
	}
	
	public static void anotherMethod() {
		// 调用方法,  方法名(实参1, 实参2, ....);
		Type var = methodName(argument1, argument2, ....);
	}
	
	// 只要能写语句的地方 就可以调用方法 
	public static int add(int a, int b) {
		short c = (short)(a + b);
		return c;	
	}
	main() {
		byte a = 10;
		char b = 20;
		int c = add(a, b);
	}

3、现在开始进入Java的重头戏-面向对象，以及比较难的数组

类 :对现实世界事物的抽象定义
用 对象属性(成员变量)或实例变量, 描述特征, 
用 对象方法或实例方法来描述行为

<span style="white-space:pre">	</span>class ClassName {
	
		// 对象属性 描述特征
		private Type1 field1;
		private Type2 field2 = value2; // 显式赋值
		....
		
		// get/set方法, 针对的是私有属性
		public void setField1(Type1 field1) {
			this.field1 = field1;
		}
		
		public Type1 getField1() {
			return field1;		
		}
		
		public void setField2(Type2 field2) {
			this.field2 = field2;
		}
		
		public Type2 getField2() {
			return field2;		
		}			
				
		// 对象方法 描述行为	
		修饰符 返回值 方法名(形参类型1 形参1, 形参类型2 形参2...) {
		}
		
		// 获取对象的详细信息		
		public String say() {
			String str = "属性1的说明:" + field1 + ",属性2的说明:" + field3 + ....;
			return str;
		}
		
	}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">	</span>

对象 :是类的实例

<span style="white-space:pre">	</span>main() {
		// 创建对象
		ClassName 引用 = new ClassName(); 
		//引用.field1 = value1;
		引用.setField1(value1);
		//引用.field2 = value22;
		引用.setField2(value22);
		System.out.println(引用.say());
	}	

创建对象

<span style="white-space:pre">	</span>main() {
		类名 引用 = new 类名();
		// 一个对象的创建过程
		// 1) 在永久区中检查要创建的对象所属的类的类模板是否存在
		// 2)	如果不存在, 则由类加载器执行加载(读取类.class文件), 如果存在, 则不加载了.
			类模板(属性的定义和方法代码)
		// 3) 依据类中的属性的定义,在GC区中开辟适当的空间
		// 4) 把此空间清0
		// 5) 如果有显式赋值,则执行显式赋值
		// 6) 执行构造器,进一步初始化
		// 7) 返回对象在GC区中的首地址	
	
		引用.成员名	
	}	

接下来新手比较头疼的一部分：数组

数组 : 相同类型的一组数据
声明 :元素的数据类型[] 数组名;
创建 :数组名 = new 元素的数据类型[长度]; // 动态创建
数组的静态创建:
元素数据类型[] 数组名 = {元素值1, 元素值2, 元素值3...}; // 只能用于声明和创建在同一条语句上.
元素数据类型[] 数组名 = new 元素数据类型[]{元素值1, 元素值2,....};
数组的动态创建:
元素类型[] 数组 = new 元素类型[长度]; // 如果是引用数组, 全部是空洞, 如果是基本类型数组,全部是0
数组元素的访问 :数组名[下标] = 值; 
数组遍历 :

<span style="white-space:pre">	</span>/*for (int i = 0; i < 数组名.length; i++) {
		System.out.println(数组名[i]); 	
	}	
	
	for (元素类型 变量 : 数组名) {
		访问变量相当于访问数组中每个元素值
	}*/

基本用法：

<span style="white-space:pre">	</span>int[] arr = {3, 8, 2, 0, 9, 7, 4};
<span style="white-space:pre">	</span>

	//增强型for循环
	for (int var : arr) {
		System.out.println(var);
	}
	//最大值
	int max = arr[0];
	for (int var : arr) {
		if (var > max) {
			max = var;	
		}
	}
	//下标法求最大值
	int maxIndex = 0;
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] > arr[maxIndex]) {
			maxIndex = i;	
		}
	}
	int maxValue = arr[maxIndex];


	// 检索元素值为70的下标
	int key = 70;
	int index = -1; 
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == key) {
			index = i;
			break;	
		}
	}


	if (index == -1) {
		System.out.println("搜索的数据不存在");
	} else {
		System.out.println("下标是" + index);
	}


	// 取出数组中能被3整除的
	int[] newArr = new int[arr.length];
	int count = 0;
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] % 3 == 0) {
			newArr[count] = arr[i];
			count++;
		}
	}
	int[] child = new int[count];
	for (int i = 0; i < count; i++) {
		child[i] = newArr[i];
	}
	newArr = null;


	// 扩容
	int[] bigger = new int[比原来大];
	for (int i = 0; i < arr.length; i++) {
		bigger[i] = arr[i]; 
	}


	arr = bigger; // 如果是引用数组,则会产生大量的空洞


	// 排序
	for (int i = 0; i < arr.length - 1; i++) {
		for (int j = 0; j < arr.length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}	
		}
	}