反射
动态代理
Java Web
- 保存的四个作用域
Java线程
什么是Java内存模型
- 主内存与工作内存
- 主内存和工作内存的交互模型
  - 作用于主内存的操作
  - 作用于工作内存
JVM划分内存
枚举类
- 作用和特点
- 使用
泛型
I/O
NIO
Java数据结构
Java8新特性
- Lambda表达式

反射

动态语言, 是指程序在运行时可以改变其结构: 新的函数可以引进, 已有的函数可以被删除等结构上的变化. JavaScript,Ruby,python等属于动态语言, C, C++则不属于动态语言. 从反射的角度来说,java属于半动态语言

反射机制的概念: 运行状态中知道类所有的属性和方法

Java的反射机制是指在运行状态中, 对于任意一个类都能够知道这个类所有的属性和方法; 并且对于任意一个对象, 都能够调用它的任意一个方法;

编译时类型和运行时类型

在Java程序中许多对象在运行时都会出现两种类型:

Person person=new Student();

编译时类型: 由声明对象时使用的类型来决定, 如上面的Person.
运行时类型: 由实际赋值给对象的类型决定,如上面的Student.

所以程序在运行的时候, 可能要接受未知的对象, 不知道其类型, 所以要用到反射来获取其信息.

Java反射 API

Class类: 反射的核心类, 可以获取类的信息,方法等
Field类: Java.lang.reflec包中的类, 表示类的成员变量, 可以用来获取和设置类中的属性
Method类: Java.lang.reflec包中的类,表示类的方法.
Constructor类: Java.lang.reflec包中的类, 表示类的构造方法

获取Class对象的3中方法

Class类就是描述一个类的类.

调用对象的getClass()

Class clazz=new Person().getClass();

调用类的class属性来获取

Class clazz=Person.class;

Class类中的forName()静态方法, 最安全, 性能最好

Class clazz=Class.forName("类的全路径");

创建实例的两种方法

Class对象的newInstance(), 要求Class对象有默认的空构造器

先使用Class对象获取指定的Constructor对象,在调用Constructor对象的newInstance()方法来创建Class对象对应类的实例. 通过这种方式可以选择不同的构造方法

Class clazz=Class.forName("reflection.Person");
Person p=(Person)clazz.newInstance();
Constructor c=clazz.getDeclaredConstructor(String.class,String.class,int.class);
Person p=(Person)c.newInstance("可汗","男",20)';

public class Apple {
    private int price;
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public static void main(String[] args) throws Exception{
        //正常的调用
        Apple apple = new Apple();
        apple.setPrice(5);
        System.out.println("Apple Price:" + apple.getPrice());
        //使用反射调用
        Class clz = Class.forName("com.chenshuyi.api.Apple");
        Method setPriceMethod = clz.getMethod("setPrice", int.class);
        Constructor appleConstructor = clz.getConstructor();
        Object appleObj = appleConstructor.newInstance();
        setPriceMethod.invoke(appleObj, 14);
        Method getPriceMethod = clz.getMethod("getPrice");
        System.out.println("Apple Price:" + getPriceMethod.invoke(appleObj));
    }
}

动态代理

通过一个方法就可以生成一个对指定接口的实现类对象

public class Student implements StudentInterface{
    private String name;
    public Student(String name) {
        this.name = name;
    }
    public Student() {
    }
    @Override
    public void eat() {
        System.out.println(this.name+" eat.");
    }
    @Override
    public void study() {
        System.out.println(this.name+" study.");
    }
}
public interface StudentInterface {
    void eat();
    void study();
}
public class TestClazz {
    public static void main(String[] args) {
        Student student = new Student("Oddity");
        //实现一个StudentProxy代理对象
        StudentInterface StudentProxy = (StudentInterface) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (method.getName().equals("study")) {
                    System.out.println("shit");
                    return null;
                } else {
                    return method.invoke(student, args);
                }
            }
        });
        StudentProxy.study();
        StudentProxy.eat();
    }
}

