dxj1016

JavaSE复习总结

JavaSE

学习视频：狂神说Java
参考网站：菜鸟教程

java用途广泛

银行系统
支付系统
政企信息系统
大数据平台
网站后台
SaaS云
手机App
云管理系统后台
电商系统后台
桌面工具
等等

Windows常用快捷键+基本DOS命令

电脑快捷键

复制：Ctrl+C
粘贴：Ctrl+V
全选：Ctrl+A
剪切：Ctrl+X
撤销：Ctrl+Z
保存：Ctrl+S
关闭窗口：Alt+F4
永久删除：Shift+delete
打开命令行窗口：win+R
打开我的电脑窗口：win+E
打开任务管理器：Ctrl+Shift+Esc

DOS命令

打开CMD方式
- 开始+命令提示符
- win+R，输入cmd打开控制台（推荐使用）
- 在任意文件下，按住Shift键+鼠标右键点击，在此打开命令行窗口
- 资源管理器的地址栏前面加上cmd然后空格再加上路径/直接去掉路径输入cmd回车
管理员方式运行
- 搜索+命令提示符+更多+以管理员方式运行
常用命令
- 盘符切换：直接选择盘后加：例如：D：+回车
- 查看当前目录下的所有文件：dir
- 同盘符切换目录：cd+路径；
- 不同盘符切换目录：cd+/d+路径
- 返回上一级：cd +…
- 清理屏幕：cls（clear scree）
- 退出终端：exit
- 查看电脑的ip：ipconfig
- 测试网络：ping+ip
  - 例如：ping+www.baidu.com
  - 例如：ping+127.0.0.1
- 打开应用
  - 打开计算器：搜索calc/win+R+输入calc
  - 打开画图工具：搜索mspaint/win+R+输入mspaint
  - 打开记事本：搜搜notepad/win+R+输入notepad
- 文件操作
  - 创建文件夹：md+文件夹名称
  - 删除文件夹：rd+文件夹名称
  - 新建文件：cd+>+a.txt（新建a.txt文件）
  - 删除文件：del+a.txt

Markdown入门

标题

Markdown语法：#/##/###/####…
快捷键：Ctrl+1/2/3/45/6

列表

有序
- Markdown语法：数字+英文句号+空格+文字
- 快捷键：Ctrl+Shift+[
无序
- Markdown语法：- 或*或 +三种符号都可以加上空格实现无序
- 快捷键：Ctrl+Shift+]

引用

接空格或者>直接回车
快捷键：Ctrl+Shift+Q

图片与链接

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mEewzC0I-1615627058481)(图片链接/路径)]
链接名称

字体

斜体：斜体 Ctrl+I
粗体：粗体 Ctrl+B
加粗斜体：加粗斜体
删除线：~~删除线~~ Alt+Shif+5
下划线：Ctrl+U

表格

Ctrl+T

代码框

