java笔记.txt

jvm (java virtual machine)
jre (java runtime environment)
jdk (java development kit)

jcp  // java community process
jsr  // java specification requests，java规范提案

jfr  // java flight recorder，生成性能日志 
jmc  // java mission control，可视化分析性能日志

*.java (源文件) -> 编译器 (javac.exe) -> *.class (字节码文件) -> java.exe 执行字节码文件，执行字节码文件时，不能加字节码文件后缀

jni(java native interface)  // 允许java与其它语言写的代码交互

                            --- java ee 企业应用 (jsp, ejb, service)
                            |
基础核心 java se (api, jvm) -
                            |
                            --- java me 移动设备，游戏，通信

windows配置环境变量
JAVA_HOME  // jdk文件夹目录
PATH  // jdk，bin文件夹目录
CLASSPATH  // jdk，lib文件夹目录

通过javadoc命令，可将注释生成api帮助文档，javadoc -d out test.java

do  // domain object，领域对象，就是从现实世界中抽象出来的有形或无形的业务实体
dao  // data access object，数据访问对象
dto  // data transfer object，数据传输对象
po  // persistant object，持久层对象，即entity
bo  // bussiness object，业务对象
vo  // 可以称为值对象(value object)，如果称呼它为值对象的话，那么可以将它理解为一个存放业务对象的地方，也可以称做页面对象(view object)，如果称做页面对象，那门它所代表的将是整个页面展示层数据的对象
pojo  // plain ordiary java object，简单java对象，一个中间对象，一个不受任何限制(继承某类、实现接口、包含注解)的java对象，可转化为dto，po，bo，vo。当一个pojo可序列化，有一个公共的无参构造函数，使用getter和setter方法来访问私有属性时，它就是一个java bean
java bean  // 一种可重用组件，它是一种开发组件，没有特定的容器去专门管理，通常情况下，java bean是由容器所创建的，可以很复杂，但必须满足三个条件，1、类必须是具体的、公共的、可序列化的，2、具有公共的无参构造函数，3、提供公共的getter，setter方法访问私有成员属性
ejb  // enterprise java bean，j2ee中的一个规范，功能包括，SessionBean，EntityBean，MessageDrivenBean，ejb是一种部署组件，可分布式部署，必须运行在ejb应用服务器中

java数据类型
                       --- 整数类型 (byte, short, int(4), long)，java中没有无符号数
                       |
            --- 数值型 -
            |          |
            |          --- 浮点类型 (float(4), double(8))
基本数据类型 --- 字符型 (char(2))
            |
            --- 布尔型 (boolean(1))

            --- 类 (class), 如, 字符串(String)
            |
引用数据类型 --- 接口 (interface)
            |
            --- 数组
float型变量赋值时要加f，否则默认浮点数是double型

自动类型转换，小内存类型可自动转为大内存类型
强制类型转换
double a = 1.300;
int b = (int)a;

常量，程序运行过程中不可改变
final String ABC = "hello java!";  // 变量名，全部大写

运算符
算术运算符, +, -, *, /, %, ++, --
赋值运算符, =, +=, -=, *=, /=, %=
比较运算符, >, <, >=, <=, ==, !=
逻辑运算符, &&, ||, !, ^
条件运算符, a ? b : c

流程控制语句
if () {  // 判断值必须是boolean类型
} else if () {
} else {
}

switch () {  // 判断值必须是数值、字符、字符串（java 7）或枚举类型
	case 'a':  // 可以是表达式，但不可以是带变量的表达式
		...
	break;
	...
	default:
}

while () {  // 判断值必须是boolean类型
}

do {
} while ();

for (int a = 0; a < 10; i++) {
}

continue;

break;

foreach:
for (int i : arr) {
}

数组
int[] list = {1, 2, 3}; or int list2[] = {1, 2, 3};  // 注意，字面量用{}
int[] a = new int[5];
int[] b = {1, 2, 3, 4, 5}; 等价于 int[] c = new int[]{1, 2, 3, 4, 5};  // 此时不能指定元素个数

