[09]-小而美

---

数据库连接池的理解和优化、事物处理

• Connection类提供事务支持，设置Connection的AutoCommit属性为 false,显式的调用commit()/rollback()
• 要实现Connection复用，采用每一个事务独占一个连接来实现，可大大降低事务管理的复杂性。

---

新生代-复制清理

• 新生代分为三个部分：一个Eden区和两个Survivor区
• Eden区存放新生的对象
• Survivor存放每次垃圾回收后存活的对象
• 复制算法将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。
• 当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用的内存空间一次清理掉。

---

linux软硬链接的区别

• 硬链接：文件名B是文件名A的硬链接
  
  • 两者目录项的inode节点号相同，都指向同一个文件
  • B和A对于文件系统来说完全平等
  • rm B删除的是B这个文件名，B对应的文件只又在inode节点链接数为0时才会被系统回收
• 软链接： 文件名B是文件名A的软链接
  
  • 两者目录项的inode节点号不同，指向两块不同的数据块
  • B的数据块存放的是A的路径名，主从关系
  • rm A，B仍然存在，但指向的是一个无效的链接

---

sql group by

//统计每个部门的高于部门平均收入的人数和部门号
//type_id 团单类型； sale_price每个团单的价格
select count(type_id),type_id from( 
    select t1.type_id from tuan_deal_table t1,
    (select t1.type_id,avg(sale_price) as avg_price from tuan_deal_table group by type_id) t2
    where t1.type_id=t2.type_id and t1.sale_prize>t2.avg_price) as s1 group by type_id;

---

策略模式

List<T> filter(List<T> list,FilterProcessor fp){
    List<T> ansList=new ArrayList<T>();
    for(T t:list){
        if(fp.process(t)){
            ansList.add(t));
        }
    }
    return ansList;
}
List<Person> result=filter(list,FilterProcessor<Person>(){
    boolean process(Person person){
        if(person.getAge)>30){return true;}
        return false;
    }
});

//函数式编程：Lamda表达式
函数的代码作为参数进行传递
List<Apple> result=filter(list,(Apple app)->app.getColor().equals("red"));

• 解决同一类问题时，大部分的处理过程一致
  
  • 接口FilterProcessor
  • 方法boolean process(T)
• 使用匿名内部类实现筛选

---

String转int：正则判断

String name="123456";
if(name!=null && !"".equals(name.trim()) && name.matches("[0-9]+")){
    Integer ans=Integer.parseInt(name);
}

---

电脑访问一个网页整个过程

• DNS:将url解析成目标ip和端口号
• 应用层HTTP:打开socket连接后，向web服务器发送请求
• 传输层TCP
• 网络层OSPF、IP：路由器通过Hello报文与邻居建立邻接关系：Dijkstra算法
• 网络层/链路层ARP：根据IP地址获取物理地址

---

Runnable开启线程：start()

RunnableImp r1=new RunnableImp();
//方法调用，与开启线程无关
r1.run();

Thread t=new Thread(r1);
//开启新线程，会执行相应的run()
//在当前线程中运行run()
t.start();

• start()执行过程：
• 判断线程状态是否为未启动
• 执行native方法，start0()分配栈内存，启动线程
• 执行run方法

---

Spring的bean id重复覆盖问题

• id一样，实现类也一样，参数值不同
• 后者直接覆盖前者
• allowBeanDefinitionOverriding，默认true

---

Mybatis

• #：字符串，对自动传入的数据加一个双引号
  
  • #方式能够很大程度防止sql注入，能用这个就用

• $：将传入的数据直接显示生成在sql，order by user_id

  • 如果传入的值是111,那么解析成sql时的值为order by user_id
  • 如果传入的值是id，则解析成的sql为order by id
  • 一般用于传入数据库对象，例如传入表名.
    
    

• DataSource:工厂模式，创建发生于Mybatis初始化过程中

• Connection：延迟到执行sql语句时
  
  
• DataSource种类 unpooled、pooled、JNDI
  
  
• 一级缓存：sqlsession级别
  
  • 操作DB时，构造sqlsession对象，内有hashmap,缓存
  • 一次service中查询相同的用户信息,session结束时清空
• 二级缓存：mapper级别，跨sqlsession
  
  • 执行两次service查询

---

synchronized

• 普通方法：防止其他线程访问该实例的同步方法
• 静态方法：锁住的是这个类