Proxy的静态方法newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)方法. 实现了interfaces数组中的接口, 这个StudentProxy么有.java文件, 是在运行时生成的.

ClassLoader loader: 类加载器, 需要代理的对象的类加载器: YourObject.class.getClassLoader
Class[] interfaces: 指定要实现哪些接口
InvocationHandler h: 是一个接口, 叫做调用处理器, 代理对象肯定是实现了你指定的接口, 调用代理对象的接口方法时 ,都是在调用InvocationHandler的invoke()方法
Java Web

保存的四个作用域

Page级别, jsp使用, 现在已经不使用了
Request级别, 在一个请求中范围内, 如果是sendRedirect重定向, 那么作用域中保存的值就失效了, 如果是重定向(request.getRequestDispatcher.forward()), 那么域中的值还能使用
session会话级别, 再一次会话中域中的值有效, request.getSession.setAttribute()
application级别, 在一个应用程序中, request.getServletContext.setAttribute

Java线程

进程: 每一个进程都有独立的代码和数据空间(进程上下文). 进程间的切换有较大的开销, 一个进程包括1-n个线程. 进程是资源分配的最小单位

线程: 同一类线程共享代码和数据空间, 每一个线程有独立的执行栈和程序计数器(PC), 线程切换的开销很小, 线程是CPU调度的基本单位

实现线程的两种方法

继承Thread类
```java package com.multithread.learning; /* @functon 多线程学习 @author 林炳文 @time 2015.3.9 */ class Thread1 extends Thread{ private String name; public Thread1(String name) { this.name=name; } public void run() {

for (int i = 0; i < 5; i++) {
    System.out.println(name + "执行  :  " + i);
    try {
        sleep((int) Math.random() * 10);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

} } public class Main {

public static void main(String[] args) {

Thread1 mTh1=new Thread1("A");
Thread1 mTh2=new Thread1("B");
mTh1.start();
mTh2.start();

}

} 输出： A执行 : 0 B执行 : 0 A执行 : 1 A执行 : 2 A执行 : 3 A执行 : 4 B执行 : 1 B执行 : 2 B执行 : 3 B执行 : 4

再执行一下：

A执行 : 0 B执行 : 0 B执行 : 1 B执行 : 2 B执行 : 3 B执行 : 4 A执行 : 1 A执行 : 2 A执行 : 3 A执行 : 4


2.  实现java.lang.Runnable接口<br />重写run方法 <br />对于Runnable接口, 在启动的时候, 需要先通过Thread类的构造方法Thread(Runnable target)构造出对象, 再调用Thread的Start()方法开启线程. 
```java
/**
 *@functon 多线程学习
 *@author 林炳文
 *@time 2015.3.9
 */
