javaSE零基础学习笔记

1、计算机结构：

计算机包括：
	* 硬件
		- CPU：中央处理器，负责计算机的核心运算，它是计算机的最核心部件，指挥官。 1 + 1 = 2
		- 内存：临时存储区域，程序在运行的过程当中，一些数据的临时存储区域。
		- 主板：链接各个部件
		- 显卡
		- 声卡
		- 鼠标
		- 键盘
		- 硬盘【外存】：永久性保存，断电之后再启动，数据仍然存在。
		.....

	* 软件
		- 系统软件
			* windows系列的
				- winxp
				- win7
				....

			* Linux系列的
				- Red Hat
				- Fedora
				- SUN Solaris
				....


		- 应用软件
			* QQ
			* 百度云管家
			* Office办公软件
			.....

	总结：
		应用软件是运行在系统软件当中的，系统软件和底层硬盘交互。

2、Java编程语言可以：完成应用软件的开发。

3、安装一个功能比记事本强大的文本编辑器，可以选择：
* Sublim
* EditPlus【我们这里选择】
* UtralEdit
…

4、安装软件EditPlus：
* 需要注意：
- 安装到哪个目录了
- 不要安装额外的插件
- 安装路径中最好不要有中文
…

5、windows操作系统默认情况下是不显示文件扩展名的，作为程序员必须将文件的扩展名显示出来：
* 计算机 --> 组织 --> 文件夹和搜索选项 --> 查看 --> 隐藏已知文件类型的扩展名【对勾去掉】

6、EditPlus工具的设置：
* windows操作系统当中.txt文件统一采用EditPlus工具打开：设置文件的默认打开程序
* 去除EditPlus工具的默认备份
* 设置EditPlus的字体大小
* 设置EditPlus缩进字符：3
工具 --> 首选项 --> ???

7、windows操作系统当中常用的DOS命令：

* 不使用UI界面，使用DOS命令可以完成所有的操作。

* 在哪里执行DOS命令？
	- 在DOS命令窗口中可以执行DOS命令

* 怎么打开DOS命令窗口呢？
	- 快捷键：win + r，打开运行窗口
	- 输入cmd回车

* 查看IP地址：
	- ipconfig
	- ipconfig /all  可以查看更详细的IP信息，这种查看方式可以看到网卡的物理地址。
						  物理地址具有全球唯一性。是在生产网卡的时候，嵌入的编号。
* 清屏：
	cls

* DOS窗口当中也可以设置字体和屏幕以及文字的颜色。

* 退出DOS命令窗口
	exit

* 怎么从DOS命令窗口当中复制文本：
	任意位置点击鼠标右键-->标记 --> 选择你要复制的文本 --> 点击鼠标右键 （此时已经到剪贴板当中了）
	找一个位置粘贴即可。

* 查看两台计算机之间是否可以正常通信：
	- ping 192.168.27.23   【发送和接收数据包4次】
	- ping 192.168.27.23 -t 【一直不停的发送和接收数据包】
	- ping www.baidu.com

	登录百度：http://119.75.218.70

* 强行终止DOS命令窗口中正在运行的程序：ctrl + c

* 打开DOS命令窗口默认所在的路径是：C:\Users\Administrator\???

* 创建目录：mkdir abc【表示在当前所在目录下新建一个目录，起名abc】

* 关于目录切换命令：cd

	- cd 命令的语法格式：

		cd 路径

	- 路径分为：

		- 绝对路径：
			C:\Users\Administrator
			D:\用户目录\收藏夹
			F:\tools\CamtasiaStudio-v6.00
			......

			从硬盘的根路径作为出发点。

		- 相对路径：
			从当前所在的位置作为起点的路径。
	
	- 自动补全：
		cd e 【然后按tab键，当前所在的目录下所有以e开始的目录自动补全路径，
			   当这个自动补全的路径不是自己想要的路径，可以继续使用tab键】
	
	- 回到上级目录：cd .. 【..是一个路径，代表当前路径的上级路径】
			cd ../../../

	- 直接回到根路径：cd \

* 查看当前目录下所有的子文件和子目录：
	dir

* 不要把相关重要的资料放到桌面上，因为桌面是属于C盘系统盘。

* 怎么切换盘符：【不需要使用cd命令】
	c: 回车
	d: 回车
	e: 回车 
	f: 回车

* 打开注册表：
	regedit

8、关于windows操作系统当中常用的快捷键：
* win + r 打开运行窗口
* win + d 显示桌面
* win + e 打开资源管理器
* win + L 锁屏
* alt + tab 应用之间的切换

9、“通用的”文本编辑快捷键：
* ctrl + a 全选
* ctrl + c 复制
* ctrl + v 粘贴
* ctrl + s 保存
* ctrl + x 剪切
* ctrl + z 撤销
* ctrl + y 重做
* tab 缩进/多行缩进
* shift + tab 取消缩进
* HOME 回到行首
* END 回到行尾
* shift + home 选中一行
* shift + end 选中一行
* ctrl + shift + 向右或者向左的箭头 选中一个单词
* 鼠标双击：选中一个单词
* 鼠标三击：选中一行
* ctrl + end 回到文件末尾
* ctrl + home 回到文件头

10、什么是JDK？
* Java Development Kits
* Java开发工具箱【Java开发必备】
* 可以从Oracle的官网上下载。http://www.oracle.com
* 目前2016-08-30最高版本Java8【Java SE 8u101 / 8u102】
* 下载JDK的时候需要注意：JDK的版本，不同的操作系统需要安装不同版本的JDK。

11、Java分三大块：1999年

* J2SE【Java的标准版本】：

	基础，无论是以后走EE还是ME，SE是必须要精通的。
	J2SE是SUN公司为java程序员准备的一套“基础类库”，这套基础类库学习之后，可以完成最基本的操作，
	例如，文件的读写、线程的控制....

* J2EE【Java的企业版本】：

	这是SUN公司为程序员专门准备的一套“类库”，这套类库可以协助程序员完成企业级软件的开发
	企业级软件：OA办公系统、进销存系统、超市系统.......

* J2ME【Java的微型版本】
	
	这是SUN公司为java程序员专门准备的另一套“类库”，这套类库可以协助程序员完成微型设备的嵌入式开发，
	Java最初就是做微型设备嵌入式开发的。

12、2005年，java诞生十周年的时候，以上的三大模块改名了：
* JavaSE
* JavaEE
* JavaME

13、关键术语：
* JDK【Java开发工具箱】
* JRE【Java的运行时环境】
* JVM【Java虚拟机】

三者之间的关系：
	JDK 中包含JRE，JRE中包含JVM。

14、Java语言特性：

* 跨平台/可移植 
	- 有一种特殊的机制：JVM
	- Java程序并没有和底层的操作系统直接交互，java程序实际上运行在jvm当中，JVM屏蔽了操作系统之间的差异。
	- 但是有一个前提：不同的操作系统中必须安装不同版本的JVM。
	- 在可移植性方面表现非常好，一次编译，到处运行。
	- 但是为了达到可移植，必须提前在操作系统中安装JRE，JRE有了之后才会有JVM。【JVM不能单独安装】
	这方面体验不是特别好。

* Java号称：开源、免费、跨平台、纯面向对象。

	- 开源：开发源代码，SUN公司编写的java类库的源代码普通程序员能看到。众人拾柴火焰高。
	这样java程序会很健壮。很少的BUG【漏洞/陷阱】

	- 免费

	- 跨平台：依靠JVM机制【java程序不和操作系统交互，java程序运行在JVM中，JVM和操作系统交互。】
	不同的操作系统有不同版本的JVM。

	- 面向对象：人类在认识现实世界的时候多数是以面向对象的方式认知的。

* 简单性：
	* 这里的简单说的是相对于C语言来说的。
	* 例如：C语言当中有指针，C++中多继承
	* java取消了指针的概念，取消了多继承，只支持单继承。
	.....

* java支持多线程

* java中还有一种特殊的机制：自动垃圾回收机制。GC机制。
	【java运行过程当中有一个“垃圾回收器”一直在守护者。】

....

15、Java的加载与执行：一个完整的java程序

* Java开发的整个生命周期，包括两个重要的阶段，分别是：编译阶段和运行阶段

* 编译生成的程序被称为：字节码程序。编译生成的文件是：xxx.class文件

* 编译和运行可以在不同的操作系统中完成。

* 程序员在xxx.java文件中编写源代码，源代码必须符合java的语法，这些源代码就是高级语言。
存放源代码的文件被称为源文件。

* 过程：

	编译期：【在windows环境中完成】
		- 安装JDK，配置环境
		- 在硬盘的某个位置创建一个xxx.java源文件
		- 打开源文件，在该文件当中编写符合java语法的源程序，然后保存。
		- 使用JDK中自带的javac.exe命令对以上的java源程序进行编译。
			* 编译通过：说明语法没有问题
				- 在硬盘上生成一个或者多个字节码文件【xxx.class】
			* 编译失败：说明源程序某个位置不符合java语法格式。
			* 编译的语法格式：打开DOS命令窗口，输入：javac 源文件路径

			注意：
				- 源文件路径可以是绝对路径，也可以是相对路径。
				- 编译之后，其实java源文件删除不会影响程序的执行。
				- 最好不要将java源文件删除，因为程序最终运行效果不是预期效果的时候，需要
				重新修改java源代码，然后进行重新编译生成全新的class字节码文件，再重新运行
				字节码程序。

	---------------------------------------------------------------------------

	运行期：【可以不在windows中完成，可以换一个操作系统，但前提是该操作系统中已经安装java的运行时环境】

		- 打开命令窗口，在命令窗口中使用java.exe命令运行java程序，语法格式：
			java 类名

			注意：java这个命令使用的时候，java命令后面不是文件的路径。必须是一个“类名”。
			例如：
				java Hello  
				java Student
				java User
				java Product

		- 以上程序的执行原理：
			* java.exe命令执行会启动：JVM
			* JVM启动之后，马上启动“类加载器-Class Loader”
			* ClassLoader负责去硬盘的“某个位置”上搜索“类名.class”字节码文件。
			* 找不到这个.class文件，一定会出现程序异常现象。
			* 找到了这个.class文件之后将.class文件转换成"二进制"，操作系统可以直接识别二进制，
			操作系统执行二进制码和底层的硬件平台进行交互。

