JAVA复习笔记

day01课堂笔记

/*
	1、什么是注释，有什么用？
		注释是对java源代码的解释说明。
		注释可以帮程序员更好的理解程序。

	2、注释信息只保存在java源文件当中，java源文件编译生成的字节码class文件，
	这个class文件中是没有这些注释信息的。

	3、在实际的开发中，一般项目组都要求积极的编写注释。这也是一个java软件工程师
	的基本素养。

	4、注释不是写的越多越好，精简，主线清晰，每个注释都应该是点睛之笔。（以后慢慢锻炼）
*/

// 这种注释属于单行注释，只注释两个斜杠后面的

/**
* 类的注释信息
* @version 1.0
* @author bjpowernode-dujubin
* ....
*/
public class HelloWorld{ // 这是一个类，类名叫做HelloWorld
	public static void main(String[] args){
		System.out.println("Hello World");
		System.out.println("动力节点-口口相传的Java黄埔军校");
	}
}

/*
	在这里可以编写多行注释
	这是一行注释
	这是第二行注释
	这是第三行注释
*/

1、常用的DOS命令
1.1、怎么打开DOS命令窗口
win键 + r （组合键）：可以打开“运行”窗口
在运行窗口文本框中输入: cmd
然后回车
1.2、什么是DOS命令呢？
在DOS命令窗口中才可以输入并执行DOS命令。
在最初的windows计算机中没有图形界面的，只有DOS命令窗口。
也就是说通过执行DOS命令窗口可以完全完成文件的新建、编辑、保存、删除
等一系列操作。
1.3、mkdir abc（这个命令不是必须掌握的）make directory（创建目录）
创建一个目录，起名abc
1.4、默认情况下DOS命令窗口打开之后，定位的位置是哪里？
C:\Users\Administrator 这是默认的当前路径
1.5、在DOS命令窗口中怎么复制内容？
win7:
任意位置点击右键–>标记–>选中要复制的内容–>点击右键–>此时就到剪贴板里面了
win10：
左键直接选中，然后右键单击一下就到剪贴板里面了。
1.6、切换盘符？
直接输入盘符就行：
c: 回车
d: 回车
e: 回车
f: 回车
就OK了。

当切换到D盘根下了，那么当前路径就是：D:>
当前路径是当前所在的位置。

1.7、切换目录？（非常重要，必须掌握）
	使用cd命令来完成目录的切换：cd是什么含义？change directory（改变目录）
	cd命令怎么用，语法格式是什么？
		cd 路径
	路径在windows系统上包括：相对路径和绝对路径。

	什么是相对路径呢？
		一定要注意，从路径形式上来看，相对路径是一定不会以盘符开始的。
		相对路径：相对路径一定是相对于当前所在“位置”而言的。
		相对路径是相对于当前而言，从当前所在的位置作为起点。

		死记：相对路径一定是从当前位置作为起点开始找。

	什么是绝对路径呢？
		在windows操作系统中凡是路径起点是盘符的都是绝对路径，例如：
			C:\Users\Administrator
			C:\Users
			C:\Users\Public\gakataka
			C:\Windows\System32
			D:\BaiduNetdiskDownload
			D:\course\01-开课\OneNote
	
	注意：
		cd .. 回到上级路径。
		cd \ 直接回到根路径。
		. 一个点，代表当前路径。（cd命令用不着。以后配置环境变量的时候一个点有用处。）

1.8、cls 清屏
1.9、dir 查看当前目录下有啥东西。
1.10、exit 退出DOS命令窗口。

day02课堂笔记

1、常用的DOS命令（续）
1.1、del命令，删除一个或者多个文件
删除T1.class文件
C:\Users\Administrator>del T1.class
删除所有.class结尾的文件，支持模糊匹配
C:\Users\Administrator>del *.class

	T1.class
	T1.glass
	del *ass 这个命令就会将T1.class和T1.glass都删除。
	删除的一定是能匹配上的。

	del *.class 这个命令中的那个“.”不要特殊化，这个“.”其实就是一个普通的字母

1.2、怎么查看本机的IP地址？
	什么是IP地址？有什么用呢？
		A计算机在网络当中要想定位到（连接到）B计算机，那么必须要先
		知道B计算机的IP地址，IP地址也可以看做计算机在同一个网络当中的
		身份证号（唯一标识）。
		IP地址就相当于电话号码是一个意思。
	ipconfig（ip地址的配置信息。）

	ipconfig /all 该命令后面添加一个/all参数可以查看更详细的网络信息。
	这个详细信息中包括网卡 的物理地址，例如：70-8B-CD-A7-BA-25
	这个物理地址具有全球唯一性。物理地址通常叫做MAC地址。

1.3、怎么查看两台计算机是否可以正常通信？
	ping命令
		语法格式：
			ping IP地址
			ping 域名
	
	ping www.baidu.com
	ping 61.135.169.121  （61.135.169.121是百度的IP地址）
	ping 61.135.169.121 -t （-t参数表示一直ping）
	一直ping的目的可以查看网络是否稳定。

	在一个DOS命令窗口中如果有一个命令一直在执行，想强行终止怎么办？
		ctrl + c 组合键
	
	http://www.baidu.com 可以打开百度（这种方式比较方便，域名更容易记忆。）
	http://61.135.169.121 也可以打开百度

	域名底层最终还是会被解析成IP地址的形式。

2、文本编辑快捷键：

2.1、掌握常用的通用的文本编辑快捷键很重要，可以大大提升开发效率。
所以，必须熟练掌握，从此刻开始强迫自己少用鼠标，用组合键快捷键
的方式。

2.2、常用的组合键都有哪些？
	复制	ctrl + c
	粘贴  ctrl + v
	剪切  ctrl + x
	保存  ctrl + s

	撤销  ctrl + z
	重做  ctrl + y

	回到行首：home键
	回到行尾：end键

	当光标在行尾，怎么选中一行？
		shift + home键
	当光标在行首，怎么选中一行？
		shift + end键
	
	回到文件头：ctrl + home
	回到文件尾：ctrl + end

	全选：ctrl + a

	查找：ctrl + f
	---------------------------（以上必须会用）--------------------------
	选中一个单词：鼠标双击
	选中一行：鼠标连续击3次

	不用鼠标选中一个单词：ctrl + shift + 右箭头/左箭头

3、计算机编程语言发展史？

第一代语言：机器语言
	程序员直接编写二进制,一串二进制代码，例如：10010100010010001000....
	计算机是由电流驱动的，电流只能表示两种状态：正、负。
	而正可以对应1，负可以对应0.
	10010010101010...这些二进制码正好和自然世界中的十进制存在转换关系。
	所以很巧妙的是：计算机可以模拟现实世界当中的事物。

	机器语言时期非常具有代表性的就是：打孔机。
	缺点：
		纸带不容易保存
		另外打孔的时候是人为操作的，孔有可能打错了。孔打错了纸带就废了。

第二代语言：低级语言
	非常具有代表性的：汇编语言。
	汇编语言比机器语言更接近人类自然语言。
	但是汇编语言还是需要专业人士进行开发，一般人拿到汇编语言也读不懂。

第三代语言：高级语言
	高级语言完全接近人类自然语言，具有代表性的：
		C语言：面向过程的
		C++语言：一半面向过程，一半面向对象
		Java语言：完全面向对象（java语言底层实际上是C++实现的。）
		Python语言：面向对象
		....

计算机编程语言是什么？
	是一个团队，或者一个组织制定的一套固定的语法规则，
	你可以学习这套语法规则，然后通过这套语法规则和计算机
	交互。

我们为什么要学习汉语？
	原因是我们学习了汉语之后，可以完成人和人的沟通。
我们为什么要学习日语？
	因为我们要和日本人沟通。。。

4、Java语言的概述以及Java语言的发展史。
JDK（Java开发工具箱，做Java开发必须安装的，这是最根本的一个环境。）
JDK不是集成开发环境。
JDK这个开发工具箱中是Java最核心的库。

98年的时候：Java升级到JDK1.2，Java被分为三大块：
	J2SE：标准版（基础，要学java，必须先学习SE。基础语法+基础库）
	J2EE：企业版（专门为企业开发软件，为企业提供解决方案。例如：OA办公系统，保险行业的系统，金融行业的系统，医院系统....）
	J2ME：微型版（专门为微型设备做嵌入式开发的。）

java诞生十周年改了名字：
	JavaSE
	JavaEE
	JavaME

day03课堂笔记

1、Java语言的特性

1.1、简单性
	在Java语言当中真正操作内存的是：JVM（Java虚拟机）
	所有的java程序都是运行在Java虚拟机当中的。
	而Java虚拟机执行过程中再去操作内存。
	对于C或者C++来说程序员都是可以直接通过指针操作内存的。
	C或者C++更灵活，可以直接程序员操作内存，但是要求程序员技术精湛。
	C语言或者C++更有驾驭感。
	Java语言屏蔽了指针概念，程序员不能直接操作指针，或者说程序员
	不能直接操作内存。这种方式有优点也有缺点：
		优点：不容易导致内存泄漏。（简单了。）
		缺点：效率问题，包括驾驭感比较差。
	
	飞机航行：
		如果是C语言表示程序员是飞机驾驶员。
		如果是Java语言表示程序员是飞机上的乘客。
	
	Java语言底层是C++，所以JVM是用C++语言写好的一个虚拟的电脑。
	JVM在哪里？告诉大家，安装了JDK之后，JVM就代表安装好了。

	内存是什么？
		对于计算机来说：最主要的几个部件是什么？
			CPU：
				中央处理器，相当于人类的大脑，负责发送并执行指令。
				是整个计算机的指挥官。
				CPU是负责计算的，负责运算的。
				10 + 20 = 30
				CPU负责将30这个结果计算出来。
				但是在计算过程中有三个数据需要临时找个空间存储一下：
					这三个数据分别是：10 20 30

			内存：
				程序运行过程当中的临时数据存储空间。
				断电之后或者关机之后内存中的数据就消失了。

			硬盘：
				持久化设备，硬盘上的数据不会因断电而丢失。

			主板：
				相当于人类的躯干，是一个载体：
					CPU、内存条、硬盘等主要的部件都是放在主板上的，
					主板上有很多线，将以上的部件链接起来。
			.....

1.2、java是堪称完全面向对象的。
	面向对象更容易让人理解，人类通常是以对象的方式认知世界的。
	采用面向对象的方式可以让复杂问题简单化。

1.3、健壮性
	主要是因为Java中有一种机制：
		自动垃圾回收机制（GC机制）。
	java语言是健壮的，相对于C语言来说，C语言没有Java健壮。
	Java不容易导致内存的泄漏。
	C++或者C语言使用不当时很容易导致内存泄漏。

	JVM负责调度GC机制。程序员不需要干涉。

	以上讲解中又描述了这几个术语：
		JVM（C++语言写的一个虚拟的计算机）、GC（垃圾回收机制）

1.4、java完全/完美支持多线程并发。

1.5、可移植性/跨平台
	java语言只要编写一次，可以做到到处运行。
	例如：java程序编写完之后，可以运行在windows操作系统上，
	不需要做任何改动可以直接运行在Linux操作系统上，同样也
	可以运行到MaC OS上面。

	一次编写，到处运行。（平台改变了，程序不需要改。）

	JVM这种机制实现了跨平台，那么这种机制优点和缺点分别是什么？
		优点：一次编写到处运行，可以跨平台。
		缺点：麻烦。对于运行java程序来说必须先有一个JVM。
		就像你要想在网页上看视频，你必须先安装一个flash是一样的。
	
	Java语言可以编写病毒吗？
		可以，没问题。但是很难让用户中毒。
		中毒的一般都是java程序员。所以很少有人编写java的病毒脚本。

2、JDK、JRE、JVM三者之间的关系？
JDK:Java开发工具箱
JRE:java运行环境
JVM:java虚拟机

JDK包括JRE，JRE包括JVM。

JVM是不能独立安装的。
JRE和JDK都是可以独立安装的。
有单独的JDK安装包。
也有单独的JRE安装包。
没有单独的JVM安装包。

安装JDK的时候：JRE就自动安装了，同时JRE内部的JVM也就自动安装了。
安装JRE的时候：JVM也就自动安装了。

问题：
	假设你在软件公司开发了一个新的软件，现在要去客户那边给客户把
	项目部署一下，把项目跑起来，你需要安装JDK吗？
		只需要安装JRE就行了。
		JRE体积很小，安装非常便捷快速。

问题：
	为什么安装JDK的时候会自带一个JRE？
		因为java程序员开发完程序之后，要测试这个程序，
		让这个程序运行起来，需要JRE。所以JDK安装的时候
		内部自带一个JRE。

3、到目前为止，我们接触过的重点术语，总结一下：

Java体系的技术被划分为三大块：
	JavaSE：标准版
	JavaEE：企业版
	JavaME：微型版

安装JDK之后：
	JDK：java开发工具箱
	JRE：Java运行环境
	JVM：Java虚拟机

4、对Java的加载与执行的理解（理论比较重要）
java程序从编写到最终运行经历了哪些过程？？？？

java程序非常重要的两个阶段：
	编译阶段
	运行阶段

注意：java程序员直接编写的java代码（普通文本）是无法执行被JVM
识别的。java程序员编写的java代码这种普通文本必须经过一个编译，
将这个“普通文本代码”变成“字节码”，JVM能够识别“字节码”。
java代码这种普通文本变成字节码的过程，被称为：编译。

java代码这种普通文本被称为：java源代码。（你编写的代码是源代码）
源代码不能直接执行，需要先进行编译，生成源代码对应的“字节码”
JVM可以识别的是字节码。

编译阶段和运行阶段可以在不同的操作系统上完成吗？
	在windows上编译
	编译之后生成了“字节码”
	把“字节码”放到linux上运行
	完全可以，因为Java是跨平台的。
	可以做到一次编写到处运行。

java源代码一旦编译之后，源代码可以删除吗？只留下字节码可以执行吗？
	完全可以执行，因为源代码不参与程序的执行过程。
	参与程序执行过程的是字节码。
	但是最好不要删除源代码。因为有可能执行结果不是你需要的，
	当执行结果不是你需要的时候，你可以重新打开源代码进行修改，
	然后重新编译生成新的字节码，再重新执行。这样会有新的执行效果。

放源代码的文件扩展名必须是：xxx.java
并且需要注意的是：编译生成的字节码文件扩展名是：xxx.class
没有为什么，死记硬背吧！！！！

.java文件就是源文件，这个文件中编写源代码。
.class文件就是字节码文件，这个文件是编译源代码而得到的。

另外需要注意的是：
	1个java源文件是可以编译生成多个class文件的。
	最终运行的是class文件。

问题：字节码文件是二进制文件吗？
	字节码文件不是二进制文件。
	如果是二进制的话，就不需要JVM了。
	因为操作系统可以直接执行二进制。

java程序从开发到最终运行经历了什么？

	编译期：（可以在windows上）
		第一步：在硬盘的某个位置（随意），新建一个xxx.java文件
		第二步：使用记事本或者其它文本编辑器例如EditPlus打开xxx.java文件
		第三步：在xxx.java文件中编写“符合java语法规则的”源代码。
		第四步：保存（一定要将xxx.java文件保存一下）
		第五步：使用编译器（javac【JDK安装后自带】）对xxx.java文件进行编译。

		第六步：如果xxx.java文件中编写的源代码是符合语法规则的，编译会通过，
		如果xxx.java文件中编写的源代码违背了语法规则，那么编译器会报错，编译器
		报错之后class文件是不会生成的，只有编译通过了才会生成class字节码文件。
		并且一个java源文件是可以生成多个class文件的。（编译实质上是检查语法）

	运行期（JRE在起作用）：（可以在windows上，也可以在其他的OS上。）
		第七步：如果是在Linux上运行，需要将windows上生成的class文件拷贝过去
		不需要拷贝源代码，真正运行的是字节码。（但是源代码也不要删除，有用）

		第八步：使用JDK自带的一个命令/工具：java（负责运行的命令/工具）执行字节码

		第九步：往下的步骤就全部交给JVM了，就不需要程序员干涉了。
		JVM会将字节码文件装载进去，然后JVM对字节码进行解释（解释器负责将字节码
		解释为1010101010..等的二进制）

		第十步：JVM会将生成的二进制码交给OS操作系统，操作系统会执行二进制码和
		硬件进行交互。

注意：在以上的过程中，需要使用两个非常重要的命令？
	javac 命令，负责编译
	java 命令，负责运行

小插曲：
	xxx.java源文件经过编译之后生成了A.class、B.class、C.class等文件，
	那么我们称A是一个类、B是一个类、C是一个类。其中A、B、C是类的名字。
	没有为什么，死记硬背，SUN公司的java语法就是这么规定的。
	A/B/C是类的名称。A类、B类、C类。

源文件中编写的代码叫做：源代码。

以上是一个复杂的过程，那么缩减一下，程序员到底要干啥？
	新建java文件
	打开java文件
	写java源代码
	保存
	javac命令编译
	java命令运行

	编写、编译、运行

5、编写java中的第一个java程序：HelloWorld（你好世界：问世）
这个程序不需要大家理解，大家照抄就行，因为目前我也不会讲解这个程序为什么这么写。
主要是为了搭建java的开发环境，测试java的环境是否能用。

第一步：安装文本编辑器（EditPlus）

第二步：安装JDK（先下载JDK）
	安装JDK13，直接下一步就行。

	JDK13安装的时候内置了一个JRE，独立于JDK之外的JRE并没有生成。
	对于java13来说，如果你希望生成一个独立于JDK之外的JRE的话需要执行特殊的命令。
	这里先不讲，后期用到的时候再说。

	注意的是：
		JDK8安装的时候，不仅JDK内置了一个JRE，而且还会在JDK目录之外
		独立的生成一个单独的JRE。（以前低版本的时候，JRE实际上是有2个。）
		一个是JDK内置的，一个是独立于JDK之外的。
	
	JDK的bin目录下有：
		javac.exe 负责编译
		java.exe 负责运行

第三步：写代码
	写一下第一个程序HelloWorld。
	这个代码在此强调：
		文件名照抄
		文件内容代码严格照抄
		照抄大小写
		照抄任何一个环节
		照抄标点符号
		不要问为什么。
		后面会解释。

		括号：
			[]
			()
			{}
			都要成对写。

第四步：编译
第五步：运行

day04 课堂笔记

1、开发第一个java程序：HelloWorld

