Java笔记

					
JavaSE笔记
1. Java概述及搭建环境配置
	1.1 Java开发的公司
	1.2 Java是由Sun公司推出的(2010年初被Oracle公司收购)
	1.3 收购价格：41亿美金
	1.4 Java版本	
		Java SE: Java Standard Edition
		Java ME: Java Micro Edition
		Java EE: Java Enterprise Edition
	1.5 Java工具
		JDK: Java Development Kit (Java开发包,包含编译和运行包)
		JRE: Java Runtime Environment (Java运行环境)
		JDK包含了JRE
		JDK 1.4, JDK 1.5(5.0), JDK 1.6(6.0), JDK 7.0(Build)
		JDK 1.5(5.0) Tiger(老虎)
		JDK 1.6(6.0) Mustang(野马)
	1.6 Java系统环境变量：
		c:\> set path : (System path + User path)	
		c:\> set Xx=aa	=> 设置系统环境变量
		set		=> 查看系统环境变量
		
		set Xx=	= >删除系统环境变量Xx
		只对当前命令行窗口有效果。
		
		c:\> set path=%path%;e:\aa
	         set path = c;		
		
		c:\> java
		
		首先在c盘符下查找java应用程序，如果没有找到，那么继续查找path环境变量中的第一变量，如果又没有找到，那么往下查找。直到找到查找结束，如果没有找到，那么返回错误信息。
		
		c:\> set classpath=d:\java_ex
		set classpath=document settiong
		注意：空格不允许有,不要把文件放在空格的目录里
	1.7 Java执行过程
		1. 下载JDK
		2. 安装JDK
		3. 设定环境变量(用户变量或系统变量)，指向JDK安装目录中的bin目录
		4. 运行cmd打开命令行窗口，输入java -version，显示出安装目录中bin目录
	1.8 Java编辑代码工具
		Windows: Notepad, EditPlus, Ultraedit, gvim
	    	Linux: vi, vim, gedit	
		轻量级的文本编辑器：UltraEdit、EditPlus、vi、vim、gvim
		使用window记事本来编写Java程序，也可以使用Editplus、 UltralEdit等高级文本编辑工具编写Java程序,还可以使用专业IDE(Integrated Development Environment)编写。所有Java代码其后缀必须使用.java结尾。
	1.9 Java程序的执行过程步骤
		1. 编写代码
		2. 编译 (javac Test.java)
		3. 执行 (java Test) 

		class文件是字节码文件，程序最终执行的就是字节码(bytecode)文件
		编译命令：java Test.java
		执行使命：java Test(注意：Test后面没有.class)
	1.10 Java特点
		Java是跨平台的语言，真正执行的不是二进制代码，而是字节码	
		JVM(Java Virtual Machine, Java虚拟机)				
		Java是跨平台的，而JVM不是跨平台的(JVM是由C语言编写的)	
		Java之所以能够做到跨平台，本质原因在于于JVM不是跨平台的。
2. 变量与常量(Variable and Constant)
	2.1 变量与常量
		所谓常量，就是值不会变化的量;
		所谓变量，就是值可以变化的量。
	2.2 如何定义变量
		变量类型 变量名(例如：int a)
	2.3 如何为变量赋值
		变量名 = 变量值(例如：int a = 20;)
		=  表示赋值，将等号左边的值赋给了左边的变量。
		Java中使用==表示相等，等价于数学中的=。
	2.4 如何变量定义与赋值
		变量类型 变量名
		变量名 = 变量值
		变量类型 变量名 = 变量值 
		例如：int a
			a = 1
			可以将上面两个步骤二为一
			变量类型 变量名 = 变量值
			int a = 1;
	2.7 变量名
		在Java中，变量名以下划线、字母、$符号开头，并且后跟并下划线、字母、$符号以及数字。总之，Java中的变量名不能以数字开头。	
		例如：_num		O
			num1		O
			$num_1		O
			#num		X
			0num		X	
	2.8 关于计算机系统中的数据表示
		位：bit(只有0，1两种状态)，是计算机系统中最小数据表示单位。
		字节:BYTE, 1 bype = 8 bit;
		1KB = 1024 BYTE(1kg = 1000g,与计算机系统不同)
		1MB = 1024 KB 
		1GB = 1024 MB
	2.9 关于注释
		注释, 是给人看的，不是给计算机看的。Java中共有3种类型的注释：
		1) 单选注释：以//开头, //后面的所有内容均被当作注释处理。
		2) 多行注释：以/*开头，以*/结束，中间的所有内容均被当作注释处理。
			多行注释来源于C/C++。关于多行注释需要注意的是，多选注释不能嵌套。
			例如： /*/**/*/ -> X
		3) 另一种多行注释（文档化处理的注释）：用于产生Java Doc帮助文档。
			例如：
				/**
					这里是文档注释
				*/
