个人学习向（自用）

java基础

重载与重写的区别

重载：是发生在同一个类中，方法名必须相同，参数类型不同，个数不同，顺序不同，方法返回值和修饰符可以不同，发生在编译时。

重写：发生在父子类中，方法名。参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，返回修饰符范围大于等于父类；如果父类方法返回修饰符为private则子类不能重写该方法。

String和StringBuffer，StringBuilder的区别是什么？String为什么是不可变的？

可变性

简单来说：String类中使用final关键字字符数所以组保存字符串，private final char value[]，所以String对象是不可变的。而StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串char[] value但是没有用final关键字修饰，所以这两种对象都是可变的。

StringBuilder与StringBuffer的构造方法都是调用的父类构造方法也就是AbstractStringBuilder实现的。
​
​
​
abstract class AbstractStringBuilder implements Appendable, CharSequence 
​
{ char[] value; 
​
int count; 
​
AbstractStringBuilder() { 
​
}
​
AbstractStringBuilder(int capacity) 
​
{ value = new char[capacity]; 
​
}

Ctrl+B：进入

Ctrl+Alt+左右：返回刚才的位置

Ctrl+Alt+L：格式化

Alt+Enter：导包

IO分类 字节流：操作一切的速度 字符流：读中文 缓冲流：加快读写速度 转换流：不同编码文件读取的时候（GBK转换为UTF-8） 序列化：把对象数据存在文件中，用的比较

缓冲流：

字节缓冲流：BufferedInputStream ， BufferedOutputStream
字符缓冲流：BufferedReader ， BufferedWriter
​
构造方法：
public BufferedInputStream(InputStream in) ：创建⼀个 新的缓冲输⼊流。
public BufferedOutputStream(OutputStream out) ： 创建⼀个新的缓冲输出流。
​
构造举例，代码如下：
// 创建字节缓冲输⼊流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
​
效率测试
查询API，缓冲流读写⽅法与基本的流是⼀致的.
基本流，代码如下：
public class BufferedDemo {
 public static void main(String[] args) throws FileNotFoundException {
 // 记录开始时间
 long start = System.currentTimeMillis();
 // 创建流对象
 try {
 FileInputStream fis = new
FileInputStream("/Users/oldyang/Desktop/demo01.png");
 FileOutputStream fos = new
FileOutputStream("/Users/oldyang/Desktop/demo02.png")
 
 // 读写数据
 int b;
 while ((b = fis.read()) != -1) {
 fos.write(b);
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
 // 记录结束时间
 long end = System.currentTimeMillis();
 System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
 }
}
⼗⼏分钟过去了...
​
​
​
// 创建字节缓冲输⼊流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"))
​
public BuffereReader(Reader in)创建一个新的缓冲输入流
public BuffereReader(Writer out)创建一个新的缓冲输出流
​
BufferedReader： public String readLine() : 读⼀⾏⽂字。
BufferedWriter： public void newLine() : 写⼀⾏⾏分隔符,由系统属性定义符号。

转换流：

InputStreamReader类

转换流 java.io.InputStreamReader ，是Reader的⼦类，是从字节流到字符流的桥梁。它读取字节，并使⽤指

定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

InputStreamReader(InputStream in) : 创建⼀个使⽤默认字符集的字符流。

InputStreamReader(InputStream in, String charsetName) : 创建⼀个指定字符集的字符流。

OutputStreamWriter类

OutputStreamWriter(OutputStream in) : 创建⼀个使⽤默认字符集的字符流。

OutputStreamWriter(OutputStream in, String charsetName) : 创建⼀个指定字符集的字符流。

序列化

ObjectOutputStream

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到⽂件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out) ： 创建⼀个指定OutputStream的ObjectOutputStream。

序列化操作

1. ⼀个对象要想序列化，必须满⾜两个条件:

该类必须实现 java.io.Serializable 接⼝， Serializable 是⼀个标记接⼝，不实现此接⼝的类将不会

使任何状态序列化或反序列化，会抛出 NotSerializableException 。

该类的所有属性必须是可序列化的。如果有⼀个属性不需要可序列化的，则该属性必须注明是瞬态的，使⽤ transient 关键字修饰。

public class Student implements java.io.Serializable {
​
 public String name;
​
 public String address;
​
 public transient int age; // transient瞬态修饰成员,不会被序列化
​
 public void addressCheck() {
​
 System.out.println("Address check : " + name + " -- " + address);
​
 }
​
}

2.写出对象⽅法

public final void writeObject (Object obj) : 将指定的对象写出。
​
​
​
public class SerializeDemo{
​
 public static void main(String [] args) {
​
 Student stu = new Stuent();
​
 stu.name = "zhangsan";
​
 stu.address = "hz";
​
 stu.age = 20;
​
 try {
​
 // 创建序列化流对象
​
 ObjectOutputStream out = new ObjectOutputStream(new
​
FileOutputStream("student.txt"));
​
 // 写出对象
​
 out.writeObject(stu);
​
 // 释放资源
​
 out.close();
​
 System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序
​
列化。
​
 } catch(IOException i) {
​
 i.printStackTrace();
​
 }
​
 } 
​
}

输出结果：

Serialized data is saved

ObjectInputStream类

构造⽅法

public ObjectInputStream(InputStream in) ： 创建⼀个指定InputStream的ObjectInputStream。

反序列化操作

如果能找到⼀个对象的class⽂件，我们可以进⾏反序列化操作，调⽤ ObjectInputStream 读取对象的⽅法：

public final Object readObject () : 读取一个对象。
​
public class DeserializeDemo {
​
 public static void main(String [] args) {
​
 Employee e = null;
​
 try { 
​
 // 创建反序列化流
​
 FileInputStream fileIn = new FileInputStream("Student.txt");
​
 ObjectInputStream in = new ObjectInputStream(fileIn);
​
 // 读取⼀个对象
​
 stu = (Student) in.readObject();
​
 // 释放资源
​
 in.close();
​
 fileIn.close();
​
 }catch(IOException i) {
​
 // 捕获其他异常
​
 i.printStackTrace();
​
 return;
​
 }catch(ClassNotFoundException c) {
​
 // 捕获类找不到异常
​
 System.out.println("Employee class not found");
​
 c.printStackTrace();
​
 return;
​
 }
​
 // ⽆异常,直接打印输出
​
 System.out.println("Name: " + stu.name); // zhangsan
​
 System.out.println("Address: " + stu.address); // beiqinglu
​
 System.out.println("age: " + stu.age); // 0
​
 }
​
}

Collection集合

Collection：单列集合类的根接⼝，⽤于存储⼀系列符合某种规则的元素，它有两个重要的⼦接

⼝，分别是 java.util.List 和 java.util.Set 。其中， List 的特点是元素有序、元素可重

复。 Set 的特点是元素⽆序，⽽且不可重复。 List 接⼝的主要实现类有 java.util.ArrayList

和 java.util.LinkedList ， Set 接⼝的主要实现类有 java.util.HashSet 和

java.util.TreeSet

Collection常用功能

public boolean add(E e) ： 把给定的对象添加到当前集合中 。

public void clear() :清空集合中所有的元素。

public boolean remove(E e) : 把给定的对象在当前集合中删除。

public boolean contains(E e) : 判断当前集合中是否包含给定的对象。

public boolean isEmpty() : 判断当前集合是否为空。

public int size() : 返回集合中元素的个数。

public Object[] toArray() : 把集合中的元素，存储到数组中。

Iterator（迭代器的使用）

public Iterator iterator() : 获取集合对应的迭代器，⽤来遍历集合中的元素的。

下⾯介绍⼀下迭代的概念：

迭代：即Collection集合元素的通⽤获取⽅式。在取元素之前先要判断集合中有没有元素，如果

有，就把这个元素取出来，继续在判断，如果还有就再取出出来。⼀直把集合中的所有元素全部取出。这种取出⽅式专业术语称为迭代。

Iterator接⼝的常⽤⽅法如下：

public E next() :返回迭代的下⼀个元素。

public boolean hasNext() :如果仍有元素可以迭代，则返回 true。

实例：

public class IteratorDemo {
​
 public static void main(String[] args) {
​
 // 使⽤多态⽅式 创建对象
​
 Collection<String> coll = new ArrayList<String>();
​
 // 添加元素到集合
​
 coll.add("串串星⼈");
​
 coll.add("吐槽星⼈");
​
 coll.add("汪星⼈");
​
 //遍历
​
 //使⽤迭代器 遍历 每个集合对象都有⾃⼰的迭代器
​
 Iterator<String> it = coll.iterator();
​
 // 泛型指的是 迭代出 元素的数据类型
​
 while(it.hasNext()){ //判断是否有迭代元素
​
 String s = it.next();//获取迭代出的元素
​
 System.out.println(s);
​
 }
​
 } 
​
}

Map

Map常用子类

HashMap<K,V>：存储数据采⽤的哈希表结构，元素的存取顺序不能保证⼀致。由于要保证键的

唯⼀、不重复，需要重写键的hashCode()⽅法、equals()⽅法。

LinkedHashMap<K,V>：HashMap下有个⼦类LinkedHashMap，存储数据采⽤的哈希表结构

+链表结构。通过链表结构可以保证元素的存取顺序⼀致；通过哈希表结构可以保证的键的唯⼀、

不重复，需要重写键的hashCode()⽅法、equals()⽅法。

Map接口中的常用方法

Map接⼝中定义了很多⽅法，常⽤的如下：

public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。

public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被

删除元素的值。

public V get(Object key) 根据指定的键，在Map集合中获取对应的值。

boolean containsKey(Object key) 判断集合中是否包含指定的键。

public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。

public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set

集合)。

public class MapDemo {
​
 public static void main(String[] args) {
​
 //创建 map对象
​
 HashMap<String, String> map = new HashMap<String, String>();
​
 //添加元素到集合
​
 map.put("⻩晓明", "杨颖");
​
 map.put("⽂章", "⻢伊琍");
​
 map.put("邓超", "孙俪");
​
 System.out.println(map);
​
 //String remove(String key)
​
 System.out.println(map.remove("邓超"));
​
 System.out.println(map);
​
 // 想要查看 ⻩晓明的媳妇 是谁
​
 System.out.println(map.get("⻩晓明"));
​
 System.out.println(map.get("邓超")); 
​
 }
​
}

Map集合遍历键找值⽅式

键找值⽅式：即通过元素中的键，获取键所对应的值

分析步骤：

1. 获取Map中所有的键，由于键是唯⼀的，所以返回⼀个Set集合存储所有的键。⽅法提

示: keyset()

1. 遍历键的Set集合，得到每⼀个键。

2. 根据键，获取键所对应的值。⽅法提示: get(K key)

代码演示：

public class MapDemo01 {
​
 public static void main(String[] args) {
​
 //创建Map集合对象
​
 HashMap<String, String> map = new HashMap<String,String>();
​
 //添加元素到集合
​
 map.put("胡歌", "霍建华");
​
 map.put("郭德纲", "于谦");
​
 map.put("薛之谦", "⼤张伟");
​
 //获取所有的键 获取键集
​
 Set<String> keys = map.keySet();
​
 // 遍历键集 得到 每⼀个键
​
 for (String key : keys) {
​
 //key 就是键
​
 //获取对应值
​
 String value = map.get(key);
​
 System.out.println(key+"的CP是："+value);
​
 } 
​
 }
​
}

Map集合遍历键值对方式

键值对⽅式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。⽅法提示: entrySet() 。

2. 遍历包含键值对(Entry)对象的Set集合，得到每⼀个键值对(Entry)对象。

3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 ⽅法提示: getkey() getValue()

public class MapDemo02 {
​
 public static void main(String[] args) {
​
 // 创建Map集合对象
​
 HashMap<String, String> map = new HashMap<String,String>();
​
 // 添加元素到集合
​
 map.put("胡歌", "霍建华");
​
 map.put("郭德纲", "于谦");遍历图解：
​
​
 map.put("薛之谦", "⼤张伟");
​
 // 获取 所有的 entry 对象 entrySet
​
 Set<Entry<String,String>> entrySet = map.entrySet();
​
 // 遍历得到每⼀个entry对象
​
 for (Entry<String, String> entry : entrySet) {
​
 // 解析
​
 String key = entry.getKey();
​
 String value = entry.getValue(); 
​
 System.out.println(key+"的CP是:"+value);
​
 }
​
 }
​
}

链表 //查询快，增删慢

基本的测试框架：

1.定义注解类

package com.czh3;
​
​
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
​
/*
* 用来检测方法是否有异常
* @author 小类
* */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}
​