---

t1线程正在访问	t2线程想要访问	能成功吗
普通：同一个对象，NO	obj1.普通()	NO
obj1.普通()	obj1.静态()	NO
普通：不同的对象，YES	obj2.普通()	YES
obj1.普通()	obj2.静态()	YES
静态：对于静态，NO	obj1.静态()	NO
obj1.静态()	obj2.静态()	NO
静态：对于普通，YES	obj1.普通()	NO
obj1.静态()	obj2.普通()	NO

---

Thread.getName()

• Thread.currentThread().getName()：对当前正在执行的线程对象的引用
• this.getName()：Runnable中不能使用,只能在Thread子类中使用
  
  • 当前调用这个函数的对象的引用，即为匿名内部类的thread对象名

---

web.xml配置节：context-param、listener、filter、servlet

• context-param:写哪都行，最先加载
  
  • 提供应用程序上下文信息的键值对
• listener
  
  • ContextLoaderListener(仅负责IOC开启关闭)初始化的上下文
  • RequestContextListener(监听web服务器的每一次请求)
• filter（顺序要保证）
  
  • filter:name与class
  • filter-mapping：name与url

• servlet：DispatcherServlet：负责职责的分派

  <servlet>
      <servlet-name>SpringMVC</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:conf/spring-mvc.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
      <async-supported>true</async-supported>
  </servlet>
  
  <servlet-mapping>
      <servlet-name>SpringMVC</servlet-name>
      <url-pattern>/</url-pattern>
  

Servlet不是单例，只是规范

• Servlet并不是单例，只是容器让它只实例化一次，表现出单例的效果
• Servlet是web容器来控制实例化的，并不是你自己用你编写的代码来实例化
• 即使你自己编写代码实例化你的servlet，Web服务器也不会直接调用你的实例化的Servlet对象的。
• 当客户端第一次请求Servlet的时候,tomcat会根据web.xml配置文件实例化servlet
• 当又有一个客户端访问该servlet的时候，不会再实例化该servlet，也就是多个线程在使用这个实例
• 它的生命周期是由Tomcat来维护的

---

Session

• 第一次请求，服务器生成session对象，用来存储该会话相关的数据
• 响应时在请求头Set-Cookie，在客户端cookies中添加session_id
• 之后进行请求时，每次服务器都会检测session_id找到对应session对象来识别客户。
  
  
• 数据结构：map+记录最后访问时间（防止存储失效过多）
• session会话级别，web应用级别，在该web程序全局可访问，实现单例的ApplicationContext

---

同步异步、阻塞非阻塞

• 同步异步（任务需要依赖另一个任务，等不等他完成）可靠性or性能
• 阻塞非阻塞（cpu的消耗，当前线程出现慢操作）等待or线程切换
• IO：应用程序、用户程序缓存、os内核缓存区、磁盘数据：[直接IO直接访问磁盘]
• 网络IO与磁盘IO不同的是：数据的写入与读取需要一个协调的过程
  
  • client和server都有一个socket实例，每个socket实例有两个缓冲区
  • 写入OutputSteam对应的sendQ队列，sendQ满了则转移到另一端的recvQ队列，
  • 如果recv队列是满的，会阻塞write

---

BIO与AIO

• 磁盘or网络IO，一旦发生阻塞，线程会失去CPU的使用权
• BIO阻塞：每个连接分配一个线程，有的连接啥都没干，浪费线程
• AIO非阻塞：每个请求分配一个线程，连接请求注册到Selector复用器上
  
  • Channel通道：等价于Socket，注册自己感兴趣的事情
  • Selector选择器：轮训，通过SelectionKey报告哪个Channel已准备好
• Buffer缓存：通过Channle获得的IO不是直接IO
• 直接IO:ByteBuffer.allocateDirector(size)每次创建/释放都调用System.gc
  

  ---

序列化

• 父类实现Serializable接口时，子类可被序列化
• 子类实现Serializable接口时，父类没有，不报错，不对父类中的属性进行序列化
• 如果序列化的属性是对象，则这个对象必须实现序列化，否则报错

---

IO类、设计模式

• 适配器：让两个接口不兼容的类协同工作
  
  • 被适配String，适配器String实现Reader接口，持有String引用
• 装饰器：通过组合动态扩展对象功能，三明治+火腿+鸡蛋
  
  • InputStream、FilterInputStream、LineNumberInputStream
    
    