16、什么是类名？
* 假设硬盘上有一个文件，叫做Hello.class，那么类名就叫做：Hello
* 假设硬盘上有一个文件，叫做Student.class，那么类名就叫做：Student
* 假设硬盘上有一个文件，叫做User.class，那么类名就叫做：User
* 假设硬盘上有一个文件，叫做Product.class，那么类名就叫做：Product
…
…

17、开始第一个java程序的开发

* JDK下载

* JDK安装
	- 只安装了JDK，独立的JRE没有安装

* 在硬盘的某个位置上新建一个java源文件：HelloWorld.java

* 在HelloWorld.java文件中编写源代码

* 打开命令窗口，使用javac命令进行编译：
	javac 源文件路径

	出现以下错误：
		C:\Users\Administrator>javac
		'javac' 不是内部或外部命令，也不是可运行的程序
		或批处理文件。
	
	怎么解决？

		第一种方案：切换到javac.exe文件所在的目录，这个时候使用javac.exe不会出问题，但是这种方式比较麻烦。

		第二种方案：配置环境变量path
	
	原理：windows操作系统在查找某个命令的时候是怎么查找的？
		* 首先会从当前目录下找这个命令
		* 当前目录下不存在这个命令的话，会去环境变量path指定的路径当中查找该命令。
		* 还是找不到则出现错误提示信息。

		- path环境变量隶属于windows操作系统，和java无关，这个环境变量主要用来指定命令的搜索路径。
	
	环境变量怎么配置？

		计算机 --> 点击右键 --> 属性 --> 高级系统设置 --> 环境变量

	环境变量配置包括用户级别和系统级别

	任何一个环境变量都有变量名和变量值，例如path环境变量：
		变量名是:path
		值：路径【多个路径之间必须采用分号隔开，而且要求分号必须是半角分号】
		path=C:\Program Files (x86)\Java\jdk1.7.0_75\bin;otherpath;otherpath.....

	编译1【绝对路径】：D:\course\JavaProjects>javac D:\course\JavaProjects\02-JavaSE\day01\HelloWorld.java
	编译2【相对路径】：D:\course\JavaProjects>javac 02-JavaSE\day01\HelloWorld.java
	编译3【相对路径】：D:\course\JavaProjects\02-JavaSE\day01>javac HelloWorld.java

* 运行：
	- 必须将路径切换到“D:\course\JavaProjects\02-JavaSE\day01”目录下
	- 执行：java HelloWorld

	- D:\course\JavaProjects\02-JavaSE\day01>java HelloWorld
		Hello World!

day02-课堂笔记

1、打开DOS命令窗口，执行java HelloWorld，执行原理？
* java.exe命令会启动JVM
* JVM启动之后会启动类加载器ClassLoader
* ClassLoader会在硬盘上的某个位置搜索HelloWorld.class字节码文件
* 找到该文件则执行
* 找不到该文件则报错

疑问:ClassLoader是在哪个位置上搜索HelloWorld.class字节码文件的？
	* 默认情况下，ClassLoader从当前路径下加载xxx.class字节码文件
	* 当然，也可以让ClassLoader去某个指定的路径下加载字节码文件，这时需要配置环境变量classpath
	* classpath环境变量属于java语言中的环境变量，不属于windows操作系统【path环境变量属于操作系统】
	* classpath是给ClassLoader类加载器指路的。
	* 设置这样的环境变量：classpath=D:\course\JavaProjects\02-JavaSE\day02
		- 打开dos命令窗口在任意位置，都可以执行：java HelloWorld
	* classpath环境变量没有配置的话，类加载器默认从当前路径下找字节码文件，
	当classpath环境变量配置为某个指定的路径之后，类加载器只去指定的路径当中加载字节码文件。
	* 综上所述，环境变量classpath不再配置，这样类加载器会自动从当前路径下加载class字节码文件。
	所以，每一次执行.class程序的时候，需要在DOS命令窗口中先切换到.class字节码文件所在的路径下。
	然后运行。
	* 当然，classpath也可以这样配置：classpath=.

	注意：
		路径中“..”表示上级目录
		路径中“.”表示当前目录

2、关于java源程序当中的注释：

* 什么是注释？注释的作用是什么？
	- 出现在java的源程序当中，对java源代码的解释说明
	- 注释不会被编译到.class字节码文件当中
	- 一个好的开发习惯应该是多编写注释，这样程序的可读性比较强。

