01 JAVA 基础

学渣好久以前学的JAVA，后来去国外玩物丧志了几年，没出息的忘了怎么编程了。。现在复习一下。。。

一、标识符

（基佬蓝~）

1. 只能有数字，字符和下划线组成

2. 数字不能作为开头

3. 不能是关键字（JAVA里面的关键字一般是小写的）

二、关键字

三、变量

变量是程序中最基本的存储单元，使用前必须声明，我们可以通过变量访问内存的某一个区域。

- 变量类型，表示我们需要预留多大的内存给变量

- 变量名

- 值，往内存中填充数据

- 作用域

1. 局部变量

方法或者语句块内部声明的变量，没有初值，不能使用

2. 成员变量

方法外，类内部，初始值为0

四、程序的执行过程

程序->disk->code segment->os->stack(临时变量，结果), code segment, data segment(静态变量，字符串), heap(new出来的对象，因为我们并不能事先知道该分配多大的空间给将要创建的对象)

五、数据类型

- 除了基本数据类型，都是引用数据类型

- 整型又分为符号和无符号型

- 十进制-》多进制，例 13=8+4+1=》1101

- 与Python不同，boolean不能用0和非0替代

- char，使用单符号括起来，如char c='\n'，JAVA还支持Unicode，如a='敏'，a='\u0061'，JAVA采用UTF-16，任何字符都占两个字节，而另一种编码方式UTF-8则更灵活

- 大小

byte：一个字节

short：两个字节

int：四个字节

long：八个字节

float：四个字节，精度7

double：八个字节，精度15

- 计数

3.14，0.14，3.14E2，.88f，012（八进制），0X12（十六进制）, 12222222L

六、数据转换

- boolean不能转换为其他类型

- byte，short和char不能相互转换，进行他们之间的运算都会先将他们转换成int类型，可以给他们直接赋值数字，但是注意不要超过表数范围，如char c = 125可以，但是后面赋值要在表上，但c1=c-1会出错，因为会把c转换成int类型

byte b1 = 1;

byte b2 = 2;

byte b3 = b1 + b2;

以上的代码会出错，因为之前b1和b2进行加运算之前，都已经转换成了int类型，如果要转回来，我们需要强制转换

- int->long->float->double

- 逆序需要强制转换，但可能造成精度降低，溢出等问题

- long类型赋值时，数字后面必须加L，否则“ long a=1;”将被看为将一个int类型的数字1转换成long类型

long a1=12345678

long a2=88888888888(出错，因为int类型存不下这么大的，需要在后面加L)

long->int，强制转换，直接砍掉多余的部分（从左到右）

- float类型赋值时，数字后面也要加上f，不然会被看成double类型的，因为double和float两种类型存取数值得格式并不相同，所以呢，将double类型直接赋值给float会出错，我们需要强制转换

public class testDataType {
	public static void main(String args[]) {
		int a1 = (int) 888888888888L;
		float f = (float) 1.8888888888888888888;
		System.out.println("a1: "+a1+", f: "+f);
	}
}

结果：

a1: -169341384, f: 1.8888888

七、程序格式

- 大括号对齐

- TAB（缩进）, SHIFT+TAB（退）

- 程序块之间加空行

- 并排语句加空格

- 运算符两侧加空格