• 字节流：InputSteam/OutputStream
  
  • File、Piped、StringBuffer、Filter(Buffered/LineNumber)

• 字符流：Reader/Writer

  public static int read(String path){
      File file=new File(path);
      FileReader reader;
      try{
          reader = new FileReader(file);
          BufferedReader bufferReader=new BufferedReader(reader);
          int ans=bufferReader.read()-'0';
          return ans;
      }
      catch (FileNotFoundException e){
          e.printStackTrace();
      }
      catch(IOException e){
          e.printStackTrace();
      }
      return Integer.MAX_VALUE;
  }
  
  public static void write(String path,int temp){
      File file=new File(path);
      FileWriter writer;
      try{
          if(!file.exists()){
              file.createNewFile();
          }
          writer=new FileWriter(file);
          BufferedWriter bufferWriter=new BufferedWriter(writer);
          char ctemp = (char)(temp+'0');
          bufferWriter.write(ctemp);
          bufferWriter.flush();
          bufferWriter.close();
      }
      catch (FileNotFoundException e){
          e.printStackTrace();
      }
      catch(IOException e){
          e.printStackTrace();
      }
  }
  

---

泛型数组

//运行时，确定数组大小
int size=5;
int []nums=new int[size];
//运行时，更改ArrayList大小
ArrayList list=new ArrayList<>(100);//100个空位置
list.size()//实际元素的数目,trimToSize()去掉预留元素位置

public static void main(String[] args){
    @SuppressWarnings(value={"unused", "rawtypes"})
    List list =new ArrayList();
}

public static Object goodCopyOf(Object obj,int newLen){
    Class c1=obj.getClass();
    if(!c1.isArray()){return null;}
    Class componentType=c1.getComponentType();
    int oldLen=Array.getLength(obj);
    Object ansObj=Array.newInstance(componentType, newLen);
    System.arraycopy(obj,0, ansObj,0,Math.min(oldLen, newLen));
    return ansObj;
}

---

回调：匿名内部类干活

• 背景1：类Worker实现接口InA
• 背景2：类Worker包括一个对类Mask的引用
• 背景3：类Mask的方法中，形参为接口InA
• 匿名内部类中：Worker作为一个匿名内部类的存在，包括一个对当前类的引用

---

ThreadLocal:创建线程的局部变量

• 创建的线程只能被当前线程访问，其他线程不能访问
• 如想设置默认的get值，需重写initialValue()
• 本质：值存于堆上，实际上被创建其的类所持有

• ThreadLocal的值，放入了当前线程的ThreadLocalMap< ThreadLocal,Value>实例中

   public T get(){
      //ThreadLocal.get():以当前线程为句柄获取ThreadLocalMap
      ThreadLocalMap localMap=getMap(Thread.currentThread());
      if(map!=null){ return localMap.getEntry(this);}
      return setInitialValue();
  }   
  
  Thread t1=new Thread(new Runnable()
              {
                  ThreadLocal<String> value=new ThreadLocal<String>();
                  @Override
                  public void run(){
                      super.run();
                      value.set("你好");
                      value.get();
                  }
              }//Thread0结束
      );
  

---

ThreadLocal不会内存泄漏

• ThreadLocal在线程处理完仍存活（其值已无用，但不能被GC），会产生内存泄漏
  
  • 线程池中，线程处理完后仍存活复用，线程的ThreadLocalMap与gc roots相连
  • ThreadLocalMap的key为ThreadLocal，TheadLocal与gc roots相连，强引用阻碍了垃圾回收
• 不会产生内存泄漏，因为ThreadLocalMap并不直接用ThreadLocal为key,而是他的弱引用
  
  • 使用弱引用，垃圾回收帮你决定何时回收ThreadLocal
  • WeakHashMap：key为垃圾时，自动移除条目

---

四种引用

• 强引用：从不被GC,jvm停止运行时终止
• 软引用：内存不足时会被GC
• 弱引用：GC时一定被弄回收
• 虚引用：任何时刻都可能被GC
  
  • 不能用get()获取真实对象，对象呗回收之后，才会加入引用队列

---

泛型

Father father=new Son(); 
Mother mother=(Mother)father;

