java总结

1.基础语法
    byte    //1 -128 ~ 127
    short   //2
    int     //4
    long    //8
    float   //4
    double  //8
    boolean //1
    char    //2 unicode gbk utf8 ansi ascii
            //‘‘ ‘abc‘ ‘\n‘ \r \t
            char c = ‘a‘ ;
                 c = 97 ;
                 c = ‘\u0061‘
                 c = ‘‘ ;
    String //常量."" null
    StringBuffer(安全) | StringBuilder(不安全)
    synchronized

2.OOP
    封装
    继承
    多态:成员变量,
    extends 
    implements
    单层继承
    面向接口编程:降低耦合。
    抽象类:
    反序列化不需要经过构造函数创建对象。
    类的成员:成员变量,成员函数,构造函数，构造代码块，静态代码块，内部类，
    创建对象过程:1.开辟内存
                 2.初始化默认值.
                 3.构造代码块或成员变量的赋值。
                 4.构造函数。

    final:  
        类       //不能继承
        方法  //不能重写
        字段  //只能被赋值一次。

        abstract + final        //非法
        abstract + private      //非法
        abstrat + static        //非法 static是属于类的，通过类名调用方法，而abstract无方法体，
        final + private         //不非法private不能继承，而final不能被重写，不能继承就免谈final，所以组合无意义

3.IO
    CharSet                     //
    InputStream/OuputStream
    Reader/Writer
    BuffedInputStream/BufferedOutputStream(8k)
    BufferedReader/BufferedWriter
    InputStreamReader/OuputStreamWriter
    new BufferedReader(new ...(System.in));
    ObjectInputStream/ObjectOutputStream
    ByteArrayOutputStream //内存流
    将对象转换成byte[]
    java.io.Serializable    //标识性接口
                            //long serializableUID,反串行。

    while((len = is.read()) != -1){

    }

4.NIO
    New IO:非阻塞.
    Selector                //
    ServerSocketChannel     //
    SocketChannel           //
    SelectionKey.OP_ACCEPT
    SelectionKey.OP_CONNECT
    SelectionKey.OP_READ
    SelectionKey.OP_WRITE

    while(true){
        sel.select();       //
    }

    ByteBuffer              //字节缓冲区
    ByteBuffer              //ByteBuffer.allocate()
                            //ByteBuffer.allocateDirect();
                            //Cleaner.clean()
                            //概念：0 <= mark <= position <= limit <= capacity
                            //buf.flip();       //
                            //buf.clear();      //
                            //buf.reset();      //pos -> mark
5.Socket
    TCP //
    UDP

    七层协议
    --------------
        物理层
        数据链路层
        网络层
        传输层 //transfer control protocal,user datagram protoca.
        会话层 //
        表示层
        应用层 //http(hyper text transfer ptotocal),ftp:file transfer pro, https smtp

    ServerSocket                    //统配ip0.0.0.0 + port
    Socket s = ss.accept()          //阻塞

    s.getInputStream()              //SocketInputStream
    s.getOutputStream()             //SocketOutputStream

    //全双工.

    DatagramSocket          //数据报套接字
    DatagramPacket          //数据报包,包里有地址。64K


6.JDBC
    标准，接口。
    driver.jar      //jdbc实现。
    insert
    update
    delete
    select
    CRUD        //create retrieve update delete DML(data mani.. language.数据操纵语言)
    DDL:        //data define language,收据定义语言.

    Statement           // -- 
    PreparedStaement    //
    CallableStatement   //存储过程 + 函数

    truncate            //截断表，无法回滚。
    事务:transaction
        A:atomic        //原子性
        C:consistent    //一致性
        I:isolate       //隔离性
        D:durable       //持久性

        commit()
        rollback();
        savepoint()

        autoCommit(false);

        并发执行现象
        -------------
            脏读      :dirty read
            不可重复读   :unrepeatable read  
            幻读      :phantom read,
        隔离级别
        --------------
            1.read uncommitted,读未提交.导致了(脏读 + 不可重复 + 幻读)
            2.read committed ,读已提交,避免了脏读,导致(不可重复 + 幻读)
            4.repeatable read,可以重复读，避免了(脏读 + 不可重复读 + 幻读 mysql)
            8.serializable(悲观锁).

            不能并发。
            锁旗标:0 / 1.

            乐观锁:version（推荐使用） + timestamp（同一时间内（毫秒内）发生两次更新有可能检测不到

            A写，B阻塞写。
            A写，B可读。

            A读:B不一定能写(for update | 隔离级别)。
            A读:B可读。

            lock table xx ;

            unlock table ;

            MVCC : multiple version concurrency control,多版本并发控制（避免了不可重复读 + 幻读）。

            HA  :high availability,高可用性。 
            SPOF:single point of failure,单点故障。 