* java中的注释怎么写呢？
	- 单行注释
		//单行注释，只注释当前行

	- 多行注释
		/*
			多行注释
			多行注释
			多行注释
			多行注释
			多行注释
			.....
		*/

	- javadoc注释((文档注释)
		/**

• 可以提供一些预设的注解
  * javadoc注释
  * javadoc注释
  * javadoc注释
  * javadoc注释
  * javadoc注释
  * javadoc注释
  */
  注意：这种注释是比较专业的注释，该注释信息会被javadoc.exe工具解析提取并生成帮助文档。

3、对HelloWorld程序进行解释：
需要记忆：
* public
* class
* static
* void
* System.out.println(""); 向控制台输出消息
* 类体
* 方法体
* 类体中不能直接编写java语句【除声明变量之外】
* 一个java语句必须以“;”结束
* 方法体中可以编写多条java语句
* 主方法是程序的入口，固定写法，SUN规定的。

4、public class 和 class的区别：

* 一个java源文件当中可以定义多个class

* 一个java源文件当中public的class不是必须的

* 一个class会定义生成一个xxx.class字节码文件

* 一个java源文件当中定义公开的类的话，只能有一个，并且该类名称必须和java源文件名称一致。

* 每一个class当中都可以编写main方法，都可以设定程序的入口，想执行B.class中的main方法：java B，
想执行X.class当中的main方法：java X

* 注意：当在命令窗口中执行java Hello，那么要求Hello.class当中必须有主方法。没有主方法会出现运行
阶段的错误：
	D:\course\JavaProjects\02-JavaSE\day02>java Hello
	错误: 在类 B 中找不到主方法, 请将主方法定义为:
		public static void main(String[] args)

5、总结第一章需要掌握的内容：
* 理解java的加载与执行
* 能够自己搭建java的开发环境
* 能够独立编写HelloWorld程序，编译并运行
* 掌握环境变量path的原理以及如何配置
* 掌握环境变量classpath的原理以及如何配置
* java中的注释
* public class 和 class 的区别

第二章：java语言基础

1、标识符
（1）什么是标识符？
*在java源程序当中凡是程序员有权利自己命名的单词都是标识符。
*标识符可以标识什么元素呢？
类名
方法名
变量名
接口名
常量名
…
（2）标识符的命名规则？【不按这个规则来，编译器会报错，这是语法】

*只能由“数字、字母、下划线_、美元符号$”组成，不能含有其他符号。
*不能数字开头。
*严格区分大小写。
*关键字不能做标识符。
*标识符不能包含空格。
*理论上无长度限制，但是最好不要太长。
（3）标识符的命名规则？【只是一种规范，不属于语法，不遵守规范编译器不会报错】
*最好见名知意

public class Userservice{
    public void login(String username,String password) {
    
	}
}

*遵守驼峰命名法
SystemService
UserService
CustomerService

包名：全部小写，多级包用.隔开。
举例：com.jourwon

类、接口：一个单词首字母大写，多个单词每个单词的首字母大写。
举例：Student,Car,HelloWorld

方法和变量：一个单词首字母小写，多个单词从第二个单词开始每个单词的首字母大写。
举例：age,maxAge,show(),getAge()

常量：如果是一个单词,所有字母大写，如果是多个单词,所有的单词大写,用下划线区分每个单词。
举例：DATE,MAX_AGE

项目名：全部用小写字母，多个单词之间用横杆-分割。
举例：demo，spring-boot

2、关键字
（1）什么是关键字？
-sun在开发Java语言的时候，提前制订好一些具有特定含义的字符序列。
-在语言当中具有特色含义的单词，这些单词构成Java程序的骨架，这些单词是需要记住的，不能随意编写，包括大小写。
（2）关键字在Java语言当中全部小写。
注：保留字：现在不是关键字，以后可能是关键字 eg：goto，const

3、字面值
（1）字面值：10\100 3.14 “abc” ‘a’ true\false
（2）字面值就是数据。
（3）字面值是java源程序的组成部分之一，包括标识符和关键字它们都是Java源程序的组成部分。
（4）数据在现实世界当中是分门别类的，所以数据在计算机编程语言当中也是有类型的：【数据类型】
10、100 属于整数型字面值
3.14 属于浮点型字面值
true、false 属于布尔型字面值
“abc”、“中国人” 属于字符串型字面值
‘A’、‘人’ 属于字符型字面值
（5）注意：Java语言当中所有的字符串型字面值必须使用双引号括起来，双引号是半角。
Java语言当中所有的字符型字面值必须使用单引号括起来，单引号是半角。

4、变量
（1）什么是变量？
*变量本质上来说是内存中的一块空间，这块空间有“数据类型”、“有名字”、“有字面值”。
*变量包含三部分：数据类型、名称、字面值【数据】。
*变量是内存中存储数据的最基本的单元。
（2）数据类型的作用？
*不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间。
*数据类型是指导程序在运行阶段应该分配多大的内存空间。
（3）变量要求：变量中存储的具体的“数据”必须和变量的“数据类型”一致，当不一致的时候报错。
（4）声明/定义变量的语法格式：
数据类型 变量名;
*变量名：
只要是合法的标识符就行，规范中要求：首字母小写，后面每个单词的首字母大写。
例如：
int i;
int age;
int length;
int size;
其中int是数据类型，i、age、length、size都是变量名。
（5）变量声明之后怎么赋值？
语法格式：
变量名 = 字面值;
要求：字面值的数据类型必须和变量的数据类型一致。
“=”等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋值给左边的变量。
（6）声明和赋值可以放到一起完成。
int i = 10;
（7）变量赋值之后，可以重新赋值，变量的值可以变化。
int i = 10;
System.out.println(i);//10
i = 20;
System.out.println(i);//20
i = 100;
System.out.println(i);//100
（8）有了变量的概念之后，内存空间得到了重复的使用。
int i = 10;
System.out.println(i);
…

…
System.out.println(i);

（9）通常访问一个变量包括两种访问形式：
*第一种：读取变量中保存的数据 get/获取
*第二种：修改变量中保存的数据 set/设置

i = 20; //set

System.out.println(i); //get
（10）变量在一行上可以声明多个
int a,b,c;
（11）java中的变量必须先声明，再赋值，才能访问。

关于java语言中的变量：
（1）在方法体当中的代码，是遵守自上而下的顺序依次执行的、逐行执行。
第一行；
第二行；
第三行；
特点：第二行的代码必须完整的结束之后，第三行程序才能执行。
（2）在同一个“作用域”当中，变量名不能重名，但是变量可以重新赋值。

变量的作用域：
（1）什么是作用域？
变量的作用域，其实描述的就是变量的有效范围。
在什么范围之内是可以被访问的，只要出了这个范围该变量就无法访问了。
（2）变量的作用域只要记住一句话：
出了大括号就不认识了。

关于变量的分类：
（1）根据变量声明的位置来分类：
*局部变量
-在方法体当中声明的变量叫做局部变量。
*成员变量
-在方法体外【类体之内】声明的变量叫做成员变量。
（2）在不同的作用域当中，变量名是可以相同的。
（3）在同一个作用域当中，变量名不能重名。

5、数据类型
（1）数据类型的作用是什么？
程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。
数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。
（2）java中的数据类型包括两种：

• 基本数据类型
• 引用数据类型
  （3）关于基本数据类型：
  *基本数据类型包括四大类八小种：
  第一类：整数型
  byte、short、int、long
  第二类：浮点型
  float、double
  第三类：布尔型
  boolean
  第四类：字符型
  char
  （4）字符串“abc”不属于基本数据类型，属于“引用数据类型”。
  （5）八种基本数据类型各自占用空间大小是多少？
  基本数据类型 占用空间大小【单位：字节】

---

byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1
char 2
（6）计算机在任何情况下都只能识别二进制。【现代的计算机采用交流电的方式，接通和断开就两种状态，计算机只识别1和0，其他不认识】
（7）什么是二进制？
*数据的一种表现形式。十进制表示十进一原则。二进制表示二进一原则。
例如：十进制
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
例如：二进制
0 1 10 11 100 101 110 111 1000 1001 …
0 1 2 3 4 5 6 7 8 9
（8）字节（byte）：
1 Byte = 8 bit 【1个字节=8个比特位】1个比特位表示一个二进制位：1/0
1 kB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
.
1 TB = 1024 * 1024 * 1024 * 1024 *8
（9）整数型当中的byte类型，占用一个字节，所以byte类型的数据占用8个比特位。那么byte类型的取值范围是什么？
*关于byte类型中的数字类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制位被称为“符号位”，并且这个“符号位”在所有二进制位的最左边，0表示正数，1表示负数。
*byte类型最大值：01111111
【
00000000 00000000 00000000 10000000（二进制）
减去1的结果是：
00000000 00000000 00000000 01111111（二进制）
】
*byte类型最大值：2的7次方-1，结果是127
*byte类型最小值：-128
*byte类型取值范围：（-128～127）
*byte类型可以表示256个不同的数字【256个不同的二进制】
（10）二进制和十进制之间的转换规则：
*二进制转换成十进制
*十进制转换成二进制
（11）计算机只认识二进制，那么计算机是怎么表示现实世界当中的文字的呢？

   *八种基本数据类型当中，byte、short、int、long、float、double、boolean这七种数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和二进制之间存在一种固定的转换规则。

*但是八种数据类型当中的char类型表示的是现实世界中的文字，文字和计算机二进制之间“默认”情况下是不存在任何转换关系的。

*为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制订好“文字”和“二进制”之间的对照关系，这种对照转换关系被称为：字符编码。

*计算机最初只支持英文，最先出现的字符编码是：ASCII码。【采用一个字节编码】
‘a’ —> 97【01100001】
‘A’ —> 65
‘0’ —> 48

  ‘a’ ----（按照ASCII码解码）--> 01100001
  01100001 ---（按照ASCII码编码）--->‘a’

编码和解码的时候采用同一套字典/对照表，不会出现乱码。
当解码和编码的时候采用的不是同一套对照表，会出现乱码问题。
*随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，这种编码方式支持西欧语言，向上兼容ASCII码，仍然不支持中文。这种编码方式是：ISO-8859-1，又被称为latin-1。
*随着计算机向亚洲发展，计算机开始支持中文、日文、韩文等国家文字，其中支持简体中文的编码方式：
GB2312 < GBK < GB18030（按内存大小）
*支持繁体中文：大五码
*后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码。
具体实现：

• UTF-8
• UTF-16
• UTF-32
  …
  *Java语言采用的是哪一种编码方式呢？
  -java语言源代码采用的是unicode编码方式，所以“标识符”可以用中文。
  *现在实际开发中，一般使用UTF-8编码方式较多。【统一编码方式】
  （12）八种基本数据类型的取值范围：

类型           取值范围
byte            [ -128 ~ 127 ]  
short           [ -32768 ~ 32767 ]  
int             [ -2147483648 ~ 2147483647 ]    
long            
float
double
boolean         [ true,false ]
char            [ 0 ~ 65535 ] 
注意：short和char所表示的种类

数量是一样的，只不过char可以表示更大的正整数。因为char没有负数。

*关于八种数据类型的默认值

  数据类型                  默认值
  byte，short，int，long        0
  float，double                0.0
  boolean                     false【在C语言中，true是1，false是0】
  char                        \u0000

八种基本数据类型的默认值是一切向0看齐。

*关于java语言当中的char类型：
转义字符
转义字符出现在特殊字符之前，会将特殊字符转换成普通字符。

\n 换行符
\t 制表符
\’ 普通的单引号
\ 普通的双斜杠
\” 普通的双引号
JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式。

*关于java语言当中的整数型：

   数据类型      占用空间大小       默认值       取值范围
Byte              1                0        [ -128 ~ 127 ]
Short             2                0        [ -32768 ~ 32767 ] 
Int               4                0        [ -2147483648 ~ 2147483647 ]
Long              8                0L

1、java语言当中的“整数型字面值”被默认当作int类型来处理。要让这个“整数型字面值”被当做long类型来处理的话，需要在“整数型字面值”后面添加1/L，建议使用大写的L。
2、java语言当中的整数型字面值有三种表示方式：
第一种方式：十进制【是一种缺省默认的方式】常用
第二种方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
第三种方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】

*关于java语言当中的浮点型数据类型：
float 单精度【4个字节】
double 双精度【8个字节，精度较高】

double的精度太低【相对来说的】，不适合做财务软件。
财务涉及到钱的问题，要求精度较高，所以sun在se基础类库当中为程序员准备了精确度更高的类型，只不过这种类型是一种引用数据类型，不属于基本数据类型，它是java.math.BigDecimal。
其实java程序中sun提供了一套庞大的类库，java程序员是基于这套基础的类库来进行开发的。所以要知道java的se类库的字节码在哪儿，要知道java的se类库的源码在哪儿？
*se类库字节码：Mac book▸资源库▸Java▸JavaVirtualMachines▸jdk1.8.0_201.jdk▸ Contents▸Home▸jre▸lib\rt.jar
*se类库源码：Mac book▸资源库▸Java▸JavaVirtualMachines▸jdk1.8.0_201.jdk▸ Contents▸Home\src.zip
例如：String.java和String.class
我们的（String[] args）中的String使用的就是String.class字节码文件

在java语言当中，所有的浮点型字面值，默认被当做double类型来处理，要想该字面值当做float类型来处理，需要在字面值后面添加F/f。

注意：double和float在计算机内部二进制存储的时候存储的都是近似值。
在现实世界当中有一些数字是无限循环的，例如：3.3333333333…
计算机的资源是有限的，用有限的资源存储无限的数据只能存储近似值。

*关于java语言当中的布尔型数据类型：
boolean
在java语言当中boolean类型只有两个值：true、false，没有其他值。
不像C语言当中，0和1可以表示假和真。

在底层存储的时候boolean类型占用一个字节，因为实际存储的时候false底层是0，
true底层是1。

布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。

*关于基本数据类型之间的互相转换：转换规则
1、八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以互相转换。
2、小容量向大容量转换，称为自动类型转换，容量从小到大排序：
byte < short < int < long < float < double < char
注：任何浮点类型不管占用多少个字节，都比整数型容量大。
char和short可表示的种类数量相同，但是char可以取更大的正整数。
3、大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用。
4、当整数字面值没有超出byte，short，char的取值范围，可以直接赋值给byte，short，char类型的变量。
5、byte，short，char混合运算的时候，各自先转换成int类型再做运算。
6、多种数据类型混合运算，先转换成容量最大的那种类型再做运算。

*关于java编程中运算符之：算术运算符
+ 求和
- 相减
* 乘积
/ 商
% 取余数【取模】

 ++   自加1
 --    自减1

注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。没有必要去专门记忆运算符的优先级。
++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后，只要++运算符结束，该变量中的值一定会自加1。
++运算符出现在变量后，先做赋值运算，再对变量中保存的值进行自加1。
++运算符出现在变量前，先进行自加1运算，然后再进行赋值运算。

关系运算符：

>         大于     
>=        大于等于
<         小于
<=        小于等于
==        等于
!=        不等于
=         是赋值运算
==        是关系运算符

关系运算符的运算结果一定是布尔类型：false/true

关系运算符的运算原理：
int a = 10;
int b = 10;
a>b比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。
a==b也是如此。

逻辑运算符：

&     逻辑与【并且】（两边的算子都是true，结果才是true）
|     逻辑或【或者】（两边的算子只要有一个是true，结果就是true）
!     逻辑非（取反，!false就是true，!true就是false，这是一个单目运算符）
^     逻辑异或（两边的算子只要不一样，结果就是true） 

&&    短路与
||    短路或

1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
2、短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象。
3、短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象。
4、什么情况下发生短路现象呢？
什么情况下发生短路或？
*第一个表达式执行结果是true，会发生短路或。
什么情况下发生短路与？
*第一个表达式执行结果是false，会发生短路与。
5、什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？
从某个角度来看，短路与更智能。由于后面的表达式可能不执行，所以执行效率较高。这种方式在实际的开发中使用较多。短路与比逻辑与使用的多，短路与更常用。
但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的表达式不执行。

关于java中的赋值类运算符：
赋值类运算符包括两种：
*基本的赋值运算符
=
*扩展的赋值运算符
+= 等同于：i = i + 5;
-=
*=
/=
%=
1、赋值类运算符的优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量。
2、注意以下代码：
byte i = 10;
i += 5; 等同于：i = (byte)( i + 5 );

int k = 10;
K += 5; 等同于：k = (int)( k + 5 );

long x = 10L;
int y = 20;
y += x;等同于：y = (int)( y + k );
3、重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎样进行追加或追减，最终该变量的数据类型还是byte类型。

关于java中的“+”运算符：
1、+运算符在java语言当中有两个作用：

• 加法运算，求和
• 字符串的连接运算
  2、当“+”运算符两边的数据都是数字的话，一定是进行加法运算。
  3、当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。并且，连接运算之后的结果还是一个字符串类型。
  数字 + 数字 ——> 数字【求和】
  数字 + “字符串”——>“字符串”【字符串连接】
  4、在一个表达式当中可以出现多个“+”，在没有添加小括号的前提下，遵循自左向右的顺序依次运算。

关于java中的三元运算符/三目运算符/条件运算符：
1、语法规则：
布尔表达式？表达式1：表达式2
2、三元运算符的执行原理？
当布尔表达式的结果是true的时候，选择表达式1作为整个表达式的执行结果
当布尔表达式的结果是false的时候，选择表达式2作为整个表达式的执行结果

关于java语言当中的if语句，属于选择结构，if语句又被称为分支语句/条件控制语句：
1、if语句的语法结构：四种编写方法
第一种：

if(布尔表达式){
     java语句；
     java语句；
	 java 语句
     ......
}

第二种：

if(布尔表达式){
	java语句；
	java语句；
	......
} else {
	java语句；
	java语句；
  	......
}	

第三种：

if(布尔表达式){
	java语句；
    java语句；
	......
} else if (布尔表达式) {
	java语句；
	java语句；
	......
} else if (布尔表达式){
	java语句；
	java语句；
	......
}...... 

第四种：

if(布尔表达式) {
	java语句；
	java语句；
	......
} else if(布尔表达式) {
	java语句；
	java语句；
	......
} else if(布尔表达式) {
	java语句；
	java语句；
	......
} else {
	java语句；
	java语句；
	......
}

2、重点：对于java中的if语句来说，只要又一个分支执行，整个if语句全部结束。
3、注意：以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证会有分支执行。
4、“所有的控制语句”都是可以嵌套使用的。只要合理嵌套就行。
注意：嵌套使用的时候，代码格式要保证完美。【该缩进的时候必须缩进】
5、if语句的分支中只有一条java语句的话，大括号可以省略不写。
if(true/false) 一条java语句；【这种方式不推荐使用，别人这么写能看懂就行】

关于java语言中的switch语句：
1、switch语句也属于选择结构，也是分支语句
2、switch语句的语法结构：

 switch(int或string类型的字面值或变量){
       case int或string类型的字面值或变量;
            java语句;
            ......
            break;
       case int或string类型的字面值或变量;
            java语句;
            ......
            break;

       case int或string类型的字面值或变量;
            java语句;
            ......
            break;

       case int或string类型的字面值或变量;
            java语句;
            ......
            break;
        ......
       default:
            java语句;
            ......
}

3、switch语句的执行原理：
switch后面小括号当中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行。按照自上而下的顺序依次匹配。
4、匹配成功的分支执行，分支当中最后有“break;”语句的话，整个switch语句终止。
5、匹配成功的分支执行，分支当中没有“break;”语句的话，直接进入下一个分支执行（不进行匹配），这种现象被称为case穿透现象。【提供break;语句可以避免穿透】
6、所有分支都没有匹配成功，当有default语句时，会执行default分支当中的程序。
7、switch后面和case后面只能是int或string类型的数据，不能是探测其他类型。
*当然byte、short、char也可以直接写到switch和case后面，因为他们可以进行自动类型转换。byte、short、char可以自动转换成int类型。
*JDK6的，switch和case后面只能探测int类型。
*JDK7之后包括7版本在内，引入新特性，switch关键字和case关键字后面可以探测int或string类型的数据。
8、case可以合并：

int i = 10;
switch(i){
   case 1:case 2:case 3:case 10:
       System.out.println(“Test Code!”);
}

关于java语言中的for循环语句：
1、循环结构：
在程序当中总有一些需要反复的/重复的执行的代码，假设没有循环结构，那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复使用。所以多数编程语言都是支持循环结构的。将来把需要反复执行的代码片段放到“循环体”，再联合“计数器”，共同控制这段需要反复执行的代码。
2、基本上所有的编程语言支持的循环包括三种：
*for循环
*while循环
*do…while循环
3、for循环的语法结构：
for（初始化表达式；布尔表达式；更新表达式）{
//需要重复执行的代码片段【循环体：由java语句构成】
}
4、for循环的执行过程/执行原理：
4.1、初始化表达式、布尔表达式、更新表达式都不是必须的！【但是两个分号是必须的】
4.2、初始化表达式最先执行，并且在整个for循环当中只执行一次。
4.3、布尔表达式只能是true/false，不能是其他值。
4.4、for的执行过程
*先执行初始化表达式，并且该表达式只执行一次
*判断布尔表达式的结果是true还是false
- 布尔表达式true
* 执行循环体
* 执行更新表达式
* 判断布尔表达式的结果是true还是false
- 布尔表达式true
* 执行循环体
* 执行更新表达式
* 判断布尔表达式的结果是true还是false
…
- 布尔表达式false
* 循环结束
- 布尔表达式false
* 循环结束
- 布尔表达式false
* 循环结束

关于java语言中的while循环语句：
1、while语句的语法结构：

    while(布尔表达式) {
         循环体；  
	}

2、while循环的执行原理：
先判断布尔表达式的结果：
*true
-执行循环体
*判断布尔表达式的结果：
*true
-执行循环体
*判断布尔表达式的结果：
…
*false
-循环结束
*false
-循环结束
3、while循环的循环次数：
0～N次
注意：while循环的循环体可能执行次数为0次。

关于java语言中的do…while循环语句：
1、do…while循环的语法结构：

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

2、do…while循环的执行原理：
先执行循环体，再判断布尔表达式，若判断结果为真，则执行循环体，若判断结果为假，则循环结束。
3、do…while循环的执行次数：
do…while循环的循环体代码片段执行次数是：1～N次。【至少一次】
4、使用do…while循环的注意事项：
do…while循环语句最终有一个“分号”别丢了。

关于java控制语句当中的break语句：
1、break是java语言当中的关键字，被翻译为“中断/折断”
2、break + “;”可以成为一个单独的完整的java语句：break;
3、break语句使用在switch语句当中，用来终止switch的语句执行。
4、break语句同样可以使用在循环语句当中，用来终止循环的执行。
5、break;语句使用在for、while、do…while循环语句当中用来跳出循环，终止循环的执行。因为当程序循环到某个条件的时候，后续的循环没必要执行了，再执行也是耗费资源，所以可以终止循环，这样可以提高程序的执行效率。
6、在默认情况下：break终止的是离它最近的循环语句。当然也可以指定终止某个循环，需要给循环起名，采用这种语法：break 循环名称;

关于java控制语句当中的continue语句：
1、continue表示：继续/go on/下一个
2、continue也是一个continue关键字加一个分号构成一个单独的完整的java语句，主要出现循环语句当中用来控制循环的执行。
3、break和continue的区别：
*break表示循环不执行了，跳出循环，终止循环。
*continue表示终止当前“本次”循环，直接进入下一次循环继续执行。
4、continue也有这样的语法：
continue 循环名称;【作为了解内容】

关于java语言中的方法：
方法的本质是什么？
*方法就是一段代码片段，并且这段代码片段可以完成某个特定的功能，并且可以被重复的使用。

方法，对应的英语单词：Method
方法在c语言中叫做函数/Function

方法定义在类体当中，在一个类当中可以定义多个方法，方法编写的位置没有先后顺序，可以随意编写。

方法体当中不能再定义方法！！！

方法体由java语句构成，方法体当中的代码遵守自上而下的顺序执行。

1、方法怎么定义，语法结构：
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
2、对以上的语法结构进行解释说明：
2.1、关于修饰符列表
*可选项，不是必须的
*目前统一写成：public static【以后讲】
*方法的修饰符列表当中“有static关键字”的话，怎么调用这个方法？
-类名.方法名(实际参数列表);
2.2、返回值类型
*什么是返回值？
一个方法是可以完成某个特定功能的，这个功能结束之后大多数都是需要返回最终执行结果的，执行结果可能是一个具体存在的数据。而这个具体存在的数据就是返回值。

 *返回值类型？
    返回值是一个具体存在的数据，数据都是有类型的，此处需要指定的是返回值的具体类型。

 *返回值类型都可以指定那些类型呢？
    java任意一种类型都可以，包括基本数据类型和所有的引用数据类型。

 *也可能这个方法执行结束之后不返回任何数据，java中规定，当一个方法执行结束之后不返回任何数据的话，返回值类型位置必须编写：void关键字。

*返回值类型若不是void，表示这个方法执行结束之后必须返回一个具体的数值。当方法执行结束的时候没有返回任何数据的话，编译器报错。怎么返回值呢？代码怎么写呢？“return 值;”，并且要求“值”的数据类型必须和“方法的返回值类型”一致，不然编译器报错。

*返回值的类型是void的时候，在方法体当中不能编写“return 值;”这样的语句。但是要注意，可以编写“return;”这样的语句。

*只要带有return关键字的语句执行，return语句所在的方法结束。【不是JVM结束，是return所在的方法结束】
2.3、方法名：
*只要是合法的标识符就行
*方法名最好见名知意
*方法名最好是动词
*方法名首字母要求小写，后面每个单词首字母大写。

2.4、形式参数列表：简称形参
*形参是局部变量：int a；double b；float c；String s；…
*形参的个数可以是：0～N个
*多个形参之间用“逗号”隔开
*形参中起决定性作用的是形参的数据类型，形参的名字就是局部变量的名字。
*方法在调用的时候，实际给这个方法传递的真实数据被称为：实际参数，简称实参。
*实参列表和形参列表必须满足：
-数量相同
-类型对应相同

2.5、方法体必须由大括号括起来，方法体当中的代码有顺序，遵循自上而下的顺序依次执行。并且方法体由java语句构成，每一个java语句以“;”结尾。

3、方法怎么调用？
方法只定义不去调用是不会执行的，只有在调用的时候才会执行。
语法规则：<方法的修饰符列表当中有static>
类名.方法名(实参);<这是一条java语句，表示调用某个类的某个方法，传递这样的实参。>

*方法的调用不一定在main方法中，也可以在其他方法当中。只要是程序可以执行到的位置，都可以去调用其他方法。

*方法调用的时候实参和形参要求个数对应相同，数据类型对应相同。类型不同的时候要求能够进行相应的自动类型转换。

*有的时候“类名.”可以省略不写，什么情况下可以省略呢？
M1(){
M2();
}
M1方法和M2方法在同一个类体当中的时候，“类名.”可以省略不写。

重点：方法调用的时候，在参数传递的时候，实际上传递的是变量中保存的那个“值”传过去了。

方法的返回值不是void的时候注意：
1、返回值的类型不是void的时候：
要求方法必须保证百分之百的执行“return 值;”这样的语句来完成值的返回。
没有这个语句编译器会报错。
2、一个方法有返回值的时候，当我们调用这个方法，方法返回了一个值，对于调用者来说，这个返回值可以选择接收，也可以选择不接收。但是，大部分情况下我们都是选择接收的。
关于return语句：
*带有return关键字的java语句只要执行，所在的方法执行结束。

*在“同一个作用域”当中，return语句下面不能编写任何代码，因为这些代码永远都执行不到。所以编译报错。

*在返回值类型是void的方法当中使用“return;”语句。
“return;”语句出现在返回值为void的方法当中主要是为了用来结束当前方法。

方法在执行过程当中，在JVM中的内存是如何分配的呢，内存是如何变化的？

1、方法只定义，不调用，是不会执行的，并且在JVM中也不会给该方法分配“运行所属”的内存空间。只有在调用这个方法的时候，才会动态的给这个方法分配所属的内存空间。

2、在JVM内存划分上有这样三块主要的内存空间（当然除了这三块之外还有其他的内存空间）：
*方法区内存
*堆内存
*栈内存

3、关于“栈”数据结构：
*栈：stack，是一种数据结构。
*数据结构反应的是数据的存储形态。
*java程序员在不精通数据结构和算法的前提下，也可能进行java开发，因为java有一套庞大的类库支撑，别人写好了，直接用。【JavaSE当中的集合使用了大量的数据结构】

4、方法代码片段存在哪里？方法执行的时候执行过程的内存在哪里分配？

*方法代码片段属于.class字节码文件的一部分，字节码文件在类加载的时候，将其放到了方法区当中，所以JVM中的三块主要的内存空间中方法区内存最先有数据，存放了代码片段。

*代码片段虽然在方法区内存当中只有一份，但是可以被重复调用。每一次调用这个方法的时候，需要给该方法分配独立的活动场所，在栈内存中分配。【栈内存中分配方法运行的所属内存空间】

5、方法在调用的瞬间，会给该方法分配内存空间，会在栈中发生压栈动作，方法执行结束之后，给该方法分配的内存空间全部释放，此时发生弹栈作用。
*压栈：给方法分配内存
*弹栈：释放该方法的内存空间

6、局部变量在“方法体”中声明。局部变量在运行阶段内存在栈中分配。

JVM内存结构

关于方法的重载机制：
方法重载：
1、方法重载又被称为：overload

2、什么时候考虑使用方法重载？
*功能相似的时候，尽可能让方法名相同。
但是，功能不同/不相似的时候，尽可能让方法名不同。

3、什么条件满足之后构成了方法重载？
*在同一个类当中
*方法名相同
*参数列表不同：
-数量不同
-顺序不同
-类型不同

4、方法重载和什么有关系？和什么没关系？
*方法重载和方法名+参数列表有关系
*方法重载和返回值类型无关
*方法重载和修饰符列表无关

关于方法的递归调用：
1、什么是递归？
方法自身调用自身。
a( ) {
a( );
}

2、递归是很耗费栈内存的，递归算法可以不用的时候尽量别用。

3、java.lang.StackOverflowError
栈内存溢出错误。
错误发生无法挽回，只有一个结果，就是JVM停止工作。

4、递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误。

5、递归即使有了结束条件，即使结束条件是正确的，也可能会发生栈内存溢出错误，因为递归的太深了。【递归次数不能过多！】

注意：递归可以不使用尽量别使用。
但是有些情况下该功能的实现必须依靠递归方式。

递归原理图

第三章：面向对象【Java语言的核心机制，最重要的内容，Java语言的特色】

* 面向过程和面向对象的区别

	- 面向过程：主要关注点是：实现的具体过程，因果关系【集成显卡的开发思路】

		* 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。

		* 缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑，另外面向过程的
		方式导致软件元素之间的“耦合度”非常高，只要其中一环出问题，整个系统受到影响，
		导致最终的软件“扩展力”差。另外，由于没有独立体的概念，所以无法达到组件复用。

	- 面向对象：主要关注点是：主要关注对象【独立体】能完成哪些功能。【独立显卡的开发思路】

		* 优点：耦合度低，扩展力强。更容易解决现实世界当中更复杂的业务逻辑。组件复用性强。

		* 缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与设计。
	  
	- C语言是纯面向过程的、C++半面向对象、Java纯面向对象

	- 现在出现的一些新的编程语言多数都是面向对象的。人在认识现实世界的时候以面向对象的方式。

	- 面向对象更符合人的思维方式。


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

	所有面向对象的编程语言都有这三大特征。

	采用面向对象的方式开发一个软件，生命周期当中：【整个生命周期中贯穿使用OO面向对象方式】
		* 面向对象的分析：OOA
		* 面向对象的设计：OOD
		* 面向对象的编程：OOP

* 类和对象的概念

	* 什么是类？
		- 类在现实世界当中是不存在的，是一个模板，是一个概念。是人类大脑思考抽象的结果。
		- 类代表了一类事物。
		- 在现实世界当中，对象A与对象B之间具有共同特征，进行抽象总结出一个模板，这个模板被称为类。

	* 什么是对象？
		- 对象是实际存在的个体。现实世界当中实际存在。
	
	* 描述一下整个软件开发的过程：
		* 程序员先观察现实世界，从现实世界当中寻找对象
		* 寻找了N多个对象之后，发现所有的对象都有共同特征
		* 程序员在大脑中形成了一个模板【类】
		* Java程序员可以通过java代码来表述一个类
		* Java程序中有了类的定义
		* 然后通过类就可以创建对象
		* 有了对象之后，可以让对象直接协作起来形成一个系统。
	
	* 类--【实例化】->对象

	* 对象又被称为实例/instance

	* 对象--【抽象】-->类

	* 重点：
		类描述的是对象的共同特征。
		共同特征例如：身高特征
		这个身高特征在访问的时候，必须先创建对象，通过对象去访问这个特征。
		因为这个特征具体的某个对象上之后，值不同。有的对象身高1.80，有的
		对象身高2.80。
	
	* 一个类主要描述什么信息呢？
		一个类主要描述的是 状态 + 动作。
		状态信息：名字、身高、性别、年龄
		动作信息：吃、唱歌、跳舞、学习

		状态--> 一个类的属性
		动作--> 一个类的方法
	
	* 
		类{
			属性; //描述对象的状态信息
			方法; //描述对象的动作信息
		}

		注意：
			状态和动作当具体到某个对象上之后，发现最终的结果可能不一样。
			对象和对象之间有共同特征，但是具体到对象之后有数据的差异。


* 类的定义
	语法结构：
		[修饰符列表] class 类名{
			属性;
			方法;
		}
	
	学生类，描述所有学生对象的共同特征：
		学生对象有哪些状态信息：
			* 学号【int】
			* 名字【String】
			* 性别【boolean】
			* 年龄【int】【年龄是一个属性，年龄是一个数据，是数据就应该有数据类型】
			* 住址【String】
			.....

		学生对象有哪些动作信息：
			* 吃饭
			* 睡觉
			* 学习
			* 玩
			* 唱歌
			* 跳舞
			....
		
	重点：属性通常是采用一个变量的形式来完成定义的。
		int no;
		int age;
		String name;
		String address;
		boolean sex;

* java语言中包括两种数据类型：

	- 基本数据类型
		byte
		short
		int
		long
		float
		double
		boolean
		char

	- 引用数据类型
		String.class SUN提供的
		System.class SUN提供的

		Student.class 程序员自定义的
		User.class 程序员自定义的
		Product.class 程序员自定义的
		Customer.class 程序员自定义的
		......	
	- java语言中所有的class都属于引用数据类型。

关于java中对象的创建和使用：

通过一个类可以是实例化N个对象。
实例化对象的语法：new 类名();
new运算符的作用是创建对象，在JVM对内存当中开辟新的内存空间。
方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间当中。
栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈。
堆内存：new的对象在堆内存中存储。
什么是对象？new运算符在堆内存中开辟的内存空间称为对象。
什么是引用？引用是一个变量，只不过这个变量中保存了另一个java对象的内存地址。
java语言当中，程序员不能直接操作堆内存，java中没有指针，不像C语言。
java语言当中，程序员只能通过“引用”去访问堆内存当中对象内部的实例变量。

访问实例变量的语法格式
读取数据：引用.变量名
修改数据：引用.变量名 = 值

局部变量在栈内存中存储。
成员变量中的实例变量在堆内存的java对象内部存储。
实例对象是一个对象一份，100个对象有100份。
关于JVM内存管理

1、关于Java的集成开发环境【集成开发环境简称：IDE】

1.1、什么是集成开发环境?
	* 集成开发环境讲究一站式开发，使用这个工具即可。有提示功能，有自动纠错功能。
	* 集成开发环境可以让软件开发变的更简单、更高效。
	* 没有IDE工具：
		- 需要安装JDK、需要配置环境变量、需要手动的将java源文件编译生成class字节码文件
		- java源程序出错之后还没有提示
		- 没有自动提示功能等。
	* 有IDE工具：
		- 不需要独立安装JDK【IDE中已经集成】
		- 不需要手动配置环境变量
		- 不需要使用javac命令对java源文件进行编译
		- 并且java源程序编写语法错误马上又提示
		- 使用IDE工具有很多代码不需要写，自动生成了。

1.2、java有哪些比较牛的IDE呢？
	* eclipse (myeclipse)
	* Intellij IDEA【最多】
	* NetBeans
	* JBuilder
	.......

2、讲解myeclipse的使用：

* workspace:工作区
	- 当myeclipse打开的时候，大多数都是会提示选择工作区
	- 这个工作区可以是已存在的工作区，也可以是新建的工作区
	- 选择工作区之后，将来编写的java代码，自动编译的class文件都会在工作区中找到
	- myeclipse可以开启两个甚至更多的会话，每一个会话对应不同的workspace

* 在workspace工作区当中有一个文件夹：.metadata

	- 在该文件夹当中存储了当前myeclipse的工作状态

	- 将.metadata文件夹删除之后，下一次再次进入这个工作区的时候，是一个全新的开始。
	但是会发现这个IDE工具当中所有的项目丢失了，没关系，这里只是丢失的myeclipse的项目，
	硬盘上真实存储的项目不会丢失。

* 打开myeclipse之后：窗口
	- 窗口双击可以最大化或者还原
	- 窗口可以拖动
	- 窗口不小心关闭了，可以再次打开：
		window --> show view --> Other --> 输入自己要找的窗口

* myeclipse为程序员准备了很多不同的布局方式：
	- 企业级开发：JavaEE开发的专用布局- MyEclipse Java Enterprise
	- 普通java开发的：JavaSE开发的专用布局 - Java
	- 怎么切换布局？
		* myeclipse右上角
	
* 当这个布局被破坏之后想复原？
	- window --> Reset...

* 重点的窗口介绍
	* Package Explore / Navigator / Project Explore ：可以看到java源文件
	* Console：控制台窗口

* 工作区workspace中基本的单元是：Project（工程/项目）

* 使用myeclipse创建工程:
	- 在Package Explore窗口当中点击右键 --> new --> Java Project【JavaSE工程】：当然还有其它方式
		* 指定java工程的名称：一般全部小写
		* 指定java工程的存放目录
		* Java的运行时环境：JRE的配置【可以选择使用myeclipse自带的JRE，也可以选择程序员自己安装的JRE】
		* Project layout : 工程的目录布局
			- 多数情况下都是选择：两个独立的文件夹存储源码(src)和字节码(bin)

* 在src目录下新建软件包：package机制后面讲，目前先用着。
	- 在src目录上点击右键 --> new --> package
	- 给package起名：com.bjpowernode.javase;
	- 包package是java中语法的一部分。后面讲

* 在软件包下新建一个java类：
	- 在包上点击鼠标右键 --> new --> class【同时生成了main方法】
	- 显示行号：在java源程序的左侧栏上点击鼠标右键：show line number
	- 设置字体大小：
		window --> Preferences --> 输入font --> colors and fonts --> Basic --> Text Font --> Edit

* 关于myeclipse中常用的部分快捷键：
	- ctrl + d 删除一行
	- alt + / 自动补全
	- ctrl + 1 纠错
	- ctrl + alt + down

• ctrl + shift + t 查找类型【Open Type】
• ctrl + shift + r 查找资源【Open Resource】
  …

*Eclipse for Mac 常用快捷键：

Command + O：显示大纲
Command + 1：快速修复
Command + D：删除当前行
Command + Option + ↓：复制当前行到下一行
Command + Option + ↑：复制当前行到上一行
Option + ↓：当前行和下面一行交互位置
Option + ↑：当前行和上面一行交互位置
Option + ←：前一个编辑的页面
Option + →：下一个编辑的页面
Option + Return：显示当前选择资源的属性
Shift + Return：在当前行的下一行插入空行
Shift + Control + Return：在当前行插入空行
Control + Q：定位到最后编辑的地方
Control + M：最大化当前的Edit或View（再按则最小化）
Control + /：注释当前行，再按则取消注释
Command + T：快速显示当前类的继承结构
Command + W：关闭当前Editer
Command + K：参照当前选中的Word快速定位到下一个
Command + E：快速显示当前Editer的下拉列表（如果当前页面没有显示的用黑体表示）
Option + /：代码助手完成一些代码的插入（俗称“智能提示”）
Command + Shift + E：显示管理当前打开的所有的View的管理器
Command + J：正向增量查找（按下Command + J后，你所输入的每个字母编辑器都提供快速匹配定位到某个单词，如果没有，则在Stutes Line中显示没有找到了）
Command + Shift + J：反向增量查找
Command + Shift + W：关闭所有打开的Editer
Command + Shift + X：把当前选中的文本全部变为大写
Command + Shift + Y：把当前选中的文本全部变为小写
Command + Shift + F：格式化当前代码
Command + Shift + P：定位到对于的匹配符（譬如{}）（从前面定位后面时，光标要在匹配符里面，后面到前面，则反之）
Option + Command + R：重命名（尤其是变量和类的Rename效果比较明显）
Option + Shift + M：抽取方法（这是重构里面最常用的方法之一了，尤其是对一大堆泥团代码有用）
Option + Command + C：修改函数结构（有N个函数调用了这个方法，修改一次就搞定）
Option + Command + L：抽取本地变量（可以直接把一些魔法数字和字符串抽取成一个变量，尤其是多处调用的时候）
Option + Shift + F：把Class中的Local变量变为Field变量（比较实用的功能）
Option + Command + Z：重构的后悔药（Undo）

• 关于myeclipse怎么链接源码？
  打开某个.class字节码文件，当没有看到源码的时候：
  点击“Attached Sourse”：

• Workspace…【源码在当前的工作区当中】

• External File…【源码在某个压缩包当中】

• External Folder…【源码在某个目录当中】

  • 注意：myeclipse当中的java源代码有的时候不保存是不会编译的。所以时刻记住：ctrl + s

  • myeclipse当中，出现红色下划线的表示编译错误，语法错误。
    鼠标停留在红色的下划线上面会有错误提示信息。
    并且点击左边的×，可以进行纠错。【当然也可以光标停留在红色下划线上面: ctrl + 1】

  • 有的时候程序出现黄色的下划线，表示警告，编译可以通过。

  • 快捷键怎么设置？
    window --> Preferences --> keys

  • 怎么运行一个带有主方法的java程序？

    • 在java源程序的任何位置点击鼠标右键 --> Run As --> Java Application

3、面向对象的封装性

封装的好处：
1、封装之后，对于那个事物来说，看不到这个事物比较复杂的那一面，只能看到该事物简单的那一面。
复杂性封装，对外提供简单的操作入口。照相机就是一个很好的封装的案例，照相机的实现原理非常复杂，但是对于使用照相机的人来说，操作起来是非常方便的。

2、封装之后才会形成真正的“对象”，真正的“独立体”。

3、封装就意味着以后的程序可以重复使用，并且这个事物应该适应性比较强，在任何场合都可以使用。

4、封装之后，对于事物本身，提高了安全性。【安全级别高】

封装的步骤：
1、所有属性私有化，使用private关键字进行修饰，private表示私有的，修饰的所有数据只能在本类中访问。

2、对外提供简单的操作入口，也就是说以后外部程序要想访问age属性，必须通过这些简单的入口进行访问。
-对外提供两个公开的方法，分别是set方法和get方法
-想修改属性，调用set方法。
-想读取属性，调用get方法。

3、set方法的命名规范：

public void set+属性名首字母大写(形参){

}
public void setAge(int a) {
	age = a;
}

4、get方法的命名规范：

public int getAge(){
	return age;
}

注意：setter and getter方法没有static关键字。
有static关键字的方法怎么调用：类名.方法名(实参);
没有static关键字的方法怎么调用：引用.方法名(实参);

4、构造方法
1、构造方法又被称为构造函数/构造器/Constructor

2、构造方法的语法结构：
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
}