• 背景：向下转型存在很大的风险：Object->String或Integer，在编译期不能被发现
• jdk1.5推出泛型（参数化类型）：在使用时指明具体类型，因此不需要向下转型
  
  
• static方法，无法访问泛型类的类型参数，若需使用泛型，使其成为泛型方法
• 上界：extends Father 只接受Father及其子类
• 下界：super Son 只接受Son及其父类
  
  
• 使用上界类进行编译，泛型的特征被抹去
• 使用泛型类的对象时，能表现出强类型的特征:无法向ArrayList.add(Integer)
• 原因：编译器在使用泛型类的时候进行预处理转义，将泛型引用的对象强制转换为泛型参数指定的类型，然后再进行真行的编译，生成Class
• 效果：从使用上看，带参的泛型可当做强类型使用，如有不正确的类型操作，编译期报错。

---

http和https的区别

• https是用SSL安全套接层加密的，Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定，HTTPS使用端口443，而不是象HTTP那样使用端口80和TCP/IP进行通信

---

StringBuilder指定初始化容量的大小

StringBuilder sbuilder=new StringBuilder(word.length*10)

• 运行时进行内存的申请，不会限制只是常量

---

安全失败、快速失败

---

迭代器for：快速失败

public class Test{
    public static void main(String[] args){
        String []word=new String [50];
        List<String>bookList=new ArrayList<String>();
        for(int i=0;i<5;i++){
            books.add(String.valueOf(i));
        }
        for(String ele:books){
            System.out.println(ele);
            books.remove(ele);
        }
    }
}

---

编码：通过Unicode编码转换

• UTF-8 国际编码，英文1B,中文3B
• GBK 国际标准，中英文都2B

---

String charset="utf-8";
FileOutputSteam outputStream=new FileOutputSream("文件名");
OutputSteamerWriter writer=new OutputStreamWriter(outputSteam,charset);

String str = "字符串";
try{
    byte[] bNums = str.getBytes("utf-8");
    String newStr = new String(temp, "gbk");
} 
catch (UnsupportedEncodingException e){
    e.printStackTrace();
}

---

连接jdbc

• 1）加载数据库驱动程序，自己先下载jarClass.forName(“com.mysql.jdbc.Driver”);
• 2）提供JDBC连接的URL 协议:子协议:数据源标识
  
  • jdbc:mysql://localhost:3306/数据库名字?useUnicode=true&characterEncoding=gbk;
• 3）创建数据库的连接
  
  • DriverManager.getConnection(url,username, password);
• 4）创建一个Statement静态sql语句，PreparedStatement动态sql语句，CallableStatement存储过程

• 5）执行：executeQuery、executeUpdate、execute

• 6）处理执行结果，ResultSet行号从1开始，更新返回更新行数

• 7）关闭jdbc连接：Connection、Statement、ResultSet

---

public class TestSql{
    public static void main(String[] args){
        try{
             Class.forName("com.mysql.jdbc.Driver").newInstance();
        }
        catch (InstantiationException e1){
            e1.printStackTrace();
        } 
        catch (IllegalAccessException e1){
            e1.printStackTrace();
        } 
        catch (ClassNotFoundException e1){
            e1.printStackTrace();
        } 
        String url="jdbc:mysql://localhost:3306/anyguide2?
            useUnicode=true&characterEncoding=utf-8";
        try{
            Connection connection = DriverManager.getConnection(url, "root", "mhealth365");
            Statement statement = connection.createStatement();
            ResultSet resultset = statement.executeQuery("select * from spot_info");

            while (resultset.next()){
                String spotName=resultset.getString(3);
                System.out.println(spotName);
            }
            if(resultset!=null){
                resultset.close();
            }
            if(statement!=null){
                statement.close();
            }
            if(connection!=null){
                connection.close();
            }
        }
        catch (SQLException e1){
            e1.printStackTrace();
        }
    }
}

---

PreparedStament

• 继承了Statement接口的接口，添加了executeQuery()空参数方法
• 声明类型PreparedStatement 对象，而不是Statement 对象，否则报错

• 预编译的sql语句存储在PreparedStatement对象中，执行效率高

  PreparedStatement statement = connection.prepareStatement
              ("select * from spot_info");
  ResultSet res = statement.executeQuery();
  

---

• 使用占位符：不用重复编写结构类似的sql语句，不用拼接字符串，防sql注入，单引转义\

  PreparedStatement statement = connection.prepareStatement
          ("insert into spot_info(spot_id_no,spot_name) values(?,?)");
  statement.setObject(1, 14);
  statement.setObject(2, "景点名");
  int changedLine = statement.executeUpdate();
  