三个```回车

分割线

—回车

公式块

$$回车
Ctrl+Shift+M

Java入门

java介绍

java的特性和优势
参考网址
- 简单性
  
  Java 语言的语法与 C 语言和 C++ 语言很接近，使得大多数程序员很容易学习和使用。另一方面，Java 丢弃了 C++ 中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java 语言不使用指针，而是引用。并提供了自动分配和回收内存空间，使得程序员不必为内存管理而担忧。
- 面向对象
  
  Java 语言提供类、接口和继承等面向对象的特性，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为 implements）。Java 语言全面支持动态绑定，而 C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。
- 可移植性
  
  这种可移植性来源于体系结构中立性，另外，Java 还严格规定了各个基本数据类型的长度。Java 系统本身也具有很强的可移植性，Java 编译器是用 Java 实现的，Java 的运行环境是用 ANSI C 实现的。
- 高性能
  
  与那些解释型的高级脚本语言相比，Java 的确是高性能的。事实上，Java 的运行速度随着 JIT(Just-In-Time）编译器技术的发展越来越接近于 C++。
- 分布式
  
  Java 语言支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段。
- 动态性
  
  Java 语言的设计目标之一是适应于动态变化的环境。Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
- 多线程
  
  在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。
- 安全性
  
  Java通常被用在网络环境中，为此，Java 提供了一个安全机制以防恶意代码的攻击。除了Java 语言具有的许多安全特性以外，Java 对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类 SecurityManager）让 Java 应用设置安全哨兵。
- 健壮性
  
  Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证。对指针的丢弃是 Java 的明智选择。Java 的安全检查机制使得 Java 更具健壮性。
java三大版本
- JavaSE
- JavaME
- javaEE
JDK：Java Development Kit
- 其它工具
  - java：
  - javac：编译
  - javadoc：把java的一些东西生成一个文档
  - jar：把java打包成一个应用
- JRE：java Runtime Environment
  - 其它工具
  - JVM：Java Virtual Machine
    - 软件实现
    - 硬件实现
    - 模拟cpu去处理java东西
    - java的跨平台核心采用了JVM，在不同的操作系统上都使用了java的虚拟机，通过java这层虚拟机，屏蔽了底层系统的一些差别，真正实现了一次编译到处执行

安装java开发环境

卸载原有的JDK

卸载JDK(如果原来有下载)

删除java的安装目录：我的电脑-->属性-->高级系统设置-->环境变量-->系统变量--J>AVA_HOME（路径）-->删除该路径下文件
删除JAVA_HOME
删除环境变量path下关于java的目录
测试是否卸载成功：java -version

下载与安装JDK

JDK下载与安装
百度搜索JDK8，找到下载地址
同意协议
下载电脑对应版本
双击安装JDK--选择安装路径--一直下一步
记住安装的路径
配置环境变量：1、我的电脑-->属性-->高级系统设置-->环境变量-->系统设置-->新建系统变量JAVA_HOME（变量值就是上面java安装路径） 2、配置Path变量： 新建-->%JAVA_HOME%\bin； 新建-->%JAVA_HOME%\jre\bin
测试JDK是否安装成功 :
        1、打开cmd（win+R）
        2、java -version

下载JDK
配置环境变量
测试安装是否成功

JDK目录介绍
- bin目录：很多可运行程序
- include目录：有很多头函数，可以引入C中的头函数
- jre目录：可以运行编写的程序
- lib目录：java开发需要用的库文件
- src目录：java源代码都放这里

java程序运行机制

编译型

举例：美国人要看一本中文书，需要中国人把这本中文书翻译为英文书，再给美国人，这就叫编译型，编译过程需要的工具就叫java编译器。操作系统、C、C++都是编译型。要使用的时候直接将程序编译一下就可以用了。
解释型

举例：美国人要看一本中文书，雇佣了一个中国翻译官，翻译官一句一句给他翻译，等以后他又想看这本书的时候，就又得请翻译官给他翻译，这就叫解释型。网页还有服务器的脚本，对速度要求没有那么高，就可以使用解释型语言，就是边执行边解释。java是编译型也是解释型，javascript，Python都是解释型。

程序运行机制

/*
java程序运行机制
	源程序（.java文件）通过java编译器编译成字节码（.class文件），class文件才真正的被执行。所以java在被真正执行之前经过了一次预编译，生成的代码就是介于源程序和机器码之间的字节码文件。字节码文件运行的时候，就会走到JVM（虚拟机），这个过程有很多步骤：
把字节码文件放到虚拟机的类转载器里面，这个类就被加载到JVM里面了，加载进来之后就放进字节码校验器里，检查代码写的有没有问题，如果没有问题那么就将其放到解释器解释给操作系统。
	随着技术发展和硬件的发展，编译型和解释型的界限越来越模糊。因为硬件有提升，所以解释型速度也很快。
	源程序到字节码经过了javac编译。
*/

Java基础

基本语法

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

注释

单行注释：//
多行注释：/* */
文档注释：/** */

java标识符注意点

标识符（identifier），是指类名(包括接口、枚举、抽象类)、方法名、变量、常量名、包名等可以自定义的字符组合。
虽然可以自定义，但是也要遵循如下规则：

由字母, 下划线, 数字, $ 符号组成;
只能以字母、下划线、$ 符号开头，不能以数字开头；
标识符长度没有限;
区分大小写
不能是关键字

java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（_）或数字的任何字符组合
不能使用关键字作为标识符（类名、变量名、方法名）
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary、#abc
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音。
String是标识符

关键字

/*Java关键字不能用于常量、变量和任何标识符的名称。
	关键字(keywords)是这Java语言规范约定用于表达语法含义的单词，截止JDK8.0，这部分单词总共有50个。
其中绝大部分关键词是Java语法发布之初就约定好的，少部分关键词是随Java语言发展后加入的。
strictfp JDK1.2 加入
assert JDK1.4 加入
enum JDK5.0 加入
还有少数单词，目前还没有明确的语法含义，但是Java语言也约定它是关键字，随着Java的发展，将来可能会被赋予语法含义。这部分关键词又被称为保留关键字（reserved keywords）,如关键字列表中的const、goto 。
*/

访问控制
- 公共的：public
- 受保护的：protected
- 私有的：private
- 默认：default
类、方法和变量修饰符
- 声明抽象：abstract
- 类：class
- 继承：extends
- 不可改变的，最终值：final
- 实现（接口）：implements
- 接口：interface
- 本地、原生方法（非Java实现）：native
- 新，创建：new
- 静态：static
- 严格、精准：strictfp
- 线程，同步：synchronized
- 短暂：transient
- 易失：volatile
程序控制语句
- 根据值选择执行：switch
- 定义一个值以供switch选择：case
- 跳出循环：break
- 继续：continue
- 默认：default
- 运行：do
- 循环：while
- 循环：for
- 如果：if
- 否则：else
- 返回：return
- 实例：instanceof
错误处理
- 抛出一个异常对象：throw
- 声明一个异常可能被抛出：throws
- 捕获异常：try
- 捕捉异常：catch
- 有没有异常都执行：finally
- 判断表达式是否为真：assert
包相关
- 引入：import
- 包：package
基本类型
- 短整型：short
- 整型：int
- 长整型：long
- 字节型：byte
- 字符型：char
- 单精度浮点：float
- 双精度浮点：double
- 布尔型：boolean
变量引用
- 父类，超类：super
- 本类：this
- 无返回值：void
保留关键字
- goto：是关键字，但是不能使用
- const：是关键字，但是不能使用
- null
String不是关键字
- String 是Java基础库中的一个常用类的类名，属于标识符(identifier)，显然不是关键字。

java修饰符

java可以使用修饰符来修饰类中的方法和属性。主要由两类修饰符。

访问控制修饰符：public protected private default

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。
非访问控制修饰符：abstract，final，static，synchronized。。。

java变量与常量

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value]...] ;
格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。
int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

变量的命名规范
- 所有变量，方法，类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary除了第一个单词以外，后面的单词首字母要大写
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man，GoodMan
- 方法名：首字母小写和驼峰原则：run(),runRun()
作用域

例子：
public class Variable{
static int allClicks=0; // 类变量
```
String str="hello world";  // 实例变量
 