二维数组
int[][] a = {{1, 2, 3}, {1, 2, 3}};
int[][] b = new int[2][3];  // 2行3列

Arrays类
import java.util.Arrays;
Arrays.sort(arr);
Arrays.toString(arr);

方法
public class Test {
	public int print(String a, int b) {
		return b;
	}
}
Test test = new Test();
int a = test.print();

重载
一个类中包含了两个或两个以上同名但参数不一致的方法，调用时，可根据传入的参数，调用对应的方法

成员变量，类的属性，声明时可不初始化该变量而使用默认值
局部变量，类方法中的变量，声明时必须初始化该变量，局部变量不可重复声明

构造方法（类的构造函数，默认系统自动生成）
无返回值，方法名和类名相同
public class Test {
	public Test(String a) {  // 可以定义多个构造方法，重载
		System.out.println('construct');
	}
}

静态变量
static修饰，为整个类所有，被所有对象共享。可通过类名访问（推荐），也可以通过对象名访问

实例化时，赋值流程
定义时直接初始化 -> 静态初始化块(static {}, 只在类第一次加载时初始化一次) -> 初始化块({}) -> 构造方法
父子实例化流程
super 定义时直接初始化
super 静态代码块
child 定义时直接初始化
child 静态代码块
super 代码块
super 构造函数
child 代码块
child 构造函数

特殊的初始化成员
A a = new A() {{a = 1;}} 
相当于
A a = new A();
a.a = 1;

包
package com.test;  // 必须写在源代码第一行，包名命名规范为全部小写
import com.test.*;
import static java.util.Calendar.*;  // 导入Calendar类上定义静态方法或属性，可直接使用

访问修饰符
private 本类
默认 本类， 同包
protected 本类，同包，子类
public 本类，同包，子类，其它

this关键字
代表当前对象

面向对象三大特性：封装， 继承， 多态

封装，将类的某些信息隐藏在类的内部，使外部不能直接访问，只能通过该类提供的方法来进行访问
private修饰变量 -> 创建getter和setter方法 -> 在getter和setter中实现控制语句

内部类  // static修饰的内部类，实际上是外部类，此时下面所说的都不成立，内部类 对象名 = new 外部类类名.内部类();
定义在类内部的类(可定义在方法中)，是外部类的成员，同外部类属性和方法一个级别
必须使用外部类对象来创建内部类对象，而不能直接去new一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类();
内部类的.class文件文件名格式为：外部类名$内部类名.class
内部类可访问外部类，外部类不可访问内部类
要访问外部类的同名变量，可通过：类名.this.{name}访问

局部类  // 定义在方法中内部类，一次性使用，可简化为匿名类

匿名类  // 特殊的内部类，一次性使用，局部类简化而来，定义类的同时生成该类的一个实例
return new A() {  // 匿名类，A为该匿名类，父类或接口的名字
  public toString() {  // 匿名类的方法
  }
}

lambda表达式  // 在java中实际上是一个匿名类的实例，jdk1.8  
() -> {} 
能写成lambda表达式的接口，要求包含且最多只能有一个抽象函数，这样的接口用@FunctionalInterface（可不写）注解，称为函数式接口

继承
java的继承是单继承
private修饰的属性或方法不能被继承
class A extends B {
}

重写
子类的要重写的方法，参数和返回值必须和父类一致，不需要使用特殊的修饰符

final关键字
final public ...
final可修饰类，属性，方法和变量
修饰类时，该类不可被继承
修饰属性时，该属性不能自动被隐式初始化，且只能赋值一次
修饰方法时，该方法不可被重写
修饰变量时，该变量为常量，只能赋值一次

super关键字
代表父类的实例对象
super();  // 调用父类构造函数

Object类
toString();
equals();

enum类型  // jdk1.5，与类同级别，内部也可定义属性、方法、构造函数，可以用在switch语句等，底层通过class实现
enum A {B, C, D}

多态
对象的多种形态，两个类要有继承关系
引用的多态，父类的引用既可以指向本类对象也可以指向子类对象，反过来不成立
Animal a = new Animal();
Animal a = new Dog();
方法的多态，父类引用本类对象时调用的方法为父类方法，父类引用子类对象时，调用的方法为子类继承或重写的方法，注意，该方法父类必须含有，否则报错