2.再定义一个被测试类：

package com.czh3;
​
//计算器的类
public class Calculator {
    //定义一个方法
    //加法
    @Check
    public void add(){
        int a=1/0;
        System.out.println("这是加法");
    }
​
    //减法
    @Check
    public void sub(){
        int a=1/0;
        System.out.println("这是减法");
    }
​
    //乘法
    @Check
    public void mul(){
        String a=null;
        a.getBytes();
        System.out.println("这是乘法");
    }
​
    //除法
    @Check
    public void div(){
        System.out.println("这是除法");
    }
}
​

3.测试框架类，存放异常信息的文件需要自己创建

package com.czh3;
​
/*
*做一个简单的测试的框架
* 1.创建测试的类
* 2.得到字节码
* 3.获取所有的方法
* 4.判断是否方法上有Check注解
* 5.有就执行方法
* 6.捕获异常
* 当main方法执行的时候，会自动去检测所有的方法（加了@check的方法），判断是否有异常，并把异常记录到文件中
 */
​
​
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
​
public class TestMethod {
    public static void main(String[] args) throws IOException {
        //定义异常计数
        int number=0;
​
        //定义异常的文件流
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("czh.txt", false));
​
        //1.创建测试的类
        Calculator calculator = new Calculator();
​
        //2.得到字节码
        Class aClass = calculator.getClass();
​
        //3.获取所有的方法
        Method[] methods = aClass.getMethods();
​
        for (Method method:methods){
            //4.判断是否方法上有Check注解
            if(method.isAnnotationPresent(Check.class)){
                try {
                    //5.有就执行方法
                    //6.捕获异常
                    method.invoke(calculator);
                } catch (Exception e) {
                    e.printStackTrace();
                    number++;//异常加1
                    bufferedWriter.write(method.getName()+"方法出现异常了");
                    bufferedWriter.newLine();
                    bufferedWriter.write("异常的名称"+e.getCause().getClass());
                    bufferedWriter.newLine();
                    bufferedWriter.write("异常的原因:"+e.getCause().getMessage());
                    bufferedWriter.newLine();
                    bufferedWriter.write("-------");
                    bufferedWriter.newLine();
                }
            }
        }
​
        bufferedWriter.write("本次一共出现"+number+"次异常！");
        bufferedWriter.newLine();
        bufferedWriter.flush();
        bufferedWriter.close();
    }
}
​