- {前面加空格

- 成对编程

八、运算符

基本优先级规律：++，-- >运算符号 >比较符号 >==，!= >逻辑符号 >三目 >=, 运算符号=, 逻辑运算符=

- i++先取值后运算，而++i先运算后取值

- ^异或，相同false，相异true

- || VS |, && VS &

||左边true, 就不计算剩余的部分了

&&左边false, 就不计算剩余的部分了

九、基本操作

- 与python不同，JAVA的连接符可以连接字符串和一些非字符串类型数据，如"a"+123

- System.out.println(), System.out.print() 换行与不换行 

- if-else

三目运算符  condition?x:y

- for, while, do-while

- continue, break

- switch-case-default

int，或者可以转换成int类型的数据，枚举，在JAVA7.0中可以放置字符串

switch(整型变量){
	case cond1:
		break;
	case cond2:	
		break;
	…
	default:
}

1. 记得break；防止case穿透（切记）

2. 多个case可以写在一起

case cond1:
case cond2:
	expr;
	break;

十、方法

【修饰符】 返回类型 方法名（形参列表）{

语句；

}

- 形参，parameter，用于接收外界输入的参数

- 实参，argument，实际传给方法的数据

- 返回值类型，如果没有返回值，必须把返回值类型设定为void

- 我们可以使用对象名.方法名（参数）来调用方法或取得参数

- return语句终止方法

值传递原则：基本类型传递数据值本身，而引用参数传递的是对象的引用，而非对象内容本身，但是我们可以修改对象的内容

十一、软件安装

MyEclipse下载与破解：http://www.cnblogs.com/weilaikeji/archive/2013/05/30/3108508.html

当前MyEclipse只支持JAVA 6（2015.7），而Eclipse 4.4 Lunar可以支持JAVA 8了，因为Eclipse是免费的，所以可以去官网直接下载，下完之后直接解压双击Eclipse那个像眼球的图标就可以打开啦~In addition，Eclipse没有MyEclipse那么多完善的插件，所以占用空间小好多。

1. Windows上安装Eclipse的时候，要注意去计算机属性-》高级配置下完成PATH（告诉OS哪里可以找到相关的命令执行环境，比如java和javac）和CLASSPATH（告诉OS哪里去查找目标代码，也就是存放.class的目录）的配置

2. 

javac：编译源代码

java：执行目标代码

appletekiMacBook-Pro:Practice apple$ javac ./src/Fabonacci_NoRecur.java

appletekiMacBook-Pro:bin apple$ java Fabonacci_NoRecur

F(3) = 2

3. 在MacOS上，我们需要配置JAVA_HOME（vi .bash_profile进入文本编辑，加入JAVA_HOME的设置，要注意该设置只针对于该用户环境）

4. 编写时，要注意文件名和public类名要一样，而且我们可以先存盘再编辑，此时IDE上的指令会显示出不同颜色

十二、递归调用

1. 例子

- 计算N的阶乘 1*2*..*N

- fabonacci数列

- 打印1到N

- 汉诺塔问题

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

- 假设三个盘子A, B, C，目标把N个盘子从A移到C

- 将A上N-1盘子，通过C，从A移到到B

- 将第N个盘子从A移到C

- 将刚才N-1个盘子，通过A，从B移到C

2. 递归调用 VS 非递归调用

在递归调用中，它的空间复杂度是O（N），如果N太大，内存可能不够用~但是如果没有递归，有些问题就会变得复杂

public class Fabonacci {
	public long fabRecur(int N) {
		if(N == 1||N == 2)
			return 1L;
		else 
			return fabRecur(N-1) + fabRecur(N-2);
	}
	
	public long fabNoRecur(int N) {
		if(N == 1||N == 2)
			return 1;
		
		long f1 = 1L, f2 = 1L, tmp = 0L;
		for(int i = 3; i <= N; i++) {
			tmp = f1 + f2;
			f1 = f2;
			f2 = tmp; 
		}
		return f2;
	}
	
	public static void main(String args[]) {
		Fabonacci fab = new Fabonacci();
		int N = 40;
		System.out.println("without recursion, fab["+N+"] is "+fab.fabNoRecur(N));
		System.out.println("under recursion, fab["+N+"] is "+fab.fabRecur(N));
	}
}

import java.util.*;

public class Hanoi {
	public static void main(String args[]) {
		System.out.print("Enter the number of the plates: ");
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		char A = '左', B = '中', C = '右';
		
		//movePlateRecur(n, A, B, C);
		movePlateNoRecur(n);
	}
	
	public static void movePlateRecur(int n, char A, char B, char C) {
		if(n == 1)
			System.out.println("Move plate" + n + " from " + A + " -》 " + C);
		else{
			movePlateRecur(n-1,A,C,B);
			System.out.println("Move plate" + n + " from " + A + " -》 " + C);
			movePlateRecur(n-1,B,A,C);
		}
	}
	
	public static void movePlateNoRecur(int n) {
		Stack stack =  new Stack();
		stack.pushState(new State(n, '左', '中', '右'));
		State popState = null;
		
		while((popState=stack.popState()) != null) {
			if(popState.nth == 1) {
				System.out.println("moves "+popState.A+"->"+popState.C);
			}
			/**
			 * 栈结构先进后出，逆序进栈
			 * 按照递归思路，先将前n-1通过C移到B，然后移动最后一个，然后通过A移到C
			 */
			else {
				stack.pushState(new State(popState.nth-1, popState.B, popState.A, popState.C));
				stack.pushState(new State(1, popState.A, popState.B, popState.C));
				stack.pushState(new State(popState.nth-1, popState.A, popState.C, popState.B));
			}
		}
	}
}

class State {
	char A;
	char B;
	char C;
	int nth;
	
	public State(int nth, char A, char B, char C) {
		this.nth = nth;
		this.A = A;
		this.B = B;
		this.C = C;
	}
}

class Stack {
	private State[] states = new State[20];
	private int top = 0;
	
	public State getTop() {
		return states[top];
	} 
	
	public void pushState(State state) {
		states[top] = state;
		top++;
	}
	
	public State popState() {
		if(top != 0){
			top--;
			return states[top];
		}
		else return null;
	}
}

Reference:

1. 马士兵 JAVA 基础（老马声音好好听）