引用类型转换
Dog a = new Dog();
Animal b = a;  // 自动类型转换，向上类型转换，无风险
Dog c = b;  // 向下类型转换，存在安全性风险，编译器不会通过
instanceof运算符
解决引用类型转换的安全性问题
if (b instanceof Dog) {
  Dog d = (Dog)b;  // 强制向下类型转换，且无风险
}

抽象类  // 被用来创建继承层级里子类的模板，体现出一个“是不是”的关系，抽象类是一种对一类事物的抽象，包括属性、行为，它是一种模板式设计。如客机和战斗机虽然有差异，但有很多的共同点，并且都属于飞机这个大类，那么，可以抽象出飞机这个抽象类
只能被public或protected修饰，内部可以包含普通的成员变量和成员方法，抽象类可以有静态代码块和静态方法
abstract关键字
作用：不关注子类的实现，但约束子类有哪些特征
public abstract class A {  // 抽象类不能直接创建，定义抽象方法的类必须是抽象类
  public abstract void call();
}

接口  // 体现出一个“有没有”的关系，接口是对类的局部(行为)进行抽象，而不是对类进行抽象。如飞机和鸟是完全不同的类别，却都拥有飞行能力，那么，飞行能力可抽象为一个接口
接口，用来定义行为规范，是比抽象类更高层次的抽象
只能被public修饰（默认public），内部的所有方法都必须是抽象方法，不能有具体的实现，接口中定义的成员变量必须定义时就初始化，接口中不能含有静态代码块以及静态方法
interface关键字
接口可以继承多个父接口，和类不同
abstract interface {name} extends interface1, interface2, ... {
}
implements关键字，实现接口
public class A extends B implements interface1, interface2, ... {
}
可以通过匿名内部类实现接口

反射  // java.lang.reflect.{Class, Field, Method, Constructor, Array, ...};  
在运行时分析类的能力
在运行时查看对象  // 要访问对象中的值，可能需要调用对应Field, Method, Constructor对象的setAccessible(true);来取得权限
实现通用的数组操作代码  // Array.newInstance(componentType, length);componentType为数组元素类型，可以通过反射得到
利用Method对象，动态调用方法  // method对象.invoke(Object obj, Object arg1, ...);第一个参数是隐式对象，其余对象提供了显式参数，对于静态方法第一个参数为null
Class类  // 实际上是泛型类，如：A.class的类型是Class<A>
得到Class对象  // Class对象上包含很多类的信息，Class对象表示一种类型，而这种类型未必是一种类，如：int不是类，而int.class是一个Class类型的对象
类名.class
对象.getClass()
Class.forName("类全名");
Class对象.newInstance();  // 动态创建对象，如果需要传入参数，则必须使用Constructor类中的newInstance方法
参数类型
int.class
DebugTime.class
...

注解  // jdk1.5，所有的注解都是java.lang.annotation.Annotation的子类
@Override  // 重写父类方法
@Deprecated  // 过时的方法
@SupressWarnings  // 让编译器不产生警告
自定义注解
@Target(ElementType.METHOD)  // 该注解用于方法上
@Retention(RetentionPolicy.RUNTIME)  // 该注解可以通过反射读取，CLASS(默认，作为字节码修改，插桩，代理的依据，如：aspectj)，RUNTIME，SOURCE
@Documented  // 该注解会生成到javadoc中
public @interface A { 
  int abc() default 1;  // 方法名相当于属性名，default关键字，定义默认值，属性值可以是数值、字符、布尔值或数组
}
通过反射读取注解
方法.getAnnotation("参数类型")  // 得到注解的类，参数的类型如：int.class
方法.getAnnotations()  

UML(unified modeling language)
统一建模语言
类图
-,表示私有
+,表示公有
实线,表示类
虚线,表示接口

异常
          --- Error 硬伤，终结程序，JVM错误
          |
Throwable -
          |
          --- Exception 可处理