3、回顾普通方法的语法结构：
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;

}

4、对于构造方法来说，“返回值类型”不需要指定，并且也不能写void，只要写上void，那么这个方法就成为普通方法了。

5、对于构造方法来说，构造方法的方法名必须和类名保持一致。

6、构造方法的作用：
(1)构造方法存在的意义是，通过构造方法的调用，可以创建对象。
(2)创建对象的同时，初始化实例变量的内容空间。【给实例变量赋值】

成员变量之实例变量，属于对象级别的变量，这种变量必须先有对象才能有实例变量。
实例变量没有手动赋值的时候，系统默认赋值，那么这个系统默认赋值是在什么时候完成的呢？
是在类加载的时候吗？
不是，因为类加载的时候只加载了代码片段，还没来得及创建对象。所以此时实例变量并没有初始化。

实际上，实例变量的内存空间是在构造方法执行过程当中完成开辟的，完成初始化的。
系统在默认赋值的时候，也是在构造方法执行过程当中完成的赋值。

7、构造方法应该怎么调用？

• new 构造方法名(实参列表)

8、构造方法调用结束之后，有返回值吗？
每一个构造方法实际上执行结束之后都有返回值，但是这个“return 值;”这个语句不需要写。构造方法结束的时候java程序自动返回值。并且返回值类型是构造方法所在类的类型。由于构造方法的返回值类型就是类本身，所以返回值类型不需要编写。

