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关键字必须是构造方法中第一行语句。
	6.36 方法重写(overrid)
		子类与父类的就去返回类型一样、方法名称一样、参数一样，这样我们说子类与父类方法构成了重写关系 。
	6.38 方法重写与方法重载之间的关系
		重载发生在同一类内部的两个或多个方法。重写发生在父类与子类之间。
	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)
		
	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 当打印引用时，实际上会打印出引用类型所指对象的toString()方法的返回值，因为每个类都直接或间接地继承自Object，而Object类中定义了toString()，因此每个类都有toString()这个方法。
	6.55 关于进制的表示：
		16进制，逢16进一。16进制的数字包括：0~9,A,B,C,D,E,F
	6.56 equals()方法，该方法定义在Object类中，因此Java中的每个类都具有该方法，对于Object类的equals()方法来说，它是判断调用equals()方法的引用与传进来的引用是否一致，即这两个引用是否指向的是同一个对象。对于Object类的equals()方法来说，它等介于==。
	6.57 对于String类的equals()方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。
	6.58 对于String对象的相等性判断来说，请使用equals方法，而不要使用==。
	6.59 String是常量，其对象一旦创建完毕就无法改变。当使用+拼接字符串时，会生成新的String对象，而不是原有的String对象追加内容。
	6.60 String Pool（字符串池）
	6.61 String s = 'aaa';	(采用字面值方式赋值)
		1) 查找String Pool中是否存在"aaa"这个对象，如果不存在，同日则在String Pool中创建一个"aaa"对象，然后将String Pool中的这个"aaa"对象的地址返回来,赋给引用变量s,这样s会指向String Pool中的这个"aaa"这个对象。
		2) 如果存在，则不创建任何对象，直接将String Pool中的这个"aaa"对象地址返回来，赋给s引用。
	6.62 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"对象。
7. 包装类(Wrapper Class)
	7.1 针对于原生数据类型的包装
		所有包装类(8个)都位于java.lang包下。Java中的8个包装类分别是：Byte,Short,Integer,Long,Float,Double,Character,Boolean。他们的使用方式都是一样的，可以实现原生数据类型与包装类型的双向转换。
	7.2.数组(Array)。相同类型数据的集合就叫做数组。
	7.3. 如果定义数组。
		type[] 变量名 = new type[元素个数];可以按照下列方式定义长度为10的数组。
		int[] a = new int[10]; int a[] = new int[10];
	7.4. 数组中的元素索引是从0开始的。对于数组来说，最大索引==数组的长度-1。
	7.5. 定义数组的第3种方式：type[] 变量名 = {new type[]}逗号分隔的初始化值列表
	7.6. Java中的每个数组都有一个名为length的属性,表示数组的长度。length属性是public,final,int的。数组长度一旦确定，就不能改变大小。
	7.7. int[] a = new int[10],其中a是一个引用，它指向了生成的数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。
	7.8. 二维数组。二维数组是一种平面的二维结构，本质上是数组的数组。type[][] 变量名 = new type[][]; 


类与类的关系
	1. 关联关系：一个类中的方法有另外一个类的对象。
			学院、教授、研究生	
	2. 继承关系：xx是一种xx
		- 运行员
			- 游泳动员员
			- 球类运动员
				- 足球运动员
				- 篮球运动员
				- 排球运动员
			- 射击运动员
	3. 聚合关系(整体和部分)
		- 球队(聚集)
			- 队长
			- 队员
		- person(组合，密不可分)
			- limb
			- head
			- body
	4. 实现关系 
		<<interface>>照顾宠物(+喂食(), +和它玩())
			- 工人
			- 农民
			- 国家干部
	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) 接口可以继承其它接口，并添加新的属性和抽象方法。
posted @ 2011-11-13 20:28 Java EE 阅读(141) 评论(0) 编辑收藏举报
刷新页面返回顶部
Java EE

java基础笔记

公告