try {

} catch (Exception1 e) {

} catch (Exception2 e) {

} finally {

}
如果try-catch代码块中，存在return
try -> catch -> finally（总是会执行，即使try、catch用了return） -> finally.return -> catch.return -> try.return，没有相应的阶段忽略该阶段，任何阶段的return被执行，则整个语句块结束
异常链
throws关键字
throw关键字
public void test() throws AException {  // 有可能抛出
  throw new AException('test error!');  // 不一定非要throw
}

字符串
java中的字符串一旦创建，就不可改变，如果要创建一个可改变的字符串，需要使用StringBuffer和StringBuilder类
通过字面量声明的相同字符串，其内存地址一致，其它方式生成的相同字符串，内存地址不一致
String a = "abc";
String b = "abc";
a == b;  // true
String c = new String("abc");
String d = new String("abc");
c == d;  // false

StringBuffer是线程安全的，而StringBuilder没有实现线程安全功能，所以性能略高
StringBuilder a = new StringBuilder("abc");

包装类
基本类型不具备对象的特性，可以通过包装类，使基本类型拥有对象的特性
jdk1.5，引入了自动装箱拆箱机制
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

集合
存储任意数量具有共同属性的对象，在类的内部，对数据进行组织
集合长度可自动增长，数组的长度是固定的

           --- List(接口) --- ArrayList, Vector(有一个子类Stack), LinkedList
           |
Collection --- Queue(接口) --- LinkedList(链表), PriorityQueue, ArrayDeque
           |
           --- Set(接口，不允许重复元素) --- HashSet, TreeSet(底层用TreeMap实现)

Map --- HashMap(哈希表，存储值类型为Entry类<key, value>)
    |
    --- TreeMap
    |
    --- HashTable (有一个子类Properties)

Dictionory --- HashTable      

早期的几个集合类
Vector  // ArrayList
Stack  // ArrayList
HashTable  // HashMap
Enumeration  // Iterator

Stream类型  // 流，不是io流，jdk1.8，用于函数式编程，用于数组和集合，map没有流，但有类似的方法
Arrays.stream(arr);
Stream<T> s = collection.stream();
s.filter().map().sum();
parallelStream()  // 并行流，底层运行多个线程

泛型  // 只能用于引用类型
规定了某集合只能存储特定类型的对象，会在编译时，检查类型
public List<ABC> a;  // ABC为泛型约束的类型
<>  // 针对类型时，写在类名后面，针对方法时，定义泛型方法时，写在方法返回值类型的前面，调用泛型方法时，写在方法名前面
类型限定
?  // 任意类型，相当于Object
? extends A  // A的所有子类
? super B  // B的所有父类、超类

Comparable接口
定义默认比较规则

Comparator接口
定义临时比较规则

线程  // 使用方法：A extends Thread or A implements Runnable，编写相应的run方法
Thread.sleep(100);  // 单位ms 
Thread thread = new Thread(A);
start()  // 启动线程
setPriority(100)  // 设置线程优先级
setDaemon(true)  // 设置是否是守护线程
线程分两类
普通线程  // 普通线程，非Daemon线程，若程序还有非Daemon线程，整个程序不会结束
Daemon线程  // 又称守护线程、后台线程，普通线程结束了，Daemon线程自动终止，垃圾回收线程是后台线程
synchronized关键字  // 取得锁，用于线程同步
synchronized(对象) {}
public synchronized void push() {}  // 相当于synchronized(this)
this.wait()  // 可以释放对象锁
this.notify()  // 通知一个wait的线程
this.notifyAll()  // 通知所有wait的线程
java.util.concurrent.*;  // 锁，集合等，jdk1.5，用于并发，底层用synchronized、wait、notify、notifyAll实现
线程池  // ExecutorService接口，ThreadPoolExecutor类，Executors工具类
ExecutorSerice pool = Executors.newCachedTreadPool(); 
pool.execute(Runnable r);
java.util.Timer  // 底层用线程实现
java.swing.Timer  // 底层用线程实现