1.1、程序写完之后，一定要ctrl + s 进行保存
第一个HelloWorld程序照抄就行了，不要问代码为什么这么写。
另外，大家需要注意的是：java源代码只要修改，必须重新编译。
重新编译生成新的class字节码文件。

1.2、编译阶段
	怎么编译？使用什么命令？这个命令怎么用？
	需要使用的命令是：C:\Program Files\Java\jdk-13.0.2\bin\javac.exe
	这个命令需要先测试一下，打开DOS命令窗口，看看javac命令是否可用。

	C:\Users\Administrator>javac
	'javac' 不是内部或外部命令，也不是可运行的程序或批处理文件。
	这说明：windows操作系统没有发现“javac.exe”命令在哪里。
	windows操作系统没有找到javac.exe文件在哪。

	为什么ipconfig、ping等命令可以使用呢？为什么javac用不了？
	我们发现windows操作系统中有这样一个环境变量，名字叫做：path，
	并且发现path环境变量的值是：
		C:\Windows\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\
	我们还发现了在：C:\Windows\System32 这个目录下存在：ipconfig.exe

	注意：修改完环境变量之后，DOS命令窗口必须关闭重新打开才会起作用。

	将path环境变量中的:C:\windows\system32; 删除之后
	再测试：
		C:\Users\Administrator>ipconfig
		'ipconfig' 不是内部或外部命令，也不是可运行的程序或批处理文件。
	
	配置环境变量path的步骤：
		桌面计算机上右键-->属性-->高级系统设置-->环境变量
		怎么修改path环境变量？
			找到path，鼠标双击！！！！
		path环境变量当中都是路径，路径和路径之间必须采用“半角的分号”分隔。
	
	让javac.exe能用，我们配置哪个路径到path中？
		将C:\Program Files\Java\jdk-13.0.2\bin配置到path当中。

	
	注意：环境变量包括“系统变量”和“用户变量”
		系统变量：范围比较大，系统变量会让计算机所有用户都起作用。
		用户变量：范围比较小，这个变量只是作用于当前用户。
	
	怎么查看编译器版本？
		C:\Users\Administrator>javac -version
		javac 13.0.2	
	
	怎么查看java虚拟机的版本？
		C:\Users\Administrator>java -version
		java version "13.0.2" 2020-01-14
		Java(TM) SE Runtime Environment (build 13.0.2+8)
		Java HotSpot(TM) 64-Bit Server VM (build 13.0.2+8, mixed mode, sharing)
	
	问题1：path环境变量的作用是什么？
		path环境变量的作用就是给windows操作系统指路的。
		告诉windows操作系统去哪里找这个命令文件。
		path环境变量中有很多很多的路径，路径和路径之间用半角分号分隔。
		path=A;B;C;D......
		path是环境变量的名字。
		A;B;C;D......是环境变量path的值。
	
	问题2：path环境变量是java中的机制，还是windows操作系统中的机制？
	path环境变量是隶属于java的吗？path环境变量和java有关系吗？
		path环境变量本质上是隶属于windows操作系统的，和java没有关系。
		java只不过用了一下path环境变量。
	
	要学会融会贯通，学一通百：
		以后在安装其他软件之后，希望在DOS命令窗口中使用该软件的某个命令
		的时候，如果出现“命令找不到错误了”，这个时候希望大家能够想起来
		配置环境变量path。
	
	path环境变量中的路径可以指定多个，没问题，多少个都行。

	------------------------------------------------------------------------------
	javac命令怎么用？
		语法格式先背会：
			javac java源文件的路径
		什么是java源文件？
			java源文件的名字以“.java”结尾，该文件中写了java源代码。
		java源文件的路径是什么意思？
			注意：路径永远包括绝对路径和相对路径。
		
		注意：神操作？？？？
			把java源文件直接拖进到DOS命令窗口，那么DOS命令窗口就有这个路径了。
		
		C:\Users\Administrator>javac D:\course\JavaProjects\02-JavaSE\chapter01\HelloWorld.java
		D:\>javac course\JavaProjects\02-JavaSE\chapter01\HelloWorld.java
		D:\course\JavaProjects>javac 02-JavaSE\chapter01\HelloWorld.java
		D:\course\JavaProjects\02-JavaSE\chapter01>javac HelloWorld.java
		以上的四种方式都行，第一种方式是绝对路径
		剩下三种方式都是相对路径。

		C:\Users\Administrator>javac course\JavaProjects\02-JavaSE\chapter01\HelloWorld.java
		错误: 找不到文件: course\JavaProjects\02-JavaSE\chapter01\HelloWorld.java
		用法: javac <选项> <源文件>
		使用 --help 可列出可能的选项
		以上报错的原因是：java源文件的路径写错了。

		C:\Users\Administrator>javac HelloWorld.java
		错误: 找不到文件: HelloWorld.java
		用法: javac <选项> <源文件>
		使用 --help 可列出可能的选项

		注意：神操作？？？？
			怎么在DOS命令窗口中快速定位到某个路径呢？
				打开计算机-->打开一些文件夹-->在地址栏上直接输入cmd回车，这样直接就过去了。
		
		编译报错的时候不会生成class字节码文件！
			D:\course\JavaProjects\02-JavaSE\chapter01>javac HelloWorld.java
			HelloWorld.java:3: 错误: 非法字符: '\uff1b'
								 System.out.println("Hello World")；
																			 ^
			1 个错误

1.3、运行阶段
	运行的前提是：class文件（字节码）生成了。没有字节码文件程序是无法运行的。
	重点重点重点重点重点重点重点重点重点!!!!!!!
		假设该文件的名字叫做：HelloWorld.class
		那么HelloWorld被称为？？？？？？？？？？
			HelloWorld 就是一个类名。
		
		如果文件名是Test.class，那么：Test就是一个类名。
	
	怎么运行，使用哪个命令？
		使用JDK的bin目录下的：java.exe命令来运行。
	
	先在DOS命令窗口中测试java.exe这个命令是否可用！！！
		java -version
	
	"java.exe"这个命令怎么用，语法格式是什么？
		java 类名
	
	java HelloWorld.class 对不对？？？？？
		不对！！！！
	正确的写法是：
		java HelloWorld
	
	千万千万要注意：java这个命令，后面跟的是“类名”，而绝对不能跟“文件路径”，
	因为java命令后面跟的不是文件，是一个“类名”。

	对于这个字节：Test.class	，应该：java Test
	对于这个字节码：A.class ，应该 java A
	对于这个字节码：Hello.class，应该java Hello
	.....

	运行java程序需要哪些步骤呢？

		第一步（必须这样做，这是必须的，先记住）：
			先使用cd命令切换到Test.class文件所在的路径。

		第二步：执行java Test

		切记：
			java命令后面只要是跟路径，就一定不行。
			java命令后面只能跟类名。

2、到目前为止，大家告诉我，一共配置了哪些环境变量？

到目前为止，我们只配置了一个环境变量path，并且这个环境变量path和java实际上
没关系，是人家windows操作系统的机制。

对于Java的JDK所属的环境变量，有一个叫做：JAVA_HOME
这个JAVA_HOME目前我们不需要，不配置这个环境变量也不会影响当前java程序的运行。
但是后期学习到JavaWEB的时候需要安装Tomcat服务器，那个时候JAVA_HOME就必须配置了。

那么除了JAVA_HOME环境变量之外，JDK相关的环境变量还有其他的吗？
	答案：有的。

3、我们一起来研究一下：“java HelloWorld”的执行过程以及原理。

D:\course\JavaProjects\02-JavaSE\chapter01>java HelloWorld
敲完回车，都发生了什么？？？？？
	
	第一步：会先启动JVM（java虚拟机）

	第二步：JVM启动之后，JVM会去启动“类加载器classloader”
	类加载器的作用：加载类的。本质上类加载器负责去硬盘上找“类”对应的“字节码”文件。
	假设是“java HelloWorld”，那么类加载器会去硬盘上搜索：HelloWorld.class文件。
	假设是“java Test”，那么类加载器会去硬盘上搜索：Test.class文件。
	.......

	第三步：
		类加载器如果在硬盘上找不到对应的字节码文件，会报错，报什么错？
			错误: 找不到或无法加载主类
		类加载器如果在硬盘上找到了对应的字节码文件，类加载器会将该字节码
		文件装载到JVM当中，JVM启动“解释器”将字节码解释为“101010000...”这种
		二进制码，操作系统执行二进制码和硬件交互。
		
问题？？？？？
	默认情况下，类加载器去硬盘上找“字节码”文件的时候，默认从哪找？？？？
		默认情况下类加载器（classloader）会从当前路径下找。

此处应该有疑问，你可以提出哪些问题？？？？
	能不能给类加载器指定一个路径，让类加载器去指定的路径下加载字节码文件。
	答案：可以的。但是我们需要设置一个环境变量，叫做：classpath

classpath是一个环境变量，是给谁指路的？
	答案：是给“类加载器”指路的。

classpath环境变量不属于windows操作系统，classpath环境变量隶属于java。

classpath环境变量是java特有的。
	classpath=A路径;B路径;C路径.....
	classpath是一个变量名
	A路径;B路径;C路径.....是变量值

我们把classpath配置一下，这个环境变量在windows中没有，需要新建！！！！
	计算机-->右键-->属性-->高级系统设置-->环境变量-->新建...

注意：变量名不能随意写：大小写无所谓，但必须叫做：classpath
	CLASSPATH
	ClassPath
	Classpath
	classpath
	都行。

我目前是随意配置的：（重启CMD）
	classpath=D:\course
	非常重要的一个特点，必须记住：
		配置了classpath=D:\course之后，类加载器只会去D:\course目录下找“xxx.class”文件
		不再从当前路径下找了。
	
	结论是：
		到目前为止：classpath环境变量不需要配置。
		但你必须理解classpath环境变量是干什么的！！！！

你一定要理解classpath环境变量的作用是什么？
	是给类加载器指路的。
	在没有配置环境变量classpath的时候，默认从当前路径下加载。
	如果配置了环境变量classpath的话，就只能从指定的路径下加载了。

path java_home classpath，这3个环境变量path需要配置，后面两个暂时不配置。

4、???【让人困惑了！！！】（了解即可，不需要掌握，现阶段也不需要这样写）
在高版本的JDK当中，有这样的一个新特性，可以直接这样一步到位：
java x/y/z/xxx.java
java后面直接加java源文件的路径。
这个特性是为了简化开发而提出，但实际上底层的实现原理还是和以前一样的，
以上命令在执行过程中，还是会先进行编译，然后再运行。并且以上的运行方式，
编译生成的class文件在硬盘上不存在，看不到。

5、关于第一个java程序代码的解释说明！

// 单行注释

/*
	多行注释
*/

/**
* javadoc注释：这里的注释信息可以自动被javadoc.exe命令解析提取并生成到帮助文档当中。
*/

day05课堂笔记

1、标识符
1.1、标识符可以标识什么，什么是标识符，怎么理解这个概念！
1.2、标识符的命名规则
1.3、标识符的命名规范
本小结最终的要求是：随意给出一个单词，判断它是否是合法的标识符。

2、每一天你会编写很多程序，你会遇到很多编译错误，也会遇到很多运行错误，
你是否需要准备一个单独的文件来记录这些信息，以及记录这些信息是怎么导致
的，原因是什么，怎么去解决的，解决办法是啥？？？？
非常有必要的，要想成为一个调错高手，这个有必要进行一下。

3、关键字

3.1、什么是关键字？
	在SUN公司开发Java语言的时候，提前定义好了一些具有特殊含义的单词，
	这些单词全部小写，具有特殊含义，不能用作标识符。

3.2、凡是在EditPlus中以蓝色字体形式存在的都是关键字，具有特殊含义。

3.3、切记：
	java语言中的所有关键字都是全部小写。
	注意：java语言中是严格区分大小写的。public和Public不一样。
	Class和class不一样。static和Static也不一样。

3.4、那么关键字有哪些呢，我们需要背会吗？需要单独去记忆吗？
	关键字：
		public 
		static
		void 
		class
		byte
		short
		int
		long 
		float
		double
		boolean
		char
		true
		false
		if
		while
		for
		private
		protected
		........
	对于这些关键字来说大家不需要单独花费时间去记忆，
	随着后面程序的积累，你会接触到所有的关键字。

4、变量
4.1、字面量
字面量就是数据
数据就是字面量
是一个东西。

	10 100 123 ：整型
	1.34 3.14 2.0：浮点型
	true false ：布尔型
	'a' '国'：字符型
	"a" "abc"  "国" "中国"：字符串型

	10：整数，是一个数字
	"10"：它不是数字，是一个字符串，或者说，它属于“文字类”的。
	性质完全不同，在计算机中的对应的二进制码也是完全不同的。

4.2、变量
	变量的理解
		什么是变量？
			变量就是一个存数据盒子。（盒子大小谁来决定啊？数据类型）
			在内存中的最基本的存储单元。
			存数据用的，而且这个数据是可变的，所以叫做变量。

	变量的使用

		变量的三要素？
			数据类型、变量名、值  （值就是数据，就是字面量。）
			int i = 100;
			
		java中的变量必须先声明，再赋值才能访问（必须手动赋值。）
		int k; System.out.println(k); 这样是不行的。

		可以在一行上声明多个变量：
			int a, b, c = 100;
			c变量赋值100，a,b变量只声明了没有赋值。
			int a = 10, b = 20, c = 100;
			可以这样每个都赋值。
		
		声明和赋值可以分开，也可以一起做！！！
			int i;
			i = 100; // 先声明再赋值
			int k = 200; // 声明的同时赋值
		
		在“同一个域”当中，变量名不能重名！！！！！！
		但可以重新赋值!!!!!!
			{
				int i = 100;
				//double i = 2.0; // 重名了编译器会报错，不允许。
				i = 300; // 可以重新赋值。
			}
		
		到底什么叫做同一个域？？？？？
			这个目前不太好解释，大家记住吧：一个大括号代表一个域。
			{A域
				{B域
					{C域
					}
				}
			}
			A域包括B域，B域包括C域。

	变量的分类
		根据位置进行分类：记住就行
			在方法体当中声明的变量叫做局部变量。
				public static void m1(){
					//局部变量，方法执行结束之后内存释放。
					int k = 100;
					int i = 200;
				}
			在方法体外以及类体内声明的变量叫做成员变量。
				public class T{
					public static void x(){
					
					}
					// 成员变量
					int i = 200;
				}

	变量的作用域
		出了大括号就不认识了。别的先别管。
		{
			int i = 100;
			{
				在这里可以访问i
			}
		}

		{
			在这里是无法访问i变量。
		}

day06课堂笔记

1、数据类型

1.1、数据类型有什么用？
	数据类型用来声明变量，程序在运行过程中根据不同的数据类型分配不同大小的空间。
	int i = 10;
	double d = 1.23;
	i变量和d变量类型不同，空间大小不同。

1.2、数据类型在java语言中包括两种：

	第一种：基本数据类型
		基本数据类型又可以划分为4大类8小种：
			第一类：整数型
				byte,short,int,long （没有小数的）
			第二类：浮点型 
				float,double （带有小数的）
			第三类：布尔型
				boolean：只有两个值true和false，true表示真，false表示假
			第四类：字符型
				char：java中规定字符型字面量必须使用单引号括起来。属于文字。

		8小种：
			byte,short,int,long
			float,double
			boolean
			char

	第二种：引用数据类型
		字符串型String属于引用数据类型。
		String字符串不属于基本数据类型范畴。
		java中除了基本数据类型之外，剩下的都是引用数据类型。
		引用数据类型后期面向对象的时候才会接触。

1.3、8种基本数据类型中
	整数型：byte short int long有什么区别？
	浮点型：float和double有什么区别？
	区别：占用的空间大小不同。

	关于计算机存储单位？
		计算机只能识别二进制。（1001101100...）
		1字节 = 8bit（8比特）--> 1byte = 8bit
		1bit就是一个1或0.
		1KB = 1024byte
		1MB = 1024KB
		1GB = 1024MB
		1TB = 1024GB

		byte b = 2; 在计算机中是这样表示的：00000010
		short s = 2; 在计算机中是这样表示的：00000000 00000010
		int i = 2;在计算机中是这样表示的：00000000 00000000 00000000 00000010
		...

		类型			占用字节数量(byte)
		------------------------------------
		byte				1
		short				2
		int				4
		long				8
		float				4
		double			8
		boolean			1  (1byte的1或0，00000001(true)或00000000(false))
		char				2

	关于二进制？
		二进制？？？
			1			2				3			4				5				6			7
			1			10				11			100			101			110		111  ....

		十进制转换成二进制
			125 转换成二进制？？？
				办法：除以2，然后余数逆序输出。
				1111101

		二进制转换成十进制
			2的2次方   2的1次方 2的0次方
			1				1			1
			4				2			1
			1*4 + 1*2 + 1*1 = 7

			2的2次方   2的1次方 2的0次方
			1				0			1
			4				2			1
			1*4 + 0*2 + 1*1 = 5

1.4、byte类型的取值范围?		
	byte是 [-128 ~ 127] 共可以标识256个不同的数字。
	byte类型的最大值是怎么计算出来的？
		byte是1个字节，是8个比特位，所以byte可以存储的最大值是：
			01111111
	注意：在计算机当中，一个二进制位最左边的是符号位，当为0时表示正数，
	当为1时表示负数。所以byte类型最大值是：01111111
	那么是不是2的7次方-1呢？
		是不是：10000000（前边是一个二进制） - 1
	
	byte类型最大值是：2的7次方 - 1.

	有几个取值范围需要大家记住：
		(1个字节)byte: [-128 ~ 127]
		(2个字节)short:[-32768 ~ 32767] 可以表示65536个不同的数字
		(4个字节)int: [-2147483648 ~ 2147483647]
		(2个字节)char: [0~65535]  可以表示65536个不同的数字

		short和char实际上容量相同，不过char可以表示更大的数字。
		因为char表示的是文字，文件没有正负之分，所以char可以表示
		更大的数字。

