主要内容：
1.1 注释
1. 2标识符和关键字
1.3数据类型
1.4数据类型拓展
1.5类型转换
1.6变量、常量和作用域
1.7基本运算符
1.8自增自减运算符
1.9. 逻辑运算符
1.10.位运算
1.11. 三元运算
1.12.包机制
1.13. JavaDoc生成文档
1.1注释
注释就是来解释代码的一段文字，它不会被执行，Java中注释分为三种：单行注释、多行注释和文档注释。
举例：
pubilc class hello{
pubilc static void main(String[] args) {
//输出一个Hello，world！，（单行注释）
System.out.print("Hello,world!");
}
}
pubilc class hello{
pubilc static void main(String[] args) {
System.out.print("Hello,world!");
}
}
文档注释：
1.2标识符与关键字
类名、变量和方法名都被称为标识符
1.2.1标识符的使用规则：1.首字符以字母、美元符、或者下划线（-）开头
2.首字符后以字母、美元符、下划线、数字的任何组合
3.不能使用关键字作为变量名或这方法名
4.注意大小写
注意：可以使用中文，但尽量使用英文。
关键字也是一种标识符，只是它事先有已经被赋予了特殊的意义，它们用来表示一种数据类型或者表示程序的结构等，由于关键字的特殊性，为此关键字不能被用来表示变量名、类名、方法名、包名和参数。
Java中关键字及其含义：
| 关键字 | 含义 | 关键字 | 含义 |
|---|---|---|---|
| abstract | 表明类或成员方法 | break | 提前跳出一个块 |
| char | 字符类型 | continue | 回到块的开始处，继续 |
| else | 否则 | false | 错误 |
| for | 循环 | implement | 一个类实现了给定的接口 |
| interface | 接口 | native | 本地 |
| private | 私有的 | public | 公共的 |
| super | 父类，超类 | synchronized | 线程，同步 |
| transient | 短暂 | try | 捕获异常 |
| boolean | 布尔型 | byte | 字节型 |
| class | 类 | default | 默认 |
| extends | 扩充，继承 | final | 最终值，不可改变 |
| if | 如果 | import | 引入 |
| long | 长整型 | new | 新，创建 |
| protected | 受保护的 | return | 返回 |
| switch | 根据值选择执行 | this | 本类 |
| true | 正确 | void | 无返回值 |
| case | 定义·一个值供switch选择 | catch | 捕获异常 |
| goto | 关键字，但不能使用 | int | 整型 |
| volatile | 易失 | fioat | 单精度浮点 |
| double | 双精度·浮点 | package | 包 |
| strictfp | 严格，精准 | short | 短整型 |
| enum | 枚举 | const | 关键字，但不能使用 |
| throws | 声明一个异常对象可能被抛出 | while | 循环 |
| finally | 有没有异常都执行 | do | 运行 |
| assert | 判断表达式是否为真 | instanceof | 实例 |
| throw | 抛出一个异常 | null | 空 |
1.3数据类型
Java属于强类型语言，因此要求变量使用严格符合规范，所有变量都必须先定义再使用。
Java的数据类型分为两类：基本数据类型、引用类型。
| 基本数据类型 | ||||
|---|---|---|---|---|
| 整型 | int， | byte | short | long |
| 浮点型 | float | double | ||
| 字符型 | char | |||
| 布尔型 | boolean |
| 引用数据类型 | |
|---|---|
| 类 | class |
| 接口 | interface |
数组
注意：String一般用来表示字符串，但String不属于基本数据类型，String是一个类。
1.4.数据类型拓展 1.4.1基本数据类型拓展
1.整数拓展：二进制以0b开头，十进制与平常数字一样，八进制以0开头，十六进制以0x开头
2.浮点数拓展：float类型特性：有限的、离散的、舍入误差、表示一个大约的值（接近但不相等）
3.字符拓展：不同类的字符都可以通过强制转换转换成数字如a——>97,中——>20013.所有字符本质还是数字
转义字符：’ ',有特殊含义的字符如‘n’表示换行
| 符号 | 字符含义 |
|---|---|
| n | 换行 |
| r | 回车 |
| f | 换页 |
| b | 退格 |
| s | 空格 |
| t | 制表符 |
| " | 双引号 |
| ’ | 单引号 |
| \ | 反斜杠 |
| ddd | 八进制字符 |
| uxxxx | 16进制Unicode字符 |
1.5类型转换
Java在计算过程中不同类型之间可以相互运算，但在这之前要线进行类型转换，类型转换主要分为两种：强制类型转换（高——>低）、自动类型转换（低——>高）
强类型转换格式：数据类型 变量=（数据类型）变量
基本数据类型高低排序
低————————————————————高
byte,short,char -> int -> long -> float -> double
注意：
1.不能对布尔值进行转换
2.不能将类型转换成不相干的类型
3.高容量转换成低容量的的时候要强制类型转换
4.转换时注意内存溢出和精度问题
1.6变量、常量和作用域
变量：可以变化的量！
每一个变量都要声明其类型，可以是基本类型或者是数据类型，变量名必须是合法的标识符，变量声明是一句完整的语句，每一条语句声明之后都要以分号结束。
变量要素包括变量名、变量类型和作用域。
变量的作用域：类变量、实例变量和局部变量。
pubilc class Variable
static int allClicks=0;//类变量
String str="hello world";//实例变量
public void method(){
int i=0;//局部变量
}
常量：初始化后值不会改变
命名规范：
方法名、类成员名、局部变量：首字母小写和驼峰原则，如mothSalary
常量：大写字母和下划线：如PI、MAX
类名：首字母大写和驼峰原则：如GoodMan
注意：所有的命名都最好要见名知意，
1.7基本运算符
| 算数运算符 | +， -， *， /， %， ++ ，- - |
|---|---|
| 赋值运算符 | = |
| 关系运算符 | > , <,>=, <= , == , != , instanceof |
| 逻辑运算符 | &&， ll，！ |
| 位运算 | &， l， ^, ~,>>, <<, >>> |
| 条件运算符 | ？ ： |
| 扩展赋值运算符 | +=， -=，*=，/= |
注意：1.关系运算符的结果是正确与错误，用布尔值（false/true）来表示。
2.取余也叫做模运算
1.8自增自减运算符
++(自增)，–(自减)属于一元运算符
当++/–在变量名之后则先给左边变量赋值，在进行自增/自减；当在后面时先自增/自减再赋值
实例
int a=3， b=a++; 输出：b=3，a=4 |b=++a; b=4, a=4
（自减运算符以此类推）
拓展：Math类
Math在Java中属于一个数学类，在其中有很多的数学运算方法。
1.9逻辑运算符
逻辑运算符有三类：&&(逻辑与)、||(逻辑或)、!(逻辑非),逻辑运算符的结果也是用布尔值(false/true)表示。
a&&b； 如果a与b都为真则结果为真，如果a与b有一个为假则结果为假。
a||b ；a与b两个只要有一个为真则结果为真。
!a；结果与a结果相反，例如a为真则结果为假，a为假则结果为真。
逻辑短路：当可以凭借第一个变量就可以判断结果的值，完全不用看后面的变量真假时，就发生了逻辑短路。例如：a&&b：当a为假时已经可以判断出结果就为假，不用再看b的真假，这就叫逻辑短路。
1.10位运算
位运算主要是对二进制的每一位进行运算的运算符
位运算有以下几种：&(与)、|(或)、^(异或)、~(取反)、<<(左移)、>>(右移)、>>>(无符号右移)
在c语言中0为假非0为真。
1.&(与)运算时都为0时表示都为假则结果仍然为0。0和1时有一个为假则结果仍未0，；两个都为1时则结果为1，以此类推，|(或)运算符的结果也可推算出来。
2.^(异或)运算符规则时如果运算对象相同位置的数字相同则为0否则就为1。
3.~(取反)运算符就是去运算对象的另一个数，即0就取1，1就取0。
实例：
a=0011 0011
b=0110 1001
a&b=0010 0001
a|b=0111 1011
a^b=0101 1010
~a=1100 1100
1.<<(左移)相当于将二进制数整体想左以，溢出的直接舍掉，空缺的用0补齐，左移n下表示乘2n。
2.>>(右移)相当于将二进制数整体想右移，溢出直接舍掉，因为二进制开头0表正数1表负数，所以当运算对象时正数时用0补齐，为负数时用1补齐，右移n下表示除以2n。
3.>>>(无符号右移)相当于在右移的基础上忽略正负的区别，一律用0补齐
1.11三元运算符
三元运算符有：（？ ：）、和+=、-=、*=、/=。
1.？ ：运算符规则，x？y：z，如果x为真则结果为y否则为z
2.a+=b表示a=a+b，其他形式以此类推。
1.12包机制
包机制：就是建立一个文件夹，将类存放在其中，这样做的好处是当有两个类名一样的类时，存放在不同的包里面可以避免引起冲突，能够更加方便的管理类。
包的语法格式时：package 包名；
如：package animals
包的命名规则：
1.包名全部用小写
2.如果包名有多个层次用 “.” 来分割
3.包名一般是倒置的域名，如www.baidu.com写成包的话就是com.baidu.www
4.自定义包不能·用java开头
一般使用import来导入某个包的类，
语法格式：import+包名+类名
如：import example.Text(用于导入包的指定类，例如这就是导入Text类)
import example，*（用于导入包的所有类）
1.13JavaDOC生成文档 1.13.1什么是API文档
1.API：全称为Appilcation Programming Interface应用程序之间的接口，通过名字可以看出api它就是一个程序之间的接口。用生活中的例子来解释譬如当你用电脑的时候你的电脑会运行，但作为大多数人不会懂电脑咋运行，但我们只需通过鼠标和键盘来使用它，这时候鼠标和键盘就相当于api，
2.API文档：用来说明应用程序接口的文档，在Java中说明每一个类、方法的功能以及用法的一些文档。
Javadoc命令可以生成自己的api文档
参数信息：
1.@作者名
2.@version版本号
3.@since指明需要最早使用的jdk版本
4.@param参数名
5.@return返回值类型
6.@throws异常抛出情况
二、Java流程控制
主要内容：
2.1用户交互scanner
2.2顺序结构
2.3if选择结构及其嵌套结构
2.4switch选择结构
2.5while循环结构与Dowhile循环结构
2.6for循环结构以及增强for循环结构
2.7break、continue、goto和Debug的使用
2.8打印九九乘法表和三角形
2.1用户交互scanner
scanner是Java中的一个工具类，我们可以通过scanner类来获取用户的输入
2.2顺序结构
顺序结构是Java语言的一种基本结构，它的含义就是自上而下一次运行代码
2.3if选择结构 2.3.1if单选择结构
语法：
if(布尔表达式){
语句
//布尔表达式为true则执行
}
语法：
if（布尔表达式）{
语句1
//布尔表达式为true则执行
}else{
语句2
//布尔表达式为false则执行
}
语法：
if（布尔表达式1）{
语句1
//如果表达式1的值为true则执行
}else if(布尔表达式2){
语句2
//如果布尔表达式2为true则执行
}else if（布尔表达式）{
语句3
//如果布尔表达式3为true则执行
}else{
语句4
//以上布尔表达式都不为true则执行
}
语法：
if（布尔表达式1）{
if（布尔表达式2）//如果布尔表达式1的值为true则执行{
语句1
//如果布尔表达式2的值为true则执行
}else {
语句2
//如果布尔表达式2的值为false则执行
}else{
语句3
/ /如果布尔表达式1的值为false则执行、
2.4switch选择结构
case后面必须为字符串常量或字面量，在switch语句中，break不一定会有，具体看情况而定，当case后面的所有的语句都不符合是则输出default后面的语句。
语法：
switch（表达式）{
case 常量1：
语句1
case 常量2：
语句2
break；
case 常量3：
语句3
default：
语句4
}
2.5while循环结构与Dowhile循环 2.5.1while语法：
while（布尔表达式）{
语句
//如果布尔值为true则执行
}
2.5.2Dowhile语法：
do{
语句
}while（布尔表达式)；
注意：while循环与Dowhile循环的区别是while循环先判断再执行，Dowhile循环先执行再判断。
2.6for循环结构 2.6.1for循环
语法：
for（初始化；布尔表达式；更新）{
语句
}
例如：
int sun=0
for(int i=0;i<5;i++){
sum+=i
}
2.6.2增强for循环
增强for循环是专门用来遍历数组和集合的
语法：
for（元素数据类型 变量：Collection集合或数组）{
语句
}
2.7break、continue、goto和Debug的使用
break：break一般用于循环体中 ，可以控制循环的流程，当执行到break是会直接跳出循环，不执行下面的语句
continue：continue与break用法相似，但和break的区别是break直接跳出来循环，不执行之后的语句了，而continue则不同，它也会跳出循环，但它只是跳出来本次循环，它之后是仍然会执行这个循环的。
goto：目前Java还未使用这个关键字
Debug*：在程序的某一段运行停下，输出停下那段的结果。用来对程序进行调试，可以检查程序执行流程或追踪程序执行过程。
2.8打印九九乘法表及三角形
九九乘法表代码及运行结果：
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + (j * i) + "t");
}
System.out.println();
}
}
}
三角形代码及运行结果：
public class sanjiao1 {
public static void main(String[] args) {
for (int i=1;i<=5;i++){
for (int j=5;j>=i;j--) {
System.out.print(" ");
}
for (int j=1;j<=i;j++) {
System.out.print("*");
}
for (int j=1;j
System.out.print("*");
}
System.out.println();
}
}
}
三、Java方法
主要内容：
3.1什么是方法
3.2方法的定义和调用
3.3方法重载
3.4命令行传参
3.5可变行参数
3.6递归
3.1什么是方法
Java方法：是一个语句的集合，它们在一起来实现一个功能，它包含在类或者对象之中，方法先被创建出来，之后会在其他地方被调用。Java的方法类似于其他语言中的函数，就是用来完成一个特定功能的代码块。
设计方法的原则：一个方法只保留一个功能，这样有利于使用。
3.2方法的定义和调用 3.2.1方法定义：
方法必须包含一个函数头和一个函数体。函数头一般是由修饰符、返回值类型、方法名还有参数类型组成；函数体就是一个具体的语句，用来实现某一特定功能。
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return 返回值；
}
1.非静态方法：
非静态没有static来修饰，非静态方法一般是通过对象来调用方法的
对象名.方法（）
例子
public class InvokeMethod{
public static void main(String[] args){
InvokeMethod in = new InvokeMethod();
in.t1();
}
public void t1(){
System.out.printfln("t1");
}
}
2.静态方法：
静态方法有static修饰符，静态方法通过类名来调用
类名.方法（）
例子：
public class InvokeMethod{
public static void main (String[] args){
InvokeMethod.t2();
}
public static void t2(){
System.out.println("static t2....");
}
}
3.方法与方法之间的调用
（1）静态方法的调用
当方法都在同一个里面时静态方法可以直接调用静态方法，静态方法调用非静态方法则需要通过对象来调用；
如果不在一个类里面时静态方法调用静态方法则需要 类名.静态方法（），静态方法调用非静态方法则需要导入该类的包，并且创建对象来调用；
（2）非静态方法的调用
当都在一个类里面时非静态方法可以直接调用静态方法和非静态方法；
当不在一个类里面时非静态方法调用静态方法需要导入该类的包，通过类名来调用。非静态方法调用非静态方法时需要导入该类的包，通过创建对象来调用。
3.3方法重载 3.3.1什么叫方法重载：
方法重载就是再一个类里面，有先相同的函数名称，但是形参不同
3.3.2方法重载的命名规则（1）方法名必须相同
（2）参数列表必须不同
//个数不同、类型不同、或则排列顺序不同
（3）返回类型可同可不同
注意：若单单时返回值类型不同的话不能成为方法重载
3.4命令行传参和可变行参数 3.4.1命令行传参
根据命令行选项将不同参数传递给函数
3.4.2可变行参数在方法声明中，在指定参数类型后加一个省略号（…）,一个方法只能指定一个可变行参数，并且指定的必须是方法最后一个参数，任何普通的参数都必须在它之前声明。
3.5递归 3.5.1定义：
递归就是方法自己调用自己
3.5.2递归的结构递归包括两个部分：递归头和递归体
递归头：递归的结束条件
递归体：什么时候需要调用自己
例子：
public class Recursion {
public static void main(String[] args) {
method();
}
// 定义一个计数的变量count，作为递归结束的条件
public static int count = 0;
public static void method() {
if (count++ < 10) {// 递归体
System.out.println("测试递归");
method();// 调用方法自己就叫递归
} else {// 递归头
return;// 小提示：return除了用于返回值以外，还有结束程序的功能哦
}
}
}
四、Java数组
主要内容：
4.1什么是数组
4.2数组的声明与创建
4.3三种初始化及内存分析
4.4数组边界问题
4.5数组的使用
4.6二位数组
4.7稀疏数组和冒泡排序
4.1什么是数组
数组就是一个相同类型的有序集合，数组中的每一个元素称为数组元素，一个数组的数组元素类型一定是相同的，并且数组的排序一定也是有先后顺序的，每一个数组元素都可以通过下标来访问它们，数组也是个对象。
4.2数组声明与创建
数组的声明：
数组的声明有两种形式
（1）数组类型 数组名 [ ] (c语言书写习惯中)
（2）数组类型 [ ] 数组名 （Java书写习惯）
数组的创建：
数组类型 [ ] 数组名 = {em1,em2,em3,…,emN};（声明数组时初始化）
数组类型[ ] 数组名 = new 数组类型[ ] （new关键字声明数组的同时初始化）
数组类型[ ] 数组名 = new 数组类型[N ] （new关键字声明数组时指定数组长度）
注意：数组声明之后长度不可改变，改变的可以是里面的数组元素，获取数组长度用arrys.length
数组未被赋值时，默认值为0
4.3三种初始化及内存分析
三种初始化：
静态初始化：创建+赋值
动态初始化：先创建再赋值
默认初始化：创建之后若不赋值则会被赋对应数据类型的默认值
public class Test3 {
public static void main(String[] args) {
// 1、声明数组
int[] array = null;
// 2、创建数组
array = new int[10];
// 3、给数组元素中赋值
for (int i = 0; i
array[i] = i;
}
// 1、静态初始化：创建 + 赋值
int[] array2 = {0,1,2,3};
// 2、动态初始化：先创建再赋值
int[] array3 = new int[10];
for (int i = 0; i < array3.length ; i++) {
array3[i] = i;
}
// 3、默认初始化
}
}
内存分析：
Java内存有三个位置：栈、堆和方法区
堆：存放new的对象和数组，可以被共享，不会被别的对象引用。
栈：存放基本变量类型（包含基本类型的具体数值），引用对象的变量（存放引用在堆里面的具体地址）
方法区：可以被共享，包含所有class和static变量
4.4数组边界问题
数组边界问题：
数组的下标是从0开始的，所以他的下标区间是0~length-1，下标不能够越界，越界会报错
4.5二维数组
什么是二维数组”
二维数组就是一维数组的每一个数组元素都是一个一维数组，相当于是数组的数组
二位维数组的声明
数组类型 [ ][ ]数组名
4.6Arrays类
arrys类主要存在于java.util包中，包含数组的各种方法。使用时导包:import java.util.Arrays
4.7.稀疏数组冒泡排序 4.7.1什么是稀疏数组
用来简化含有大量相同元素二维数组，例如含有大量0的数组。
稀疏数组的使用
1）记录原始二维数组一共几行几列，有多少个不同的值；
（2）把具有不同值的元素的行及列值记录在一个小规模的数组中，从而缩小程序的规模
例如：
0: 10 10 3 1: 1 2 1 2: 2 3 2 3: 4 4 34.7.2冒泡排序
冒泡排序：比较数组中相邻的两个元素，如果第一个数比第二个数大就交换这两个的位置。
五、面向对象
主要内容：
5.1什么是面向对象
5.2类与对象的创建
5.3什么是封装、继承、多态
5.4super与重写
5.5抽象类与内部类
5.6接口
5.1什么是面向对象
面向对象就是将一件要做的事情先分类，然后再每一个类下面再具体去实现，从而达到完成这件事的目的。
面向对象和面向过程的区别是面向过程没有这个分类的阶段，直接开始做。
面向对象的特性
封装、继承、多态
5.2类与对象的创建 5.2.1什么是类与对象
类可以理解为一些有着共同特性事务的集合，例如我们平常所说的手机、电脑…类中最多包含属性与方法
对象就是具体实例，例如华为手机、惠普电脑…
（1）使用new关键字来创建对象。
（2）在使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中的构造器的调用。
一个学生类：
public class student {
//属性：字段
String name;//默认值是null
int age;//默认值是0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
用new来创建对象
public class application {
public static void main(String[] args) {
//类是抽象的，需要实例化，使用new来进行实例化。
//类实例化后，会返回一个自己的对象。
//students对象就是一个student类的具体实例。
//同样，我们还可以new许多其他的对象。
student students = new student();
student xiaoming = new student();
student xiaohong = new student();
System.out.println(xiaohong.name);//此时，我没有对xiaohong.name进行初始化或者赋值
System.out.println(xiaohong.age);
}
}
=======================================================
那么最终输出结果是
null
0
5.3封装、继承、多态 5.3.1封装
封装就是将类的属性与方法隐藏起来，不会被直接找到，一般会用private来修饰它，他的使用范围在同一个包的同一个类中使用，一般如果需要调用封装好的函数需要通过get和set来实现，set是给属性赋值的，get是取得属性值的。
5.3.2继承继承就是子类继承父类的特征和行为，使得子类获得父类的实例或方法，继承一般用关键字extands，继承的是子类，被继承的是父类，Java中只有单继承没有多继承。
5.3.3多态：多态就是同一间行为通过不同的事物可以表现出不同的形态
多态存在的前提
（1）存在继承或者实现关系
（2）子类或实现类必须重写父类方法
（3）父类引用指向子类对象
注意：多态是方法的多态，属性没有多态。
5.3super与重写： 什么是重写
子类在继承父类之后可以对父类中同名同参数的方法，进行覆盖操作。
子类中的叫重写方法，父类中的叫被重写方法。
super 关键字可以在子类的构造方法中显式地调用父类的构造方法，基本格式如下：
super(parameter-list);
5.5抽象类与内部类 5.5.1什么是抽象类
用abstract修饰的类就叫抽象类，抽象类无法实例化，不能直接使用new关键字来生成对象，
基本格式
（public）abstract class 类名{}
5.5.2什么是内部类
内部类是在其他类或方法内部定义的类，
例如：
class Person {
class StoneVillage { //内部类——石村
...
}
}
5.5.3内部类作用
（1）实现类的重用功能
（2）实现多重继承
（3）增强封装
5.6接口
有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果，接口是抽象方法和常量值的定义的集合
例如：
public interface Runner int id = 1 public void start() public void run() public void stop(） }
六、异常
主要内容：
6.1什么是异常
6.2异常处理机制
6.3自定义异常
6.1什么是异常
在程序执行期间发生的事件，它中断正在执行的程序的正常指令流。
异常类型
Throwable是异常的父类，它包含了Error和Exception两个类
Error
Error 是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。
Exception
Exception以及它的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。
6.2异常处理机制
异常处理机制：抛出异常和捕获异常
java异常处理的方式：
方式一： try-catch-finally
方式二： throws + 异常类型
异常处理关键字：try、catch、finally、throw、throws
6.3自定义异常
自定义异常类的主要作用是区分异常发生的位置，当用户遇到异常时，根据异常名就可以知道哪里有异常，根据异常提示信息进行修改。
语法格式：
<自定义异常名>