package com.multithread.runnable;
class Thread2 implements Runnable{
    private String name;
    public Thread2(String name) {
        this.name=name;
    }
    @Override
    public void run() {
          for (int i = 0; i < 5; i++) {
                System.out.println(name + "执行  :  " + i);
                try {
                    Thread.sleep((int) Math.random() * 10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
}
public class Main {
    public static void main(String[] args) {
        new Thread(new Thread2("C")).start();
        new Thread(new Thread2("D")).start();
    }
}

实际上全部的多线程代码都是通过执行Thread的start()方法来执行的, 不管是继承Thread类, 还是实现Runnable接口来实现多线程, 最终还是通过Thread的API来控制线程的.

Thread和Runnable的差别

如果继承了Thread类, 那么不适合资源的共享, 如果实现了Runnable接口, 非常容易实现

实现Runnable接口不继承Thread类所具有的优势:

适合多个同样的代码程序的线程去处理同一个资源
能偶避免Java中的单继承的限制
增加程序的健壮性, 代码能够呗多个线程共享, 代码和数据独立
线程池仅仅能放入Runnable或者callable类线程, 不能直接放入继承Thread的类

main程序其实也是一个线程, Java中所有的线程都是同一时间开启的,什么时候, 哪个执行, 取决于CPU的资源分配

每次程序的执行至少启动2个线程, 一个是main线程, 一个是垃圾收集线程

每当使用java命令执行一个类的时候, 实际上会启动一个JVM, 每一个JVM就是在操作系统中启动了一个进程.

Java - 图1

经常使用的函数

sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
join(): 指等待t线程终止
如果子程序没有调用t.join()方法, 那么主程序可能在子程序之前执行完, 而调用以后, main程序会在子程序完成后再结束
yield()是指当前的线程让出当前的CPU占有权, 让出的时间是不可设定的, 称为退让, 先检测是否有同样优先级的线程处于可执行状态, 如果, 那么就交给此线程, 否则执行原来的线程, 不可能让优先级低的线程来获取CPU的占有权, 但是Sleep()方法可以.
Java线程的6个状态
```
//Thread.State源码
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
```
1. NEW
处于此状态表示没有启动. 指创建了Thread实例, 但是没有调用start()方法
Question:
反复调用一个线程的start()方法, 是否可行, 或者说一个线程执行完毕, 处于TERMINATED状态, 再次调用start()是否可行?
Answer:
都不可行, 第一次调用start()后会将ThreadStatus(原值为0)改为非零, 此时调用start()方法会抛异常.
2. RUNNABLE
此状态表示线程正在JVM中运行, 也可能在等待其他系统资源, 如果I/O
包含了传统操作系统中的ready和running两个状态
3. BLOCKED
阻塞状态. 处于此状态的线程等待锁的释放以进入同步区

你去只有一个窗口的食堂打饭, 前面已经有一个人T1线程, 你是T2线程. 此时T1线程占有锁, 你正在等待锁的释放, 所以你处于BLOCKED状态

4. WAITING

等待状态. 此时处于等待状态的线程需要等待其他线程的唤醒.
以下三个方法会使线程处于等待状态:

Object.wait():使当前的线程变成等待状态直到另一个线程唤醒它, 会释放锁
Thread.join():等待线程的执行完毕, 底层是Object.wait()方法
LockSupport.park():除非获得调用许可, 非则禁止当前线程进行线程调度

5. TIMED_WAITING
超时等待状态. 线程等待一个具体的时间, 到时间后自动被唤醒.
Thread.sleep(long millis):当前的线程睡眠指定的时间, 不会释放锁
Object.wait(long timeout):休眠指定时间, 可以通过notify() notifyAll()唤醒
Thread.join(long millis):等待线程最多执行millis毫秒, 如果为0, 则一直执行直到完毕.
LockSupport.parkNanos(long nanos):除非获得调用许可, 否则禁止当前线程进行线程调度指定时间
LockSupport.parkUtil(long nanos):同上

6. TERMINATED
终止状态.线程执行完毕

线程中断
Java中没有安全的直接方法来停止线程, 但是提供了线程中断机制来处理需要中断线程的情况, 线程中断是一种协助机制, 中断线程并不能直接中断一个线程, 而是通知线程中断自行处理
中断的方法:
Thread.interrupt():中断线程, 并不会立即停止线程, 而是这是线程的中断状态为true
Thread.interrupted():测试线程是否被中断. 调用一次设置为中断状态为true, 再次调用使得变为false, 影响线程状态.
Thread.isinterrupted():测试线程是否被中断. 不会影响线程状态
什么是Java内存模型

在虚拟机中将变量存储到内存，以及从内存中取出变量这样的底层细节

主内存与工作内存

Java内存模型规定了所有的变量都存在于主内存，每条线程有自己的工作内存，工作内存保存了线程所用到的变量的内存副本。

主内存和工作内存的交互模型

内存模型中定义了8种操作完成主内存与工作内存之间具体的交互协议，每个操作都是原子级的，不能再分

作用于主内存的操作

lock操作
把一个变量标识为一条线程独占的状态
unlock操作
把一个处于锁定状态的变量释放出来，释放后的变量才能被其他的线程锁定
read
把一个变量的值从主内存传输到工作内存中，以便load使用
write
把store操作从工作内存中得到的变量值存入到主内存变量中

作用于工作内存

load
把read操作从主内存中得倒的变量值放入工作内存的变量副本中
use
将工作内存中的一个变量的值传递给执行引擎，当虚拟机遇到一个需要使用的变量的值的字节码执行时会执行这个操作
assign
将执行引擎接受到的值赋值给工作内存的变量，当虚拟机遇到一个变量赋值的字节码执行这个操作
store
将工作内存中的一个变量的值传送到主内存中，以便随后的write操作

JVM划分内存

线程私有数据区

程序计数器

三个特点：

内存较小

当前线程所指向的字节码的行号指示器

线程私有

多线程是通过线程轮流切换并分配处理器指向时间的方式来实现，在一个特定的时间，一个处理器只会执行一条线程的指令。每个线程都有一个独立的程序计数器，互不影响。

无异常

如果执行的是java方法，计数器记录的是正在执行的虚拟机字节码指令的地址，如果是Native方法，那么计数器为空，此内存区域是唯一一个在java虚拟机规范中没有任何OutOfMemoryError情况的区域

虚拟机栈

线程私有

与程序计数器一样

描述java方法执行的内存模型

描述Java方法执行的内存模型，一个方法对应一个栈帧，栈帧是方法执行的基础数据结构，一个方法被调用直至执行完成，就对应一个栈帧在虚拟机栈从入栈到出栈的过程

异常

StackOverflowError
执行Java方法会执行压栈操作，JVM规定了栈的最大深度，如果线程执行方法时栈的最大深度大于了规定的深度，那么就会抛此异常

OutOfMemoryError
如果虚拟机扩展时无法申请到足够的内存，就会抛出此异常

本地方法栈

本地方法栈的作用与虚拟机非常相似

为native服务

虚拟机栈为Java服务，本地方法栈为native服务

异常

StackOverFlowError和OutOfMemoryError

所有线程共享的数据区域

Java堆

Java堆（Java Heap）也就是实例堆，有四个特点

内存最大
线程共享

被所有线程共享一块内存的区域，虚拟机启动时创建

存放实例

唯一目的就是存放对象的实例，几乎所有的对象实例都在这里分配内存。

Java堆是垃圾收集器管理的主要区域，因此也被称为“GC堆”

方法区

存储的是已经被虚拟机加载的数据

线程共享
存储的数据类型

类的信息
常量
静态变量
即时编译器编译后的代码

异常

方法区的大小决定JVM 系统可以保存多少个类，如果定义的类太多，会报OutOfMemoryError

方法区分为运行常量池和直接内存两部分

运行常量池

常量池用于存放编译器生成的各种自变量和符号引用，当类加载之后进入方法区中的运行池常量中存放

直接内存

不是运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域
直接分配
受设备内存大小的限制
异常

栈

存放：

main（）
基本类型变量（int，short，long。。。）
引用类型变量（User user，其中user就是引用类型变量）
方法函数

对象访问

Object obj=new Object();

映射如下

使用句柄

reference中存储的是稳定的句柄地址, 对象被移动(垃圾回收等)时, 只是改变句柄中的实例数据指针, reference不会被修改

使用直接指针

速度快

垃圾回收—分代收集算法

根据对象存活周期不同将内部划分为以下的区域, 每个区域采用不同的回收算法

现在大多使用分带收集法, 新生代使用Copying算法, 因为姚回收大部分对象, 复制的较少. 老年代使用标记-整理算法, 每次只回收少量的对象.

枚举类

作用和特点

用来约束类型
在拓展性方面比常量更方便

使用

public enum UserRole {
    ROLE_ROOT_ADMIN( "系统管理员", 000000 ),
    ROLE_ORDER_ADMIN( "订单管理员", 100000 ),
    ROLE_NORMAL( "普通用户", 200000 ),
    ;
    // 以下为自定义属性
    private final String roleName;  //角色名称
    private final Integer roleCode; //角色编码
    // 以下为自定义构造函数
    UserRole( String roleName, Integer roleCode ) {
        this.roleName = roleName;
        this.roleCode = roleCode;
    }
    // 以下为自定义方法
    public String getRoleName() {
        returnthis.roleName;
    }
    public Integer getRoleCode() {
        returnthis.roleCode;
    }
    public static Integer getRoleCodeByRoleName( String roleName ) {
        for( UserRole enums : UserRole.values() ) {
            if( enums.getRoleName().equals( roleName ) ) {
                return enums.getRoleCode();
            }
        }
        returnnull;
    }
}

泛型

特性

泛型只有在编译阶段有效

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();
Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();
if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型测试","类型相同");
}

编译后, 将泛型的相关信息擦出, 泛型在逻辑上是不同的类型, 但实际是相同的基本类型

泛型的使用

泛型类
泛型接口
泛型方法

泛型类

用在类上

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;
    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}
/*
    usage
*/
//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);
//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());
//result
12-27 09:20:04.432 13063-13063/? D/泛型测试: key is 123456
12-27 09:20:04.432 13063-13063/? D/泛型测试: key is key_vlaue

类型参数只能是引用类型, 不能是简单类型

泛型接口

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}
/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}
/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