1.5、对于8种基本数据类型来说：
	其中byte,short,int,long,float,double,boolean，这7种类型计算机表示起来
	比较容易，因为他们都是数字。其中布尔类型只有两个值true和false，实际上
	true和false分别在C++中对应的是1和0，1为true，false为0。

	对于char类型来说计算机表示起来比较麻烦，因为char对应的是文字，每一个国家
	的文字不一样，文字不能直接通过“自然算法”转换成二进制。这个时候怎么办？
		字符编码诞生了。
	
	什么是字符编码？
		字符编码是人为的定义的一套转换表。
		在字符编码中规定了一系列的文字对应的二进制。
		字符编码其实本质上就是一本字典，该字段中描述了文字与二进制之间的对照关系。
		字符编码是人为规定的。（是某个计算机协会规定的。）
	
	字符编码涉及到编码和解码两个过程，编码和解码的时候必须采用同一套字符编码
	方式，不然就会出现乱码。

	关于字符编码的发展过程？
		起初的时候计算机是不支持文字的，只支持科学计算。实际上计算机起初是为了
		战争而开发的，计算导弹的轨道....

		后来随着计算机的发展，计算机开始支持文字，最先支持的文字是英文，英文
		对应的字符编码方式是：ASCII码。

		ASCII码采用1byte进行存储，因为英文字母是26个。（键盘上所有的键全部算上也
		超不过256个。1byte可以表示256种不同的情况。所以英文本身在计算机方面就占有
		优势。）
			'a' --(采用ASCII码进行编码)-> 01100001
			01100001 --(采用ASCII码进行解码)-> 'a'
			如果编码和解码采用的不是同一个编码方式，会出现乱码。
			'b' ---> 98
			'c' ---> 99...
			'a' ---> 97

			'A' ---> 65
			'B' ---> 66
			...

			'0' ---> 48  （这个'0'不是那个0，是文字'0'）
			'1' ---> 49
		
		随着计算机语言的发展，后来国际标准组织制定了ISO-8859-1编码方式，
		又称为latin-1编码方式，向上兼容ASCII码。但不支持中文。

		后来发展到亚洲，才支持中文，日文，韩文....
		中文这块的编码方式：GB2312

2、八种基本数据类型详解
字符型 char
整数型 byte short int long
浮点型 float double
布尔型 boolean

day07课堂笔记

1、关于数据类型详解
字符型：char
整数型：byte short int long
byte b = 127; // 可以直接赋值
short s = 32767; // 可以直接赋值
char // 没有超出char的取值范围可以直接赋值给char变量吗?

浮点型：float double
布尔型：boolean

2、综合的看一下，在类型转换的时候需要遵循哪些规则？

第一条：八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以
进行转换；

第二条：如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋
值给byte,short,char 类型的变量；

第三条：小容量向大容量转换称为自动类型转换，容量从小到大的排序为：
byte < short(char) < int < long < float < double，其中 short和 char 
都占用两个字节，但是char 可以表示更大的正整数；

第四条：大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，
但运行时可能出现精度损失，谨慎使用；

第五条：byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；

第六条：多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；

所有的笔试题都超不出以上的6条规则。死记硬背。

3、运算符

算术运算符：
	+ - * / % ++ --

关系运算符：
	> >= < <= == != 

逻辑运算符：
	& | ! && ||

赋值运算符：
	= += -= *= /= %=

三目运算符：
	布尔表达式 ? 表达式1 : 表达式2

字符串连接运算符：
	+

day08课堂笔记

1、怎么接收用户键盘输入？
java.util.Scanner s = new java.util.Scanner(System.in);
// 接收整数
int i = s.nextInt()
// 接收字符串
String str = s.next();

2、控制语句
2.1、控制语句的出现可以让我们的程序具有逻辑性/条理性，可以使用控制语句
来实现一个“业务”了。

2.2、控制语句包括几类？
	3类：
		选择语句
		循环语句
		转向语句

2.3、选择语句也可以叫做分支语句
	if语句
	switch语句

2.4、循环语句：主要循环反复的去执行某段特定的代码块
	for循环
	while循环
	do..while..循环

2.5、转向语句
	break
	continue
	return（这个目前先不需要学习，后面讲方法的时候会使用。）

3、选择语句/分支语句if

4、选择语句switch

day09 课堂笔记

1、控制语句

1.1、关于循环语句
	for循环
	while循环
	do..while循环

	什么是循环语句，为什么要使用这种语句？
		因为在现实世界当中，有很多事情都是需要反复/重复的去做。
		对应到程序当中，如果有一块代码需要重复执行，此时为了减少
		代码量，我们使用循环语句。

1.2、关于转向语句：
	break;
	continue;
	return;（return语句后期讲到方法的时候再详细学习。目前先不用管。）

day10课堂笔记

1、今天三件事
第一：回顾之前所有的内容
第二：讲解昨天的所有作业题
第三：布置大量的练习题，坚决这个周末大家把之前所学习的所有内容全部掌握。

2、回顾
2.1、windows操作系统中，文件扩展名的展示。
2.2、安装EditPlus并且进行相关配置。
2.3、windows的dos命令
cls 清屏
exit 退出
ipconfig 查看IP地址
ping 查看两台计算机之间是否可以正常通信
d: 回车 切换盘符
cd 命令切换目录：相对路径和绝对路径
C:\Windows>cd System32 相对路径（相对于当前位置而言）
C:>cd c:\windows\system32 绝对路径（路径以盘符开始）
cd … 回到上级
cd \ 回到根
mkdir 创建目录
del 删除文件
dir 查看当前目录下有哪些子目录或者子文件

	注意：
		在DOS命令窗口中，可以使用tab键自动补全。
		在DOS命令窗口中，使用上下箭头可以翻出历史命令。
2.4、快捷键：
	补充两个windows系统的组合键：
		win + r 打开运行窗口
		win + d 显示桌面
		win + l 锁屏（离开电脑的时候要锁屏）
		alt + tab 切换应用
2.5、计算机语言的发展史
	第一代
	第二代
	第三代
2.6、Java语言的发展史
	JDK：java开发工具包
	JavaSE JavaEE JavaME
	SUN公司开发的，带头人：james gosling java之父
2.7、java语言的特点：
	简单性
	多线程
	面向对象
	可移植，跨平台：因为JVM的存在。（Java虚拟机屏蔽了操作系统之间的差异）
		windows上安装的JDK和Linux上安装的JDK的版本不同。
		JDK版本不同，最终JVM的版本也是不同的，每一个操作系统都有自己的JVM。
	健壮性：自动GC垃圾回收机制。
2.8、java的加载与执行（java从开发到最终运行，经历了哪些过程）
	要求：自己能够从头描述到最后。（不参考任何资料的前提下）
	从编写到最终的运行，把过程描述出来。
		第一步：
		第二步：
		.....
2.9、术语
	JDK JRE JVM
	JDK java开发工具包
	JRE java运行时环境
	JVM java虚拟机

	JavaSE JavaEE JavaME

2.10、开始开发第一个java程序HelloWorld
	第一：要会下载对应版本的JDK（http://www.oracle.com）
	第二：要会安装JDK（双击，下一步）
	第三：配置环境变量path
		path=C:\Program Files\Java\jdk-13.0.2\bin
		这样javac和java命令就可以使用了。
	第四：编写HelloWorld.java程序。
	第五：javac进行编译：
		javac命令在使用的时候
		javac + java源文件的路径（注意：路径包括绝对和相对。）
	第六：java命令进行运行
		java 类名    (一定要注意：这里不是路径。是类名)
		这里涉及到另一个环境变量叫做：classpath
		classpath没有配置的情况下：从当前路径下找xxx.class文件
		classpath设置了具体路径之后，不再从当前路径下找了。
	
	重点掌握path和classpath两个环境变量。
2.11、java语言中的注释：

	// 单行注释

	/*
		多行注释
	*/
	/**
	*	javadoc注释
	*/
2.12、public class 和class的区别
	一个java文件中可以定义多个class
	一个class编译之后会生成1个class字节码文件，2个class编译之后会生成2个class文件
	任何一个class中都可以编写main方法，每一个main方法都是一个入口
	public的类可以没有
	public的类如果有的话，只能有1个，并且public的类名要求和文件名一致。
		class A{
			main(){}
		}
		java A

		class B{
			main(){}
		}
		java B
		....
2.13、标识符
	标识符可以标识什么？
		类名、接口名
		变量名、方法名
		常量名
	标识符的命名规则？
		标识符只能由数字 字母(可以有中文) 下划线 美元符号组成，不能有其它符号。
		标识符不能以数字开始
		标识符严格区分大小写
		关键字不能做标识符
		理论上没有长度限制
	标识符的命名规范？
		见名知意
		驼峰命名方式，一高一低
		类名、接口名：首字母大写，后面每个单词首字母大写。
		变量名、方法名：首字母小写，后面每个单词首字母大写。
		常量名：全部大写，每个单词之间使用下划线衔接。

	标识符在editplus中是黑色字体。

2.14、关键字
	关键字都是全部小写的，在editplus中以蓝色显示。
	不需要特意记忆，一边学习一边记忆。
	public 
	class
	static
	void
	byte 
	short
	int
	long
	float
	double
	boolean
	char
	true
	false
	if
	else
	switch
	for
	while
	break
	continue
	........

2.15、变量

	什么是变量，怎么理解的？
		一个存储数据的盒子，
		一个存储数据的单元。
		int i = 100;
		System.out.println(i);

	什么是字面量，怎么理解的？
		1 2 3 4 -100 100 整数型字面量
		3.14   浮点型的字面量。
		true false 布尔型字面量
		'a' '中' 字符型字面量
		"abc" "a" 字符串型的字面量
		字面量其实本质上就是“数据”。

	变量怎么声明，怎么赋值？
		声明：
			数据类型 变量名;
			int i;
		赋值：用=赋值
			变量名 = 字面量;
			i = 100;
			重新赋值：i = 200;

		变量在同一个域当中不能重名。
			{
				int i = 2;
				double i = 2.0;
				//报错了，重名了。
			}
	变量的分类？
		在方法体当中声明的就是局部变量。
		在方法体外面声明的就是成员变量。

	变量的作用域？
		出了大括号就不认识了。
		每一个变量都有自己的有效范围。出了范围就不认识了，就不能用了。

2.16、数据类型
	1. 什么是数据类型，有啥用？
		数据类型决定了变量分配空间的大小，类型不同，空间大小不同。
		（在内存中分配空间）
		计算机的主要部件：CPU 内存 硬盘 主板。
	2、数据类型分类？
		基本数据类型：
			byte short int long float double boolean char
		引用数据类型：
			String..........
	3、要求要理解二进制
	4、要求理解二进制和十进制之间的互相转换。
	5、8种基本数据类型，每个占用空间大小。
		类型		字节
		------------------
		byte		1
		short		2
		int		4
		long		8
		float		4
		double	8
		boolean	1
		char		2
	6、记忆byte short int char的取值范围：
		byte -128 ~ 127
		short -32768 ~ 32767
		int -2147483648 ~ 2147483647
		char 0~65535
	7、理解字符编码？
		什么时候会有乱码？编码和解码采用的不是同一套字符编码方式。
		怎么理解字符编码？字符编码是人为制定的，一个字典表，字典中描述了转换关系。
		常见的字符编码？
			ASCII：
				'a' 97
				'A' 65
				'0' 48
				...
			ISO-8859-1(latin-1)
			GBK
			GB2312
			GB18030
			Big5
			unicode : java中采用的统一了全球所有的文字。
	8、数据类型详细介绍
		char
			可以存储1个汉字
			用单引号括起来
			转义字符：
				\t
				\n
				\'
				\"
				\\
				\u
				....
			char c = 97;
			System.out.println(c); //输出'a'

		byte short int long
			int最常用
			任何一个数字，例如：1232 3 5 9，默认都是当做int处理，想当做long，必须加L或者l
			123L这就是long类型
			自动类型转换：小-->大
			强制类型转换：大-->小，需要加强制类型转换符。另外运行可能损失精度。

			当一个整数没有超出byte short char的取值范围，
			可以直接赋值给byte short char类型的变量。

			在java中整数型字面量表示的时候有四种方式：
				10 十进制
				010 八进制
				0x10 十六进制
				0b10 二进制

		float double
			浮点型的数字默认被当做double来处理，
			想以float形式存在，数字后面添加F/f
			float f = 1.0; //错误的
			float f = 1.0f;
			float f = (float)1.0;

			要知道浮点型数据在java语言中存储的都是近似值。
			还有一点：float和double的空间永远比整数型空间大，比long大。

		boolean
			boolean类型只有两个值：true false，没有其他值。
			布尔类型使用在逻辑运算，条件判断当中。

	9、基本数据类型转换的6条规则：
		第一条：只有boolean不能转换，其它都行。

		第二条：自动类型转换
			byte < short(char) < int < long < float < double
			char可以取到更大的正整数。

		第三条：强制类型转换需要加强制类型转换符。可能损失精度。

		第四条：当一个整数没有超出byte short char的取值范围时，可以直接赋值
		给byte short char类型的变量。

		第五条：byte short char混合运算的时候，各自先转换成int再做运算。

		第六条：多种数据类型混合运算的时候，先转换成容量最大的那一种再做运算。

2.17、运算符
	算术运算符
		+ - * / % ++ --
		重点：++
			++无论出现在变量前还是后，只要++运算结束，一定会自加1.
			int i = 10;
			i++;
			System.out.println(i); // 11

			int k = 10;
			++k;
			System.out.println(k); // 11

			++出现在变量前：
				int i = 10;
				int k = ++i;
				System.out.println(k); // 11
				System.out.println(i); // 11
			
			++出现在变量后：
				int i = 10;
				int k = i++;
				System.out.println(k); // 10
				System.out.println(i); // 11
			
			int i = 10;
			System.out.println(i++); // 10
			解开以上题目的窍门是什么？拆代码
				int temp = i++;
				System.out.println(temp); // 10
				System.out.println(i); // 11
			
			int i = 10;
			System.out.println(++i);
			会拆代码:
				int temp = ++i;
				System.out.println(temp); // 11
				System.out.println(i); // 11

	关系运算符
		>
		>=
		<
		<=
		==
		!=
		结果都是布尔类型。true/false

	逻辑运算符
		&
		|
		!
		&&
		||

		逻辑运算符要求两边都是布尔类型，并且最终结果还是布尔类型。
			左边是布尔类型 & 右边还是布尔类型 -->最终结果还是布尔类型。
		& 两边都是true，结果才是true
		| 一边是true，结果就是true
		! 取反

		&&实际上和&运算结果完全相同，区别在于：&&有短路现象。
		左边的为false的时候：&& 短路了。

		左边为true的时候：|| 短路了。

	赋值运算符
		=
		+=
		-=
		*=
		/=
		%=
		重要规则：
			扩展赋值运算符在使用的时候要注意，不管怎么运算，最终的
			运算结果类型不会变。

			byte x = 100; // byte最大值127

			x += 1000; // 编译可以通过，x变量还是byte类型，只不过损失精度了。

			x += 1000; 等同于： x = (byte)(x + 1000);
			
			int i = 10;
			i += 10; // 等同于：i = i + 10; 累加。
		

	条件运算符
		?:
		三目
		布尔表达式 ? 表达式1:表达式2

		布尔表达式为true，选择表达式1作为结果。
		反之选择表达式2作为结果。

	字符串连接运算符
		+
		+ 两边都是数字，进行求和。
		+ 有一边是字符串，进行字符串的拼接。
		+ 有多个的话，遵循自左向右依次执行：1 + 2 + 3
		如果想让其中某个加号先执行，可以添加小括号：1 + (2 + 3)
		注意：字符串拼接完之后的结果还是一个字符串。

		技巧：怎么把一个变量塞到一个字符串当中。
			String name = "jackson";
			System.out.println("登录成功，欢迎"+name+"回来");

2.18、控制语句

	选择语句
		if
		switch
	循环语句
		for
		while
		do..while
	转向语句
		break;
		continue;
		return;
	
	1、选择语句/分支语句 if
		四种写法。
		语法机制：
			if(布尔表达式){
			}
			
			if(布尔表达式){
			}else{
			}

			if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}

			if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else{
			}

			if语句嵌套：
				if(布尔表达式){ //前提条件
					if(布尔表达式){
						if(布尔表达式){
						
						}else{
						
						}
					}
				}else{
				
				}
			
		执行原理：
			对于一个if语句来说，只要有1个分支执行，整个if语句结束。
			当布尔表达式的结果为true时，分支才会执行。
			分支当中只有一条java语句，大括号可以省略。
			带有else的可以保证肯定会有一个分支执行。

	2、选择语句/分支语句 switch

		完整语法结构：
			switch(值){ //值允许是String、int，（byte,short,char可以自动转换int）
			case 值1: case 值x:
				java语句;
				break;
			case 值2:
				java语句;
				break;
			case 值3:
				java语句;
				break;
			default:
				java语句;
			}

	3、for循环

		for循环语法机制：
			for(初始化表达式;条件表达式;更新表达式){
				循环体;
			}

			for(int i = 0; i < 10; i++){
				System.out.println(i);
			}

		for循环执行原理：
			1、先执行初始化表达式，并且只执行1次。
			2、然后判断条件表达式
			3、如果为true，则执行循环体。
			4、循环体结束之后，执行更新表达式。
			5、继续判断条件，如果条件还是true，继续循环。
			6、直到条件为false，循环结束。

	4、while循环
		while(布尔表达式){
			循环体;
		}
		执行次数：0~N次。

	5、do..while循环
		do{
			循环体;
		}while(布尔表达式);

		执行次数：1~N次。

	6、break;
		默认情况下，终止离它最近的循环。
		当然，也可以通过标识符的方式，终止指定的循环。

		for(int i = 0; i < 10; i++){
			if(i == 5){
				break;
			}
			code1;
			code2;
			code3;
			code4;
			....
		}

	7、continue;
		终止当前“本次”循环，直接跳入下一次循环继续执行。
		for(int i = 0; i < 10; i++){
			if(i == 5){
				continue;
			}
			code1;
			code2;
			code3;
			code4;
			....
		}

1、方法是什么？
方法是一段可以完成某个特定功能的并且可以被重复利用的代码片段。
方法的出现，让代码具有了很强的复用性。

2、方法最难实现的是：
根据业务怎么进行方法的抽取。
方法的返回值类型定义为 什么？
方法的名字叫什么？
方法的形式参数列表定义为 什么？
…
一个方法就是一个独立的功能。

3、方法的定义

[修饰符列表] 返回值类型 方法名(形式参数列表){
	方法体; 
}