public void method(){
       
 
    int i =0;  // 局部变量
 
}
```
}
- 局部变量：类的方法中的变量。
- 局部变量声明在方法、构造方法或者语句块中；
  - 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
  - 访问修饰符不能用于局部变量；
  - 局部变量只在声明它的方法、构造方法或者语句块中可见；
  - 局部变量是在栈上分配的。
  - 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
    不同的非嵌套块中多次声明一个具有相同的名称局部变量，但不能在嵌套块内两次声明局部变量。
- 类变量（静态变量）：独立于方法之外的变量，用 static 修饰。
- 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
  - 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
  - 静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
  - 静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
  - 静态变量在第一次被访问时创建，在程序结束时销毁。
  - 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
  - 默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
  - 静态变量可以通过：ClassName.VariableName的方式访问。
  - 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。
- 成员变量（非静态变量）：：独立于方法之外的变量，不过没有 static 修饰。
- 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
  - 当一个对象被实例化之后，每个实例变量的值就跟着确定；
  - 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
  - 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
  - 实例变量可以声明在使用前或者使用后；
  - 访问修饰符可以修饰实例变量；
  - 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
  - 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
  - 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
java常量
- 常量：初始化后不能再改变的值
- 常量用final修饰符修饰
- 所谓常量可以理解成一种特殊的变量，他的值被设定后，在程序运行过程中不允许被改变。
- 例子：
  final 常量名=值；
  final double PI=3.14;
- 常量名一般使用大写字符。

数据类型

Java的数据类型分为两大类
```
字节
		位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
		字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示，1B=8bit
		字符：是计算机中使用的字母，数字，字和符号。

1bit表示1位，
1Byte表示一个字节 1B=8b
1024B=1KB
1024KB=1M
1024M=1G
```
- 基本类型
  
  变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
  
  内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
  - 数值类型
    - 整数类型
      - byte占1个字节范围
        
        byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
      - short占2个字节范围
        
        Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
      - int占4个字节范围
      - long占8个字节范围
        
        这种类型主要使用在需要比较大整数的系统上；
    - 浮点类型
      
      浮点数不能用来表示精确的值，如货币；
      Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。
      - float占4个字节
      - double占8个字节
    - 字符类型char占2个字节
      
      char类型是一个单一的 16 位 Unicode 字符；
      最小值是 \u0000（即为 0）；
      最大值是 \uffff（即为65、535）；
      char 数据类型可以储存任何字符；
      例子：char letter = ‘A’;。
  - boolean类型：占1位，其值只有true和false两个
- 引用类型
  - 类
  - 接口
  - 数组
数据类型扩展及面试题
- 整数扩展
  - 二进制：0b开头
  - 十进制
  - 八进制：0开头
  - 十六进制：0x开头
- 浮点数扩展
  - 最好完全避免使用浮点数进行比较，因为会精度丢失，如果想要进行计算然后比较就可以使用BigDecimal 数据工具类进行比较。
  - 例子：
```
float f=0.1f;
double d=1.0/10;
System.out.println(f);//0.1
System.out.println(d);//0.1
System.out.println(f==d);//false
float d1=231212121212f;
float d2=d1+1;
System.out.println(d1==d2);//true
```
- 字符扩展
  - 所有的字符本质都是数字
  - 例子：
```
char c1='a';
System.out.println(c1);//a
System.out.println((int)c1);//强制转换  97
char c2 = '中';
System.out.println(c2);//中
System.out.println((int)c2);//强制转换 20013
```
  - char涉及到编码 Unicode编码可以处理各种语言的文字占2字节 0-65536 最初的Excel最长有2的16次方=65536
  - 例子：
```
char c3 = '\u0061';
System.out.println(c3);//a
```
- 转义字符
  - 水平制表符（在文本该处插入一个tab键）：\t
    - 例子：
```
System.out.println("Hello\tWorld");
//Hello  world
```
  - 换行：\n
    - 例子：
```
System.out.println("Hello\nWorld");
//Hello
//World
```
  - 后退键：\b
  - 回车：\r
  - 换页符：\f
  - 单引：’
  - 双引："
  - 反斜杠：\
- ==与equals区别
  - ==：比较的是对象的地址是否一致。
  - equals：比较的是内容是否一致。
  - 例子：
```
String sa = new String("hello World");
String sb = new String("hello World");
System.out.println(sa==sb);//false
String sc = "hello world";
String sd = "hello world";
System.out.println(sc=sd);//true
```
  - 例子解释：
    前面的sa和sb是引用类型，采用==来比较的时候，比较两者地址是否一致，很明显sa和sb都通过new开辟了新的内存空间，存在两个不同的堆中，地址不一样，返回false。
    后面的sc和sd是基本数据类型，都保存在字符串常量池中，不new的是指向同一个内存空间。所以地址一样，返回true。
    equals：比较的是内容是否相同，如果第一个采用sa.equals(sb)，这样就是对的。因为两者的内容是一样的。
- 布尔值扩展
  - 例子：
```
boolean flag=true;
 //Less is More! 代码要精简易读
 if (flag) {
           System.out.println("新手");}
 if (!flag) {
           System.out.println("老手");}