3. 数据类型(Data Type)
	3.1 Java中的数据类型分为两大类 
		1). 原生数据类型(primitive Data Type)
		2). 引用类型(对象类型)(Reference Type)
	3.2 Java中的原生数据类型共有8种
		1) 整形：	使用int 表示(32位)
		2) 字节形：	使用type表示。(表示128~127之间的256个整数)
		3) 短整形：	使用short表示 (16位)
		4) 长整形：	使用long表示(64位)
		5) 单精度浮点型：使用float表示(32)。所谓浮点型，指的就是小数，也叫做实数。比如1.2
		6) 双精度浮点型：使用double表示(64) 。双精度浮点型表示的数据范围要比单精度浮点型大。
		7) 字符型：	使用char表示(char是character缩写)。所谓字符，就是单个字符表示，比如字母a，或者中文张，外面用单引号包围上。比如 char a = 'B'; char b= '张';
		8) 布尔类型：	使用boolean表示。布尔类型只有两种可能值，分别是true与false
	3.2 浮点型
		Java中的所有浮点类型默认情况下都是double。不能将double类型的值赋给float类型的变量，即使该double类型的值处于float类型的范围内也是不可以的。总之，能否成功赋值取决于等号右边的值类型与等号左边的变量类型是否一致。
		
		如何将double类型的值赋给float类型的变量?答案就是强制类型转换，将double类型值强制转换为float类型。
		强制类型转换的语法：类型 变量名 = (类型) 变量值
		使用Java预言的支持。						
	3.4 变量在使用前必须赋值
		变量必须要声明其类型方可使用：变量在使用前必要要定义，并且只能定义一次。
		如下代码无法通过编译：
			int a = 1;
			short b = a;		
		a是int类型，b是short类型。int类型表示的数据范围要比short类型大，不能将表示范围大的值赋给表示范围小的变量。
	3.5 如下代码可能通过编译
		short a = 1;
		int b = a;
		a是short类型，b是int类型。int类型表示的数据范围要比short类型大，可以将表示范围小的值赋给表示范围大的变量。

		可以将表示范围小的值赋给表示范围大的变量；
		但不能直接将表示范围大的值赋给表示范围小的变量。
		只能通过强制类型转换实现。
		
		当有若干个变量参与运算时，结果类型取决于这些变量中表示范围最大的那个变量类型。
		
		比如，参与运算的变量中，有整形int，有双精度浮点型double，有短整型，那么最后的结束类型是double:
		
			int a = 1;
			int b = 2;
			double c  = (double)a / b;
		
		上面的代码中，a与b都是整型，但是通过(double)a，这种强制类型转换将a转换为匿名的变量，该变量的类型是double，但是要注意：a本身依旧是int类型，而不是double类型，这样 (double)a / b 就是double类型除以int类型，结果自然是double类型

		取模的规律：取模的结果符号永远与被除数的符号相同。
		int a = 5;
		int b = -3;
		int c = a % b ;
		被除数是-3, 那么取模的结果是-2

		int a = -5;
		int b = 3;
		int c = a % b;
		被除数是-5，那么取模的结果是2
4. 运算符(Operatort)
	4.1 关系运算符
		大于(>)
		小于(<)
		等于(==)
		不等于(!=)
		大于等于(>=)
		小于等于(<=)
		全等于(===)
		全不等(!==)
		关系运算的结果是个boolean值。
		
	4.2 逻辑运算符
		重点讲解两个，逻辑运算符本身也返回一个boolean值。
		1) 逻辑与，使用&&表示，逻辑与是个双目运算符（即有两个操作数的运算符）,只有当两个操作数都为真的是时候，结果才为真。其作情况结果均为假。逻辑与表示的并且的意思。		
			第一个操作数	第二个操作数		结果
			true			ture		ture
			true			false		false
			false			true		false
			false			false		false
		2) 逻辑或,使用||表示，逻辑或也是双目运算符，只有当两个操作数都为假的时候结果才为假；其余情况结果均为真。逻辑或表示或者的意思。
			第一个操作数	第二个操作数		结果
			true			ture		ture
			true			false		ture
			false			true		ture
			false			false		false
		
		关于逻辑运算符的短路特性。
		1) 逻辑与，如果第一个操作数为false,那么结果肯定是false,所以在这种情况下，将不会执行逻辑与后面的运算了。即发生的短路。
		2) 逻辑或，如果第一个操作数为true，那么结果肯定是true,所以在这种情况下，将不会执行逻辑与后面的运算了。即书生的短路。
	4.3 自增与自减运算
		1) 关于int b = a++; 作用是将a的值先赋给b,然后再让a自增。
		2) 关于int b = ++a; 作用是将a自增之后的值赋给b。
5. 流程控制语句(Flow Control Statement)
	5.1 条件运算符(三元表达式)
		其形式为：
		type d = a ? b : c; 具体化形式为: int d = 2 < 1 ? 3:4;
	5.2 if语句
		第一种形式：
			if (布尔表达式) {
				// 待执行的代码
			}
		第二种形式：
			if (布尔表达式) {
				// 待执行的代码
			} else {
				// 待执行的代码
			}
		第三种形式：
			if (布尔表达式) {
				// 待执行的代码
			} else if (布尔表达式) {
				// 待执行的代码
			} else {
				// 待执行的代码
			}
	5.3 switch语句
		switch(变量) // 此处的变量类型就目前所学内容来看，只能为4种类型：byte, short, int, char。
		switch(变量) {
			case 常量1：
				// 待执行的代码
				break;
			case 常量2：
				// 待执行的代码
				break;
			case 常量3：
				// 待执行的代码
				break;
			case 常量4：
				// 待执行的代码
				break;
			default:
				// 待执行的代码
		}
		虽然case语句中的break是可选的，但在绝大多数情况下，如果没有break,程序的逻辑就会发生错误，因此，通常情况下都需要加上break。
	5.4.white语句
		white(布尔表达式) {
			// 待执行的代码
		}
	5.5 do...while循环
		do {
			// 待执行的代码
		} while();
		
		while与do...while之间的区别:如果布尔表达式的第一次判断就为false,那么while循环一次也不执行；do...while循环会执行一次。如果布尔表达第一次判断为true，那么while循环与do...while循环等价。
	5.6 for语句
		for (变量初始化; 条件判断; 步进) {
			// 待执行的代码
		}
		for 循环的执行过程：
			1) 执行变量初始化；
			2) 执行条件判断; 如果条件判断结果为假，那么退出for循环，开始执行循环后面的代码。如果条件判断为真，执行for循环里面的代码。
			3) 执行步进。
			4) 重复步骤2)
	5.6 break语句
		经常用在循环语句中，用于跳出整个循环，执行循环后面的代码。
	5.6 continue语句
		经常用在循环语句中，用于跳出本次循环，继续执行余下的循环。
		
		break与continue可以搭配标签使用，在实际开发中，根本没有人会将break与continue搭配标签来使用。