4、方法的每一个细节学习
4.1、修饰符列表：可选项，目前先写成：public static
4.2、怎么理解返回值？返回值是一个方法执行结束之后的结果。
4.3、返回值类型都可以指定哪些类型？
4.4、返回值和“return语句”的关系。
4.5、方法名只要是合法的标识符就行，首字母小写，后面每个单词首字母大写。见名知意。
4.6、形式参数列表
4.7、方法体：方法体当中的代码遵循自上而下的顺序依次逐行执行。
4.8、方法怎么调用？“类名.”什么时候可以省略？
实际参数列表，简称实参。（调用方法时传递的实际数据。）
实参和形参的关系是一一对应。

5、JVM的内存结构中三块比较重要的内存空间。
方法区：
存储代码片段，存储xxx.class字节码文件，这个空间是最先有数据的，
类加载器首先将代码加载到这里。
堆内存：
后面讲（面向对象）
栈内存：
stack栈当中存储什么？
每个方法执行时所需要的内存空间（局部变量）。

6、关于数据结构中的栈数据结构
原则：
后进先出
先进后出
栈数据结构相关的术语：
栈帧：永远指向栈顶部的元素（栈顶元素具有活跃权。）
栈顶元素
栈底元素
压栈，入栈，进栈，push
弹栈，出栈，pop

昨天还聊了一些：什么是数据结构？什么是算法？
	有一本书：数据结构与算法。
	数据结构和算法的选择很重要，选择对了程序的执行效率大大提升。
	可以很好的优化程序。

7、分析程序运行过程中的内存变化
方法只定义不调用是不会执行的。
方法调用时：压栈 （在栈中给该方法分配空间）
方法执行结束时：弹栈（将该方法占用的空间释放，局部变量的内存也释放。）

day11 课堂笔记

1、方法
1.1、什么是方法，有什么用？
（可以先看一下一个程序如果没有方法，会出现什么问题？）
方法（英语单词：method）是可以完成某个特定功能的并且可以被重复利用的代码片段。
在C语言中，方法被称为“函数”。在java中不叫函数，叫做方法。

	你定义了一个/抽取了一个方法出来，而这个方法确无法完成某个功能，
	那么你抽取的这个方法毫无意义。一般一个方法就是一个“功能单元”。
	假设在以后的开发中，某个功能是可以独立抽取出来的，建议定义为
	方法，这样以后只要需要这个功能，那么直接调用这个方法即可，而
	不需要重复编写业务逻辑代码。

1.2、方法怎么定义，语法机制是什么？

day12 课堂笔记

1、方法重载overload

1.1、什么情况下我们考虑使用方法重载机制？
	当功能相似的时候，建议将方法名定义为一致的，
	这样代码美观，又方便编程。

	注意：如果功能不相似，坚决要让方法名不一致。

1.2、代码满足什么条件的时候构成了方法重载？
	条件1：在同一个类当中
	条件2：方法名相同
	条件3：形式参数列表不同（类型、个数、顺序）

	注意：
		方法重载和返回值类型无关，和修饰符列表无关。

1.3、方法重载的优点？
	代码美观
	方便代码的编写

2、方法递归

2.1、需要理解什么是方法递归？
	方法自身调用自身。

2.2、使用递归的时候，必须添加结束条件，没有结束条件，会发生栈内存溢出错误。
	StackOverflowError
	原因：一直压栈，没有弹栈，栈内存不够用。

2.3、会画出递归方法的内存结构图。
	递归的过程当中可以将图画出来。

2.4、能够使用循环代替递归的尽量使用循环，循环的执行耗费内存少一些，
递归耗费内存相对多一些，另外递归使用不当很容易内存溢出，JVM停止工作。
当然，只有极少数情况下，只能用递归，其它代码解决不了问题。

2.5、当递归有结束条件，并且结束条件合法的时候，就一定不会内存溢出吗？
	也不一定。可能递归的太深了。

2.6、分享了一些递归方面的经验
	在实际的开发中遇到递归导致的栈内存溢出错误是怎么办？
		第一步：先检查结束条件是否正确。
		第二步：如果正确，可以调整JVM的栈内存大小。(java -X)

3、我们要一味地将变量缩减吗？代码缩减吗？这样好吗？

public class Test{
	public static void main(String[] args){
		/*
		int i = 100;
		System.out.println(i);
		*/

		System.out.println(100);

		boolean flag = test();
		if(flag){
			...
		}

		// 缩减之后的
		if(test()){
			....
		}
	}

	public static boolean test(){
		return true;
	}
}

太计较变量的数量会有什么后果呢？（运行效率不会低）
	后果1：代码的可读性差。
	后果2：可读性差也可以会牵连到代码的开发效率。
	
	其实计算机内存不差这个。。。。。。

	注意：在编码过程中，有一些变量名是必须要定义的。
	因为在后面代码中还需要访问这个数据。重复的访问这个
	数据。

day13课堂笔记

1、面向过程和面向对象有什么区别？

从语言方面出发：
	对于C语言来说，是完全面向过程的。
	对于C++语言来说，是一半面向过程，一半是面向对象。（C++是半面向对象的）
	对于Java语言来说，是完全面向对象的。

什么是面向过程的开发方式？
	面向过程的开发方式主要的特点是：
		注重步骤，注重的是实现这个功能的步骤。
		第一步干什么
		第二步干什么
		....
		另外面向过程也注重实现功能的因果关系。
			因为A所有B
			因为B所以C
			因为C所以D
			.....
		面向过程中没有对象的概念。只是实现这个功能的步骤以及因果关系。
	
	面向过程有什么缺点？（耦合度高，扩展力差。）
		面向过程最主要是每一步与每一步的因果关系，其中A步骤因果关系到B
		步骤，A和B联合起来形成一个子模块，子模块和子模块之间又因为因果
		关系结合在一起，假设其中任何一个因果关系出现问题（错误），此时
		整个系统的运转都会出现问题。（代码和代码之间的耦合度太高，扩展力
		太差。）
			螺栓螺母拧在一起：耦合度高吗？
				这是耦合度低的，因为螺栓螺母可以再拧开。（它们之间是有接口的。）
			螺栓螺母拧在一起之后，再用焊条焊接在一起，耦合度高吗？
				这个耦合度就很高了。耦合度就是黏连程度。
				往往耦合度高的扩展力就差。
			
			耦合度高导致扩展力差。（集成显卡：计算机显卡不是独立的，是集成到主板上的）
			耦合度低导致扩展力强。（灯泡和灯口关系，螺栓螺母关系）
		
		采用面向过程的方式开发一台计算机会是怎样？
			这台计算机将没有任何一个部件，所有的都是融合在一起的。
			你的这台计算机是一个实心儿的，没有部件的。一体机。
			假设这台一体机的任何一个“部位”出问题，整个计算机就不能用了，
			必须扔掉了。（没有对象的概念。）

		采用面向对象的方式开发一台计算机会是怎样？
			内存条是一个对象
			主板是一个对象
			CPU是一个对象
			硬盘是一个对象
			然后这些对象组装在一起，形成一台计算机。
			假设其中CPU坏了，我们可以将CPU拆下来，换一个新的。

	面向过程有什么优点？（快速开发）
		对于小型项目（功能），采用面向过程的方式进行开发，效率较高。
		不需要前期进行对象的提取，模型的建立，采用面向过程
		方式可以直接开始干活。一上来直接写代码，编写因果关系。
		从而实现功能。

什么是面向对象的开发方式？
	采用面向对象的方式进行开发，更符合人类的思维方式。（面向对象成为主流的原因）
	人类就是以“对象”的方式去认识世界的。
	所以面向对象更容易让我们接受。

	面向对象就是将现实世界分割成不同的单元，然后每一个单元
	都实现成对象，然后给一个环境驱动一下，让各个对象之间协
	作起来形成一个系统。

	对象“张三”
	对象“香烟”
	对象“打火机”
	对象“吸烟的场所”
	然后将以上的4个对象组合在一起，就可以模拟一个人的抽烟场景。
	其中“张三”对象可以更换为“李四”
	其中“香烟”也可以更换品牌。
	其中“打火机”也可以更换。
	其中“吸烟的场所”也可以更换。

	采用面向对象的方式进行开发：
		耦合度低，扩展力强。

找一个合适的案例。说明一下面向对象和面向过程的区别？
	蛋炒饭：
		鸡蛋和米饭完全混合在一起。没有独立对象的概念。
		假设客户提出新需求：我只想吃蛋炒饭中的米饭，怎么办？
			客户提出需求，软件开发者必须满足这个需求，于是
			开始扩展，这个软件的扩展是一场噩梦。（很难扩展，耦合度太高了。）

	盖饭：
		老板，来一份：鱼香肉丝盖饭
		鱼香肉丝是一道菜，可以看成一个独立的对象。
		米饭可以看成一个独立的对象。
		两个对象准备好之后，只要有一个动作，叫做：“盖”
		这样两个对象就组合在一起了。

		假设客户提出新需求：我不想吃鱼香肉丝盖饭,想吃西红柿鸡蛋盖饭。
		这个扩展就很轻松了。直接把“鱼香肉丝”对象换成“西红柿鸡蛋”对象。


目前先听一下，需要三四年的时候才能彻底领悟面向对象。

面向过程主要关注的是：实现步骤以及整个过程。
面向对象主要关注的是：对象A，对象B，对象C，然后对象ABC组合，或者CBA组合.....

2、当我们采用面向对象的方式贯穿整个系统的话，涉及到三个术语：
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
整个软件开发的过程，都是采用OO进行贯穿的。

实现一个软件的过程：
	分析(A) --> 设计(D) --> 编程(P)

在软件公司当中，一般同事与同事之间聊天，有的时候会突然说出来一个英语单词。
这种情况是很常见的。所以一些术语还是要知道的，不然会闹出笑话。

leader 领导/经理/组长
team 团队
PM 项目经理（整个项目的监管人）Project Manager

3、面向对象包括三大特征
封装
继承
多态

任何一个面向对象的编程语言都包括这三个特征
例如：
	python也有封装 继承 多态。
	java也有封装 继承 多态。

	注意：java只是面向对象编程语言中的一种。
	除了java之外，还有其它很多很多的编程语言也是面向对象的。

以上三个特征的名字先背会，后面一个一个进行学习。

4、类和对象的概念

面向对象当中最主要“一词”是：对象。

什么是类？
	类实际上在现实世界当中是不存在的，是一个抽象的概念。
	是一个模板。是我们人类大脑进行“思考、总结、抽象”的一个
	结果。(主要是因为人类的大脑不一般才有了类的概念。)

	类本质上是现实世界当中某些事物具有共同特征，将这些共同
	特征提取出来形成的概念就是一个“类”，“类”就是一个模板。

	明星是一个类

什么是对象？
	对象是实际存在的个体。（真实存在的个体）

	宋小宝就是一个对象
	姚明就是一个对象
	刘德华就是一个对象
	....

	宋小宝、姚明、刘德华这3个对象都属于“明星”这个类。

在java语言中，要想得到“对象”，必须先定义“类”，“对象”是通过“类”
这个模板创造出来的。
	类就是一个模板：类中描述的是所有对象的“共同特征信息”
	对象就是通过类创建出的个体。

这几个术语你需要自己能够阐述出来：
	类：不存在的，人类大脑思考总结一个模板（这个模板当中描述了共同特征。）
	对象：实际存在的个体。
	实例：对象还有另一个名字叫做实例。
	实例化：通过类这个模板创建对象的过程，叫做：实例化。
	抽象：多个对象具有共同特征，进行思考总结抽取共同特征的过程。

	类 --【实例化】--> 对象(实例)
	对象 --【抽象】--> 类

类是一个模板，是描述共同特征的一个模板，那么共同特征包括什么呢？

	潘长江对象：
		名字：潘长江
		身高：165cm

		打篮球：非专业的，自己玩儿呢，无所谓了
		学习：考试80分

	姚明对象：
		名字：姚明
		身高：240cm
		打篮球：NBA专业球员，打篮球非常棒
		学习：考试100分

	共同特征包括哪些？
		名字、身高都属于名词（状态特征）
		打篮球、学习都属于动词（动作特征）
	
	类 = 属性 + 方法
	属性来源于：状态
	方法来源于：动作

	public class 明星类{
		//属性-->状态，多见于名词
		名字属性;
		身高属性;

		//方法-->动作，多见于动词
		打篮球方法(){
		
		}
		学习方法(){
		
		}
	}

	陈赓同学、何伟彬同学，他们俩有没有共同特征呢？
		有共同特征，就可以抽象一个类模板出来。
	
	可以定义一个学生类（Student）
	public class Student {
		// 属性
		// 姓名
		// 性别
		// 身高

		// 方法
		public .... sing(){
		
		}
		public .... dance(){
		
		}
		public .... study(){
		
		}
		....
	}

5、思考：“java软件工程师”在开发中起到的一个作用是什么？

我们为什么要做软件开发？
	说的大一些是为了人民服务。解决现实生活当中的问题。

软件开发既然是为了解决现实世界当中的问题，那么首先
java软件必须能够模拟现实世界。

其实软件是一个虚拟的世界。
这个虚拟的世界需要和现实世界一一对应，这才叫模拟。

6、类的定义
6.1、怎么定义一个类，语法格式是什么？
[修饰符列表] class 类名 {
//类体 = 属性 + 方法
// 属性在代码上以“变量”的形式存在（描述状态）
// 方法描述动作/行为
}

	注意：修饰符列表可以省略。

6.2、为什么属性是“以”变量的形式存在的？
	假设我们要描述一个学生：
		学生包括哪些属性：
			学号: 110
			姓名："张三"
			性别：'男' (true/false)
			住址："深圳宝安区"
	答案：是因为属性对应的是“数据”，数据在程序中只能放到变量中。
	结论：属性其实就是变量。

	变量的分类还记得吗？
		变量根据出现位置进行划分：
			方法体当中声明的变量：局部变量。
			方法体外声明的变量：成员变量。（这里的成员变量就是“属性”）

6.3、请大家观察“学生对象1”和“学生对象2”的共同特征，然后再利用java语言
将该“学生类”表述/表达出来。（这里只表达属性，不表达方法.）

7、关于编译的过程
按说应该先编译XueSheng.java，然后再编译XueShengTest.java
但是对于编译器来说，编译XueShengTest.java文件的时候，会自动
找XueSheng.class，如果没有，会自动编译XueSheng.java文件，生成
XueSheng.class文件。
第一种方式：
javac XueSheng.java
javac XueShengTest.java
第二种方式：
javac XueShengTest.java
第三种方式：
javac *.java

8、在语法级别上是怎么完成对象创建的呢？
类名 变量名 = new 类名();
这样就完成了对象的创建。

9、什么是实例变量？
对象又被称为实例。
实例变量实际上就是：对象级别的变量。
public class 明星类{
double height;
}
身高这个属性所有的明星对象都有，但是每一个对象都有“自己的身高值”。
假设创建10个明星对象，height变量应该有10份。
所以这种变量被称为对象级别的变量。属于实例变量。

实例变量在访问的时候，是不是必须先创建对象？

10、对象和引用的区别？
对象是通过new出来的，在堆内存中存储。
引用是：但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象的。

day14课堂笔记

1、画内存图注意事项：

第一：大家在内存图上不要体现出代码。内存上应该主要体现“数据”。

第二：大家画图的时候，图上的图形应该有先后顺序，先画什么，再
画什么，必须是有顺序的，而不是想起来这个画这个，想起来那个画那个。
程序代码是有执行顺序的，程序执行到哪里你就画哪里就行了。

2、为什么要画内存图（非常重要）？
第一：有了内存图，程序不运行，我也知道结果。（可以推算出结果）
第二：有了内存图，有助于你调试程序。
画内存图是对Java运行机制的一种理解。不知道运行机制，以后复杂的
程序出现错误之后你是不会调试的，调不明白。

3、程序在什么情况下会出现空指针异常呢？
空引用 访问 "对象相关"的数据时，会出现空指针异常。
垃圾回收器主要针对堆内存。

4、方法在调用的时候参数是如何传递的？
实际上，在java语言中，方法调用时参数传递，和类型无关，都是将变量中保存
的那个“值”传过去，这个“值”可能是一个数字100，也可能是一个java对象的内存
地址：0x1234
记住这句话：不管是哪一种数据类型的传递，都是将“变量中保存的那个值复制一份传递过去。”

5、构造方法。
5.1、当一个类中没有提供任何构造方法，系统默认提供一个无参数的构造方法。
这个无参数的构造方法叫做缺省构造器。

5.2、当一个类中手动的提供了构造方法，那么系统将不再默认提供无参数构造方法。
建议将无参数构造方法手动的写出来，这样一定不会出问题。

5.3、无参数构造方法和有参数的构造方法都可以调用。
	Student x = new Student();
	Student y = new Student(123);

5.4、构造方法支持方法重载吗？
	构造方法是支持方法重载的。
	在一个类当中构造方法可以有多个。
	并且所有的构造方法名字都是一样的。

	方法重载特点：
		在同一个类中，方法名相同，参数列表不同。

5.5、对于实例变量来说，只要你在构造方法中没有手动给它赋值，
统一都会默认赋值。默认赋系统值。

构造方法需要掌握的知识点：
	1.构造方法有什么作用？
	2.构造方法怎么定义，语法是什么？
	3.构造方法怎么调用，使用哪个运算符？
	4.什么是缺省构造器？
	5.怎么防止缺省构造器丢失？
	6.实例变量在类加载是初始化吗？实例变量在什么时候初始化？

6、封装

6.1、面向对象的三大特征：
	封装
	继承
	多态

	有了封装，才有继承，有了继承，才能说多态。

6.2、面向对象的首要特征：封装 。什么是封装？有什么用？
	现实生活中有很多现实的例子都是封装的，例如：
		手机，电视机，笔记本电脑，照相机，这些都是外部有一个坚硬的壳儿。
		封装起来，保护内部的部件。保证内部的部件是安全的。另外封装了之后，
		对于我们使用者来说，我们是看不见内部的复杂结构的，我们也不需要关心
		内部有多么复杂，我们只需要操作外部壳儿上的几个按钮就可以完成操作。

	那么封装，你觉得有什么用呢？
		封装的作用有两个：
			第一个作用：保证内部结构的安全。
			第二个作用：屏蔽复杂，暴露简单。
		
	在代码级别上，封装有什么用？
		一个类体当中的数据，假设封装之后，对于代码的调用人员来说，
		不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。
		另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，
		来保证数据的安全性。
	
6.3、怎么进行封装，代码怎么实现？
	第一步：属性私有化（使用private关键字进行修饰。）
	第二步：对外提供简单的操作入口。