9、当一个类中没有定义任何构造方法的话，系统默认给该类提供一个无参数的构造方法，这个构造方法被称为缺省构造器。

10、当一个类显示的将一个构造方法定义出来了，那么系统则不再默认为这个类提供缺省构造器。建议开发中手动的为当前类提供无参数构造方法，因为无参数构造方法太常用了。

11、构造方法支持重载机制。在一个类当中编写多个构造方法，这多个构造方法显然已经构成方法重载机制。

5、对象和引用：

5.1、对象和引用的概念？
	* 对象：目前在使用new运算符在堆内存中开辟的内存空间称为对象。
	* 引用：是一个变量，不一定是局部变量，还可能是成员变量。引用保存了内存地址，指向了堆内存当中的对象。
	* 所有访问实例相关的数据，都需要通过“引用.”的方式访问，因为只有通过引用才能找到对象。
	* 只有一个空的引用，访问对象的实例相关的数据会出现空指针异常。

	class Student{

		Computer com; //com是一个引用【实例变量】

		public static void doSome(){
			Computer cc; //cc是一个引用【局部变量】
		}
	}

5.2、参数的传递？
	主要研究和学习的是方法在调用的时候，涉及到参数传递的问题，到底是怎么传递数据的呢？
		值传递。
		int i = 10;
		int j = i; //i传递给j，实际上只是将i变量中保存的10传递给j了，j实际上是一块全新的内存空间。

		User u = 0x1234;
		User u2 = u; //u传递给u2，实际上是将0x1234这个值赋值给u2了，u和u2实际上是两个不同的局部变量，
						 //但是它们这两个变量指向堆内存中同一个java对象。