```
数据类型转换
- java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
- 低-----------------------------------------》高
  byte，short，char–》int–》long–》float–》double
- 运算中，不同类型的数据先转化为同一类型，然后进行运算
- 强制类型转换
  
  int i=128;
  byte b=(byte) i;//-128 //强制转换高-低（类型）变量名 //内存溢出 Byte进去知道最大值为127，i为128，导致内存溢出
  double d=i;//128 //自动转换低-高
  - 高–>低：（类型）变量名
- 自动类型转换
  - 低–>高：自动转换
- 注意点
  
  注意点：
  1、不能对布尔值进行转换
  2、不能把对象类型转换为不相干的类型
  3、在把高容量转换为低容量的时候，强制转换
  4、转换的时候可能存在内存溢出，或者进度问题

基本运算符

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

 //++    --  自增  自减  一元运算符
        int a = 3;
        //执行完这行代码后，先给b赋值，a再自增
        int b = a++;//b=3;a=4;
        //a++   a=a+1
        System.out.println(a);//4
// 执行完这行代码前，a先自增，再给c赋值
    //a++   a=a+1
    int c = ++a;//c=5;a=5

赋值运算符：=
关系运算符：>，<，>=，<=，==，!=，instanceof

逻辑运算符：&&，||，！

//与（and）    或（or）   非（取反）
        boolean a = true;
        boolean b = false;
        //逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a && b:"+(a && b));//a && b:false
        //逻辑或运算：两个变量有一个额为真，则结果才为true
        System.out.println("a || b:"+(a || b));//a || b:true
        //如果是真的，则变为假，如果是假则为真
        System.out.println("!(a && b):"+!(a && b));//!(a && b):true
//短路运算
    int c=5;
    boolean d=(c<4)&&(c++<4);
    System.out.println(d);//false
    System.out.println(c);//5  因为c<4是错误的，所以不再执行后面的c++，所以c的值没有变化

位运算符：&，|，^，~，>>，<<，>>>（了解即可）
条件运算符？：
String type=score<60?“不及格”:“及格”;//必须掌握
扩展赋值运算符：+=，-=，*=，/=

包机制

防止命名冲突

package pkg1[.pkg2[.pkg3…]];

域名倒置
import

javaDoc生成文档

javadoc命令是用来生成自己API文档的
生成JavaDoc文档方式
- 加载在类上面就是类注释，需要自己写上去
- 加载在方法上就是方法注释，可以写好方法之后，在方法上面/**回车就好了。
- 可以通过命令行生成Doc文档：javadoc -encoding UTF-8 -charset UTF-8 Doc.java
- 生成的文档打开index.html文件可以看到我们跟java帮助文档格式的东西
- 可以使用IDEA生成JavaDoc文档：工具栏找到Tool–》Generate JavaDoc–》简单的配置
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况

Java流程控制

用户交互Scanner

通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext 与 hasNextLine 判断是否还有输入的数据

概念
- java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。
基本语法
- Scanner s = new Scanner(System.in);
获取输入的字符串方式

next() 与 nextLine() 区别

next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
- next（）方法
- nextLine（）方法
判断是否还有输入方式
使用与上面的方法对应。
- hasNext（）方法
- hasNextLine（）方法
获取其它类型数据的方法
这些的用法跟next（）用法相似
- nextInt（）
- nextFloat（）
- nextDouble（）
- hasNextInt（）
- hasNextFloat（）
- hasNextDouble（）
循环输入
- 使用while实现，使用next的时候，如果遇到有效字符之后遇到空白，就会把空白后面的有效字符当做第二个输入的内容，不是字符串类型的输入过程中遇到字符串就会结束整个程序运行过程，跳出while运行。

顺序结构：概念

Java的基本结构就是顺序结构，除非按照特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构
语句与语句之间，框与框之间是按照从上到下的顺序进行的，他是由若干个依次执行的处理步骤组成的
他是任何一个算法都离不开的一种基本算法结构

选择结构

条件语句
- if
  - 单选泽结构，判断一个东西是否可行，然后才切执行，这样的过程用使用if语句表示
  - 语法：
    if(布尔表达式){如果布尔表达式为true将执行的语句}
- if…else
  - 双选择结构，有两个判断。
  - 语法：
```
if(布尔表达式){
           //如果布尔表达式的值为true}
else{
           //如果布尔表达式的值为false}
```
- if…else if…else
  - 多选择结构，选择很多的时候使用。
  - 语法：
```
if(布尔表达式 1){
           //如果布尔表达式 1的值为true}
else if(布尔表达式 2){
           //如果布尔表达式 2的值为true}
else if(布尔表达式 3){
           //如果布尔表达式 3的值为true}
else{
           //如果布尔表达式的值为false}
```
  - if语句至多有1个else语句，else语句在所有的else if语句之后；
    if语句可以有若干个else if语句，它们必须在else语句之前；
    一旦其中一个else if 语句检测为true，其它的else if以及else语句都将跳过执行。
- 嵌套的if…else：if(){if(){}}
  - 可以在另一个if或者else if语句中使用if或者else if语句,可以像if语句一样嵌套else if…else
  - 语句：
```
f(布尔表达式 1){
           
//如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
           2为true执行代码} 
}
```
switch 多选择结构
- 多选择结构实现方式是switch case语句
- switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
  
  switch case 语句有如下规则：
  - switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
  - switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
  - case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
  - 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
  - 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
  - switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
    switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断
- 语法：
```
switch(expressinon){
         
  case value:
          //语句
          break;//可选
  case value:
          //语句
          break;//可选
    default:
         //语句
}
```

循环结构

while循环
do…while循环：至少执行一次
while循环和do…while循环的区别：
do…while循环至少有一次执行do里面的内容，然后再判断while中的条件
while循环要先判断条件之后才可以执行while中的内容

for循环

/*for循环语句是支持迭代的一种通用结构，是最有效的，最灵活的循环结构。
for循环执行的次数是在执行前就确定了。
关于for循环有以下几点说明：
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。
语法格式如下：
*/
for(初始化; 布尔表达式; 更新) {
       
    //代码语句
}

java增强for循环

Java5 引入了一种主要用于数组或集合的增强型 for 循环。

//Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
       
   //代码句子
}
//声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
//表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

break，continue，goto

break关键字：用于强行退出循环，不执行循环中剩余的语句。
Continue关键字：跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
goto关键字
- 仍是关键字，但是未在语言中得到正式使用；Java没有goto，然而在break和continue身上，又看到goto的影子：带标签的break和continue。
- “标签”是指后面是一个冒号的标识符，例如label：

对Java来说唯一用到标签的地方是在循环语句之前，希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随标签使用，他们就会中断到存在标签的地方。

例子：

  //打印101-150之间所有的质数
   //质数是指在大于1的自然数中，除了1和它本身以外不再有其它因数的自然数
      int count = 0;
      outer:for (int i = 101; i < 150; i++) {
       
          for (int j = 2; j < i / 2; j++) {
       
              if (i % j == 0) {
       
                  continue outer;
              }
          }
          System.out.print(i+"  ");
      }

反编译

反编译 java—class（字节码文件）----反编译（IDEA）将class文件复制到java文件下，打开就是反编译内容
查看class文件打开项目结构下面复制路径，下面有个production，打开将class文件复制到java文件下。

debug

在代码前打个断点查看代码运行过程

Java方法

何谓方法？

Java方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，就是师兄某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

方法的优点

使程序变得更简短而清晰。
有利于程序维护。
可以提高程序开发的效率。
提高了代码的重用性。

方法的命名规则

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test_，例如 testPop_emptyStack。

方法的定义

//Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段。方法包含一个方法头和一个方法体，定义语法如下：

修饰符 返回值类型 方法名(参数类型 参数名){
     
    ...
    方法体
    ...
    return 返回值;
}

修饰符
- 修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型
- 方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名
- 是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型
- 参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体
- 方法体包含具体的语句，定义该方法的功能。

方法的调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：int larger = max(30, 40);
如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：System.out.println(" ");
静态方法的调用：类名.方法名（）或者
对象名.方法名（）
非静态方法的调用：对象名.方法名（）
静态方法是和类一起加载的；非静态方法是在类实例化之后才存在的，所以静态的a方法中无法调用非静态的b；但非静态的b可以调用静态的a

方法的重载

定义
- 在一个类中，有相同的函数名称，但是形参不同的函数。
规则
- 方法名称必须相同
- 参数列表必须不同（个数不同，或类型不同，或参数排序顺序不同等）
- 方法的返回值类型可以改变
- 方法的访问修饰符可以改变
- 仅仅返回类型不同不足以成为方法的重载
- 方法能够在同一个类中或者在一个子类中被重载
实现理论
- 方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错
命令行传参
- javac CommandLine.java
- java CommandLine this Jiao

方法的重写

注解：@Override
需要有继承关系，子类重写父类的方法，重写，子类的方法和父类必须要一致；方法体不同
方法的重写规则
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
- 抛出异常：范围可以被缩小，但不能扩大；ClassNotFoundException ---->Exception（大）
- 父类的成员方法只能被他的子类重写
- 声明为final的方法不能被重写
- 声明为static的方法不能被重写，但是能够被再次声明
- 子类与父类在同一个包，子类可以重写父类所有方法，除了声明为final和private方法
- 子类与父类不在同一个包，子类只能重写父类的声明为public和protected和非final方法。
- 构造方法不能被重写
- 如果不能继承一个类，则不能重写该类的方法
为什么要重写
- 父类的功能，子类不一定需要，或者不一定满足！

方法的可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号。例如：public void a(double… numbers){};
一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在他之前声明。

递归

A方法调用A方法，就是自己调用自己。
把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归结构
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法。
- 能不用递归就不用递归，解释看进栈机制。
进栈机制
- java都是使用栈机制的，像一个罐子，把方法一个一个往里面压。执行的时候从main方法进栈，也就是在栈最底部，然后到里面调用的各种方法，按顺序进栈，每调用一个方法就往里面压一层，然后进栈结束之后再从上面把方法一层一层清空，等main方法结束的时候栈就空了。
  进栈的过程就叫压栈。
- 加入栈里面在无限的往里面压东西，就会造成空间不行，物理上就是内存崩溃，在一些嵌套程度不深的算法，递归就不适用了。

构造方法

当一个对象被创建时候，构造方法用来初始化该对象。
构造方法和它所在类的名字相同，但构造方法没有返回值。
通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。
一旦你定义了自己的构造方法，默认构造方法就会失效。

finalize() 方法

清除回收对象。它在对象被垃圾收集器析构(回收)之前调用
可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。
语法：
protected void finalize()
{
// 在这里终结代码
}
关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。

java数组

数组的定义

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
每一个数据称作一个数组元素，每个数组可以通过一个下标来访问他们。
数组是储存在堆上的对象，可以保存多个同类型变量。
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，…，number99。
new int[5]
{1,2,3,4,5}

数组声明

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; // 首选的方法
dataType arrayRefVar[]; // 效果相同，但不是首选方法
Java语言使用new操作符来创建数组，语法如下：
arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事：
一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组的元素是通过索引访问的，数组索引从0开始
获取数组长度：arrays.length

数据变量声明和创建合并

dataType[] arrayRefVar = new dataType[arraySize];


dataType[] arrayRefVar = {
     value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

三种初始化

静态初始化
- int[] a={1,2,3};
- Man[] mans={new Man(1,1),new Man(2,2)};
动态初始化
- int[] a=new int[2];
- a[0]=1;
- a[2]=2;
数组的默认初始化
- 数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的四个基本特点

长度是确定的，数组一旦被创建，他的大小就是不可以改变的
其元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数据变量属引用类型，数组也可以看成是对象，数组中的元素相当于该对象的成员变量。java中的对象是在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。

数组的使用

通过下标拿到值
for循环
增强for循环
数组作为函数的参数
- public static void printArray(int[] array){};
数组作为函数的返回值
- public static int[] reverse(int i){};

多维数组

多维数组的动态初始化
- String str[][]=new String[3][4];
多维数组的引用
- str[1][0];

数组的工具类Arrays

java.util.Arrays
数组本身没有提供方法给我们调用，但API中提供了一个工具类Aarrays来对数据对象进行一些基本操作
Arrays类中方法都是static修饰的静态方法，在使用的时候可是直接使用类型进行调用，也可以使用对象调用。
功能
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法,按升序。
- 比较数组：通过 equals 方法比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

排序算法

冒泡排序
选择排序
插入排序
快速排序
归并排序
希尔排序
堆排序
基数排序

稀疏数组

介绍
- 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
处理方式
- 记录数据一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模

Java内存分析

堆

存放new的对象和数组
可以被所有的线程共享，不会存放别的对象引用

栈

存放基本变量类型（会包含这个基本数据类型的具体数值
引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区

可以被所有的线程共享
包好了所有的class和static变量

Java的对象和类

面向过程

步骤清晰简单，第一步做什么，第二步做什么
面向过程适合处理一些较为简单的问题

面向对象

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象编程的本质

以类的方式组织代码，以对象的方式组织（封装）数据

面向对象三大特征

封装
- 该露的露，该藏的藏
  - 高内聚
    - 类的内部数据操作细节自己完成，不允许外部干涉
  - 低耦合
    - 仅暴露少量的方法给外部使用
- 封装（数据的隐藏)
  - 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
- 属性私有，get/set
继承
- 概念：本质是对某一批类的抽象，从而实现对现实世界更好的建模。是类与类之间的一种关系。
- extends的意思是“扩展”。子类是父类的扩展
- Java中只有单继承，没有多继承
- 所有类默认继承Object类；
- super
  - super调用父类的构造方法，必须在构造方法的第一个
  - super必须只能出现在子类的方法或者构造方法中
  - super和this不能同时调用构造方法
- final关键字修饰类
  - 把类定义为不能继承的，即最终类，或者用于修饰方法，该方法不能被子类重写。
- 声明为 static 的方法不能被重写，但是能够被再次声明。
- super与this区别
  - 代表的对象不同
    - this：本身调用者这个对象
    - super：代表父类对象的应用
  - 前提
    - this：没有继承也可以使用
    - super：只能在继承条件才可以使用
  - 构造方法
    - this()：本类的构造
    - super()：父类的构造
- 私有的东西，子类无法继承
- 构造器
  - 子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
  - 如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
多态
- 概念
  - 多态是同一个行为具有多个不同表现形式或形态的能力。比如打印机有彩色打印，黑白打印
  - 多态就是同一个接口，使用不同的实例而执行不同操作
  - 多态性是对象多种表现形式的体现。
  - 方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
- 优点
  1. 消除类型之间的耦合关系
  2. 可替换性
  3. 可扩充性
  4. 接口性
  5. 灵活性
  6. 简化性
- 多态存在的必要条件
  - 继承
  - 重写
  - 父类引用指向子类对象：
    Parent p=new Child（）；
- 多态的实现方式
  - 重写
  - 接口
  - 抽象类和抽象方法
- Parent p=new Child()；p.add()在编辑的时候，编译器使用Parent类中的add方法验证该语句，但是在运行的时候，Java虚拟机（JVM）调用的是Child类中的add方法。

类

类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。类是一个模板，它描述一类对象的行为和状态。
静态的属性：属性
动态的行为：方法

对象创建和使用

概念
- 对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
- 对象是抽象概念的具体实现
使用new关键字创建
- 声明
  - 声明一个对象，包括对象名称和对象类型。
- 实例化
  - 使用关键字 new 来创建一个对象。
- 初始化
  - 使用 new 创建对象时，会调用构造方法（类中构造器）初始化对象。
使用
- 对象的属性：对象名.属性名;
- 对象的方法：对象名.方法名();
构造器
- 和类名相同
- 没有返回值
作用
- 使用new关键字，new本质在调用构造方法，必须要有构造器
- 初始化对象的值
注意点
- 定义有参构造之后，如果想使用无参构造，不能使用默认的无参构造，只能显示的定义一个无参的构造。
打开class文件
- 打开class文件看看，步骤：打开项目结构–>Modules–>Add_Content ROot,将out文件夹加上
自动生成构造器的快捷键
- Alt+insert

抽象类

概念
- 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
- 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
- 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
- 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
- 在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
abstract修饰
抽象方法
- 如果一个类包含抽象方法，那么该类必须是抽象类。
- 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。
抽象类总结规定
- 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
- 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
- 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
- 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
- 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
思考
- 抽象类不能new，那他存在构造器吗？可以打开class看看；可以看到class中存在构造器
- 抽象类存在的意义？提高开发效率

内部类

概念
- 内部类就是在一个类的内部再定义一个类，比如A类中定义一个B类，B类相对A类来说就是内部类，A类就是B类的外部类。
类型
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类

向上转型

子类转换为父类

向下转型

父类转换为子类

接口

概念

是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口的特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类与接口的区别

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口的实现

implements关键字
类要实现接口中的所有方法，否则该类要定义为抽象类

接口的继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。
类的多继承是不合法，但接口允许多继承。
接口多继承语法：
public interface aaa extends bbb,ccc,ddd

标记接口：没有任何方法和属性的接口

建立一个公共的父接口
向一个列添加数据类型

接口的作用

约束
定义一些方法，让不同的人实现
方法都是public abstract
属性都是public static final
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口
必须要重写接口中的方法

Java枚举

枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。

例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。

概念

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等

定义

ava 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。
语法：
enum Color {RED, GREEN, BLUE; }

内部类中使用枚举

在内部类中使用枚举的时候，每个枚举都是通过内部类实现的，且所有的枚举值都是public static final的

class Color
{
       
     public static final Color RED = new Color();
     public static final Color BLUE = new Color();
     public static final Color GREEN = new Color();
}

迭代枚举元素

使用for语句来迭代

enum Color
{
       
    RED, GREEN, BLUE;
}
public class MyClass {
       
  public static void main(String[] args) {
       
    for (Color myVar : Color.values()) {
       
      System.out.println(myVar);
    }
  }
}

values(), ordinal() 和 valueOf() 方法

enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口。
values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：
values() 返回枚举类中所有的值。
ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
valueOf()方法返回指定字符串值的枚举常量。

Java正则表达式

概念

正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。
正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

语法

在 Java 中，\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。
字符“\“：将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，“n"匹配字符"n”。"\n"匹配换行符。序列"\\“匹配”\"，"\(“匹配”("。

异常

概念

指程序运行中出现的不期而至的各种状况，如：文件找不到，网络连接失败，非法参数等。
异常发生在程序运行期间，他影响了正常的程序执行流程。

体系结构

java把异常当做对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
Throwable
- Error
  - VirtulMachineError
  - AWTError
- Exception
  - IOException
  - RuntimeException
    - ArrayIndexOutOfBoundsBoundsException数组下标越界
    - NullPointerException空指针异常
    - ArithmeticException算术异常
    - MissingResourceException丢失资源
    - ClassNotFoundException找不到异常
    - 这些异常可以选择捕获处理，也可以不处理，这些异常都是由程序逻辑错误引起的，程序应该尽可能避免。

异常处理机制

抛出异常
- throw
  - 在方法中直接使用throw抛出异常，遇到异常就会停止运行，并抛出异常
- throws
  - 在方法上使用throws抛出异常，那么在语句使用try捕获异常并处理他，程序就不会停止，继续往下执行。
捕获异常
- try
- catch
- finally

自定义异常

继承Exception类即可

常用类

Object类

hashcode（）
toString（）
clone（）
getClass（）
notify（）
wait（）
equals（）

包装类

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
Object：Number，Boolean，Character
Number：Byte，Short，Integer，Long，Float，Double

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

Boolean：基本数据类型为boolean
Byte
Short
Integer:int
Long
Character:char
Float
Double

Java Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

Math.sin()
Math.cos()
Math.tan
Math.atan

Random类

生成随机数UUID

Date类

Date
- ava中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间。
  Date date=new Date()；
  date.toString();

SimpleDateFormat

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。例如：

import  java.util.*;
import java.text.*;

public class DateDemo {
       
   public static void main(String args[]) {
       
  Date dNow = new Date( );
  SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
 
  System.out.println("当前时间为: " + ft.format(dNow));

}
}

使用SimpleDateFormat格式化日期:yyyy-MM-dd HH:mm:ss

Java Character类

在某些情况下，Java编译器会自动创建一个Character对象。

例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。这种特征称为装箱，反过来称为拆箱。
Character ch = new Character(‘a’);

实例：
// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';

// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');

String类

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。

如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

创建字符串：

String str=“Runoob”；
  String str=new String（“Runoob”）；

String创建的字符串存储在公共池中，而new创建的字符串对象在堆上。
字符串长度

用于获取有关对象的信息的方法称为访问器方法。

String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
连接字符串
学习资料：https://blog.csdn.net/Zen99T/article/details/51255418

创建格式化字符串

我们知道输出格式化数字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。
例子1：

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

例子2：

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

String方法
- 返回索引处的char值：char charAt(int index)
- 将指定字符串连接到此字符串的结尾：String concat(String str)
- 将此字符串与指定的对象比较：boolean equals(Object anObject)
- 返回此字符串的哈希码
- 。。。。

StringBuffer类

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

可变长；append（）；多线程数据量较大；低效率，安全。

StringBuilder类

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

可变长；单线程数据量较大；效率高，不安全

集合框架

Collection

List（有序可重复）
- ArrayList（常用）
  - add
  - remove
  - contains
  - size
- LinkedList（链表）（常用）
  - getFirst（）
  - getLast（）
  - removeFirst（）
  - addFirst（）
  - 。。。
Set（无序不可重复）
- HahSet（常用）
- TreeSet
Iterator：迭代器

Map

HashMap（重点，天天用）
TreeMap

Collections工具类

泛型<约束，避免类型转换之间的问题>

IO流

字符流

Reader
Writer

字节流

输出：OutputStream
输入：InputStream

节点流

CharArrayReader，Writer，InputStream，OutPutStream
StringReader，Writer
Pipe（管道流） PipedOutPutStream
File

处理流

buffer
序列化
- 反序列化
  - Serializable
    - transient（透明的）
data
- DataInputStream
- DataOutputStream
转换流
- InputStreamReader
- OutputStreamWriter
Filter
- 四个
print
- PrintWriter
- PrintStream

字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。
例子1：

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);