day15 课堂笔记

1、封装的代码实现两步：

第一步：属性私有化

第二步：1个属性对外提供两个set和get方法。外部程序只能通过set方法修改，只能通过get方法读取，
可以在set方法中设立关卡来保证数据的安全性。

在强调一下：
	set和get方法都是实例方法，不能带static。
	不带static的方法称为实例方法，实例方法的调用必须先new对象。

	set和get方法写的时候有严格的规范要求：（大家要按照规矩来）
		set方法长这个样子：
			public void set+属性名首字母大写(1个参数){
				xxx = 1个参数;
			}
		get方法长这个样子：
			public 返回值类型 get+属性名首字母大写(无参){
				return xxx;
			}

2、static关键字
2.1、static修饰的统一都是静态的，都是类相关的，不需要new对象。直接采用“类名.”访问。
2.2、当一个属性是类级别的属性，所有对象的这个属性的值是一样的，建议定义为静态变量。
2.3、

day16课堂笔记

1、this
1.1、this是一个关键字，是一个引用，保存内存地址指向自身。
1.2、this可以使用在实例方法中，也可以使用在构造方法中。
1.3、this出现在实例方法中其实代表的是当前对象。
1.4、this不能使用在静态方法中。
1.5、this. 大部分情况下可以省略，但是用来区分局部变量和实例变量的时候不能省略。
1.6、this() 这种语法只能出现在构造方法第一行，表示当前构造方法调用本类其他的
构造方法，目的是代码复用。

2、总结所有的变量怎么访问，总结所有的方法怎么访问！！！！
总结一下到目前为止我们在一个类中都接触过什么了。

3、继承extends
3.1、什么是继承，有什么用？
继承：在现实世界当中也是存在的，例如：父亲很有钱，儿子不用努力也很有钱。
继承的作用：
基本作用：子类继承父类，代码可以得到复用。（这个不是重要的作用，是基本作用。）
主要(重要)作用：因为有了继承关系，才有了后期的方法覆盖和多态机制。

3.2、继承的相关特性
	① B类继承A类，则称A类为超类(superclass)、父类、基类，
	B类则称为子类(subclass)、派生类、扩展类。
		class A{}
		class B extends A{}
		我们平时聊天说的比较多的是：父类和子类。
		superclass 父类
		subclass 子类

	② java 中的继承只支持单继承，不支持多继承，C++中支持多继承，
	这也是 java 体现简单性的一点，换句话说，java 中不允许这样写代码：
		class B extends A,C{ } 这是错误的。

	③ 虽然 java 中不支持多继承，但有的时候会产生间接继承的效果，
	例如：class C extends B，class B extends A，也就是说，C 直接继承 B，
	其实 C 还间接继承 A。

	④ java 中规定，子类继承父类，除构造方法不能继承之外，剩下都可以继承。
	但是私有的属性无法在子类中直接访问。(父类中private修饰的不能在子类中
	直接访问。可以通过间接的手段来访问。)

	⑤ java 中的类没有显示的继承任何类，则默认继承 Object类，Object类是 
	java 语言提供的根类（老祖宗类），也就是说，一个对象与生俱来就有 
	Object类型中所有的特征。

	⑥ 继承也存在一些缺点，例如：CreditAccount 类继承 Account 类会导致它
	们之间的耦合度非常高，Account 类发生改变之后会马上影响到 CreditAccount 类

day17课堂笔记

1、继承extends

1.1、测试：子类继承父类之后，能使用子类对象调用父类方法吗？
	可以，因为子类继承了父类之后，这个方法就属于子类了。
	当然可以使用子类对象来调用。

1.2、在实际开发中，满足什么条件的时候，我可以使用继承呢？
	凡是采用“is a”能描述的，都可以继承。
	例如：
		Cat is a Animal：猫是一个动物
		Dog is a Animal：狗是一个动物
		CreditAccount is a Account：信用卡账户是一个银行账户
		....
	
	假设以后的开发中有一个A类，有一个B类，A类和B类确实也有重复的代码，
	那么他们两个之间就可以继承吗？不一定，还是要看一看它们之间是否能够
	使用is a来描述。

		class Customer{
			String name; // 名字
			// setter and getter
		}

		class Product{
			String name; // 名字
			// setter and getter
		}

		class Product extends Customer{
		
		}

		以上的继承就属于很失败的。因为：Product is a Customer，是有违伦理的。

1.3、任何一个类，没有显示继承任何类，默认继承Object，那么Object类当中有
哪些方法呢？老祖宗为我们提供了哪些方法？

	以后慢慢的大家一定要适应看JDK的源代码（多看看牛人写的程序自己才会变成牛人。）
	先模仿后超越。
	java为什么比较好学呢？
		是因为Java内置了一套庞大的类库，程序员不需要从0开始写代码，程序员可以
		基于这套庞大的类库进行“二次”开发。（开发速度较快，因为JDK内置的这套库
		实现了很多基础的功能。）

		例如：String是SUN编写的字符串类、System是SUN编写的系统类。
		这些类都可以拿来直接使用。
	
	JDK源代码在什么位置？
		C:\Program Files\Java\jdk-13.0.2\lib\src.zip
	
	你现在能看懂以下代码了吗？
		System.out.println("Hello World!");
		System.out 中，out后面没有小括号，说明out是变量名。
		另外System是一个类名，直接使用类名System.out，说明out是一个静态变量。
		System.out 返回一个对象，然后采用“对象.”的方式访问println()方法。
	
	我们研究了一下Object类当中有很多方法，大部分看不懂，其中有一个叫做toString()
	的，我们进行了测试，发现：
		System.out.println(引用);
		当直接输出一个“引用”的时候，println()方法会先自动调用“引用.toString()”，然后
		输出toString()方法的执行结果。

2、方法覆盖

2.1、什么时候考虑使用方法覆盖？
	父类中的方法无法满足子类的业务需求，子类有必要对继承过来的方法进行覆盖。

2.2、什么条件满足的时候构成方法覆盖？
	第一：有继承关系的两个类
	第二：具有相同方法名、返回值类型、形式参数列表
	第三：访问权限不能更低。
	第四：抛出异常不能更多。

2.3、关于Object类中toString()方法的覆盖？
	toString()方法存在的作用就是：将java对象转换成字符串形式。
	大多数的java类toString()方法都是需要覆盖的。因为Object类中提供的toString()
	方法输出的是一个java对象的内存地址。

	至于toString()方法具体怎么进行覆盖？
		格式可以自己定义，或者听需求的。（听项目要求的。）

2.4、方法重载和方法覆盖有什么区别？

	方法重载发生在同一个类当中。

	方法覆盖是发生在具有继承关系的父子类之间。

	方法重载是一个类中，方法名相同，参数列表不同。

	方法覆盖是具有继承关系的父子类，并且重写之后的方法必须和之前的方法一致：
		方法名一致、参数列表一致、返回值类型一致。

3、多态的基础语法

3.1、向上转型和向下转型的概念。

	向上转型：子--->父 (upcasting)
		又被称为自动类型转换：Animal a = new Cat();

	向下转型：父--->子 (downcasting)
		又被称为强制类型转换：Cat c = (Cat)a; 需要添加强制类型转换符。
		什么时候需要向下转型？
			需要调用或者执行子类对象中特有的方法。
			必须进行向下转型，才可以调用。
		向下转型有风险吗？
			容易出现ClassCastException（类型转换异常）
		怎么避免这个风险？
			instanceof运算符，可以在程序运行阶段动态的判断某个引用指向的对象
			是否为某一种类型。
			养成好习惯，向下转型之前一定要使用instanceof运算符进行判断。
	
	不管是向上转型还是向下转型，首先他们之间必须有继承关系，这样编译器就不会报错。

3.2、什么是多态。
	多种形态，多种状态，编译和运行有两个不同的状态。
	编译期叫做静态绑定。
	运行期叫做动态绑定。
	Animal a = new Cat();
	// 编译的时候编译器发现a的类型是Animal，所以编译器会去Animal类中找move()方法
	// 找到了，绑定，编译通过。但是运行的时候和底层堆内存当中的实际对象有关
	// 真正执行的时候会自动调用“堆内存中真实对象”的相关方法。
	a.move();

	多态的典型代码：父类型的引用指向子类型的对象。（java中允许这样写代码！！！）

3.3、什么时候必须进行向下转型？
	调用子类对象上特有的方法时。

day18课堂笔记

1、多态在开发中有什么作用？
非常重要：五颗星。。。。（多态你会天天用，到处用！！！！）

多态在开发中的作用是：
	降低程序的耦合度，提高程序的扩展力。

	public class Master{
		public void feed(Dog d){}
		public void feed(Cat c){}
	}
	以上的代码中表示：Master和Dog以及Cat的关系很紧密（耦合度高）。导致扩展力很差。

	public class Master{
		public void feed(Pet pet){
			pet.eat();
		}
	}
	以上的代表中表示：Master和Dog以及Cat的关系就脱离了，Master关注的是Pet类。
	这样Master和Dog以及Cat的耦合度就降低了，提高了软件的扩展性。

面向对象的三大特征：
	封装、继承、多态

	真的是一环扣一环。

	有了封装，有了这种整体的概念之后。
	对象和对象之间产生了继承。
	有了继承之后，才有了方法的覆盖和多态。

这里提到了一个软件开发原则：
	七大原则最基本的原则：OCP（对扩展开放，对修改关闭）
	目的是：降低程序耦合度，提高程序扩展力。
	面向抽象编程，不建议面向具体编程。

2、解释之前遗留的问题

私有方法无法覆盖。

方法覆盖只是针对于“实例方法”，“静态方法覆盖”没有意义。（这是因为方法覆盖通常和多态联合起来）

总结两句话：
	私有不能覆盖。
	静态不谈覆盖。

在方法覆盖中，关于方法的返回值类型。
	什么条件满足之后，会构成方法的覆盖呢？
		1、发生具有继承关系的两个类之间。
		2、父类中的方法和子类重写之后的方法：
			具有相同的方法名、相同的形式参数列表、相同的返回值类型。
	
	学习了多态机制之后：
		“相同的返回值类型”可以修改一下吗？
			对于返回值类型是基本数据类型来说，必须一致。
			对于返回值类型是引用数据类型来说，重写之后返回值类型可以变的更小（但意义不大，实际开发中没人这样写。）。

3、super关键字

super能出现在实例方法和构造方法中。

super的语法是：“super.”、“super()”

super不能使用在静态方法中。

super. 大部分情况下是可以省略的。

super.什么时候不能省略呢？
	父类和子类中有同名属性，或者说有同样的方法，
	想在子类中访问父类的，super. 不能省略。

super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中
的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。

super的使用：
	super.属性名				【访问父类的属性】
	super.方法名(实参)		【访问父类的方法】
	super(实参)					【调用父类的构造方法】

day19课堂笔记

1、使用集成开发工具eclipse

1.1、java的集成开发工具很多，包括：eclipse、Intellij IDEA、netbeans.....

	eclipse：
		IBM开发的。eclipse翻译为：日食。寓意吞并SUN公司（SUN是太阳。）
		最终没有成功，SUN公司在2009年的时候被oracle甲骨文公司收购。
		eclipse在以前的开发中使用非常多，但是由于IDEA工具的出现，让eclipse
		的用户大大减少，目前eclipse占市场份额30%。IDEA占市场份额60%，
		剩下10%是其他的开发工具。
	
	Intellij IDEA：
		提示功能比eclipse强大。更好用。


1.2、什么是集成开发工具？
	集成开发工具又称为集成开发环境，把开发中需要的东西全部集成在一起，
	包括编写代码时大量的代码提示，及时的编译，程序员编写代码之后，集成
	开发工具自动编译，有语法错误的时候集成开发工具会马上标红色。运行的
	时候也不需要命令，直接使用鼠标操作即可。总之集成开发工具就是为了提高
	开发速度。另外集成开发工具会为程序员生成很多代码，有很多代码不需要写。
		及时编译
		语法错误及时提醒
		代码提示功能
		代码自动生成功能
		方便的运行
		.....

1.3、eclipse的安装：
	我的eclipse是一个解压版的。直接解压就能用。
	使用当前的这个eclipse的时候，需要计算机上已经安装了JDK，并且bin目录已经配置到path当中。
	解压之后：eclipse.exe 是启动eclipse开发工具的。

1.4、eclipse工具的使用
	* 第一次打开eclipse的时候，会让你选择工作区，工作区就是java代码存放的位置。
		默认位置：C:\Users\Administrator\eclipse-workspace
		你可以修改成其他位置，没问题。
		我这里改一下：D:\course\JavaProjects\02-JavaSE\eclipsecode
		选择工作区的窗口左下角有一个复选框：
			这个复选框选中表示下一次再打开eclipse的时候默认进入这个工作区。不再询问。
			我这里就不选中了。（让他每一次询问。）

	* 打开之后，会呈现一个：welcome，（直接关闭即可）

	* 关闭welcome之后，默认的布局方式：javaee方式，我们目前是javase，怎么切换
	布局方式到javase呢？
		点击右上角倒数第二个小图标，打开一个窗口，选择java。
	
	* 我把这个javase布局中所有没有用的窗口全部关闭：
		只留下：package explorer
		一不小心把：package explorer关闭了怎么办？
			可以再打开：window菜单 --> show view--> package explorer
	
	* 一个布局打乱了，能重置吗？手机恢复出厂设置....
		window菜单 --> Perspective --> reset.....
	
	* 在eclipse的workspace工作区当中以project（工程）为单位。所以要编写
	java代码，必须先新建工程。在工程上编写代码：
		怎么创建工程？
			在package explorer窗口的空白位置右键 --> new --> java project
		
		新建工程（java project）的时候：
			需要指定：
				工程的名字：我这里起名javase
				选择JRE，当前eclipse默认选择的是JRE11.(我电脑上没有，这个应该是eclipse自带的。)
				JRE(java的运行环境。)
			目前为止：大家只要指定工程名字就行，别的不用修改。
			直接finish，就新建工程完成了。
		
		注意：最后一步finish的时候，会提醒你是否创建java文件，可以创建，也可以不创建。
	
	* 怎么删除工程？
		工程上右键--> delete --> 弹出窗口之后，选中复选框表示彻底删除（硬盘上也删了。）
	
	* 编写第一个HelloWorld程序
		在src上点击右键--> new --> Class :
			填写上类名：HelloWorld
			在下面有一个选中创建main方法。选中表示自动创建main方法。
			finish完成。

	* 出现了兼容问题：
		eclipse（2018-12的版本），不支持JDK11以及更高版本。
		我这里先这样处理一下：下载一个低版本的JDK，选择JDK8.
	
	* 安装了JDK8之后，再重新在eclipse中创建java project。
		怎么在eclipse当中指定使用某个JRE/JDK呢？
			在新建工程的窗口上有一个：Configure jres....
			弹出的窗口中：add 
			add之后选择：standard vm
			然后next
			在弹出的窗口中点击：Directory
			目录选中这个即可：C:\Program Files\Java\jdk1.8.0_101
			别的位置不用动。
			finish.
			完成的过程中：你要记得把jdk8的对勾打上。
			apply and close...
	
	* 一会我给大家分享一个高版本的eclipse。能够让eclipse支持高版本的JDK。

	* eclipse设置字体：
		window菜单--->最后一个-->窗口上输入font-->选中color and font
		--> basic -->  最后一个双击。
	
	* eclipse是实时编译的，有语法错误会报红。

	* 注意：eclipse有的时候是必须保存之后才会编译的。要时刻ctrl + s

	* main方法怎么生成？
		main，然后alt + /
	
	* System.out.println()怎么生成？
		sysout ，然后atl + /
	
	* 怎么运行：
		在有main方法的程序上右键 --> run as --> java application..
	
	* 怎么生成构造方法
		在空白处右键 --> source --> generate constructor

	* 怎么生成set和get方法
		在空白处右键 --> source --> generate setter and getter
	
	* eclipse默认情况下，当你“点”的时候都会有提示。

2、回顾从面向对象开始到目前讲解的位置，将所有的结论总结出来。

2.1、强调一下学习方法

	第一：上课过程中要记笔记（但是笔记一定要记简笔），笔记上最好没有废话，
	笔记上记的全是结论。有一些是需要死记硬背的，有一些是需要理解记忆的。
	总之最后不管是死记硬背还是理解记忆，都是需要“记忆”的。（听课不走神，
	集中精力捕捉重点结论。）

	第二：课下整理笔记（快速的整理），一天的笔记整理要在30分钟之内完成。

	第三：别抄老师代码。根据笔记上整理的重要“结论”，一个结论一个结论去验证，
	验证这个结论的时候，写属于自己的代码。（验证的时候脑子要灵光一些，这样
	试验一下，那样试验一下，想尽一切办法推翻结论，如果最终结论没有被推翻，
	说明这个结论没毛病。）

	第四：只有上课中所有的结论都已经验证完毕了，你剩下的时间再去考虑作业题。
	作业题做不做都行，作业是次要的，课堂上的结论是重要的。

