数据库
mysql,oracle,sqlserver,mongdb
基础
h5+css3,js+jquery,bootstrap,vuejs,layui
java,jsp
持久化
jdbc,mybatis,mybatisplus,hibernate
高阶
spring,springmvc,springboot,springcloud,springcloudalibaba
其他
docker,linux,redis,nginx,es
java打包
.jar 类打包成jar
.war web应用程序打包
jdk
包含源代码和运行环境
适合开发人员
jre
包含运行环境
适合运维人员
配置环境变量
java_home
C:\Program Files\Java\jdk1.8.0_121
path
C:\Program Files\Java\jdk1.8.0_121\bin
不同的操作系统需要安装对应的系统的jdk
java是面向对象的语言
java是开源的语言
java是跨平台
JVM
java要经过编译成.class的字节码文件，
.class的字节码文件经过jvm装载校验转换成机器码
javac 编译密令
java 运行密令
变量语法
数据类型 变量名
剖析：
数据类型：
基本数据类型
整数 byte short int（推荐） long
小数 float double（推荐）
字符 char（推荐）
布尔 boolean（推荐）
引用数据类型
类、接口、数组、对象、String（推荐）
变量
首字母 其后字母
字母 _ $ 字母 _ $ 数字
方法
访问修饰符 返回类型 方法名称(参数列表)
{
方法体
}
剖析：
访问修饰符
private 默认 protected public
返回类型
基本数据类型
引用数据类型
void
类
class 类名{
属性（变量）
数据类型 变量名;
行为（方法）
访问修饰符 返回类型 方法名(参数列表){
方法体
}
}
循环
四要素
1从哪开始 int i=0;
2到哪结束 i<10
3趋近结束条件 i++
4循环体 代码块
1
while(2){
4
3
}
1
for(;2;){
4
3
}
1
do{
4
3
}while(2);
判断分支
表达式?值1:值2
switch(整数/字符/String){
case 常量1:
break;
case 常量2:
break;
default:
break;
}
简单if
if(){
}
一般if
if(){
}else{
}
多重复if
if(){
}else if(){
}else{
}
嵌套if
if(){
if(){
}
}
===========================================================
java
封装
定义:
封装就是为了隐藏信息实现细节的过程
实现方式：
使用private私有化然后在提供一个public公有的访问操作
使用的到的关键字:
private
public
分类:
属性封装
实现方式：
1、将属性使用private私有化
2、提供公有的get/set方法
Emg：
public class Person{
//1、将属性私有化
private int id;
private String name;
//2、提供公有的get/set方法
public int getId(){
return this.id;
}
public void setId(int id){
this.id=id;
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
}
方法封装
实现方式：
1、将方法使用private私有化
2、提供公有的方法去访问
Emg：
public class Person{
//1、使用private修饰方法
private void printInfo(){
....
}
//提供公有的方法去访问私有的方法
public void aprintInfo(){
//调用私有方法
printInfo();
}
}
继承
定义：继承就是子类沿用父类非私有的属性和行为
实现方式：
将程序中共同的属性和方法抽取出来建立一个新的类，该类用于被继承，子类就可以沿用父类的非私有的属性和行为
特点：
减少代码重用性，有利于程序的扩展
关键字：
extends
语法：
public class 子类 extends 父类{
}
注意：
继承具有传递性，且单根继承
一个类没有显示继承某一个类，则默认继承Object类
=====================================================================================
继承
关键字：extends
语法：
class 子类 extends 父类{
}
特点：
1、子类可以沿用父类的非私有的属性和方法
2、一个类没有显式继承，则默认继承Object
3、继承是单根性继承即：一个类只能有一个父类
4、继承具备传递性
5、一个类可以是父类也可以同时是子类
6、父类构造方法运行先于子类构造方法的运行
7、构造方法不能被继承
8、继承关系中new的对象是谁则就从谁开始向上找止到找到为止，否则报错
final
修饰类
特点:修饰类该类为最终类,不能被继承
语法:
final class 类名{
}
修饰变量
特点:修饰变量为常量必须给值
语法：
final 数据类型 变量名=值;
修饰方法
特点:修饰方法该方法不能被重写
语法：
final 返回类型 方法名(参数列表){
}
this
作用：this指向的当前类的对象
语法：
调用属性：
语法：this.属性
作用：访问当前类的属性
调用方法：
语法：this.方法名(参数列表)
作用：访问当前类的方法
调用构造方法：
语法：this(参数列表)
作用：在当前构造方法中调用当前类的其他构造方法
super
作用：super指向当前类的父类对象
语法：
调用属性：
语法：super.父类属性
作用：访问当前类的父类的属性
调用方法：
语法：super.父类方法名(参数列表)
作用：访问当前类的父类的方法
注意：
1、this和super不允许出现在static修饰的方法类
2、this和super调用构造方法必须放在当前构造方法的第一行
重载
特点：
1、一个类
2、方法名相同，参数列表不同
3、能否构成重载和返回类型以及访问修饰符无关
4、调用重载方法的版本取决于参数列表
重写
特点：
1、两个类
2、父子关系
3、方法签名（返回类型、方法名、参数列表）相同
4、访问修饰符要么一致要么升级
5、调用重写方法的版本取决于new的对象类型而非引用类型
=============================================================================================
多态
多态表示多种形态,即多种实现方式
分类:
重载(overload)
特征:
1)一个类中
2)方法名相同,参数列表不同(参数的个数、类型、顺序一个不同则不同)
3)能否构成重载和返回类型以及修饰符无关
调用重载方法的版本取决于参数列表
普通方法可以构成重载
构造方法也可以构成重载
重写(override)
特征：
1）两个类
2）继承关系即：父子关系
3）返回类型、方法名称、参数列表必须相同
4）访问修饰符要么一致要么升级
调用重写方法的版本取决于对象类型
Emg：
class Person{
void eat(){}
}
class Stus extends Person{
int eat(){}//错误
int eat(int age){//和父类的eat()构成了重载
return 0;
}
}
抽象
抽象表示不够具体，既：属性和行为不具体
关键字：abstract
分类：
abstract修饰的类为抽象类,该类只能被继承
语法：
abstract class 类名{
}
abstract修饰的方法为抽象方法,该方法没有方法体，只能被重写
语法：
abstract 返回类型 方法名(参数列表);
作用：
抽象类是一个模板，开发人员可以根据抽象类定义个格式修改和创建新的类
特点：
1）抽象类主要用于被继承，有利于程序的扩展性
2）抽象类中的抽象方法不能有方法体
3）抽象类中可以有抽象方法和非抽象方法
4）抽象类中可以构造方法、静态（static）方法、最终（final）方法、常量、变量，但构造方法静态方法最终方法不能被抽象修饰
5）抽象类不能被实例化（new），但是可以采用父类引用指向子类对象创建
6）抽象类中的抽象方法必须在子类中重写，否则该子类为抽象类
7）有抽象方法的类一定为抽象类
8）抽象方法不能是private修饰
Emg:
abstract class Person{
//变量
public int age=10;
//常量
public static final String name="liusir";
//最终方法,静态方法。不能被抽象
public final static String getName(){
return name;
}
//抽象方法，不能有方法体
public abstract int getAge();
//构造方法。不能被抽象
public Person(){}
}
3w1h
what？
where？
when？
how？
接口
接口是为了弥补继承的单一性（一个类只能有一个父类），即：使用接口可以实现多重继承
关键字：interface
定义：
接口就是对外的一些功能的声明
语法：
interface 接口名{
//常量
static final String PI=3.14;
//方法声明
void 方法名(参数列表);
}
注意：
接口是一个特殊的抽象类
接口能实现多重继承
类和类之间是继承extends关系
接口和接口之间也是继承extends关系
类和接口之间是实现implements关系
接口中可以定义常量和方法
接口中变量默认为final、static、public修饰
接口中方法默认为public、abstract修饰
接口中方法不能有方法体
==================================================================================
异常：
定义：程序在运行的过程中发生的错误，这些错误处理不当，就会终止程序运行
解决异常问题的办法：
1、判断
处理的是已知的非常明确的异常位置
Emg：
System.out.println(“sa”);
int secondnum=0;
if(secondnum!=0){
int num = 3 / secondnum;
System.out.println(num);
}else{
System.out.println(“出错拉!”);
}
System.out.println(“admin”);
2、异常处理
处理未知可能会出错的异常位置
异常处理分类：
Throwable（异常处理的父类）
Error（致命性异常）
特点：
Error类通常是java运行内部问题如：资源耗尽，jvm错误
该错误是无法捕获的，程序是不可恢复执行，致命性错误
Exception（可捕获的异常）
特点：
可捕获可处理的异常，正确的处理之后程序将继续运行
分类：
编译时异常（非运行时异常）
特点：该异常很好排错，一般属于语法错误或系统定义的错误
包含：
IOException 文件读写异常
SQLException SQL异常
ClassNotFoundException 类找不到的异常
运行时异常（RuntimeException）
特点：该异常语法是正确的，在运行时候才会出现，一般是逻辑问题（除数为0或死循环）
包含：
SystemException
NumberFormatException 数字格式化异常
NullPointerException 空指针异常
ArithmeticException 数学异常
异常处理关键字：
try
可能出错的代码块放在try块内
catch
捕获try块中匹配的异常，当catch捕获的异常和try块中出现的异常不匹配则无法捕获，程序结束
finally
必须会被执行的，一般用于释放资源（赋值为null）
throw
特点：
一般是手动抛出异常，和if判断一起使用，通常情况下可以抛出自定义异常
throw抛出异常最后必须有方法使用try-catch-finally去解决掉，如果不解决就会给jvm解决
语法：
if(){
throw new 异常类("错误信息")
}else{
}
throws
特点：
方法后面抛出异常，谁调谁使用try-catch-finall解决，不解决可以继续throws止到最后交给jvm处理
语法：
访问修饰符 返回类型 方法名称(参数列表) throws 异常类{
}
注意：
try-catch-finally，try是必须的，catch和finally可以省略但不能同时省略
可以多重catch，当try中出现异常，会在catch块中找第一个能匹配的异常进行处理，此时其他异常会被忽略
Emg：
try {
int result = firstNum/secondNum;
System.out.println("两个数字相除的结果是:"+result)
}catch(ArithmeticException e) {
System.out.println("算术异常:");
}catch(NumberFormatException e) {
System.out.println("数字转换异常");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("数组下标越界异常");
}catch(Exception e) {
System.out.println("其他异常");
}
多重catch，捕获范围小的必须放在捕获范围大的上面，保证最后一个Exception
如果try块中异常，没有对应的catch捕获，则程序结束
自定义异常
创建步骤：
1、写一个类
2、继承Exception
3、写一个带String类型的参数的构造函数，super(msg)调用父类的Exception的构造函数即可
4、在程序中需要出现自定义异常的地方通过判断然后throw出去就可以了
定义自定义异常类
class MyException extends Exception{
public MyException(String msg){
super(msg);
}
}
使用自定义异常类
public class Demo1 {
public static void main(String[] args) {
try {
int age=10;
if(age==10){
throw new MyException("恭喜你");
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
注意：
throw之后一定要使用throws继续抛出或直接使用try-catch-finally捕获
一个方法被重写时，子类中重写父类的方法，则子类必须抛出父类相同的异常类或比父类抛出的异常更细致的异常子类
==================================================================================
log4j
log4j是Apatch提供的开源日志包
作用:
记录操作日志
log4j三大组件
1、日志信息的优先级别
级别分类：off fatal error warn info debug all
常用四个级别为：error warn info debug
注意：
在log4j配置文件中定义一个日志级别，
只有大于或等于该日志级别的日志请求才会被打印出来
这是log4j的核心原则
2、日志信息的输出目的地
输出目的地分类：
1、控制台(console)
2、文件(files)
3、图形组件(GUI components)
常用输出目的地：
文件和控制台
3、日志信息的输出格式
输出格式分类：
1、PatternLayout(可以灵活地指定布局模式)
2、HTMLLayout(以HTML表格形式布局)
常用输出格式：
PatternLayout日志输出格式，此时配置layout.ConversionPattern
log4j的优点
1、可以决定log信息的目的地
2、可以定义每一条日志信息的级别
3、有利于系统的规划
4、输出格式
使用log4j记录日志
1、在工程中加入log4j所使用的jar文件
2、将log4j.properties文件拷贝到src目录
3、在需要进行日志操作的类中实现如下操作：
1）导包
import org.apache.log4j.Logger;
2）创建Logger对象
Logger logger = Logger.getLogger(类名.class.getName());
3）设置日志记录操作
logger.debug("日志内容");
logger.info("日志内容");
基本数据类型和包装类型
byte Byte
short Short
int Integer
long Login
float Float
double Double
char Character
boolean Boolean
自动装箱和自动拆箱
自动装箱
基本数据类型转换成其对应的包装类型
int a=10;
Integer b=a;//a是基本数据类型，赋值给Integer的b
自动拆箱
包装类型转换成其对应的基本数据类型
Integer b=10；
int a=b;//b是包装类型，赋值给int类型的a
注意：
自动装箱和自动拆箱只针对基本数据类型和其对应的包装类型之间自动转换
int a=10;
Double b=a;//错，不能称为自动装箱因为int的a的包装类是Integer。
反射
定义：程序在运行过程中获取自身信息（属性和行为）的一种机制
特点：
java.lang.Class表示java应用程序在运行的过程中所加载的类或接口的实例。
每加载一个类JVM都会自动为其生成一个Class对象
实现方式：
1、通过Object类的getClass()方法获取Class对象
2、Class.forName()方法获取Class对象
======================================================================
集合有缺点：
List(有序,可重复)
ArrayList
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
Vector
底层数据结构是数组,查询快,增删慢
线程安全,效率低
LinkedList
底层数据结构是链表,查询慢,增删快
线程不安全,效率高
Set(无序,唯一)
HashSet
底层数据结构是哈希表。
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可
LinkedHashSet
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
TreeSet
底层数据结构是红黑树。(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象
2）Map(双列集合)
A:Map集合的数据结构仅仅针对键有效，与值无关。
B:存储的是键值对形式的元素，键唯一，值可重复。
HashMap
底层数据结构是哈希表。线程不安全，效率高
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可
LinkedHashMap
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
Hashtable
底层数据结构是哈希表。线程安全，效率低
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可
TreeMap
底层数据结构是红黑树。(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象
107
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