6. 深入理解面向对象程序设计(Inside Object Oriented Programming)
	6.1 面向对象程序设计
		OOP:Object Oriented Programming 
		OOD:Object Oriented Design
		问：什么是面向对象？	
		答：在面向对象程序设计中两个重要的概念：类(class)与对象(object)。
	6.2 类
		类是一种抽象的概念，类中包含了数据(通常使用名词来表示)与对数据的操纵(能常使用动词来表示)。比如说人就是一种抽象的概念，人具有姓名、年龄、身高等数据，还有吃饭、跑步等操纵数据的动作。
	6.3 对象
		对象是一种具体的概念，是类的一种具体表示方式。比如说人是一个类，而张三、李四、王五等具体的人就是对象。
	6.4 类所包含的内容，类一共包含两部分内容：
		a) 数据，数据在类中称作属性(Propery或者Attribute)或者叫成员变量(Member variable)。
		b) 对数据的操纵。这种操纵在类中称为方法(method)。
	6.5 面向对象程序设计的三大基本特征	
		封装(encapsulation)
		继承(inheritance)	
		多态(polymorphism)
	6.6 封装(encapsultion)
		类包含了数据和方法，将数据与方法放在一个类中就构成了封装。
	6.7 如果定义类
		修改符 class 类的名字 {
			// 类的内容(包含了属性与方法)
		}
	6.8 如果定义方法
		修饰符 返回类型 方法名称([参数1， 参数2， 参数3...]) {
			// 方法体
		}	
		main方法是整个Java程序的入口点。如果类的定义中没有main方法，则程序无法执行。

		方法定义不能嵌套，也就是说不有在一个方法中定义另外一个方法。方法只能定义在类中。

		关于方法的执行：首先需要定义方法，接下来就可以使用方法(调用方法)。当方法调用完毕之后，方法可以返回值。方法到底是否返回值就由方法的定义决定的。
	6.9 如何生成对象
		通过类来生成对象(通常使用new关键字来生成对象)
		public class Person {
		
		}
		类名 变量名 = new 类名();

		Person person	= new Person();
		Person person2	= new Person();
		Person person3	= new Person();
	6.10 方法调用需要通过对象来完成
		方法调用的形式是：
		对象变量.方法名([参数值 1， 参数值2，参数值3...]);
	6.11 关于方法的注意事项
		1) 在方法的定义中，方法的返回类型与return后面的变量或常量类型保持一致。
		2) 在方法调用时，给方法传递的参数需要与方法定义时的参数保持一致(参数个数一致、参数类型一致)。
		3) 方法定义时的返回类型与接收方法返回值的变量类型保持一致。
		
		public int add(int a, int b) {
			return a + b;
		}
		方法定义时的参数叫做形式参数。
		
		int a  = test.add(9, 3);
		方法调用时所赋予的具体值叫做实际参数。		
		
		关键字void表示方法不返回值。
			public void output () {
				System.out.println("Hello World!");
			}
		如果方法不返回值，那么声明方法的时候使用void关键字，的方法定义中可以有两种情况实现不返回值：
			a) 不使用return语句。
			b) 使用return。但return后面没有任何值或者变量。return 后面只有一个分号。表示退出方法，返回到方法的调用端。
		使用方式：return;
			
	6.12 类中的属性又叫做成员变量(member variable)
		属性用英文表示为property或者atrribute。
	6.13 对象(object)又叫做实例(instance)。生成一个对象的过程又叫做类的实例化。
	6.14 命名约定
		a) 类：首字母大写，如果一个类名由多个单词构成，那么每个单词的首字母都大写，中间不使用任何的连接符。比如Peson类，MemberTest类。

		b) 方法：首字母小写。如果一个方法由多个单词构成，那么第一个单词的所有字母全都小写。从第二个单词开始，每个单词的首字母大写。比如add, addTrheeInt。

		c) 属性：命名约定与方法相同。比如：age, ageOfPerson。
	6.15 属性需要定义在类中，又叫做成员变量；而定义在方法中的变量叫做局部变量。
	6.16 如何定义属性
		public class Peson {
			修饰符 类型 属性名称
		}
		如何使用属性？与方法一样，使用.运算符。首先需要生成类的实例，然后使用实例+"."运算符的方式来使用属性。
		Person person = new Person();
		person.age;
	6.17 局部变量使用前必须要声明并赋初值：成员变量使用前必须声明，但可以不赋初值。
	6.18 成员变量与局部变量的联系与区别
		a) 无论是成员变量还是局部变量，使用前都需要声明(定义)。
		b) 对于局部变量来说，使用前必须初始化；对于成员变量来说，使用前可以不初始化。	
			如果没有初始化成员变量就开始使用，那个每个类型的成员变量都有一个默认的初始值。
			  i. byte、short、int、long类型的初始值为0; 
			 ii. float、double类型的初始值为0.0
			iii. char类型的初始值"\u0000" unicode字符
			iv. boolean类型的初始值为false
	6.19 引用类型(reference type)
		引用类型是用在对象上的。一个对象可以被多个引用所指向。但同一时刻，每个引用只能指向唯一的一个对象。如果一个对象被多个引用所指向，那么无论哪个引用对对象的属性进行了修改，都会反映到其他的引用当中。
	6.20 如果一个类包含了属性与方法，那么该类的每个对象都具有自己的属性，但无论一个类有多少个对象，这些对象共享同一个方法。
	6.21 关于方法参数传递的总结
		对于Java中的方法参数传递。无论传递的是原生数据类型还是引用类型，统一是传值(pass by value)
	6.22 什么类型的引用就能指向什么类型的对象
		比如People类型的引用就能指向People类型的对象，但不能指向Student类型的对象。比如：
		People people = new People(); //正确 
		People people = new Student(); //错误
	6.23 构造方法(constructor)
		构造方法用于完成对象属性的初始化工作，构造方法的特点：
		a) 构造方法的名字必须与类名完全一致(包含大小写)
		b) 构造方法没有返回值，连void也不能出现。
		c) 如果在定义一个类的时候，没有为类声明构造方法，那么Java编译器会自动为类添加一个没有参数且方法体为空的构造方法(默认的构造方法)
		d) 如果在定义一个类的时候，为类声明了构造方法，那么Java编译器不会再为类添加构造方法了。
		e) 不能显示调用类的构造方法。构造方法通常是通过new关键字隐式调用。
	6.24 new关键字在生成对象时完成了三件事情
		a) 为对象开辟内存空间
		b) 调用类的构造方法
		c) 将生成的对象的地址返回
	6.25 默认的构造方法：构造方法没有参数且方法体为空。
	6.26 使用new来生成对象的时候，后面的小括号{}表示构造方法的参数列表，如果构造方法不接收参数，那么小括号中的内容为空。如果构造方法接受参数，那么小括号中的实际参数就需要与构造方法定义中的形式参数保持一致(参数数量一致、参数类型一致、按照顺序逐一赋值)。
	6.27 如果一个java源文件中定义了多个类，那么这些类中最多只能有一个类是public的。换句话说，定义的多个类可以都不是public的。
	6.28 方法重载(Overload)
		表示两个或多个方法名字相同，但方法参数不同。方法参数不同两层含义：
		a) 参数个数不同；
		b) 参数类型不同。
		注意：方法的返回值对重载没有任何影响。
	6.29 构造方法重载
		只需要看参数即可。如果想在一个构造方法中调用另外一个构造方法，那么可以使用this()的方式调用，this()括号中的参数表示目标构造方法的参数。this()必须作为构造方法的第一条语句，换句话说，this()之前不能有任何可执行的代码。
	6.30继承(Inheritance)
		Java是单继承的，意味着一个类只能从另一个类继承(被继承的类叫做父类[基类，base class])，继承的类叫子类，Java中的继承使用extends关键字。
	6.31 当生成子类对象时，Java默认首先调用父类的不带参数的构造方法,然后执行该构造方法，生成父类的对象。
		接下来，再去调用子类的构造方法，生成子类的对象。[要想生成子类的对象，首先调用父类的对象，没有父亲对象就没有子类对象。比如：没有父亲，就没有孩子]
	6.32 super关键字
		super表示对父类对象的引用。
	6.33 如果子类使用super()显示调用父类的某个构造方法，那么在执行的时候就会寻找与super()所对应构造方法而不会再去寻找父类的不带参数的的构造方法。
		与this()一样，super也必须作为构造方法的第一条执行语句，前面不能有其他可执行语句。
	6.34 关于继承的3点
		a) 父类有的，子类也有
		b) 父类没有的，子类可以有
		c) 父类有的，子类可以改变
	6.35 关于继承的注意事项：
		a) 构造方法不能被继承
		b) 方法和属性可以被继承
		c) 子类的构造方法隐式地调用父类的不带参数的构造方法
		d) 当父类没有不带参数的构造方法时，子类需要使用super来显示地调用父类的构造方法，super指的是对父类的引用。
		d) super关键字必须是构造方法中第一行语句。
		
		this与super的区别
			区别点				this												super
			属性访问				访问本类中的属性，如果本类没有些属性则从父类中继续查找			访问父类中的属性
			方法					访问本类中的方法，如果本类中没有此方法，则此父类中继续查找		直接访问父类中的方法		
			调用构造				调用本类构造，必须放在构造方法的首行							调用父类构造，必须放在子类构造方法的首行
			特殊					表示当前对象											无此概念
			
			* this和super本身都可以调用构造方法，而且调用的时候都必须放在构造方法的首先，所以这两个关键字肯定不能同时出现。
			
	6.36 方法重写(override)
		子类与父类的就去返回类型一样、方法名称一样、参数一样，这样我们说子类与父类方法构成了重写关系 。
	6.38 方法重写与方法重载之间的关系
		重载发生在同一类内部的两个或多个方法。重写发生在父类与子类之间。
		
		区别点		重载							覆写
		单词			Overloading					Overriding
		定义			方法名称相同，参数类型或个数不同	方法名称、参数的类型、返回值类型全部相同
		权限			没有要求						被覆写的方法不能拥有更严格的权限		
		范围			在一个类中						在继承类中
		
	6.39 当两个方法形成重写关系时，可以在子类方法中通过super.run()形式调用父类的run()方法，其中super.run()不必放在第一行语句，因此此时父类对象已经构成完毕，先调用父类的run()方法还是先调用子类的run()方法是根据程序的逻辑决定的。
	6.40 在定义一个类的时候，如果没有显示指定该类的父类，那么该类就会继承于java.lang.Object类(JDK提供的一个类，Object类是Java中所有类的直接或间接父类)。
	6.41 多态(Polymorphism)
		我们说子类就是父类(玫瑰是花，男人是人)，因此多态的意思就是：父类型的引用可以指向子类的对象。
		
		多态：父类型的引用可以指向子类型的对象。
		Parent p = new Child(); 当使用多态方式调用方法时，首先检查父类中是否有sing()方法，如果没有则编译错误；如果有，再去调用 子类的sing()方法。
	6.42 抽象类(abtract)
		使用了abstract关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说不能new出来一个抽象类的对象(实例)。
		1. 抽象方法(abstract method)：使用abstract关键字所修饰的方法叫做抽象方法。抽象方法需要定义在抽象类中。相对于抽象方法，之前所定义的方法叫做具体方法(有声明，有实现)

		2. 如果一个类包含了抽象方法，那么这个类一定是抽象类。

		3. 如果某个类是抽象类，那么该类可包含具体方法(有声明、有实现)

		4. 如果一个类中包含抽象方法，那么这个类一定要声明成abstract class, 也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法。

		5. 无论何种情况，只要一个类抽象类，那么这个类就无法实例化。
		
		6. 在子类继承父类(父类是个抽象类)的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，该子类需要声明成一个abstract class。
	6.43 接口(interface)
		接口的地位等同于class, 接口中的所有方法都是抽象方法。在声明接口中的方法时，可以使用abstract关键字，也可以不使用。通常情况下，都会省略掉abstract关键字。
		1. 可以将接口看作是特殊的抽象类(抽象类中可以有具体方法，也可以有抽象方法，而接口中只能有抽象方法，不能有具体方法。) 
		2. 类可以实现接口。实现使用关键字implements表示，代表了某个类实现了某个接口。
		3. 一个类实现了某个接口，那么该类必须实现接口中声明的所有方法。如果该类是抽象类，那么就无需实现接口中的方法。
		4. Java是单继承的，也就是说某个类只能有唯一一个父类；
			一个类可以实现多个接口，多个接口之间用逗号分隔。
		5. 多态；所谓多态，就是父类性的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。
		6. static关键字：可以用在修饰属性，也可以用于修饰方法，还可以用于修饰类(后面的课程讲)
		7. static修改属性：无论一个类生成了多少个对象，所有这些对象共同使用唯一一份静态成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也随之发生变化。
		8. 如果一个成员变量是static的，那么我们可以通过类名.成员变量名的方式来使用它(推荐使用这种方式)
		9. static修饰方法：static修饰的方法叫做静态方法。对于静态方法来说 ，可以使用类名.方法名来方式来访问。
		10. 静态方法只能继承，不能重写(Override)
		11. final关键字: final 可以修饰属性、方法、类。
		12. final修饰类：当一个类被final所修饰时，表示该类是一个终态类，即不能被继承。
		13. final修饰方法：当一个方法被final所修饰时，表示该方法是一个终态方法，即不能被重写(Override)。
		14. final修饰属性：当一个属性被final所修饰时，表示该属性不能改写。
		15. 当final修饰一个数据类型时，表示该原生数据类型的值不能发生变化(比如说不能从10变为20);如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。
		16. 对于final类型成员变量，一般来说两种赋初值方式：
			a) 在声明final类型的成员变量时就赋上初值；
			b) 在声明final类型的成员变量时不赋初值，但在类的所有构造方法中都为其赋上初值。
		17. static代码块： 静态代码块。静态代码块的作用也是完成一些初始化工作。
		首先执行静态代码块，然后执行构造方法。静态代码块在类被加裁的时候执行，而构造方法是在生成对象的时候执行；要想调用某个类来生成对象，首先需要将类加载到Java虚拟机上(JVM)，然后由JVM加载这个类来生成对象。
		18. 类的静态代码块只会执行一次，是在类被加载的时候执行的。因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象的时候都会调用类的构造方法，所以new一交就会调用构造方法一次。
		19. 如果继承体系中有构造方法，以有静态代码块，那么首先执行最顶层类的静态代码块，一直执行到最底层类的构造方法。
		注意：静态代码块只会执行一次。
		20. 不能在静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量。可以在非静态方法中可以访问静态的成员变量。
		21. 总结：静态的只能访问静态的;非静态的可以访问一切。
		22. 不能在静态方法中使用this关键字。
		23. 接口中所声明的方法都是抽象方法。接口中的方法都是publick的。
		24. 接口中也可以定义成员变量 。接口中的成员变量都是public、fianl、static。
		25. 一个类不能既是final, 又是abstract的。因为abstract的主要目的是定义一种约定，让子类去实现这种约定，而final表示该类不能被继承，这样abstract希望该类可以被继承而final明确说明该类不能被继承，两者矛盾。因此一个类不能既是final的，又是abstract的。
		26. Design Pattern(设计模式)。单例模式(Singleton)：表示一个类只能生成唯一的一个对象。
		27. 包(package):用于将完成不同功能的类分六别类，放在不同的目录(包)下。
			包的命名规则：将公域名反转作为包名。
			www.skydao.net => net.skydao(包名)
			对于包名：每个字母都需要小写。
			使用package, 那么Java就认为我们所定义的类位于默认的包里面(default package)
		28. 设计模式
			1. 工厂模式				
				interface Fruit{
					public void eat();
				}
				class Apple implements Fruit{
					public void eat(){
						System.out.println("吃苹果");
					}
				}
				class Orange implements Fruit{
					public void eat(){
						System.out.println("吃橘子");
					}
				}
				class Factory{
					public static Fruit getInstance(String className){
						Fruit f = null;
						if (className.equals("apple")){
							f = new Apple();
						} else if (className.equals("orange")) {
							f = new Orange();
						}
						return f;
					}
				}
				public class InterfaceDemo03 {
					public static void main(String[] args){
						Fruit f = Factory.getInstance("apple");
						if (f != null) f.eat();
					}	
				}
				
			2. 代理设计模式
				interface Network{
					public void browse();	
				}
				class Real implements Network{
					public void browse(){
						System.out.println("上网浏览信息");
					}
				}
				class Proxy implements Network{
					private Network network;
					
					public Proxy(Network network){
						this.network = network;
					}
					public void check(){
						System.out.println("检查用户是否合法。");
					}
					public void browse(){
						this.check();
						this.network.browse();
					}
				}
				public class ProxyDemo {
					public static void main(String[] args){
						Network net = null;
						net = new Proxy(new Real());
						net.browse();
					}
					
				}
			3. 适配器设计
				interface Window{
					public void open();			//打开
					public void close();		//关闭
					public void activated();	//窗口活动
					public void iconified();	//窗口最小化
					public void deiconified();	//窗口恢复大小
				}
				abstract class WindowAdapter implements Window{
					public void open(){};			//打开
					public void close(){};		//关闭
					public void activated(){};	//窗口活动
					public void iconified(){};	//窗口最小化
					public void deiconified(){};	//窗口恢复大小	
				}
				class WindowImpl extends WindowAdapter{
					public void open(){
						System.out.println("窗口打开");
					}
					public void close(){
						System.out.println("窗口关闭");
					}
				}
				public class AdapterDemo {
					public static void main(String[] args){
						Window win = new WindowImpl();
						win.open();
						win.close();
					}
				}
			4. 内部类的扩展
				abstract class A{
					public abstract void printA();
					interface B{
						public void printB();
					}
				}
				class X extends A{
					public void printA(){
						System.out.println("Hello --> A");
					}
					class Y implements B{
						public void printB(){
							System.out.println("Hello --> B");
						}
					}
				}
				public class InnerExtDemo {
					public static void main(String[] args){
						A a = new X();
						a.printA();
						
						A.B b = new X().new Y();
						b.printB();
					}
					
				}
				
		29. 抽象类与接口之间的关系
			区别点			抽象类						接口
			定义			包含一个抽象方法的类				抽象方法和全局常量的集合
			组成			构造方法、抽象方法、普通方法、常量、变量	常量、抽象方法
			使用			子类继承抽象类(extends)				子类实现接口(implements)		
			关系			抽象类可以实现多个接口				接口不能继承抽象类，但允许继承多个接口
			常见设计模式		模板设计					工厂设计、代理设计
			对象					都通过对象的多态性产生实例化对象
			局限			抽象类有单继承的局限				接口没有此局限
			实际			作为一个模板					是作为一个标准或是表示一种能力
			选择			如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限
			特殊			一个抽象类中可以包含多个接口，一个接口中可以包含多个抽象类
			
			重要的提示：
				在开发中，一个类永远不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口，如果接口和抽象类同时都可以使用的话，那么优先使用接口，避免单继承局限。

	6.44 编译带有package声明的Java源文件有两种方式：
		a) 直接编译，然后根据类中所定义包名，逐一手工建立目录结构，最后将生成的class文件放到该目录结构中(很少使用，比较麻烦)。

		b) 使用编译参数 -d , 方式为javac -d . 源文件.java，这样在编译后，编译器会自动帮助我们建立好包所对应的目录结构。
	6.45 有两个包名，分别是aa.bb.cc与aa.bb.cc.dd，那么我们称后者为前者的子包。
	6.46 导入(import)，将使用package分离的各个类导入回来，让编译器能够找到所需要的类。
	6.47 import的语法：import net.skydao.PackageTest;
	6.48 import net.skydao.*, 表示导入 net.skydao包下面的所有类。
	6.49 import aa.bb.*并不会导入aa.bb.cc包下面的类。这时需要这样写：
		import aa.bb.*;
		import aa.bb.cc.*;
	6.50 关于package、import、class的顺序问题：
		a) 首先需要定义包(package)，可选;
		b) 接下来使用import进行导入，可选;
		c) 然后才是class或interface的定义。
	6.51 如果两个类在同一个包下面，那么则不需要导入，直拉使用即可。
	6.52 访问修饰符(access modifier)
		1) public(公共的): 被public所修饰的属性和方法可以被所类访问。
		2) protected(受保护的): 被protected所修饰的属性和方法可以在类内部、相同包以及该子类所访问。
		3) private(私有的): 被private所修饰的属性和方法只能在该类内部使用。
		4) 默认的(不加任何访问修饰符): 在类内部以及相同包下面的类所使用。
	6.53 instanceof语句
		判断某个对象是否是某个类的实例。语法形式：引用名instanceof 类名(接口名), 返回一个boolean值。
	6.54 相等性的比较（==）
		1）对于原生数据类型来说，比较的是左右两边的值是否相等。
		2）对于引用类型来说，比较左右两边的引用是否指向同一个对象，或者是说左右两边的引用地址是否相同。
	6.55 java.lang.Object类。java.lang包在使用的时候无需显式导入，编译时由编译器自动帮助我们导入。
	6.56 当打印引用时，实际上会打印出引用类型所指对象的toString()方法的返回值，因为每个类都直接或间接地继承自Object，而Object类中定义了toString()，因此每个类都有toString()这个方法。
	6.57 关于进制的表示：
		16进制，逢16进一。16进制的数字包括：0~9,A,B,C,D,E,F
	6.58 equals()方法，该方法定义在Object类中，因此Java中的每个类都具有该方法，对于Object类的equals()方法来说，它是判断调用equals()方法的引用与传进来的引用是否一致，即这两个引用是否指向的是同一个对象。对于Object类的equals()方法来说，它等介于==。
	6.59 对于String类的equals()方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。
	6.60 对于String对象的相等性判断来说，请使用equals方法，而不要使用==。
	6.61 String是常量，其对象一旦创建完毕就无法改变。当使用+拼接字符串时，会生成新的String对象，而不是原有的String对象追加内容。
	6.62 String Pool（字符串池）
	6.63 String s = 'aaa';	(采用字面值方式赋值)
		1) 查找String Pool中是否存在"aaa"这个对象，如果不存在，同日则在String Pool中创建一个"aaa"对象，然后将String Pool中的这个"aaa"对象的地址返回来,赋给引用变量s,这样s会指向String Pool中的这个"aaa"这个对象。
		2) 如果存在，则不创建任何对象，直接将String Pool中的这个"aaa"对象地址返回来，赋给s引用。
	6.64 String s = new String("aaa");
		1) 首先在String Pool中查找有没有"aaa"这个字符串对象，
		如果有，则不在String Pool中再去创建"aaa"这个对象了，
		直接在堆中(head)中创建一个"aaa"字符串对象，然后将堆中的这个"aaa"对象的地址返回来，赋给s引用，导致s指向了堆中创建的这个"aaa"字符串对象。

		2) 如果没有，则首先在String Pool中创建一个"aaa"对象，然后再堆中(head)创建一个"aaa"对象，然后将堆中的这个"aaa"对象的地址返回来，赋给s引用，导致指向了堆中所创建的这个"aaa"对象。
	6.65 StringBuffer
		StrinbBuffer buffer = new StringBuffer();
		buffer.append("hello").append(" world").append(" welcome");
		//buffer.append("hello");
		//buffer.append(" world");
		//buffer.append(" welcome");		
		String result = buffer.toString();
		System.out.println(result);