2.2、回顾所有结论
	
	第八章重点以及结论：
		重点：
			什么是类？一个模板
			什么是对象？真实存在的，通过模板创建的
			什么是实例？对象就是实例
			怎么定义类？

		结论：
			定义类的语法机制：
				[修饰符列表] class 类名 {
					类体 = 属性+方法;
				}
			属性来源于状态（属性描述状态）
			方法来源于动作（方法描述动作）

		课下思考：
			现实生活中有哪些对象？
			对象上有哪些属性？
			对象有什么行为？
			如果用java代码应该怎么描述？
	
	第九章 对象的创建和使用

		重点以及结论：

			怎么创建对象？
				new 类名();

			怎么使用对象？
				需要将创建的对象赋值给一个变量。
				而这个变量被称为引用。
				怎么使用对象？“引用.”，死记硬背，使用对象的时候，就用“引用.”就行了。

			构造方法怎么定义？
				语法需要记忆：
					[修饰符列表] 构造方法名(形参){
						构造方法体;
					}

			构造方法怎么调用？
				new
				语法： new 构造方法名(实参);

			构造方法的方法体中写什么？
				给属性赋值。

			构造方法的重要结论：
				一个类没有提供任何构造方法，会有一个默认的无参的。
				一个类提供了构造方法，系统就不再默认提供无参构造了。
				建议把无参构造写出来。

			空指针异常怎么发生的？
				“空引用”访问“实例”相关的就会出现空指针异常。

			方法调用时参数是怎么传递的？
				方法调用的时候参数传递一定是将变量中保存的那个值
				复制一份传过去。可能这个值是100，可能这个值是一个
				对象的内存地址：0x1234

			一个java程序执行过程的内存图（对象的创建）？（实在搞不定就放弃先。）
	
	第十章 封装
		重点以及结论？
			怎么封装：
				属性私有化
				对外提供公开的set和get方法

	第十一章 this关键字和static关键字
		static的重点以及结论
			static修饰的方法静态方法
			static修饰的变量静态变量
			static修饰的都用“类名.”访问。（都不需要new对象，就能访问）
			static{} 是静态代码块，在类加载时执行，并执行一次。
			{} 实例语句块，在构造方法执行前执行，构造一次执行一次。

			static的也能用“引用.”的方式访问，不过运行时仍然和此对象无关，
			空指针异常充分的说明了以上的结论。（用空引用访问静态的不会出现空指针异常）

		this的重点以及结论
			this用法就两个：this. 和 this()
			this不能用在静态方法中。只能使用在实例方法中。
			this. 大部分可以省略，区分局部变量和实例变量的时候不能省略。
			this() 只能出现在构造方法第一行，通过当前构造方法调用本类其它构造方法，代码复用。
	
	第十二章 继承
		重点以及结论
			语法怎么实现？
				extends关键字
			单继承
			默认继承Object
			自己验证一下子类继承父类之后，用子类能不能调用继承过来的方法。

	第十三章 方法覆盖和多态

		方法覆盖的重点以及结论

			代码怎么写方法就能覆盖。
				继承关系需要有
				相同的返回值类型，相同的方法名，相同参数列表。

			方法覆盖之后，子类对象执行的一定是覆盖之后的方法。
			结论写出来了，你需要自己编代码验证一下这个结论是否正确。

		多态的重点以及结论
			无论向上转型还是向下转型，都要有继承关系。
			Animal a = new Cat();
			a.move(); 编译阶段和运行阶段绑定的move方法不一样。（向上转型）

			if(a instanceof Cat){ // 什么时候必须向下转型？？？？
				Cat c = (Cat)a;  // 向下转型之前养成什么好习惯？？？
			}

			有同学有疑问？
				我不理解怎么用！！！！
				以后到处都用多态，你只要记住这个就行。
				心里一直想着一件事：能用多态就用多态。。。。。
				尽量使用。用着用着你就明白了。。。。。。
				我最初学习多态的时候也不理解多态有什么用。。。
			
			放弃式的学习要会！！！！！不会的先放一放，凑合能让自己代码编写就行。
	
	第十四章 super

		重点以及结论

			super的用法：super. 和 super()

			super. 大部分可以省略，当父子都有相同的属性和方法时，
			在子类中访问父类的特征时，必须使用super.

			一个构造方法第一行啥也没有，自动会有一个super()

			super不能出现在静态方法中，只能是实例方法。

			super()是干啥的：是通过子类的构造方法调用父类的构造方法。

---

1、关于java的集成开发环境：
eclipse、IntelliJ IDEA等。
其中目前主流的集成开发环境是：IntelliJ IDEA

这只是一个工具，不要让一个工具把你难住了。
开发工具不要使用汉化版，太low。
英语单词太多别害怕，记位置。（一共就那几个主要的操作位置。）

2、安装IDEA工具
自己课下按照破解文档进行破解。

3、IDEA工具的使用：

第一次打开的时候：会弹出一个窗口（import idea settings）
	这个表示导入idea的设置，但我们是第一次使用idea工具，
	没有设置过idea，所以这里选择：do not import setting...不导入设置。

第二步：会让你接受条款，接受即可。

第三步：don't send

第四步：一直下一步（最终选择免费试用30天。）

第五步：可能会让你填写email等信息，这里不填写，继续continue。

第六步：弹出welcome窗口
	点击create new project
	注意：在IDEA当中一个project相当于eclipse当中的一个workspace。

第七步：新建一个Empty Project
	新建一个空的工程，选择创建工程窗口下面“最后的那一项”，Empty Project

第八步：给空的工程起一个名字：javase
	存储到：C:\Users\Administrator\IdeaProjects\javase
	点击finish。

第九步：自动弹出一个每日提示，这个每日提示可以取消掉。以后每一次打开就不再提示了。

第十步：会自动弹出一个：project structure，这个窗口先取消掉。

第十一步：在空的工程下新建Module（模块），IDEA中模块类似于eclipse当中的project。
	eclipse的组织方式：
		workspace--> project
	idea的组织方式：
		project --> module
	
	怎么创建module?
		file菜单-->new --> Module
	
第十二步：在New Module窗口上点击左上角的java，然后next

第十三步：给module起一个名字：chapter15

第十四步：编写代码，在src目录下新建类，写代码，并运行。

4、关于IDEA工具的快捷键以及一些简单的设置

4.1、字体设置
	file --> settings --> 输入font --> 设置字体样式以及字号大小。

4.2、快速生成main方法
	psvm

4.3、快速生成System.out.println()
	sout 

4.4、注意：IDEA是自动保存，不需要ctrl + s

4.5、删除一行
	ctrl + y

4.6、怎么运行：
	代码上右键-->run
	或者点击左侧的绿色箭头。
	ctrl + shift + F10

4.7、左侧窗口中的列表怎么展开？怎么关闭？
	左箭头关闭。
	右箭头展开。
	上下箭头移动。

4.8、idea中退出任何窗口，都可以使用esc键盘。（esc就是退出）

4.9、任何新增/新建/添加的快捷键是：
	alt + insert

4.10、窗口变大，变小：
	ctrl + shift + F12

4.11、切换java程序：从HelloWorld切换到User
	alt + 右箭头 
	或者
	alt + 左箭头

4.12、切换窗口：
	alt + 标号
	alt + 1（打开，关闭）
	alt + 2

4.13、提示方法的参数：ctrl + p

4.14、注释：
	单行注释：ctrl + /
	多行注释：ctrl + shift + /

4.15、idea中怎么定位方法/属性/变量？
	光标停到某个单词的下面，这个单词可能是：
		方法名、变量名
	停到单词下面之后，按ctrl键，出现下划线，点击跳转。

4.16、idea当中复制一行是ctrl + d

day20课堂笔记

1、final关键字
1.1、final修饰的类无法继承。
1.2、final修饰的方法无法覆盖。
1.3、final修饰的变量只能赋一次值。
1.4、final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用
指向的对象内部的数据是可以修改的。
1.5、final修饰的实例变量必须手动初始化，不能采用系统默认值。
1.6、final修饰的实例变量一般和static联合使用，称为常量。
public static final double PI = 3.1415926;

2、抽象类和接口以及抽象类和接口的区别。

2.1、抽象类
	第一：抽象类怎么定义？在class前添加abstract关键字就行了。
	第二：抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
	第三：final和abstract不能联合使用，这两个关键字是对立的。
	第四：抽象类的子类可以是抽象类。也可以是非抽象类。
	第五：抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
	第六：抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
	第七：抽象方法怎么定义？
		public abstract void doSome();
	第八（*****五颗星）：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。

	到目前为止，只是学习了抽象类的基础语法，一个类到底声明为抽象还是非抽象，
	这个以后慢慢来吧。写代码多的时候，自然就理解了。

	面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。
		不对，错误的。
		Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们
		都不是抽象方法，例如：
			public native int hashCode();
			这个方法底层调用了C++写的动态链接库程序。
			前面修饰符列表中没有：abstract。有一个native。表示调用JVM本地程序。

2.2、接口的基础语法。
	1、接口是一种“引用数据类型”。
	2、接口是完全抽象的。
	3、接口怎么定义：[修饰符列表] interface 接口名{}
	4、接口支持多继承。
	5、接口中只有常量+抽象方法。
	6、接口中所有的元素都是public修饰的
	7、接口中抽象方法的public abstract可以省略。
	8、接口中常量的public static final可以省略。
	9、接口中方法不能有方法体。

2.3、接口在开发中的作用。

day21课堂笔记

1、抽象类和接口以及抽象类和接口的区别。

1.1、抽象类的基础语法（见昨天笔记）

1.2、接口的基础语法
	1、接口是一种“引用数据类型”。
	2、接口是完全抽象的。
	3、接口怎么定义：[修饰符列表] interface 接口名{}
	4、接口支持多继承。
	5、接口中只有常量+抽象方法。
	6、接口中所有的元素都是public修饰的
	7、接口中抽象方法的public abstract可以省略。
	8、接口中常量的public static final可以省略。
	9、接口中方法不能有方法体。
	10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。
	11、一个类可以实现多个接口。
	12、extends和implements可以共存，extends在前，implements在后。
	13、使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。

	课下代码就不要翻阅讲师的了，直接根据这个结论进行验证。
	推翻它。尝试推翻它。

1.3、接口在开发中的作用

	注意：接口在开发中的作用，类似于多态在开发中的作用。

	多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。
		/*
		public class Master{
			public void feed(Dog d){}
			public void feed(Cat c){}
			//假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了）
			//这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
		}
		*/

		public class Master{
			public void feed(Animal a){
				// 面向Animal父类编程，父类是比子类更抽象的。
				//所以我们叫做面向抽象编程，不要面向具体编程。
				//这样程序的扩展力就强。
			}
		}
	
	接口在开发中的作用？
		接口是不是完全的？是。
		而我们以后正好要求，面向抽象编程。
		面向抽象编程这句话以后可以修改为：面向接口编程。
		有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。

		主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新
		买一个换下来。这叫做高扩展性。（低耦合度。）

		接口在现实世界中是不是到处都是呢？
			螺栓和螺母之间有接口
			灯泡和灯口之间有接口
			笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
			接口有什么用？扩展性好。可插拔。
			接口是一个抽象的概念。
		
		分析：
			中午去饭馆吃饭，这个过程中有接口吗？

				接口是抽象的。	

				菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）

				谁面向接口调用。（顾客面向菜单点菜，调用接口。）

				谁负责实现这个接口。（后台的厨师负责把西红柿鸡蛋做好！是接口的实现者。）

				这个接口有什么用呢？
					这个饭馆的“菜单”，让“顾客”和“后厨”解耦合了。
					顾客不用找后厨，后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通。
		
		总结一句话：三个字“解耦合”
			面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。
			接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

			接口可以解耦合，解开的是谁和谁的耦合！！！
			任何一个接口都有调用者和实现者。
			接口可以将调用者和实现者解耦合。
			调用者面向接口调用。
			实现者面向接口编写实现。

			以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，
			模块和模块之间采用接口衔接。降低耦合度。

1.4、类型和类型之间的关系：

	is a（继承）、has a（关联）、like a（实现）

		is a：
			Cat is a Animal（猫是一个动物）
			凡是能够满足is a的表示“继承关系”
			A extends B

		has a：
			I has a Pen（我有一支笔）
			凡是能够满足has a关系的表示“关联关系”
			关联关系通常以“属性”的形式存在。
			A{
				B b;
			}
		
		like a:
			Cooker like a FoodMenu（厨师像一个菜单一样）
			凡是能够满足like a关系的表示“实现关系”
			实现关系通常是：类实现接口。
			A implements B

1.5、抽象类和接口有什么区别？
	在这里我们只说一下抽象类和接口在语法上的区别。
	至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

	抽象类是半抽象的。
	接口是完全抽象的。

	抽象类中有构造方法。
	接口中没有构造方法。

	接口和接口之间支持多继承。
	类和类之间只能单继承。

	一个类可以同时实现多个接口。
	一个抽象类只能继承一个类（单继承）。

	接口中只允许出现常量和抽象方法。
	
	这里先透露一个信息：
		以后接口使用的比抽象类多。一般抽象类使用的还是少。
		接口一般都是对“行为”的抽象。

2、package和import

2.1、package
	第一：package出现在java源文件第一行。
	第二：带有包名怎么编译？javac -d . xxx.java
	第三：怎么运行？java 完整类名

	补充：以后说类名的时候，如果带着包名描述，表示完整类名。
	如果没有带包，描述的话，表示简类名。
		java.util.Scanner 完整类名。
		Scanner 简类名

2.2、import

	import什么时候不需要？
		java.lang不需要。
		同包下不需要。 
		其它一律都需要。

	怎么用？
		import 完整类名;
		import 包名.*;

		import java.util.Scanner; // 完整类名。

		// 同学的疑问：这样是不是效率比较低。
		// 这个效率不低，因为编译器在编译的时候，会自动把*变成具体的类名。
		import java.util.*;

		// 想省懒劲你不能太省了。
		import java.*; 这是不允许的，因为在java语言中规定，这里的*只代表某些类的名字。

day22课堂笔记

1、访问控制权限

1.1、访问控制权限都有哪些？
	4个。
	private	私有
	public 公开

	protected	受保护
	默认

1.2、以上的4个访问控制权限：控制的范围是什么？
	private 表示私有的，只能在本类中访问
	public 表示公开的，在任何位置都可以访问
	“默认”表示只能在本类，以及同包下访问。
	protected表示只能在本类、同包、子类中访问。

	访问控制修饰符			本类			同包			子类			任意位置
	---------------------------------------------------------------------------
	public					可以			可以			可以			可以
	protected				可以			可以			可以			不行
	默认						可以			可以			不行			不行
	private					可以			不行			不行			不行

	这个不要死记硬背，自己下去之后编写代码自己测试。

	范围从大到小排序：public > protected > 默认 > private

1.3、访问控制权限修饰符可以修饰什么？
	属性（4个都能用）
	方法（4个都能用）
	类（public和默认能用，其它不行。）
	接口（public和默认能用，其它不行。）
	.....

2、JDK类库的根类：Object

2.1、这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。
任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。

2.2、Object类当中有哪些常用的方法？
	我们去哪里找这些方法呢？
		第一种方法：去源代码当中。（但是这种方式比较麻烦，源代码也比较难）
		第二种方法：去查阅java的类库的帮助文档。

	什么是API？
		应用程序编程接口。（Application Program Interface）
		整个JDK的类库就是一个javase的API。
		每一个API都会配置一套API帮助文档。
		SUN公司提前写好的这套类库就是API。（一般每一份API都对应一份API帮助文档。）
	
	目前为止我们只需要知道这几个方法即可：
		protected Object clone()   // 负责对象克隆的。
		int hashCode()	// 获取对象哈希值的一个方法。
		boolean equals(Object obj)  // 判断两个对象是否相等
		String toString()  // 将对象转换成字符串形式
		protected void finalize()  // 垃圾回收器负责调用的方法

2.3、toString()方法
	以后所有类的toString()方法是需要重写的。
	重写规则，越简单越明了就好。

	System.out.println(引用); 这里会自动调用“引用”的toString()方法。

	String类是SUN写的，toString方法已经重写了。

2.4、equals()方法
	以后所有类的equals方法也需要重写，因为Object中的equals方法比较
	的是两个对象的内存地址，我们应该比较内容，所以需要重写。

	重写规则：自己定，主要看是什么和什么相等时表示两个对象相等。

	基本数据类型比较实用：==
	对象和对象比较：调用equals方法

	String类是SUN编写的，所以String类的equals方法重写了。
	以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法。

	注意：重写equals方法的时候要彻底。

2.5、finalize()方法。
	这个方法是protected修饰的，在Object类中这个方法的源代码是？
		protected void finalize() throws Throwable { }

3、匿名内部类

day23课堂笔记

1、数组
1.1、数组的优点和缺点，并且要理解为什么。
第一：空间存储上，内存地址是连续的。
第二：每个元素占用的空间大小相同。
第三：知道首元素的内存地址。
第四：通过下标可以计算出偏移量。
通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，
直接通过内存地址定位，效率非常高。

	优点：检索效率高。
	缺点：随机增删效率较低，数组无法存储大数据量。
	注意：数组最后一个元素的增删效率不受影响。

1.2、一维数组的静态初始化和动态初始化
	静态初始化：
		int[] arr = {1,2,3,4};
		Object[] objs = {new Object(), new Object(), new Object()};
	动态初始化：
		int[] arr = new int[4]; // 4个长度，每个元素默认值0
		Object[] objs = new Object[4]; // 4个长度，每个元素默认值null

1.3、一维数组的遍历
	for(int i = 0; i < arr.length; i++){
		System.out.println(arr[i]);
	}

1.4、二维数组的静态初始化和动态初始化
	静态初始化：
		int[][] arr = {
								{1,2,34},
								{54,4,34,3},
								{2,34,4,5}
							};

		Object[][] arr = {
								{new Object(),new Object()},
								{new Object(),new Object()},
								{new Object(),new Object(),new Object()}
							};
	动态初始化：
		int[][] arr = new int[3][4];
		Object[][] arr = new Object[4][4];
		Animal[][] arr = new Animal[3][4];
		// Person类型数组，里面可以存储Person类型对象，以及Person类型的子类型都可以。
		Person[][] arr = new Person[2][2];
		....

1.5、二维数组的遍历
	for(int i = 0; i < arr.length; i++){ // 外层for循环负责遍历外面的一维数组。
		// 里面这个for循环负责遍历二维数组里面的一维数组。
		for(int j = 0; j < arr[i].length; j++){
			System.out.print(arr[i][j]);
		}
		// 换行。
		System.out.println();
	}

1.6、main方法上“String[] args”参数的使用（非重点，了解一下，以后一般都是有界面的，用户可以在界面上输入用户名和密码等参数信息。）

1.7、数组的拷贝：System.arraycopy()方法的使用
	数组有一个特点：长度一旦确定，不可变。
	所以数组长度不够的时候，需要扩容，扩容的机制是：新建一个大数组，
	将小数组中的数据拷贝到大数组，然后小数组对象被垃圾回收。

1.8、对数组中存储引用数据类型的情况，要会画它的内存结构图。

day24课堂笔记

1、解决昨天的两个作业题：
第一题：数组模拟栈。
第二题：酒店管理系统的模拟。

2、数组

2.1、常见的算法：

	排序算法：
		冒泡排序算法
		选择排序算法

	查找算法：
		二分法查找
	
	以上算法在以后的java实际开发中我们不需要使用的。
	因为java已经封装好了，直接调用就行。
	只不过以后面试的时候，可能会有机会碰上。

2.2、算法实际上在java中不需要精通，因为java中已经封装好了，
要排序就调用方法就行。例如：java中提供了一个数组工具类：
	java.util.Arrays
		Arrays是一个工具类。
		其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。

3、冒泡排序：

