趁着周末整理了一下java知识点，时间比较仓促，大概梳理了一下易忘点还有整体框架。有的地方难免可能会有错误，欢迎提出。
一 switch 结果返回值
byte short int char
在JDK1.5 的时候可以是枚举
在JDK1.7 的时候可以是String
二 内存结构
如果一个String类型的变量相加，那么在堆内存中开辟空间。
例如： String a = "ac"; //a是一个常量，有常量优化机制，在方法区开辟内存空间。
String b = a+"d"; // 此时的a是一个变量，在堆内存中开辟空间。
三 类型参数
如果参数是一个引用数据但非String类型，那么值改变。
如果参数是一个基本数据类型||String类ixng，那么值是不变的
匿名内部类使用局部变量 ，局部变量前面必须加final修饰 为了延长局部变量的声明周期
四 排序
// 冒泡排序
for (int i = 0; i < args.length -1 ; i++) {
for (int j = 0; j < args.length - 1- i ;j++){
if (args[j] > args[j+1]) {
// 互换
}
}
}
//选择排序
for (int i = 0; i < args.length -1; i++) {
for (int j = i+1; j < args.length ; j++) {
if (args[i]> args[j]) {
// 互换
}
}
}
五 面向对象
三大特征：
封装
把属性和实现细节隐藏起来，不让外界直接访问，提供公共的方法访问方式 但private仅仅是封装的表现形式。
继承
只能单继承，不能多继承《接口除外》，也是多态的前提
多态
父类引用指向子类对象。
抽象类：
1·有构造方法；
2·可有非抽象函数，可有抽象函数，但是被abstract修饰，该类也被abstract修饰。
3.抽象方法必须被子类重写。
4.不可实例化。
接口：
1·没有构造方法；
2·该类中所有的函数都是抽象的。
3·成员常量 默认被public static final 修饰
成员方法 默认被public abstract 修饰
abstract 《修饰类和函数》这个关键字不可以和哪些关键字共存
1.final：因为被final修饰的类不能被继承，被final修饰的方法不能被重写。
2.private：因为被private修饰的方法不能重写，但是abstract方法要求重写。
3.static：因为一个方法要是同时被static 和abstract修饰，那么这个方法就可以类名.方法名 调用.
但是此方法是抽象的,调用也无意义,所以就导致static 和abstract不能共存.
final 修饰符 类，方法，成员常量
1·被修饰的类不可被继承
2·被修饰的方法不可被重写
3·被修饰的常量不可改变
局部变量，成员变量，静态变量区别
1·生命周期
2·书写位置
3·是否有默认初始化值
4·内存位置
5，调用方式
一个对象的创建经历7步：
1：首先想要创建某个类的对象 必须先把类的class文件加载到方法区
2：写一个引用
3：遇到new就去堆内存中开辟空间
4：默认初始化
5：显示初始化（如果有显示初始化就进行）
6：执行构造方法， 如果构造方法里面有赋值操作 就进行赋值
7：把地址值赋值给 引用
六 String.StringBuffer.StringBuilder三者的区别：
①.String 引用数据类型，长度不可发生改变。
②.StringBuffer 引用数据类型，字符缓冲。长度可发生改变。线程安全，效率比较低。
③.StringBuilder 引用数据类类型，带字符的缓冲。是JDK1.5的新特性，拥有同StringBuffer相同的api，但是不同点是该类是线程不安全的
效率高。
其实StringBuffer默认重写了String的toString方法。
七 集合框架
集合分为单列集合和双列集合 八 关于文件
创建文件 createNewFile()
创建文件夹 mkdir()
创建多级文件夹 mkdirs()
**无论是创建文件还是文件夹如果已经存在的话，就不在创建。返回值为false；
九 IO流 流对象原则：流对象要及时地释放，晚开早关。
字节流：可以操作任何数据，因为在计算机中任何数据都是以字节的形式进行存储的
InputStream:
FileInputStream:
方法：read()返回值类型为int，每次读取是一个字节，读取不到数据返回-1；
为什么读取的是一个byte字节，而返回的是一个int类型的数据；因为二进
制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到
111111111那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不
读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111
会在其前面补上24个0凑足4个字节,那么byte类型的-1就变成int类型的255了
这样可以保证整个数据读完,而结束标记的-1就是int类型
OutputStream:
FileOutputStream:
构造方法传入文件时，不存在就重新创建，如果存在了就清空之前的数据，重新写入。
如果想在之前的文件里面追加数据内容，那么就使用new FileOutputStream(String pathName,true)这个构造方法
高效率的复制文件：
try {
FileInputStream fis = new FileInputStream("a.text");
FileOutputStream fos = new FileOutputStream("b.text");
int len = 0;
byte [] args = new byte [1024 * 8];
while ((len = fis.read(args))!= -1){
fos.write(args,0,len); //0表示是从数组的0索引开始 len表示写入数组的0-len长度的数据
}
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
// 使用带缓冲的输入输出流进行数据传输
FileInputStream fis = new FileInputStream("a.text");
FileOutputStream fos = new FileOutputStream("b.text");
BufferedInputStream bis = new BufferedInputStream(fis); // 默认读取1024 * 8 个字节
BufferedOutputStream bos = new BufferedOutputStream(fos);
int b;
while ((b = bis.read())!= -1){
bos.write(b);
}
bis.close();
bos.close();
close 和 flush 的区别：
close ：关闭流，并且在关闭流之前在刷新一下缓冲区域，一旦关闭了流资源就不能使用流对象了。
flush ：只刷新缓存区域，不刷新流，流对象还可以继续使用。
try catch finally return 执行顺序：
try花括号中存放可能会出现异常的代码，可以存放return 将对象返回。如果出现异常，则执行catch。
无论是出异常还是不出异常finally中的代码一定会执行。
如果try中没有出现问题，执行到return语句的时候不会直接结束该方法，而是先开辟一条返回路径
然后执行finally中的语句，执行完毕，按照之前return开辟的返回路径结束。
标准的异常处理，必须要保证流对象要关闭
private void text3() throws IOException{
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("a.txt");
fos = new FileOutputStream("b.text");
int len;
byte [] args = new byte[1024 * 8];
while ((len = fis.read(args)) != -1) {
fos.write(args,0,len);
}
} finally {
try{
if (null != fis) { //try finally的嵌套目的能关一个就关一个
fis.close();
}
}finally {
if (null != fos) {
fos.close();
}
}
}
}
字符流：只能操作纯字符数据
Reader:
Writer:
十线程
JVM 是多线程 至少启动了垃圾回收线程和main 主方法。
生命周期：新建--》就绪--》运行--》堵塞--》死亡
实现方式：
① 继承Thread,重写run方法，在run方法中操作新线程要做的事，创建该对象，并调用start方法开启新线程。
② 实现Runnable接口，重写run方法，且在run方法中操作新线程要做的事。创建实现Runnable接口的类，创建
Thread类，将实现Runnable子类传入，调用start方法，开启线程。
同步代码块 synchronized
使用背景： 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
何为同步代码块：使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块。
多个同步代码块如果使用相同的锁对象, 那么他们就是同步的。
synchronized(任意对象 但是必须是同一个){
}
同步方法 被synchronized修饰的方法，成为同步方法，该方法中所有的代码都是同步的。
锁对象：
① 非静态同步函数，同步锁对象默认是当前对象this。
② 静态同步函数，同步锁对象默认是当前类的字节码文件。
线程通信 两个线程或两个线程以上 wait() && notifyAll()
注意：
① 这两个方法必须在同步代码块中执行，并且使用锁对象来调用。
② 这两个方法定义在Object类中，因为锁对象是任意对象，而Object是所有对象的基类。
③ sleep 和 wait 的区别
a. sleep在使用的时候必须传入时间，时间到了自动醒来。不释放锁
wait在使用的时候可以传可不传，传参的话时间到了自动醒来。释放锁.不传的话等待唤醒。
b.sleep 可以在同步函数或者同步块中使用，反之也可以。
wait 必须在同步函数中使用.
十一 单例设计模式
饿汉式
① 私有默认构造函数
② 创建本类对象，但外界不可访问，私有
③ 对外提供公共的获取方法 获取唯一的对象
class Demo {
private Demo(){}
private static Demo demo = new Demo();
public static Demo getInstance(){
return demo;
}
}
懒汉式
class Demo {
private Demo(){}
private static Demo demo;
public static synchronized Demo getInstance(){ // 可能会出现多线程并发，所以加同步，
if (demo == null) { // 但是效率低，所以加if判断。
demo = new Demo();
}
return demo;
}
}