7. 包装类(Wrapper Class)
	7.1 针对于原生数据类型的包装
		所有包装类(8个)都位于java.lang包下。
		Java中的8个包装类分别是：
		Byte,Short,Integer,Long,Float,Double,Character,Boolean。
		他们的使用方式都是一样的，可以实现原生数据类型与包装类型的双向转换。
		
		int a = 10;
		Integer integer = new Integer(1):
		int b = integer.intValue();
		System.out.println(a == b);		
8. 数组(Array)
	相同类型数据的集合就叫做数组。
	
	8.1 如果定义数组。
		type[] 变量名 = new type[元素个数];
		可以按照下列方式定义长度为10的数组。
		int[] a = new int[10]; 
		int a[] = new int[10];
		int[] a = {1,2,3,4};
		int[] a = new int[]{1,2,3,4};
	8.2 数组中的元素索引是从0开始的。对于数组来说，最大索引==数组的长度-1。
	8.3 定义数组的第3种方式：type[] 变量名 = {new type[]}逗号分隔的初始化值列表
	8.4 Java中的每个数组都有一个名为length的属性,表示数组的长度。length属性是public,final,int的。数组长度一旦确定，就不能改变大小。
	8.5 int[] a = new int[10],其中a是一个引用，它指向了生成的数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。
	8.6 二维数组
		二维数组是一种平面的二维结构，本质上是数组的数组。type[][] 变量名 = new type[][]; 
	8.7 三维数组
		type[][][] a = new type[2][3][4];

		int[][][] a = new int[2][3][4];
		System.out.println(a instanceof int[][][]);
		System.out.println(a instanceof Object);
		System.out.println(a[0] instanceof int[][]);
		System.out.println(a[0][0] instanceof int[]);

		for(int i=0; i<a.length; i++){
			for(int j=0; j<a[i].length; j++){
				for(int k=0; k<a[i][j].length; k++){
					a[i][j][k] = 100;
				}
			}
		}
	8.8 冒泡排序、交换排序、快速排序
	8.9 选择查询、二分查询(Binary Search)
	8.10 随机生成50个数字（整数），每个数字的范围是[10,50]，统计每个数字出现的次数以及出现次数最多的数字与它的个数，最后将每个数字及其出现次数打印出来，如果某个数字出现次数为，则不要打印它。打印时按照数字的升序排列。
	