泛型通配符

Generic不是Generic的父类

所以下面的代码会报错

public void showKeyValue1(Generic<Number> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
showKeyValue(gInteger);
// showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer> 
// cannot be applied to Generic<java.lang.Number>

使用通配符

public void showKeyValue1(Generic<?> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}

此处’？’是类型实参，而不是类型形参

泛型方法

public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

/*
泛型方法的基本介绍
@param tClass 传入的泛型实参
@return T 返回值为T类型
说明：
1）public 与返回值中间非常重要，可以理解为声明此方法为泛型方法。
2）只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
3）表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
/

public class GenericTest {
   //这个类是个泛型类，在上面已经介绍过
   public class Generic<T>{     
        private T key;
        public Generic(T key) {
            this.key = key;
        }
        //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }
        /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
        public E setKey(E key){
             this.key = keu
        }
        */
    }
    /** 
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }
    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }
    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }
     /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */
    /**
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
    public void showkey(T genericObj){
    }
    */
    public static void main(String[] args) {
    }
}

泛型类钟泛型方法的使用

public class GenericFruit {
    //内部类
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }
    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }
    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }
    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }
        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }
        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }
    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();
        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);
        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);
        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

类型方法与可参数

public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("泛型测试","t is " + t);
    }
}
printMsg("111",222,"aaaa","2323.4",55.55);