关于java语言当中this关键字：

1、this是一个关键字，翻译为：这个。

2、this是一个引用，this是一个变量，this变量中保存了内存地址指向了自身。所以，严格意义上来说，this代表的就是“当前对象”，this存储在JVM堆内存java对象内部。

3、创建100个java对象，每一个对象都有this，也就说有100个不同的this。

4、this可以出现在“实例方法”当中，this指向当前正在执行这个动作的对象。（this代表当前对象）

5、this在多数情况下都是可以省略不写的。

6、this不能使用在静态方法当中。

注意：用来区分局部变量和实例变量的时候，“this.”不能省略。

this可以用在哪里：

• 1、可以使用在实例方法当中，代表当前对象【语法格式：this.】
• 2、可以使用在构造方法当中，通过当前的构造方法去调用另一个本类其他的构造方法【语法格式：this(实参);】
• 重点【记忆】：this();这种语法只能出现在构造函数第一行。

关于java语言当中static关键字：

1、static修饰的方法是静态方法。

2、static修饰的变量是静态变量。

3、所有static修饰的元素抖出能称为静态的，都可以使用类名.的方式访问，当然也可以用引用.的方式访问【不建议】

4、static修饰的所有元素都是类级别的特征，和具体的对象无关。

5、空引用访问静态变量不会出现空指针异常，因为静态变量存放在方法区内存，没有对象的概念。