了解并使用Ajax

Ajax=异步JavaScript和XML

Ajax是一种创建快速动态网页的技术。

通过在后台与服务器进行少量数据交换，Ajax可以使网页实现异步更新。这意味可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

传统的网页（不使用Ajax）如果需要更新内容，必须重载整个网页面。

Ajax怎么做异步请求

Ajax请求默认是异步的，如果需要同步，把async设置为false就行，默认是true

如果是jquery

$.ajax({
    url:some.php,
    async:false,
    success:function(){
        
    }
});

SpringMVC框架

什么是SpringMVC？以及对SpringMVC的理解

SpringMVC是一个基于java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过将Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。

SpringMVC的优点：

可以支持各种视图技术，而不仅仅局限于jsp；

与Spring框架集成（如IOC容器AOP等）

清晰的角色分配：前端控制器（dispatcherServlet），请求到处理器映射（handlerMapping），处理适配器（HandlerAdapter），视图解析器（ViewResolver）

支持各种请求资源的映射策略

SpringMVC主要组件：

（1）前端控制器DispatcherServlet（无需程序员对其进行开发）

作用：接收请求，响应结果，相当于转发器，有了它之后就减少了其他组件之间的耦合度。

（2）处理器映射器HandlerMapping（无需程序员开发）

作用：根据请求的URL来查找Handler

（3）处理器适配器HandlerAdapter

注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler

（4）处理器Handler（需要程序员开发）

（5）视图解析器ViewResolver（不需要程序员开发）

（6）视图View（需要程序员开发jsp）

View是一个接口，它的实现类支持不同的视图类型（jsp，，freemarker，pdf等等）

Dao层，Service层和Controller层的运用及区别

Dao层：数据访问层，主要是关于数据库的使用，里面封装了增删查改语句（只是封装增删改查），也就是说一个Dao一定是和我们建立在数据库中的某张表一一对应的。

Service层：服务层，将一个或多个Dao再次进行封装，封装成一个服务来完成用户请求的处理。主要是将Dao层中的增删查改调用过来（管理具体功能）。

Controller层：业务层，管理用户操作，根据用户界面传过来的请求，调用Service层中相应的服务（管理业务（Service）调度及跳转）。