---

sql注入

  //1）普通sql
  select * from spot_info where spot_id_no=11 and spot_name='南大仙林';
  //2）恶意sql，补全前一个'，后一个'通过--进行转义，中间添加or 1=1
  select * from spot_info where spot_id_no=11 and spot_name='' or 1=1 --';

---

Comparable和Comparator

• Comparable：内在顺序，类实现Comparable接口，this>参数，正
  
  • Collections.sort(list)
• Comparator：外在顺序，类没实现Comparable接口，左>右，正
  
  • HelpComp类泛型实现Comparator接口，Collections.sort(List, comparator)，

---

class Student{
    public int sex;
    public int bihuaLen;
    public Student(int sex,int bihuaLen){
        this.sex=sex;
        this.bihuaLen=bihuaLen;
    }
    public String toString(){
        return sex+" "+bihuaLen;
    }
}
class HelpComp implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2){
        if(o1.sex<o2.sex){
            return -1;
        }
        else if(o1.sex==o2.sex){
            if(o1.bihuaLen<o2.bihuaLen){
                return -1;
            }
            else if(o1.bihuaLen==o2.bihuaLen){
                return 0;
            }
            else{
                return 1;
            }
        }
        else{
            return 1;
        }
    }
}
public class TestTreeMap{
    public static void main(String[] args){
        HelpComp help=new HelpComp();
        TreeMap tMap=new TreeMap(help);
        Student s1=new Student(0,6);
        Student s2=new Student(1,4);
        Student s3=new Student(1,3);
        Student s4=new Student(0,7);
        tMap.put(s1, 1);
        tMap.put(s2, 1);
        tMap.put(s3, 1);
        tMap.put(s4, 1);
        System.out.println(tMap);
        System.out.println(tMap.keySet());
    }
}

---

动态绑定

• 声明类型：变量被声明时的类型

• 实际类型：变量所引用的对象的真实类型

• 分派：根据对象的类型对方法进行选择，静态多分派、动态单分派

  • 静态分派：重载，编译期，声明类型，方法名参数
  • 动态分派：重写，运行期，实际类型，方法接收者，动态置换某方法
    
    
• 动态绑定：虚拟机预先为每个类创建了一个方法表:方法的签名和实例调用的方法
• 动态绑定无需修改现存代码，就可以对程序进行拓展，添加一个新类Executive，e可能引用该类的对象，不用对调用e.getSalary()的代码重新编译，自动调用Executive.getSalary()
  
  
• obj.func(paran)隐式参数obj，实际类型为SON
• 可能存在多个名字为func，但参数类型不同的方法，如func(int),func(string)，编译器列举SON类（超类中public）名为func的方法，匹配的过程，允许类型转换（匹配到0或多个都报错）
  
  
• final 修饰方法：编译时考虑性能，可将final函数视为内联函数。

---

//重载：WhiteCat、BlackCat继承Cat
public class Mozi{
    public void feed(Cat cat){
        System.out.println("猫");
    }
    public void feed(WhiteCat cat){
        System.out.println("白猫");
    }
    public void feed(BlackCat cat){
        System.out.println("黑猫");
    }
    public static void main(String[] args){
        Cat wCat = new WhiteCat();
        Cat bCat = new BlackCat();
        Mozi obj= new Mozi();
        obj.feed(wCat);
        p.feed(bCat);
    }
}
//重写:继承覆盖方法时，返回类型与父类相容
class Cat {
    public void eat(){
        System.out.println("吃鱼");
    }
}
class WhiteCat extends Cat {
    @Override
    public void eat(){
        System.out.println("吃白鱼");
    }
}
public class Mozi{
    public static void main(String[] args){
        Cat wCat = new WhiteCat();
        wCat.eat();
    }
}

---

继承和复合场景

• 对普具体类进行跨域包边界的继承不合适
  
  • 计算HashSet类中曾添加过的元素数量，addAll()通过调用add()实现
  • 1）不重写addAll()方法，直接使用HashSet中的addAll()，通过add实现
  • 2）自己重新写addAll()方法，耗时且容易出错
• 复合：不扩展现有类，在新类中，增加一个私有域，引用一个实例

---

单例：私有构造函数：私有静态实例：公有静态方法