什么时候成员变量声明为实例变量呢？

• 所有对象都有这个属性，但是这个属性的值会随着对象的变化而变化【不同对象的这个属性具体的值不同】

什么时候成员变量声明为静态变量呢？

• 所有对象都有这个属性，并且所有对象的这个属性的值是一样的，建议定义为静态变量，节省内存的开销。

静态变量在类加载的时候初始化，内存在方法区中开辟。访问的时候不需要创建对象，直接使用“类名.静态变量名”的方式访问。

可以使用static关键字来定义“静态代码块”：

1、语法格式：

static {
	java语句;
}

2、静态代码块在类加载时执行，并且只执行一次。

3、静态代码块在一个类中可以编写多个，并且遵循自上而下的顺序依次执行。

4、静态代码块的作用是什么？怎么用？用在哪儿？什么时候用？

• 这当然和具体的需求有关，例如项目中要求 在类加载的时刻/时机执行代码完成日志的记录。那么这段记录日志的代码就可以编写到静态代码块当中，完成日志记录。

• 静态代码块是java为程序员准备一个特殊的时刻，这个特殊的时刻被称为类加载时刻。若希望在此刻执行一段特殊的程序，这段程序可以直接放到静态代码块当中。

5、通常在静态代码块当中完成预备工作，先完成数据的准备工作，例如：初始化连接池、解析XML配置文件…

6、除了静态代码块之外，还有一种语句块叫做：实例语句块。实例语句在类加载时没有执行。

7、实例语句语法结构：

{
	java语句;
}

8、实例语句块在什么时候执行？
只要是构造方法方法执行，必然在构造方法执行之前，自动执行“实例语句块”中的代码。实际上这也是sun公司为java程序员准备一个特殊的时机，叫做对象构建时机。

方法什么时候定义为静态的？

方法描述的是动作，当所有的对象执行这个动作的时候，最终产生影响是一样的，那么这个动作已经不再属于某一个对象动作了，可以将这个动作提升为类级别的动作，模版级别的动作。

静态方法中无法直接访问实例变量和实例方法。

大多数方法都定义为实例方法，一般一个行为或者一个动作在发生的时候，都需要对象的参与。但是也有例外，例如：大多数“工具类”中的方法都是静态方法，因为工具类就是方便编程，为了方便方法的调用，自然不需要new对象是最好的。

关于java语言当中的继承：

1、继承是面向对象三大特征之一，三大特征分别是：封装、继承、多态。