参与比较的数据：9 8 10 7 6 0 11
第1次循环：
8 9 10 7 6 0 11 (第1次比较：交换)
8 9 10 7 6 0 11 (第2次比较：不交换)
8 9 7 10 6 0 11 (第3次比较：交换)
8 9 7 6 10 0 11 (第4次比较：交换)
8 9 7 6 0 10 11 (第5次比较：交换)
8 9 7 6 0 10 11 (第6次比较：不交换)
最终冒出的最大数据在右边：11

参与比较的数据：8 9 7 6 0 10
第2次循环：
8 9 7 6 0 10（第1次比较：不交换）
8 7 9 6 0 10（第2次比较：交换）
8 7 6 9 0 10（第3次比较：交换）
8 7 6 0 9 10（第4次比较：交换）
8 7 6 0 9 10（第5次比较：不交换）

参与比较的数据：8 7 6 0 9
第3次循环：
7 8 6 0 9（第1次比较：交换）
7 6 8 0 9（第2次比较：交换）
7 6 0 8 9（第3次比较：交换）
7 6 0 8 9（第4次比较：不交换）

参与比较的数据：7 6 0 8
第4次循环：
6 7 0 8（第1次比较：交换）
6 0 7 8（第2次比较：交换）
6 0 7 8（第3次比较：不交换）

参与比较的数据：6 0 7
第5次循环：
0 6 7（第1次比较：交换）
0 6 7（第2次比较：不交换）

参与比较的数据：0 6
第6次循环：
0 6 （第1次比较：不交换）

for(int i = 6; i > 0; i–){ // 6次
//7条数据比6次
//6条数据比5次
//5条数据比4次
//4条数据比3次
//3条数据比2次
//2条数据比1次
for(int j = 0; j < i; j++){

}

}

4、选择排序：

选择排序比冒泡排序的效率高。
高在交换位置的次数上。
选择排序的交换位置是有意义的。

循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和
最前面的数据“交换位置”。


参与比较的数据：3 1 6 2 5 （这一堆参加比较的数据中最左边的元素下标是0）
第1次循环之后的结果是：
1 3 6 2 5 

参与比较的数据：3 6 2 5 （这一堆参加比较的数据中最左边的元素下标是1）
第2次循环之后的结果是：
2 6 3 5 

参与比较的数据：6 3 5 （这一堆参加比较的数据中最左边的元素下标是2）
第3次循环之后的结果是：
3 6 5 

参与比较的数据：6 5 （这一堆参加比较的数据中最左边的元素下标是3）
第4次循环之后的结果是：
5 6

注意：5条数据，循环4次。

5、二分法查找（折半查找）：

第一：二分法查找建立在排序的基础之上。
第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
第三：二分法查找原理？
	10(0下标) 23 56 89 100 111 222 235 500 600(下标9) arr数组
	
	目标：找出600的下标
		(0 + 9) / 2 --> 4（中间元素的下标）
	
	arr[4]这个元素就是中间元素：arr[4]是 100
	100 < 600
	说明被查找的元素在100的右边。
	那么此时开始下标变成：4 + 1

		(5 + 9) / 2 --> 7（中间元素的下标）
		arr[7] 对应的是：235
		235 < 600
		说明被查找的元素在235的右边。
	
	开始下标又进行了转变：7 + 1
		(8 + 9) / 2 --> 8
		arr[8] --> 500
		500 < 600
		开始元素的下标又发生了变化：8 + 1
		(9 + 9) / 2 --> 9
		arr[9]是600，正好和600相等，此时找到了。

6、介绍一下java.util.Arrays工具类。
所有方法都是静态的，直接用类名调用
主要使用的是两个方法：
二分法查找，排序
以后要看文档，不要死记硬背。

day25课堂笔记

1、String类。
1.1、对String在内存存储方面的理解：
第一：字符串一旦创建不可变。
第二：双引号括起来的字符串存储在字符串常量池中。
第三：字符串的比较必须使用equals方法。
第四：String已经重写了toString()和equals()方法。

1.2、String的构造方法。
	String s = "abc";
	String s = new String("abc");
	String s = new String(byte数组);
	String s = new String(byte数组, 起始下标, 长度);
	String s = new String(char数组);
	String s = new String(char数组, 起始下标, 长度);

1.3、String类常用的21个方法。

2、StringBuffer/StringBuilder
2.1、StringBuffer/StringBuilder可以看做可变长度字符串。
2.2、StringBuffer/StringBuilder初始化容量16.
2.3、StringBuffer/StringBuilder是完成字符串拼接操作的，方法名：append
2.4、StringBuffer是线程安全的。StringBuilder是非线程安全的。
2.5、频繁进行字符串拼接不建议使用“+”

3、八种基本数据类型对应的包装类
3.1、包装类存在有什么用？
方便编程。
3.2、八种包装类的类名是什么？
Byte
Short
Integer
Long
Float
Double
Boolean
Character
3.3、所有数字的父类Number
3.4、照葫芦画瓢：学习Integer，其它的模仿Integer。
3.5、什么是装箱？什么是拆箱？

day26课堂笔记

1、八种基本数据类型对应的包装类。
1.1、什么是自动装箱和自动拆箱，代码怎么写？
Integer x = 100; // x里面并不是保存100，保存的是100这个对象的内存地址。
Integer y = 100;
System.out.println(x == y); // true

	Integer x = 128;
	Integer y = 128;
	System.out.println(x == y); // false

1.2、Integer类常用方法。
	Integer.valueOf()
	Integer.parseInt("123")
	Integer.parseInt("中文") : NumberFormatException

1.3、Integer String int三种类型互相转换。

2、日期类
2.1、获取系统当前时间
Date d = new Date();
2.2、日期格式化：Date --> String
yyyy-MM-dd HH:mm:ss SSS
SimpleDateFormat sdf = new SimpleDate(“yyyy-MM-dd HH:mm:ss SSS”);
String s = sdf.format(new Date());
2.3、String --> Date
SimpleDateFormat sdf = new SimpleDate(“yyyy-MM-dd HH:mm:ss”);
Date d = sdf.parse(“2008-08-08 08:08:08”);
2.4、获取毫秒数
long begin = System.currentTimeMillis();
Date d = new Date(begin - 1000 * 60 * 60 * 24);

3、数字类
3.1、DecimalFormat数字格式化
###,###.## 表示加入千分位，保留两个小数。
###,###.0000 表示加入千分位，保留4个小数，不够补0
3.2、BigDecimal
财务软件中通常使用BigDecimal

4、随机数
4.1、怎么产生int类型随机数。
Random r = new Random();
int i = r.nextInt();
4.2、怎么产生某个范围之内的int类型随机数。
Random r = new Random();
int i = r.nextInt(101); // 产生[0-100]的随机数。

5、枚举
5.1、枚举是一种引用数据类型。
5.2、枚举编译之后也是class文件。
5.3、枚举类型怎么定义？
enum 枚举类型名{
枚举值,枚举值2,枚举值3
}
5.4、当一个方法执行结果超过两种情况，并且是一枚一枚可以列举出来
的时候，建议返回值类型设计为枚举类型。

day27课堂笔记

0、异常处理机制
0.1、java中异常的作用是：增强程序健壮性。
0.2、java中异常以类和对象的形式存在。

1、java的异常处理机制

1.1、异常在java中以类和对象的形式存在。那么异常的继承结构是怎样的？
我们可以使用UML图来描述一下继承结构。
画UML图有很多工具，例如：Rational Rose（收费的）、starUML等....
	Object
	Object下有Throwable（可抛出的）
	Throwable下有两个分支：Error（不可处理，直接退出JVM）和Exception（可处理的）
	Exception下有两个分支：
		Exception的直接子类：编译时异常（要求程序员在编写程序阶段必须预先对这些异常进行处理，如果不处理编译器报错，因此得名编译时异常。）。
		RuntimeException：运行时异常。（在编写程序阶段程序员可以预先处理，也可以不管，都行。）

1.2、编译时异常和运行时异常，都是发生在运行阶段。编译阶段异常是不会发生的。
编译时异常因为什么而得名？
	因为编译时异常必须在编译(编写)阶段预先处理，如果不处理编译器报错，因此得名。
	所有异常都是在运行阶段发生的。因为只有程序运行阶段才可以new对象。
	因为异常的发生就是new异常对象。

1.3、编译时异常和运行时异常的区别？

	编译时异常一般发生的概率比较高。
		举个例子：
			你看到外面下雨了，倾盆大雨的。
			你出门之前会预料到：如果不打伞，我可能会生病（生病是一种异常）。
			而且这个异常发生的概率很高，所以我们出门之前要拿一把伞。
			“拿一把伞”就是对“生病异常”发生之前的一种处理方式。

			对于一些发生概率较高的异常，需要在运行之前对其进行预处理。

	运行时异常一般发生的概率比较低。
		举个例子：
			小明走在大街上，可能会被天上的飞机轮子砸到。
			被飞机轮子砸到也算一种异常。
			但是这种异常发生概率较低。
			在出门之前你没必要提前对这种发生概率较低的异常进行预处理。
			如果你预处理这种异常，你将活的很累。
	
	假设你在出门之前，你把能够发生的异常都预先处理，你这个人会更加
	的安全，但是你这个人活的很累。
	
	假设java中没有对异常进行划分，没有分为：编译时异常和运行时异常，
	所有的异常都需要在编写程序阶段对其进行预处理，将是怎样的效果呢？
		首先，如果这样的话，程序肯定是绝对的安全的。
		但是程序员编写程序太累，代码到处都是处理异常
		的代码。

1.4、编译时异常还有其他名字：
	受检异常：CheckedException
	受控异常

1.5、运行时异常还有其它名字：
	未受检异常：UnCheckedException
	非受控异常

1.6、再次强调：所有异常都是发生在运行阶段的。

1.7、Java语言中对异常的处理包括两种方式：

	第一种方式：在方法声明的位置上，使用throws关键字，抛给上一级。
		谁调用我，我就抛给谁。抛给上一级。

	第二种方式：使用try..catch语句进行异常的捕捉。
		这件事发生了，谁也不知道，因为我给抓住了。

	举个例子：
		我是某集团的一个销售员，因为我的失误，导致公司损失了1000元，
		“损失1000元”这可以看做是一个异常发生了。我有两种处理方式，
		第一种方式：我把这件事告诉我的领导【异常上抛】
		第二种方式：我自己掏腰包把这个钱补上。【异常的捕捉】
		
		张三 --> 李四 ---> 王五 --> CEO
	
	思考：
		异常发生之后，如果我选择了上抛，抛给了我的调用者，调用者需要
		对这个异常继续处理，那么调用者处理这个异常同样有两种处理方式。

1.8、注意：Java中异常发生之后如果一直上抛，最终抛给了main方法，main方法继续
向上抛，抛给了调用者JVM，JVM知道这个异常发生，只有一个结果。终止java程序的执行。

2、什么是UML？有什么用？
UML是一种统一建模语言。
一种图标式语言（画图的）
UML不是只有java中使用。只要是面向对象的编程语言，都有UML。
一般画UML图的都是软件架构师或者说是系统分析师。这些级别的人员使用的。
软件设计人员使用UML。

在UML图中可以描述类和类之间的关系，程序执行的流程，对象的状态等.

盖大楼和软件开发一样，一个道理。
	盖楼之前，会先由建筑师画图纸。图纸上一个一个符号都是标准符号。
	这个图纸画完，只要是搞建筑的都能看懂，因为这个图纸上标注的这些
	符号都是一种“标准的语言”。

在java软件开发当中，软件分析师/设计师负责设计类，java软件开发人员
必须要能看懂。

day28课堂笔记

1、集合概述

1.1、什么是集合？有什么用？

	数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。

	集合为什么说在开发中使用较多？
		集合是一个容器，是一个载体，可以一次容纳多个对象。
		在实际开发中，假设连接数据库，数据库当中有10条记录，
		那么假设把这10条记录查询出来，在java程序中会将10条
		数据封装成10个java对象，然后将10个java对象放到某一个
		集合当中，将集合传到前端，然后遍历集合，将一个数据一个
		数据展现出来。

1.2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，
集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）
	list.add(100); //自动装箱Integer
	注意：
		集合在java中本身是一个容器，是一个对象。
		集合中任何时候存储的都是“引用”。

1.3、在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中
存储元素，等于将数据放到了不同的数据结构当中。什么是数据结构？数据存储的
结构就是数据结构。不同的数据结构，数据存储方式不同。例如：
	数组、二叉树、链表、哈希表...
	以上这些都是常见的数据结构。

	你往集合c1中放数据，可能是放到数组上了。
	你往集合c2中放数据，可能是放到二叉树上了。
	.....
	你使用不同的集合等同于使用了不同的数据结构。

	你在java集合这一章节，你需要掌握的不是精通数据结构。java中已经将数据结构
	实现了，已经写好了这些常用的集合类，你只需要掌握怎么用？在什么情况下选择
	哪一种合适的集合去使用即可。

	new ArrayList(); 创建一个集合，底层是数组。
	new LinkedList(); 创建一个集合对象，底层是链表。
	new TreeSet(); 创建一个集合对象，底层是二叉树。
	.....

1.4、集合在java JDK中哪个包下？
	java.util.*;
		所有的集合类和集合接口都在java.util包下。

1.5、为了让大家掌握集合这块的内容，最好能将集合的继承结构图背会！！！
	集合整个这个体系是怎样的一个结构，你需要有印象。

1.6、在java中集合分为两大类：
	一类是单个方式存储元素：
		单个方式存储元素，这一类集合中超级父接口：java.util.Collection;

	一类是以键值对儿的方式存储元素
		以键值对的方式存储元素，这一类集合中超级父接口：java.util.Map;

2、总结重点：

第一个重点：把集合继承结构图背会。

第二个重点：把Collection接口中常用方法测试几遍。

第三个重点：把迭代器弄明白。

第四个重点：Collection接口中的remove方法和contains方法底层都会调用equals，
				这个弄明白。

day29课堂笔记

1、List接口中的常用方法。
List是Collection接口的子接口。所以List接口中有一些特有的方法。
void add(int index, Object element)
Object set(int index, Object element)
Object get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
Object remove(int index)
2、迭代器迭代元素的过程中不能使用集合对象的remove方法删除元素，
要使用迭代器Iterator的remove方法来删除元素，防止出现异常：
ConcurrentModificationException

3、ArrayList
ArrayList集合初始化容量10
扩容为原容量1.5倍。
底层是数组。

数组优点和缺点要能够说出来！
另外要注意：ArrayList集合末尾增删元素效率还是可以的。

4、链表数据结构
第一：单向链表和双向链表数据结构要理解。
第二：链表数据结构的优点和缺点要能够说出来。

5、Vector：
Vector初始化容量是10.
扩容为原容量的2倍。
底层是数组。
Vector底层是线程安全的。

怎么得到一个线程安全的List：
	Collections.synchronizedList(list);

6、JDK5.0新特性：泛型
第一：集合使用泛型来减少向下转型的操作。
第二：怎么使用泛型？
第三：怎么自定义泛型？

7、JDK5.0新特性：
foreach
对数组怎么遍历？
for(int i : arr){
System.out.println(i);
}
对集合怎么遍历？
for(String s : list){
System.out.println(s);
}

8、JDK8新特性：钻石表达式
List list = new ArrayList<>();
类型自动推断！

day30课堂笔记

1、掌握Map接口中常用方法。

2、遍历Map集合的两种方式都要精通。
第一种：获取所有key，遍历每个key，通过key获取value.
第二种：获取Set即可，遍历Set集合中的Entry
调用entry.getKey() entry.getValue()

3、了解哈希表数据结构。

4、存放在HashMap集合key部分和HashSet集合中的元素需要同时重写hashCode和equals。

5、HashMap和Hashtable的区别。
HashMap：
初始化容量16，扩容2倍。
非线程安全
key和value可以为null。

Hashtable
	初始化容量11，扩容2倍+1
	线程安全
	key和value都不能是null。

6、Properties类的常用两个方法。
setProperty
getProperty

7、了解自平衡二叉树数据结构。
左小右大原则存储。
中序遍历方式。

8、TreeMap的key或者TreeSet集合中的元素要想排序，有两种实现方式：
第一种：实现java.lang.Comparable接口。
第二种：单独编写一个比较器Comparator接口。

9、集合工具类Collections:
synchronizedList方法
sort方法（要求集合中元素实现Comparable接口。）

day31课堂笔记

1、集合这块最主要掌握什么内容？
1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合
1.5、主要的集合类：
ArrayList
LinkedList
HashSet (HashMap的key，存储在HashMap集合key的元素需要同时重写hashCode + equals)
TreeSet
HashMap
Properties
TreeMap

2、IO流，什么是IO？
I : Input
O : Output
通过IO可以完成硬盘文件的读和写。

3、IO流的分类？

有多种分类方式：

	一种方式是按照流的方向进行分类：
		以内存作为参照物，
			往内存中去，叫做输入(Input)。或者叫做读(Read)。
			从内存中出来，叫做输出(Output)。或者叫做写(Write)。

	另一种方式是按照读取数据方式不同进行分类：
		有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。
		这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件等....
			假设文件file1.txt，采用字节流的话是这样读的：
				a中国bc张三fe
				第一次读：一个字节，正好读到'a'
				第二次读：一个字节，正好读到'中'字符的一半。
				第三次读：一个字节，正好读到'中'字符的另外一半。

		有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取
		普通文本文件而存在的，这种流不能读取：图片、声音、视频等文件。只能读取纯
		文本文件，连word文件都无法读取。
			假设文件file1.txt，采用字符流的话是这样读的：
				a中国bc张三fe
				第一次读：'a'字符（'a'字符在windows系统中占用1个字节。）
				第二次读：'中'字符（'中'字符在windows系统中占用2个字节。）

综上所述：流的分类
	输入流、输出流
	字节流、字符流

4、Java中的IO流都已经写好了，我们程序员不需要关心,我们最主要还是掌握，
在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有
哪些？？？？
java中所有的流都是在：java.io.*;下。

java中主要还是研究：
	怎么new流对象。
	调用流对象的哪个方法是读，哪个方法是写。