9. 常量 
	9.1 对于Java中的常量命名规则：所有单词的字段都是大写，如果有多个单词，那么使用下划线连接即可。
	比如说：
		public static final int AGE_OF_PERSON = 20;
	9.2 在Java中声明final常量时通常都会加上static关键字，这样对象的每个实例都会访问唯一一份常量值。
10. 集合
	集合框架中的接口:
		Collection
		 -Set
		  -SortedSet
		  -List
		- Map
		  -SortedMap
		所谓框架就是一个类库的集合，集合框架就是一个用来表示和操作集合的统一的架构，包含了实现集合的接口与类。	

		生成帮助文档： htmlhelpexe和jd2chm.exe
	10.1 IDE(Integrated Development Environment)，集成开发环境。
		1) NetBeans http://netbeans.org
		2) Jbiulder
		3) Intellij IDEA http://www.jetbrains.com
		4) Eclipse(日蚀、月蚀) http://www.eclipse.org/
		5) MyEclipse http://wwww.myeclipseide.com
		服务器:GlobalSCAPE CUTE ftp
		Ctrl+Shift+O:制动载入包
		Alt+大箭头: 回到原来的鼠标处
		Ctrl+Shift+W: 关闭所有文件
	10.2 集合中存放物依然是对象的引用而不是对象本身。	
	12.3 ArrayList底层采用数组实现，当使用不带参数的构造方法生成ArrayList对象时，实际上会底层生成一个长度为10的Object类型数组。
	10.4 如果增加的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新数组当中。当新数组无法容纳增加的元素时，重复该过程。
	10.5 对于ArrayList元素的删除操作，需要将被删除元素的后续元素向前移动，代价比较高。
	10.6 集合当中只能放置对象的引用，无法放置原生数据类型，我们需要使用原生数据类型的包装类才能加入到集合当中。
	10.7 集合当中放置的都是Object类型，因此取出来的也是Object类型，那么必须使用强制类型转换将其转换为真正的类型（旋转进行的类型）。
	10.8 关于ArrayList与LinkedList的比较分析
		a) ArrayList底层采用数组实现，LinkedList底层采用双向链表实现。
		b) 当执行插入或者删除操作时，采用Linked比较好。
		c) 当执行搜索操作时，采用ArrayList比较好。
		作业：
			1.独立分析LinkedList源代码
			2.阅读pdf文档 
	10.9 LIFO(Last In First Out)
	     FIFO(First In First Out)
	     Queue:队列
	     Statck:栈
		栈与队列
		
		队列:Queue
		public void put(Object o){
			
		}
		public Object get(){
		
		}
		public boolean isEmpty(){
		
		}
		
		栈:Stack
		public void push(Object o) {
		
		}
		public Object pop(){
		
		}
		public Object peek(){
		
		}
		public boolean isEmpty(){
		
		}
		无论是栈还是队列，里面都会维护一个成员变量，该成员变量用于存储栈或队列中的元素。该成员变量请使用LinkedList类型。
	10.10 当向ArrayList添加一个对象时，实际上就是将该对象放置到了ArrayList底层所维护的数组当中；当向LinkedList中添加一个对象时，实际上LinkedList内部会生成一个Entry对象，该Entry对象的结构为：
		Entry {
			Entry previous;
			Object elements;
			Entry next;
		}
		其中的Object类型的元素element就是我们向LinkedList中所添加的元素，然后Entry又构造好了向前与向后的引用previous、next，最后将生成的这个Entry对象加入到了链表当中。换句话说，LinkedList中所维护的是一个个的Entry对象。
	10.11 关于Object类的equals方法的特点：
		a)自反性：x.equals(x)应该返回true
		b)对称性：x.equals(y)为true,那么y.equals(x)也为true
		c)传递性：x.equals(y)为true,并且y.equals(z)为true,那么x.equals(z)也应该返回true
		d)一致性：x.equals(y)的第一次调用为true,那么x.equals(y)的第二次、第三次、第n次调用也应该为true，前提条件是在比较之间没有修改x也没有修改。
		e) 对于非空引用x,x.equals(null)返回false。

	10.12 关于Object类的hashCode()方法的特点：
		a)在Java应用的一次执行过程当中，对于同一个对象的hashCode()方法的多次调用，他们应该返回同样的值（前提是该对象的信息没有发生变化）。
		b)对于两个对象来说，如果使用equals方法比较返回true,那么这两个对象的hashCode值一定是相同的。
		c)对于两个对象来说，如果使用equals方法比较返回false,那么这两个对象的hashCode值不要求一定不同（可以相同，可以不同），但是如果不同则可以提高应用的性能。
		d)对于Object类来说，不同的Object对象的hashCode值是不同的(Object类的hashCode值表示的是对象的地址)
			
		当使用HashSet时，hashCode()方法就会得到调用,判断已经存储在集合中的对象的hash code值是否与增加的对象的hash code值一致；如果不一致，直接加进去；如果一致，再进行equals方法的比较，equals方法如果返回true,表示对象已经加进去了，就不会再增加新的对象，否则加进去。

	10.13 如果我们重写equals方法，那么也要重写hashCode方法，反之亦然。
	10.14 getClass().getName()+'@'+Integer.toHextString();
	10.15 Map(映谢):Map的keySet方法会返回key的集合，因为Map的键是不能重复的，因此keySet()方法的返回类型是Set;而Map的值是不可以重复的，因此values()方法的返回类型是Collection,可以容纳重复的元素。	
	
	什么是集合框架类？
		集合：
			将多个元素组成一个单元的对象
			用于存储、检索、操纵和传输数据			
		集合框架：
			提供用于管理对象集合的接口和类
			包括接口、实现和算法
	
		接口体系结构
			Collection(单独元素)
				- List(有序的)
				- Set(没有重复的元素,后面的会覆盖前面的)
					- SortedSet
			Map(两个元素,必须有别名,键值对)
				- SortedMap
			
			Collection(I)
				- List(i)
					- AbstractList(A)
						- Vector
						- ArrayList
						- AbstractSequentialList(A)
							- LinkedList
				- Set(i)
					- SortedSet(I)
					- AbstractList(A)
						- HashSet
							- LinkedHashList
													
						TreeSet
			Map(I)
				- SortedMap(I)
				-AbstractMap(A)
					- HashMap
					- HashTable				
				
					TreeMap
					
			
			Collection方法：
				contains(Object o)	是否包含指定的元素				
				toArray()			返回此集合中所有元素的数组
				size()				得到此集合元素的长度
				isEmpty()			判断此集合内部是否有元素
				Iterator iterator()		返回在此collection的元素上进行迭代的迭代器
				
				String类length方法
			
			Collection与Collections的区别：
				Collection是集合类的上级接口，继承与他的接口主要有Set和List。
				
			Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
				
	
					
			
				
	为什么需要集合框架类？
		
	集合框架体系结构？
	迭代器
	Hashtable
		
	