1）饿汉:不管用不用，都先初始化好，有点浪费
class Single1{
    private Single1() {}
    private static Single1 single=new Single1();
    public static Single1 getInstance(){
        return single;
    }
}

2）懒汉粗锁：即使是无竞争的、也被锁降低了效率
class Single2{
    private Single2() {}
    private static Single2 single;
    public static synchronized Single2 getInstance(){
        if(single==null){
            single=new Single2();
        }
        return single;
    }
}

3）懒汉细锁：双重检查法、可能因指令重排序访问到未初始化的实例
class Single3{
    private Single3() {}
    private static Single3 single;
    public static Single3 getInstance(){
        if(single==null){
            synchronized(Single3.class){
                if(single==null){
                    single=new Single3();
                }
            }
        }
        return single;
    }
}

4）volatile修饰实例： 分配内存、初始化、指向内存
private static  volatile Single4 single;

---

异常分类

• 非检查异常：RuntimeException类及其子类
  
  • NullPointerException、IndexOutOfBoundsException
• 检查异常：Exception类中除了非检查异常的子类
  
  • IOException、SQLException
• 错误
  
  • OutOfMemoryError
    
    

• 异常的对象从哪里来

  • java运行时环境自动抛出的系统生成的异常
  • 程序员自己抛出的异常，throw关键字，常用来向调用者汇报异常的一些信息

• 异常转译

  • 将一种异常转换成另一种异常
  • 异常转译针对所有继承 Throwable超类的异常类而言的
  • 在异常的层层转译过程中，就形成一个异常链，整个异常链保存了每一层的异常原因

• try catch

  • try块后面必须跟着一个catch块或finally块
  • try块可有多个catch块，每个只能定义一种异常类
  • Exception e可以捕获所有类型的异常
  • 如果有多个catch块，Exception e最好放在最后
  • 如果在try块中使用了System.exit(0)，finally块不会被执行

• System.exit(status)：用来结束当前正在运行中的java虚拟机，不管status为何值都会退出程序， 0是正常退出程序

---

//try/catch有return，finally块仍会会执行   
//finall有return，会覆盖try/catch的return语句，调用方无法收到catch异常，Eclipse会给出警告，
@SuppressWarnings("finally")
public static String test(String path){
    String ans="返回状态";
    File file=new File(path);
    FileReader reader=null;
    try{
        reader=new FileReader(file);
        System.out.println("try");
        ans="try";
        return ans;
    }
    catch (FileNotFoundException e){
        System.out.println("catch");
        ans="catch";
        return ans;
    }
    finally{
        System.out.println("finally");
        close(reader);
        ans="finally";
        return ans;
    }
}
public static void main(String[] args){
    String ans=test("Test");
    System.out.println("test()返回:"+ans);
}

---

枚举

• static final的不足：类型不安全（int-123-4），没有命名空间，修改要重编译
• 枚举类型定义转变成类定义

---

public enum StudyEnum {
    ZhangSan("长江边上"),
    LiSi("鹅住在南极啊"),
    WangWu("黄土小坡坡啊");
    private String address;
    private StudyEnum(String address){
        this.address = address;
    }
    public String getAddress(){
        return this.address;
    }
    public static void main(String[] args){
        String address=StudyEnum.ZhangSan.getAddress();
        System.out.println(address);
        EnumSet<StudyEnum> list = EnumSet.range(StudyEnum.ZhangSan, StudyEnum.LiSi);
        for(StudyEnum ele:list){
            System.out.println(ele.getAddress());
        }

        EnumMap<StudyEnum,Integer> map=new EnumMap<StudyEnum,Integer> (StudyEnum.class);
        map.put(StudyEnum.LiSi, 4);
        Set<StudyEnum> set=map.keySet();
        for(StudyEnum ele:set){
            System.out.println(ele);
            System.out.println(map.get(ele));
        }
    }
}

---

优雅关闭IO流：Closeable接口

public class StduyTry{
    public static void close(Closeable obj) {
        if (obj == null){
            return; 
        }
        try {
            obj.close();
        } 
        catch (IOException e) {
        }
    }
}

---

equals()

• ==：判断两个对象的地址是否相等、即：判断两个对象是不是同一个对象
• equals：判断两个对象是否相等
  
  • 没有覆盖Object.equals()，默认实现是比较==
  • 覆盖了Object.equals()，执行覆盖后的函数进行内容相等的判断咯

---