2、继承“基本”的作用是：代码复用。但是继承最“重要”的作用是：有了继承才有了以后“方法的覆盖”和“多态机制”。

3、继承语法格式：
[修饰符列表] class 类名 extends 父类名{
类体 = 属性 + 方法
}

4、java语言当中的继承只支持单继承，一个类不能同时继承很多类，只能继承一个类。在C++中支持多继承。

5、关于继承中的一些术语：
B类继承A类，其中：
A类称为：父类、基类、超类、superclass
B类称为：子类、派生类、subclass

6、在java语言当中子类继承父类都继承那些数据呢？

• 私有的属性无法在子类中直接访问
• 构造方法不支持继承
• 其他数据都可以被继承

7、虽然java语言当中只支持单继承，但是一个类也可以间接继承其他类，例如：
C extends B{
}
B extends A{
}
A extends T{
}
C直接继承B类，但是间接继承T、A类。

8、java语言中假设一个类没有显示的继承任何类，该类默认继承javaSE库当中提供的java.lang.object类。java语言中任何一个类都有obiect类的特征。

9、我们研究了一下Object类当中有很多方法，大部分看不懂，其中有一个叫做toString()的，我们进行了测试，发现：
System.out.println(引用);
当直接输出一个“引用”的时候，println()方法会先自动调用“引用.toString()”，然后
输出toString()方法的执行结果。（将“java对象”转换成“字符串的形式”）

10、继承的缺点：耦合度高，父类修改，子类受牵连。

关于java语言当中方法的覆盖：

1、方法覆盖又被称为方法重写，英语单词：override【官方的】/overwrite。

2、什么时候使用方法重写？
当父类中的方法已经无法满足当前子类的业务需求，子类有必要将父类中继承过来的方法进行重新编写，这个重新编写的过程称为方法重写/方法覆盖。

3、什么条件满足之后方法会发生重写呢？(一同，一大，两小)

• 方法重写发生在具有继承关系的父子类之间。
• 方法重写的时候：返回值类型相同，方法名相同，形参列表相同。
• 方法重写的时候：访问权限不能更低，可以更高。
• 方法重写的时候：抛出异常不能更多，可以更少。

4、建议方法重写的时候尽量复制粘贴，不要编写，容易出错，导致没有产生覆盖。

5、注意：
私有方法不能继承，所以不能覆盖。
构造方法不能继承，所以不能覆盖。
静态方法不存在覆盖。（这是因为方法覆盖通常和多态联系在一块，多态和对象有关系，而静态方法的执行不需要对象）
覆盖只针对方法，不针对属性。

在方法覆盖中，关于方法的返回值类型。
什么条件满足之后，会构成方法的覆盖呢？
1、发生具有继承关系的两个类之间。
2、父类中的方法和子类重写之后的方法：
具有相同的方法名、相同的形式参数列表、相同的返回值类型。

学习了多态机制之后：
“相同的返回值类型”可以修改一下吗？
对于返回值类型是基本数据类型来说，必须一致。
对于返回值类型是引用数据类型来说，重写之后返回值类型可以变的更小（但意义不大，实际开发中没人这样写。）

关于java语言当中的多态语法机制：

1、关于多态中涉及到的几个概念：

• 向上转型（upcasting）
  子类型 —> 父类型
  又被称为：自动类型转换。

• 向下转型（downcasting）
  父类型 —> 子类型
  又被称为：强制类型转换。【需要加强制类型转换符】

什么时候需要使用向下转型呢？
当调用的方法是子类型中特有的，在父类型当中不存在，必须进行向下转型。

• 需要记忆：
  无论是向上转型还是向下转型，两种类型之间必须要有继承关系。
  没有继承关系，程序是无法编译通过的。

2、 java.lang.ClassCastException
类型转换异常，这种异常总是在“向下转型的时候”会发生。

怎么避免向下转型出现的ClassCastException呢？
使用instanceof运算符可以避免出现以上的异常。

instanceof运算符怎么用？

1、语法格式：
（引用 instanceof 数据类型名）

2、以上运算符的执行结果类型是布尔类型，结果可能是true/false

3、关于运算结果true/false：
假设：（a instanceof Animal）
true表示：
a这个引用指向的对象是一个Animal类型。
false表示：
a这个引用指向的对象不是一个Animal类型。

4、java规范中要求：在进行强制类型转换之前，建议采用instanceof运算符进行判断，避免ClassCastException异常的发生。这是一种编程的好习惯！

3、多态的作用？
降低程序的耦合度，提高程序的扩展力。
能使用多态尽量使用多态。
父类型引用指向子类型对象。

核心：面向抽象编程，尽量不要面向具体编程。

关于java语言当中的super关键字：

1、super是一个关键字，全部小写。

2、super和this对比着学习。
this：
this不能出现在实例方法和构造方法中。

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

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

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

this.什么时候不能省略呢？在区分局部变量和实例变量的时候不能省略。

public void setName(String name) {
	this.name = name;
}

this( )只能出现在构造方法第一行，通过当前的构造方法方法去调用“本类”中其他的构造方法，目的是：代码复用。

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

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

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

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

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

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

3、super( )
表示通过子类的构造方法去调用父类的构造方法。
模拟现实世界中的这种场景：想要有儿子，需要先有父亲。

4、重要结论：
当一个构造方法第一行：
既没有this( )又没有super( )的话，默认会有一个super( )；
表示通过当前子类的构造方法调用父类的无参数构造方法。
所以必须保证父类的无参数构造方法是存在的。

5、注意：
this( )和super( )不能共存，它们都是只能出现在构造方法第一行。

在构造方法执行过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，但是实际上对象只创建了一个。

super(实参)的作用是：初始化当前对象的父类型特征。并不是创建新对象，实际上对象只创建了一个。

super不是引用。super也不保存内存地址，super也不指向任何对象。
super只是代表当前对象内部的那一块父类型的特征。

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

6、无论是怎样折腾，父类的构造方法是一定会执行的。（百分百的。）

7、在java语言中不管是new什么对象，最后object类的无参数构造方法一定会执行。（object类的无参数构造方法是处于“栈顶部”）

关于java语言当中final关键字：

1、final是一个关键字，表示最终的，不可变的。
2、final修饰的类无法被继承。
3、final修饰的方法无法被覆盖。
4、final修饰的变量一旦赋值之后，不可重新赋值。
5、final修饰的实例变量，必须手动赋值，不能采用系统默认值。
6、final修饰的引用，一旦指向某个对象之后，不能再指向其他对象，那么被指向的对象无法被垃圾回收器回收。
final修饰的引用虽然指向某个对象之后不能指向其他对象，但是所指向的对象内部的内存是可以被修改的。
7、final修饰的实例变量，一般和static联合使用，被称为常量。

关于java语言当中的包机制：

1、包又称为package，java中引入package这种语法机制主要是为了方便程序的管理。不同功能的类被分门别类放到了不同的软件包当中，查找比较方便，管理比较方便，易维护。

2、怎么定义package呢？

• 在java源程序的第一行上编写package语句。
• package只能编写一个语句。
• 语法结构：
  package 包名；

3、包名的命名规范：

公司域名倒序 + 项目名 + 模块名 + 功能名；

采用这种方式重名的几率较低。因为公司域名具有全球唯一性。
例如：
com.bjpowernode.oa.user.seriver;
org.apache.tomcat.core;

4、包名要求全部小写，包名也是标识符，必须遵守标识符的命名规则。

5、一个包将来对应一个目录。

6、使用了package机制之后，应该怎么编译？怎么运行呢？

• 使用了package机制之后，类名不再是Test01了，类名是：com.bjpowernode.javase.day11.Test01;

• 编译：javac java源文件路径（在硬盘上生成一个class文件：Tset01.class）

• 手动方式创建目录，将Tset01.class字节码文件放到指定的目录下

• 运行：java com.bjpowernode.javase.day11.Test01;

• 另一种方式（编译 + 运行）：

• 编译：
  javac -d 编译之后存放路径 java源文件的路径

• 例如：将F:\Hello.java文件编译之后放到C:\目录下
  javac -d C:\ F:\Hello.java

• javac -d . .java
  将当前路径中.java编译之后存放到当前目录下。

• 运行：JVM的类加载器ClassLoader默认从当前路径下加载。
  保证DOS命令窗口的路径先切换到com所在的路径，执行：
  java com.bjpowernode.javase.day11.Test01;

关于java语言当中的import：

1、import语句用来完成导入其他类，同一个包下的类不需要导入，不在同一个包下需要手动导入。【java.lang.*;不需要手动导入，系统自动引入。】

2、import语法格式：
import 类名;
import 包名.*;

3、什么时候需要import？

• 不是java.lang包下，并且不在同一个包下的时候，需要使用import进行导入。

4、myeclipse导入类的快捷键：ctrl + shift + o

关于java语言当中的访问控制权限：

1、访问控制权限修饰符来控制元素的访问范围。

2、访问控制权限修饰符包括：
public 表示公开的，在任何位置都可以访问
protected 同包，子类
缺省(default) 同包
private 表示私有的，只能在本类中访问

3、访问控制权限修饰符可以修饰类、变量、方法、接口。

属性（4个都能用）
方法（4个都能用）
类（public和默认能用，其它不行。）
接口（public和默认能用，其它不行。）
…

4、当某个数据只希望子类使用，使用protected进行修饰。

5、修饰符范围：
private < 缺省 < protected < public

6、访问修饰符图：