静态方法与泛型

如果静态方法要使用泛型的话, 那么静态方法必须定义为泛型方法

泛型上下边界

Generic<? extends Number> obj

obj只能是Number或者Number的子类, String会提示错误

Generic<? super Number> obj

obj只能是Number或者Number的父类

I/O

常用的类
Java - 图7

File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。
InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。
OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。
Reader（文件格式操作）：抽象类，基于字符的输入操作。
Writer（文件格式操作）：抽象类，基于字符的输出操作。
RandomAccessFile（随机文件操作）：一个独立的类，直接继承至Object.它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。

字节流

文件的拷贝

利用字节流缓冲区拷贝文件

使用字节缓冲流拷贝文件

字符流

逐个字符读取, 写入

使用字符流缓冲区拷贝文件

使用字符缓冲流拷贝文件

转换流

将字节流转换为字符流

RandomAccessFile

不属于流类, 但具有读写文件数据的功能, 可以从文件的任何位置开始并以指定的操作权限读写数据

NIO

传统的IO是面向字节流或者字符流的, 而NIO是面向缓冲区的,数据总是聪通道读到缓冲区, 或者聪缓冲区写入到通道中, 其中Selector用于监听多个Channel, 因此单个线程可以监听多个数据通道, 其中包括三个部分

Channel
Buffer
Selector