类与类的关系
	1. 关联关系：一个类中的方法有另外一个类的对象。
			学院、教授、研究生	
	2. 继承关系：xx是一种xx
		- 运行员
			- 游泳动员员
			- 球类运动员
				- 足球运动员
				- 篮球运动员
				- 排球运动员
			- 射击运动员
	3. 聚合关系(整体和部分)
		- 球队(聚集)
			- 队长
			- 队员
		- person(组合，密不可分)
			- limb
			- head
			- body
	4. 实现关系 
		<
  
   >照顾宠物(+喂食(), +和它玩())
			- 工人
			- 农民
			- 国家干部
	5. 多态
		职员- 交通工具(+行驶(), +刹车())	
					- 自行车(+行驶(), +刹车())
					- 汽车(+行驶(), +刹车())	
					- 摩托车(+行驶(), +刹车())
	6. 面向对象思维：
		a) 有哪些类和对象?
		b) 这些类和对象都有什么属性和方法?
		c) 类与类之间是什么关系?
	7. 旅行社 -----> 预定机票 -----> 准备机票 -----> 旅客
			航班目录^	记账文件->记账->旅客	
		类：机票，旅游社，客户，帐户，目录，
		机票：
			属性：时间、价格、班次、
			方法：作废、显示价格、显示航班时间
	8. Java语言中除基本类型之外变量类型都称之为引用类型。
		类是静态的概念，代码区对象是new出来的，位于堆内存，类的每个成员变量在不同的对象中都有不同的值(除了静态变量)而方法只有一份，执行的时候占用内存。

		同一个类的每个对象有不同的成员变量存储空间
		同一类的每个对象共享该类的方法
	9. jar -cvf test.jar *.*
	10. class类文件 
		修饰符		类内部		同一个包	子类		任何地方					
		private		Yes
		default		Yes		Yes
		protected	Yes		Yes		Yes
		public		Yes		Yes		Yes		Yes
		public类可以在任意地方被访问
		default类只可以被同一个包内部类访问
			
		重写方法被重写方法具有相同方法名称、参数列表和返回类型。
		重写方法不能使用比被重写方法更严格的访问权限。

		jkd = java编译器 + jre(java运行时环境)
		jre = jvm + 运行支持库(String, verctor)
		eclipse本身自带了java编译器但不包含jre
	11. 反编译: JAD
		jad -s java clss文件目录
	12. Java语言区分大小写
	13. 动态绑定：
			1. 继承
			2. 重写
			3. 父类引用子类
	14. Final关键字
		- final的变量的值不能够被改变
			- final的成员变量
			- final的局部变量(形参)
		- final的方法不能够被重写
		- final的类不能够被继承
	15. 接口(interface)
		a) 接口可以多重实现
		b) 接口中声明的属性默认为public static final的；也只能是public static final的;
		c) 接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的；
		d) 接口可以继承其它接口，并添加新的属性和抽象方法。
异常
	异常定义：
程序编译和运行时发生错误称为异常。处理发生的异常称为异常处理。
 
	异常处理目的：保证程序继续运行
	其它：一个异常就是一个异常类（对象）
	
	异常分类：
		-Trowable
			-Error(用于定义不指望程序能从其它恢复过来的灾难性故障。所以程序员不需要捕捉它们。如：线程停止，虚拟机错误等。)
				-AWTError
				-Thread Death
					
			-Exception(对于从Exception派生出来的所有其它类，是我们重点关注的内容)
				-SQLException 						-编译时异常（必须处理）
  
				-ClassNotFoundException 	-编译时异常(Class.forName("ggggg.sfsdf.com"))
				
				-RuntimeException 				-运行时异常 （可以不处理）
					-ArithmeticException(非法算术操作)
					-ArrayIndexOutOfBoundsException(数组下标越界)
					-NullPointerException(空指针对象)
					-NumberFormatException(当把字符串转换为数字时格式不匹配)
					-ClassCastException(对象转换成非法类型)
					-IllegalArgumentException(传递给一个方法的实际参数和该方法的形式参数类型不符)
					-SecurityException(程序执行违反安全规定的非法操作)
	自定义异常