流  // 把不同类型的输入、输出都抽象为流。jdk 1.4加入java.nio，jdk 1.7加入java.nio2
字节流字符流  // 按流的内容分类，字节流一个一个字节读取，字符流一个一个字符读取，每一个字符在字符流中占据的字节数，由编码方式决定
输入流输出流  // 按流的方向分类
节点流处理流  // 按流的功能分类，节点流，向一个特定的地方(节点)读写，处理流，对一个已存在的流进行连接和封装，又称为过滤流

       字节流         字符流
输入流  InputStream   Reader
输出流  OutputStream  Writer

节点类型  字节流                                        字符流
文件     FileInputStream, FileOutputStream            FileReader, FileWriter           
内存数组  ByteArrayInputStream, ByteArrayOutputStream  CharArrayReader, CharArrayWriter     
字符串                                                 StringReader, StringWriter
管道     PipedInputStream, PipedOutputStream          PipedReader, PipedWriter

处理类型         字节流                                      字符流
缓冲            BufferedInputStream, BufferedOutputStream  BufferedReader, BufferedWriter
过滤            FilterInputStream, FilterOutputStream      FilterReader, FilterWriter
字节流转字符流                                               InputStreamReader, OutputStreamWriter
对象序列化       ObjectInputStream, ObjectOutputStream
基本数据类型转化  DataInputStream, DataOutputStream
行号处理         LineNumberInputStream                      LineNumberReader
可回退流         PushbackInputStream                        PushbackReader
可显示流         PrintStream                                PrintWriter

File  // 文件类， 在java中将目录(文件夹)也当作文件处理
getName()
getPath()
getAbsolutePath()
getParent()
renameTo("newFileName")
exists()
canWrite()
canRead()
isFile()
isDirectory()
isAbsolute()
lastModified()
length()
delete()
mkdir()
list()

RandomAccessFile  // 可实现对文件的随机读取
构造方法
RandomAccessFile(String name, String mode)
RandomAccessFile(File file, String mode)
定位方法
seek(long pos)
读写方法读写方法
readBoolean(), readChar(), readInt(), readLong(), readFloat(), readDouble(), readLine(), readUTF()...
writeBoolean(), writeChar(), writeInt(), writeLong(), writeFloat(), writeDouble(), writeLine(), writeUTF()...

正则表达式  // java.util.regex包
Pattern类
Pattern.compile(regexString)
Pattern.matches(pattern, text)  // 返回boolean
Matcher类  // 通过pattern.matcher(text)得到
find() 
appendReplacement(stringBuffer, "new $0")  // $0表示整个匹配项，$1, $2...表示各个分组
appendTail(stringBuffer)
group()  // group()或group(0)表示整个匹配项，group(1), group(2)...表示各个分组

jpa  // 持久化规范
jdbc  // 提供规范，具体驱动由数据库厂商提供
DDL  // Data Definition Language，数据定义语言。用于完成对数据库对象（数据库、数据表、视图、索引等）的创建、删除、修改。创建删除库、表等操作
DML  // Data Manipulation Language，数据操作语言。用于完成对数据表中数据的添加、删除、修改操作。返回值，影响的数据行数 or 0 
DQL  // Data Query Language，数据查询语言。用于将数据表中的数据查询出来。返回值，ResultSet，ResultSet.next()返回true or false
DCL  // Data Control Language，数据控制语言。用于完成事务管理等控制性操作。权限控制
基本流程：贾琏欲执事  // 贾，加载驱动，事，释放资源
DAO  // 结合抽取出的jdbcUtil，精简、共用代码
Statement和PreparedStatement
事务  // 每一条DML语句，默认自动提交事务
sql批处理  // mysql开启批处理，连接url增加后缀，?rewriteBatchedStatements=true
jdbc获取新增记录的主键  // PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS); ... ResultSet rs = pstmt.getGeneratedKeys();
连接池  // DataSource，一般由服务器提供者提供，DBCP(spring推荐，apache维护)，DRUID(性能最好，阿里维护)，C3P0(性能最差(但测试环境性能较高)，已停止维护，hibernate推荐)
jdbcTemplate