5、java IO流这块有四大家族：
四大家族的首领：
java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流

	java.io.Reader		字符输入流
	java.io.Writer		字符输出流

	四大家族的首领都是抽象类。(abstract class)

	所有的流都实现了：
		java.io.Closeable接口，都是可关闭的，都有close()方法。
		流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，
		不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。

	所有的输出流都实现了：
		java.io.Flushable接口，都是可刷新的，都有flush()方法。
		养成一个好习惯，输出流在最终输出之后，一定要记得flush()
		刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据
		强行输出完（清空管道！）刷新的作用就是清空管道。
		注意：如果没有flush()可能会导致丢失数据。


注意：在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。

6、java.io包下需要掌握的流有16个：

文件专属：
	java.io.FileInputStream（掌握）
	java.io.FileOutputStream（掌握）
	java.io.FileReader
	java.io.FileWriter

转换流：（将字节流转换成字符流）
	java.io.InputStreamReader
	java.io.OutputStreamWriter

缓冲流专属：
	java.io.BufferedReader
	java.io.BufferedWriter
	java.io.BufferedInputStream
	java.io.BufferedOutputStream

数据流专属：
	java.io.DataInputStream
	java.io.DataOutputStream

标准输出流：
	java.io.PrintWriter
	java.io.PrintStream（掌握）

对象专属流：
	java.io.ObjectInputStream（掌握）
	java.io.ObjectOutputStream（掌握）

7、java.io.File类。
File类的常用方法。

8、java io这块还剩下什么内容：
第一：ObjectInputStream ObjectOutputStream的使用。
第二：IO流+Properties集合的联合使用。

1、拷贝目录。

2、关于对象流
ObjectInputStream
ObjectOutputStream

重点：
	参与序列化的类型必须实现java.io.Serializable接口。
	并且建议将序列化版本号手动的写出来。
		private static final long serialVersionUID = 1L;

3、IO + Properties联合使用。
IO流：文件的读和写。
Properties:是一个Map集合，key和value都是String类型。

day32课堂笔记

4、多线程

4.1、什么是进程？什么是线程？
	进程是一个应用程序（1个进程是一个软件）。
	线程是一个进程中的执行场景/执行单元。
	一个进程可以启动多个线程。

4.2、对于java程序来说，当在DOS命令窗口中输入：
	java HelloWorld 回车之后。
	会先启动JVM，而JVM就是一个进程。
	JVM再启动一个主线程调用main方法。
	同时再启动一个垃圾回收线程负责看护，回收垃圾。
	最起码，现在的java程序中至少有两个线程并发，
	一个是垃圾回收线程，一个是执行main方法的主线程。

4.3、进程和线程是什么关系？举个例子

	阿里巴巴：进程
		马云：阿里巴巴的一个线程
		童文红:阿里巴巴的一个线程
	
	京东：进程
		强东：京东的一个线程
		妹妹：京东的一个线程
	
	进程可以看做是现实生活当中的公司。
	线程可以看做是公司当中的某个员工。

	注意：
		进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享的！）
			魔兽游戏是一个进程
			酷狗音乐是一个进程
			这两个进程是独立的，不共享资源。

		线程A和线程B呢？
			在java语言中：
				线程A和线程B，堆内存和方法区内存共享。
				但是栈内存独立，一个线程一个栈。
		
			假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，
			互不干扰，各自执行各自的，这就是多线程并发。
		
		火车站，可以看做是一个进程。
		火车站中的每一个售票窗口可以看做是一个线程。
		我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。
		所以多线程并发可以提高效率。

		java中之所以有多线程机制，目的就是为了提高程序的处理效率。

4.4、思考一个问题：
	使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束。
	main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在
	压栈弹栈。

4.5、分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？

	对于多核的CPU电脑来说，真正的多线程并发是没问题的。
		4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。

	什么是真正的多线程并发？
		t1线程执行t1的。
		t2线程执行t2的。
		t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。

	单核的CPU表示只有一个大脑：
		不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。
		对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于
		CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情
		同时在做！！！！！
			线程A：播放音乐
			线程B：运行魔兽游戏
			线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，
			给我们的感觉是同时并发的。
	
	电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，
	人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像
	一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在
	这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

5、java语言中，实现线程有两种方式，那两种方式呢？

java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。

第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。
	// 定义线程类
	public class MyThread extends Thread{
		public void run(){
		
		}
	}
	// 创建线程对象
	MyThread t = new MyThread();
	// 启动线程。
	t.start();

第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法。
	// 定义一个可运行的类
	public class MyRunnable implements Runnable {
		public void run(){
		
		}
	}
	// 创建线程对象
	Thread t = new Thread(new MyRunnable());
	// 启动线程
	t.start();

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承
其它的类，更灵活。

6、关于线程对象的生命周期？
新建状态
就绪状态
运行状态
阻塞状态
死亡状态

day33课堂笔记

1、(这部分内容属于了解)关于线程的调度

1.1、常见的线程调度模型有哪些？

	抢占式调度模型：
		那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
		java采用的就是抢占式调度模型。

	均分式调度模型：
		平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
		平均分配，一切平等。
		有一些编程语言，线程调度模型采用的是这种方式。

1.2、java中提供了哪些方法是和线程调度有关系的呢？

	实例方法：
		void setPriority(int newPriority) 设置线程的优先级
		int getPriority() 获取线程优先级
		最低优先级1
		默认优先级是5
		最高优先级10
		优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）
	
	静态方法：
		static void yield()  让位方法
		暂停当前正在执行的线程对象，并执行其他线程
		yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
		yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
		注意：在回到就绪之后，有可能还会再次抢到。
	
	实例方法：
		void join()  
		合并线程
		class MyThread1 extends Thread {
			public void doSome(){
				MyThread2 t = new MyThread2();
				t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
			}
		}

		class MyThread2 extends Thread{
			
		}

2、关于多线程并发环境下，数据的安全问题。

2.1、为什么这个是重点？
	以后在开发中，我们的项目都是运行在服务器当中，
	而服务器已经将线程的定义，线程对象的创建，线程
	的启动等，都已经实现完了。这些代码我们都不需要
	编写。

	最重要的是：你要知道，你编写的程序需要放到一个
	多线程的环境下运行，你更需要关注的是这些数据
	在多线程并发的环境下是否是安全的。（重点：*****）

2.2、什么时候数据在多线程并发的环境下会存在安全问题呢？
	三个条件：
		条件1：多线程并发。
		条件2：有共享数据。
		条件3：共享数据有修改的行为。

	满足以上3个条件之后，就会存在线程安全问题。

2.3、怎么解决线程安全问题呢？
	当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在
	线程安全问题，怎么解决这个问题？
		线程排队执行。（不能并发）。
		用排队执行解决线程安全问题。
		这种机制被称为：线程同步机制。

		专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。
	
	怎么解决线程安全问题呀？
		使用“线程同步机制”。
	
	线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全
	第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

2.4、说到线程同步这块，涉及到这两个专业术语：

	异步编程模型：
		线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，
		谁也不需要等谁，这种编程模型叫做：异步编程模型。
		其实就是：多线程并发（效率较高。）

		异步就是并发。

	同步编程模型：
		线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行
		结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，
		两个线程之间发生了等待关系，这就是同步编程模型。
		效率较低。线程排队执行。

		同步就是排队。

3、Java中有三大变量？【重要的内容。】

实例变量：在堆中。

静态变量：在方法区。

局部变量：在栈中。

以上三大变量中：
	局部变量永远都不会存在线程安全问题。
	因为局部变量不共享。（一个线程一个栈。）
	局部变量在栈中。所以局部变量永远都不会共享。

实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

4、如果使用局部变量的话：
建议使用：StringBuilder。
因为局部变量不存在线程安全问题。选择StringBuilder。
StringBuffer效率比较低。

ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
Hashtable是线程安全的。

5、总结：
synchronized有三种写法：

	第一种：同步代码块
		灵活
		synchronized(线程共享对象){
			同步代码块;
		}

	第二种：在实例方法上使用synchronized
		表示共享对象一定是this
		并且同步代码块是整个方法体。
	
	第三种：在静态方法上使用synchronized
		表示找类锁。
		类锁永远只有1把。
		就算创建了100个对象，那类锁也只有一把。
	
	对象锁：1个对象1把锁，100个对象100把锁。
	类锁：100个对象，也可能只是1把类锁。

6、聊一聊，我们以后开发中应该怎么解决线程安全问题？

是一上来就选择线程同步吗？synchronized
	不是，synchronized会让程序的执行效率降低，用户体验不好。
	系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
	线程同步机制。

第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，
对象不共享，就没有数据安全问题了。）

第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候
就只能选择synchronized了。线程同步机制。

7、线程这块还有那些内容呢？列举一下
7.1、守护线程
7.2、定时器
7.3、实现线程的第三种方式：FutureTask方式，实现Callable接口。（JDK8新特性。）
7.4、关于Object类中的wait和notify方法。（生产者和消费者模式！）

1、线程这块还有那些内容呢？列举一下

1.1、守护线程

	java语言中线程分为两大类：
		一类是：用户线程
		一类是：守护线程（后台线程）
		其中具有代表性的就是：垃圾回收线程（守护线程）。

	守护线程的特点：
		一般守护线程是一个死循环，所有的用户线程只要结束，
		守护线程自动结束。
	
	注意：主线程main方法是一个用户线程。

	守护线程用在什么地方呢？
		每天00:00的时候系统数据自动备份。
		这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
		一直在那里看着，没到00:00的时候就备份一次。所有的用户线程
		如果结束了，守护线程自动退出，没有必要进行数据备份了。

1.2、定时器
	定时器的作用：
		间隔特定的时间，执行特定的程序。

		每周要进行银行账户的总账操作。
		每天要进行数据的备份操作。

		在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
		那么在java中其实可以采用多种方式实现：
			
			可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行
			任务。这种方式是最原始的定时器。（比较low）

			在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。
			不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持
			定时任务的。

			在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
			这个框架只要进行简单的配置，就可以完成定时器的任务。


1.3、实现线程的第三种方式：实现Callable接口。（JDK8新特性。）
	这种方式实现的线程可以获取线程的返回值。
	之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

	思考：
		系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
		会有一个执行结果，我们怎么能拿到这个执行结果呢？
			使用第三种方式：实现Callable接口方式。


1.4、关于Object类中的wait和notify方法。（生产者和消费者模式！）

	第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象
	都有的方法，因为这两个方式是Object类中自带的。
		wait方法和notify方法不是通过线程对象调用，
		不是这样的：t.wait()，也不是这样的：t.notify()..不对。
	
	第二：wait()方法作用？
		Object o = new Object();
		o.wait();

		表示：
			让正在o对象上活动的线程进入等待状态，无期限等待，
			直到被唤醒为止。
			o.wait();方法的调用，会让“当前线程（正在o对象上
			活动的线程）”进入等待状态。

	第三：notify()方法作用？
		Object o = new Object();
		o.notify();

		表示：
			唤醒正在o对象上等待的线程。
		
		还有一个notifyAll()方法：
			这个方法是唤醒o对象上处于等待的所有线程。

day34课堂笔记

2、反射机制（比较简单，因为只要会查帮助文档，就可以了。）

2.1、反射机制有什么用？
	通过java语言中的反射机制可以操作字节码文件。
	优点类似于黑客。（可以读和修改字节码文件。）
	通过反射机制可以操作代码片段。（class文件。）

2.2、反射机制的相关类在哪个包下？
	java.lang.reflect.*;

2.3、反射机制相关的重要的类有哪些？

	java.lang.Class：代表整个字节码，代表一个类型，代表整个类。

	java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。

	java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法

	java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。

	java.lang.Class：
		public class User{
			// Field
			int no;

			// Constructor
			public User(){
			
			}
			public User(int no){
				this.no = no;
			}

			// Method
			public void setNo(int no){
				this.no = no;
			}
			public int getNo(){
				return no;
			}
		}

3、关于JDK中自带的类加载器：（聊一聊，不需要掌握，知道当然最好！）
3.1、什么是类加载器？
专门负责加载类的命令/工具。
ClassLoader

3.2、JDK中自带了3个类加载器
	启动类加载器:rt.jar
	扩展类加载器:ext/*.jar
	应用类加载器:classpath

3.3、假设有这样一段代码：
	String s = "abc";
	
	代码在开始执行之前，会将所需要类全部加载到JVM当中。
	通过类加载器加载，看到以上代码类加载器会找String.class
	文件，找到就加载，那么是怎么进行加载的呢？

		首先通过“启动类加载器”加载。
			注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar
			rt.jar中都是JDK最核心的类库。
		
		如果通过“启动类加载器”加载不到的时候，
		会通过"扩展类加载器"加载。
			注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar


		如果“扩展类加载器”没有加载到，那么
		会通过“应用类加载器”加载。
			注意：应用类加载器专门加载：classpath中的类。

3.4、java中为了保证类加载的安全，使用了双亲委派机制。
	优先从启动类加载器中加载，这个称为“父”
	“父”无法加载到，再从扩展类加载器中加载，
	这个称为“母”。双亲委派。如果都加载不到，
	才会考虑从应用类加载器中加载。直到加载
	到为止。

1、回顾反射机制

1.1、什么是反射机制？反射机制有什么用？
	反射机制：可以操作字节码文件
	作用：可以让程序更加灵活。

1.2、反射机制相关的类在哪个包下？
	java.lang.reflect.*;

1.3、反射机制相关的主要的类？
	java.lang.Class
	java.lang.reflect.Method;
	java.lang.reflect.Constructor;
	java.lang.reflect.Field;

1.4、在java中获取Class的三种方式？
	第一种：	 
		Class c = Class.forName("完整类名");
	第二种：
		Class c = 对象.getClass();
	第三种：
		Class c = int.class;
		Class c = String.class;

1.5、获取了Class之后，可以调用无参数构造方法来实例化对象

	//c代表的就是日期Date类型
	Class c = Class.forName("java.util.Date");

	//实例化一个Date日期类型的对象
	Object obj = c.newInstance();

	一定要注意：
		newInstance()底层调用的是该类型的无参数构造方法。
		如果没有这个无参数构造方法会出现"实例化"异常。

1.6、如果你只想让一个类的“静态代码块”执行的话，你可以怎么做？
	Class.forName("该类的类名");
	这样类就加载，类加载的时候，静态代码块执行！！！！
	在这里，对该方法的返回值不感兴趣，主要是为了使用“类加载”这个动作。

1.7、关于路径问题？

	String path = Thread.currentThread().getContextClassLoader()
					  .getResource("写相对路径，但是这个相对路径从src出发开始找").getPath();	

	String path = Thread.currentThread().getContextClassLoader()
					  .getResource("abc").getPath();	//必须保证src下有abc文件。

	String path = Thread.currentThread().getContextClassLoader()
					  .getResource("a/db").getPath();	//必须保证src下有a目录，a目录下有db文件。
	
	String path = Thread.currentThread().getContextClassLoader()
					  .getResource("com/bjpowernode/test.properties").getPath();	
					  //必须保证src下有com目录，com目录下有bjpowernode目录。
					  //bjpowernode目录下有test.properties文件。

	这种方式是为了获取一个文件的绝对路径。（通用方式，不会受到环境移植的影响。）
	但是该文件要求放在类路径下，换句话说：也就是放到src下面。
	src下是类的根路径。

	直接以流的形式返回：
	InputStream in = Thread.currentThread().getContextClassLoader()
							.getResourceAsStream("com/bjpowernode/test.properties");

1.8、IO + Properties，怎么快速绑定属性资源文件？

	//要求：第一这个文件必须在类路径下
	//第二这个文件必须是以.properties结尾。
	ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/test");
	String value = bundle.getString(key);

2、今日反射机制的重点内容
2.1、通过反射机制访问对象的某个属性。
2.2、通过反射机制调用对象的某个方法。
2.3、通过反射机制调用某个构造方法实例化对象。
2.4、通过反射机制获取父类以及父类型接口。

day35课堂笔记

3、注解

3.1、注解，或者叫做注释类型，英文单词是：Annotation
	疑问：注解到底是干啥的？？？？？？？？？

3.2、注解Annotation是一种引用数据类型。编译之后也是生成xxx.class文件。

3.3、怎么自定义注解呢？语法格式？

	 [修饰符列表] @interface 注解类型名{

	 }

3.4、注解怎么使用，用在什么地方？

	第一：注解使用时的语法格式是：
		@注解类型名
	
	第二：注解可以出现在类上、属性上、方法上、变量上等....
	注解还可以出现在注解类型上。

3.5、JDK内置了哪些注解呢？

	java.lang包下的注释类型：

		掌握：
		Deprecated 用 @Deprecated 注释的程序元素，
		不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。 

		掌握：
		Override 表示一个方法声明打算重写超类中的另一个方法声明。 

		不用掌握：
		SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的
		所有程序元素）中取消显示指定的编译器警告。 

3.6、元注解
	什么是元注解？
		用来标注“注解类型”的“注解”，称为元注解。

	常见的元注解有哪些？
		Target
		Retention
	
	关于Target注解：
		这是一个元注解，用来标注“注解类型”的“注解”
		这个Target注解用来标注“被标注的注解”可以出现在哪些位置上。

		@Target(ElementType.METHOD)：表示“被标注的注解”只能出现在方法上。
		@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})
			表示该注解可以出现在：
				构造方法上
				字段上
				局部变量上
				方法上
				....
				类上...
	
	关于Retention注解：
		这是一个元注解，用来标注“注解类型”的“注解”
		这个Retention注解用来标注“被标注的注解”最终保存在哪里。

		@Retention(RetentionPolicy.SOURCE)：表示该注解只被保留在java源文件中。
		@Retention(RetentionPolicy.CLASS)：表示该注解被保存在class文件中。
		@Retention(RetentionPolicy.RUNTIME)：表示该注解被保存在class文件中，并且可以被反射机制所读取。
	
3.7、Retention的源代码

		//元注解	
		public @interface Retention {
			//属性
			RetentionPolicy value();
		}
		
	RetentionPolicy的源代码：
		public enum RetentionPolicy {
			 SOURCE,
			 CLASS,
			 RUNTIME
		}

		//@Retention(value=RetentionPolicy.RUNTIME)
		@Retention(RetentionPolicy.RUNTIME)
		public @interface MyAnnotation{}



3.8、Target的源代码
	

3.9、注解在开发中有什么用呢？

	需求：
		假设有这样一个注解，叫做：@Id
		这个注解只能出现在类上面，当这个类上有这个注解的时候，
		要求这个类中必须有一个int类型的id属性。如果没有这个属性
		就报异常。如果有这个属性则正常执行！

4、JDK新特性
后续。。。。。。。

附录:
所有课堂源代码