7.反射
    Class
    Method
    Feild
    Constructor

    setAccessible(true);（内存中的可见性，不是字节码的）

    clazz.getDecleardMethods()      //所以本来定义的方法
    clazz.getMethods();             //所有可用的方法。
    method.invoke();
    field.get() / field.set(obj,xx) //

    Introspector        //内省
    BeanInfo
    PropertyDescriptor
    MethodDescriptor
    read
    write

    //不改变源码，增加新功能。
    Proxy p = Proxy.newProxInstance(classloader,Class[], handler);

8.集合
    java.lang.Object
                //equals

    List        //----|>Collection -----|>Iterable
                //有序，可重复(equals)
                //ArrayList,封装数组,读快。
                //LinkedList，写块。（读慢，从头到结尾一个个地进行判断）

    Set         //----|>Collection -----|>Iterable
                //无序列，不重复

    Map         //none
                //key-value
                //HashMap:内部通过ArrayList（桶的个数） + linkedList（桶内部元素）组合实现。
                //hashcodo1  == hashcode2 , (o1 == o2 || o1.equals(o2))（怎么定位桶？新hashcode与桶15做与运算，根据结果定位。
                新hashcode=对象的特征值与组装整数值，因为hash值就是整数，拿到hashmap当中之后，高16为右移16位，再与低16位做异或
                运算，得到新hashcode值定位桶的下标）

    hash:       //散列（把对象在空间中分散，分成多个空间（桶），再用hashcode定位桶，这样查询起来很快（一次性排除（n-1)/n的对象），



9.多线程
    状态
    ------------------
        NEW
        Runnable    //
        blocked     //阻塞
        wait
        wait_timing
        terminate
        sleep       //
        注意（生产消费问题堆内存溢出）

    较真.
    java.lang.Thread
    java.lang.Runnable
    new Thread().start();
    yield()     //放弃
    join()      //

    daemon()    //守护线程
    sleep()     //休眠,
    同步代码块同步方法
                //非静态方法以当前对象为锁，静态方法以类描述符为锁。
    wait()      //锁旗标的等待队列（线程的引用）。
    notify()    //
    notifyAll() //
    wait(n)     //

10.JVM
    java virtual machine,
    runtime data area,运行时数据区
    -------------------------
        heap                            //共享,对象 + []
        method area                     //共享
        java stack                      //
        native method stack             //
        program counter register        //

        heap                            //young(eden + s1 + s0) + old
        non-heap                        //permnent / metaspace
        off-heap                        //jvm之外的内存(直接内存)

        -Xmx
        -Xms
        -Xmn        //New
        -Xss        //stack 1m
        -XX:NewSize=
        -XX:MaxNewSize=
        -XX:NewRatio=       //
        -XX:SurvivorRatio=  //s : eden
        -XX:CompressedClassSpaceSize=，（XX不稳的选项），（X非标准选项）
        jvisualvm
        jconsole

11.异常
    throw       //抛异常

    throws      //方法声明抛出异常
    extends
    implements

    Throwable
    java.lang.Throwable
        /|         |---------Exception  ---<|---- RuntimeException
         |---------Error

    try{
    }
    catch(Exception e){
    }
    finally{
        ..
    }

    final       //可以修饰局部变量
    finally     //
    finalize()  //gc


    overload        //重载

    override        //覆盖
    overwrite       //重写