NIO的非阻塞

IO的各种流都是阻塞的, 当调用read或者write操作的时候, 线程都是被阻塞. 而NIO的非阻塞模式使一个线程从某通道请求读取数据, 只能得到可用的数据, 如果没有数据, 那么就不会获取, 不会阻塞, 可以做其他的事情, 写也是同样的操作. 所以一个线程可以管理多个输入和输出通道

Channel

跟传统的IO中的Stream差不多是同样的等级, 只不过Stream是单向的, 而Channel是双向的, 可以进行读, 也可以写操作
实现类主要有:

FileChannel
DatagramChannel
SocketChannel
ServerSockketChannel

分别对应文件IO UDP TCP(Server和client)

Buffer

实际上是一个容器, 是一个连续的数组, Channel提供从文件, 网络读取数据的渠道, 但是文件的读写必须经过Buffer

Buffer是一个顶层的抽象父类, 他的子类有

ByteBuffer
IntBuffer
CharBuffer
LongBuffer
DoubleBuffer
FloatBuffer
ShortBuffer
Selector
是NIO的核心类, Selector可以检测多个注册通道上是否有时间发生. 所以只用一个线程就可以监听多个通道.
Java数据结构

HashMap
为什么要重写hashcode和equals方法

利用Hash函数计算存入对象的hashcode, 将对象存入到对应的hashcode索引上, 如果有两个对象的hashcode一样, 那么就产生了”Hash冲突”, Java采用”链地址法”解决方案, 为所有hashcode是i的对象建立一个同义链表, 如果存入一个对对象的时候, 发现此位置已经被占了, 那么就会新建一个链表结点放入存入的对象.
Java - 图23
没有重写两种方法

第26行会返回null, 因为没有在Key中定义hashcode()方法, 这里调用的是Object类的hashCode()方法, 此类是所有类的父类, 而Object类的hasCode()方法返回hash值是k1对象的内存地址, 假设为1000, 第26行取的是k2对象, 再次调用Object的hashCode()方法, 得到的其实是k2的内存地址, 假设2000, 用于对象不同, 那么得到的地址肯定也不相同, hash值一定不同, 无法取到k2.
Java - 图25

将16行的注释取消, 实现Key的hashCode()方法, 返回的是id的hashcode, k1和k2的id是相同的, 所以得到的hash值是相同的, 但是取到的结果还是null, 是因为没有重写equals方法, 在相同的位置上可能有多个用链表形式存储的对象, 取的时候如果发现有多个对象, 那么就需要调用Key对象的equals方法来判断对象是否相等了, 没有重写equals方法, 所以调用Object的equals方法, 此方法根据两个对象的内存地址判断, 所以k1和k2一定不相等.
Java - 图26

Queue队列

接口于List, Set同一级别, 继承了Collection接口, LinkedList实现了Deque接口

queue.offer() //添加一个元素到末尾,如果满了,返回false
queue.peek()    //返回队列的头部元素, 不移除
queue.poll()  //返回第一个元素, 并移除

Stack栈

是Vector的一个子类

方法:

boolean empty() //判断是否为空
Object peek()     //查看栈顶对象, 不移除
Object pop()        //移除栈顶对象, 最为返回值
Object push(Object element)//压入栈
int search(Object element)    //搜素元素, 以1为基数

Java8新特性

Lambda表达式

允许把函数作为一个方法的参数，使代码更加的简洁

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
   interface MathOperation {
      int operation(int a, int b);
   }
   interface GreetingService {
      void sayMessage(String message);
   }
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

Java

反射