重写equals()必须重写hashCode()

• 否则两个相等的对象可能有不同的散列码，会散列岛不同的位置
• 散列表会存在重复元素

---

instanceof

• 对象instanceof类：左边具体
• 类.isInstance(对象)
• 类.isAssignableFrom(类)
  

  ---

重写equals()

• 1）对称性问题：参数.istanceof(this) 普通点(1,2) 有色点(1,2,red)

  • 普通点.equals(有色点) 左边更具体，返回true
  • 有色点.equals(普通点) 左边不具体，返回false

• 2）解决对称性：分类讨论

  • 如果至少一个是普通点，直接普通点.equeals（另一个）

  • 否则，两个都是有色点，首先super.equeals(另一个)，再比较颜色

  • 3）传递性问题

    • 有色点.equals(普通点) 不比较颜色，返回true
    • 普通点.equals(有色点) 不比较颜色，返回true
    • 但是有色点可能颜色不符合，会违背了传递性

  • 4）无法在拓展可实例化的类同时、既增加新组件、又同时保留equals约定

---

post和get区别

• 参数数据的存储位置不同：get()在头部url；post()在请求正文
• tcp请求次数不同：get()请求一次，头部；post()请求两次，头部、正文

---

final关键字

• 修饰类：该类不可被继承，类中所有的方法都是final、成员不影响
• 修饰方法：可在子类中被正常继承、但不可重写
• 修饰字段
  
  • 基本类型：只能被赋值一次
  • 非基本类型：指向哪块内存是不可变的，但是指向的内存的内容是可以变的

---

String:运行时常量池

• 1）String case1=”计算机软件”常量池中不存在，常量池中创建，再解析引用
• 2）String case2=”计算机软件”常量池中已存在，直接解析引用
  
  
• 3）String case3=”计算机”+”软件”编译器优化
• 4）final String temp4=”计算机” String case4=temp4+”软件” 编译器优化
  
  
• 5）String case5=new String(“计算机软件”)
  
  • 如果常量池中已存在，堆中创建，返回堆中引用
  • 否则先创常量池对象，堆中创建，返回堆中引用
• 6）String case6=case5.intern() 得到常量池中的引用
  
  
• 7）String temp7=”计算机” String case7=temp7+”软件”;
  
  • 不为常量，不创常量池对象，堆中创建，返回堆中引用

---

反射：运行状态

 every类，能知道属性、方法;every对象，能调用属性、方法

• 1）类的公有方法：getMethod()
  
  • 自身public+基类public+接口public
• 2）类的自身方法:getDeclaredMethod()
  
  • 自身public+自身protected+自身private

---

finalize()

• System.gc() “强制”请求系统执行垃圾回收
  
  • 但是不能保证系统何时进行垃圾回收，jvm不一定会立刻执行，
  • jvm感觉内存空间有限时，才会开始执行finalize()
• Object.finalize() 允许被重写
  
  • 是jvm自动调用的
  • 当该对象在gc roots不可达，第一次标记后，指定对象应该做什么行为
  • 典型的做法是释放系统资源
• 何时调用finalize()
  
  • 显示调用
  • 对象被gc时自动调用,比如运行System.gc()的时候
  • 程序退出时为每个对象调用一次finalize方法

---

Class：对象equals

• Class属性：编译时决定、仅装入内存，不链接、不初始化
• Class.forName()：编译时决定、仅链接（静态代码块）、不初始化
• obj.getClass()：运行时决定、如果没加载链接、就加载链接、初始化

---

public class Test{
    {
        System.out.println("normal");
    }
    public Test(){
        System.out.println("constructor");
    }
    static{
        System.out.println("static");
    }
    public static void main(String[] args){}
}

---

class T{
    {
        Print.print("normal");
    }
    public static T t1=new T();
    public static T t2=new T();
    static {
        Print.print("static");
    }
}

---

public class LoadSeq{
    private static LoadSeq load = new LoadSeq(); 
    private static int count1;               
    private static int count2 = 2;            

    public LoadSeq(){                           
        count1++;  
        count2++;  
       Print.print("构造函数中"+count1+" "+count2); 
    }
    public static LoadSeq getLoad(){        
        return load;  
    }  
    public static void main(String[] args){
        LoadSeq.getLoad();  
        Print.print("count1="+count1);
        Print.print("count2="+count2);
        T t=new T();
    }  
}

---