Java学习笔记_系列03

1.集合：保存多个其他对象的对象，不能保存简单类型

List :有序(存放元素的顺序)，可重复的集合

ArrayList：实质就是一个会自动增长的数组查询效率比较高，增删的效率比较低，适用于查询比较频繁，增删动作较少的元素管理的集合。加载大批量的数据时，先进行手动扩容(就是调用ensureCapacity(int minCapacity)方法)，这样可以提高效率。
LinkedList：底层是用双向循环链表来实现的查询效率低，但是增删效率很高，适用于增删动作的比较频繁，查询次数较少的元素管理的集合
Set：无序的，不允许有重复元素的集合

HashSet：Object类中的hashCode()的方法是所有类都会继承的方法，这个方法会算出一个Hash码值返回，HashSet会用Hash码值去和数组长度取模，对象的模值(这个模值就是对象要存放在数组中的位置，和数组的下标相同)相同时才会判断数组中的元素和要加入的对象的内容是否相同，如果不同才会再找位置添加进去，相同则不允许添加。如果数组中的元素和要加入的对象的hashCode()返回了相同的Hash码值，才会用equals()方法来判断两个对象的内容是否相同。  
注意：要存入HashSet的集合对象中的自定义类必须覆盖hashCode()、equals()两个方法，才能保证集合中元素不重复。
TreeSet：可排序的Set
SortedSet接口:是Set的子接口，TreeSet是SortedSet接口的实现类，他可以对集合中的元素进行排序。将自定义类的对象存放在TreeSet中，这个类需要实现了Comparable接口，TreeSet可以自动过滤掉重复元素所以不在需要重载hashCode()方法，TreeSet会根据比较规则判断元素内容是否相同，不同则会存入，TreeSet会在元素存入时就进行排序。
Comparable接口：也叫做可比较接口，这个接口在java.lang包下，只要根据指定类型的排序规则实现了这个接口，就是可排序的。这个接口中只定义了一个 compareTo(Object o) 方法，该方法的返回值类型是整型，如果当前对象大于参数对象就返回正数，当前对象等于参数对象就返回0，当前对象小于参数对象就返回负值，这样写就是升序排列，反之则是进行降序排列。
Comparator接口：比较器Comparator接口，是另一种对自定义类型对象的集合整体排序的方法，存在于java.util包下。   这个接口中定义了一个 compare(Object o1,Object o2) 方法来比较两个对象，这个方法的返回值定义和上面介绍的那个方法是一样。利用这种方式，则在创建集合的时候把定义好的比较器作
为参数，构造一个集合
Map：存放key-value对(有关系的两个对象，一个做key，一个做value，同时存入)

HashMap：基于哈希表的 Map 接口的实现，此实现提供所有可选的映射操作，并允许使用 null 值和 null 键
遍历：先调用keySet()得到key的set集合，再迭代遍历key的set集合，根据key得到value。
Hashtable：同HashMap，一般不使用
HashMap与Hashtable的区别：
         HashMap：非线程安全，不支持并发控制，允许空的键值对。
         Hashtable：是线程安全，支持并发控制，不允许有空的键值对。
SortedMap接口：Map的子接口，按某一特定排序规则来存放所加入的键值对
         实现类：TreeMap类。
            Key值的排序规则，同SortedSet接口实现类TreeSet
      注意：
         key一般是8种基本类型的封装类或者是String类，拿自己自定义的类作为Key没有意义。
         key不可重复，value可以重复
2.反射：
   反射：在运行时动态分析或使用一个类进行工作。
   java.lang.Class类：描述类信息的类。
   类对象：描述一个类信息的对象，当虚拟机加载类的时候，就会创建这个类的类对象并加载该对象，Class是类对象的类型。
  
   获得类对象的方式：
      用" 类名.class "获得这个类的类对象。
      用类的对象掉用getClass()，如object.getClass()得到这个对象的类型的类对象。
      可以使用Class.forName(类名)，也可以得到这个类的类对象，（注意，这里写的类名必须是全限定名（全名），是包名加类名，XXX.XXX.XXXX）。
      基本类型也有类对象，用" 封装类.TYPE "可以获得对应的基本类型的类对象。

   java.lang.reflect包下的三个重要类：
      Field属性类：用来描述属性的信息。
      Method方法类：方法的信息的描述。
      Constructor构造方法类：用来描述构造方法的信息。

   Class类中的常用方法：
      newInstance()
         创建此 Class 对象所表示的类的一个新实例(调用无参构造创建的对象)。
      getDeclaredMethods()
         获得的是一个Method方法类对象的数组，获得本类(不包括父类)声明的所有(包括private的)方法对象。
      getMethods()     //推荐使用
         获得的是一个Method方法类对象的数组，获得所有(父类的也包括)publice的方法对象。
      getDeclaredConstructors()
         获得的是一个Constructor构造方法类对象的数组，获得这个类声明的所有构造方法对象。
      getConstructors()    //推荐使用
         获得的是一个Constructor构造方法类对象的数组，获得所有publice的构造方法对象。
      getDeclaredFields()    //推荐使用
         获得的是一个Field属性类对象的数组，获得本类声明的所有属性的属性对象。
      getFields()
         获得的是一个Field属性类对象的数组，获得所有publice的属性对象。
        
   使用反射构造一个类的对象的步骤：
      a. 获得类对象
      b. 获得构造方法对象
      c. 获得对象，用构造方法对象调用构造方法，如果使用无参构造方法，可以跳过第二步，直接使用" 类对象.newInstance() "方法来获得这个类的对象
      d. 获得方法对象
      e. 用方法对象调用方法（用这个类的对象作为第一参数）
      如下面的例子：
         反射机制的实现类：
          

 package day07.reflect;            
            import java.lang.reflect.Field;
            import java.lang.reflect.Method;
            import java.util.HashMap;
            import java.util.Map;
            import java.util.Set;         
            public class TestReflect {               
               public static Object get(String className , Map<String,Object> map) throws Exception{
                  Class c = Class.forName(className);                  //获得类对象
                  Object o = c.newInstance();                   //获得对象
                  Set<String> set = map.keySet();
                  for(String str : set){
                     String s = "set" + str.substring(0,1).toUpperCase()+str.substring(1);
                     Field f = c.getDeclaredField(str);
                     Method m = c.getMethod(s, f.getType());        //获得方法对象
                     m.invoke(o, map.get(str));                       //用方法对象调用方法
                  }
                  return o;
               }
               
               public static void main(String[] args) throws Exception {   
                  Map m = new HashMap();
                  m.put("name", "zhang");
                  m.put("age", 22);
                  Object o = get("day07.reflect.Student",m);
                  Student s = (Student) o;
                  System.out.println(s.getName() + "   " + s.getAge());
                  
                  Map m1 = new HashMap();
                  m1.put("name", "li");
                  m1.put("gender", "男");
                  Object o1 = get("day07.reflect.Teacher",m1);
                  Teacher t = (Teacher) o1;
                  System.out.println(t.getName() + "    " + t.getGender());
               }
            }

   
     学生类：
         

  package day07.reflect;            
            public class Student {
               private String name;            
               private int age;            
               public int getAge() {
                  return age;
               }            
               public void setAge(int age) {
                  this.age = age;
               }            
               public String getName() {
                  return name;
               }            
               public void setName(String name) {
                  this.name = name;
               }
            }   

    
    教师类：
          

 package day07.reflect;            
            public class Teacher {
               private String name;            
               private String gender;            
               public String getGender() {
                  return gender;
               }            
               public void setGender(String gender) {
                  this.gender = gender;
               }                  
               public String getName() {
                  return name;
               }            
               public void setName(String name) {
                  this.name = name;
               }            
            }

3.内部类：
   定义：
      定义在另外一个类中的类，就是内部类。
      编译后生成的两个独立的类：Outer.class 和Outer$Inner.class。
     
   内部类的分类：
      静态内部类：静态内部类定义在类中，任何方法外，用static修饰
         静态内部类只能访问外部类的静态成员。
         在外部类的外部，要创建一个静态内部类对象不需要外部类对象：
            Outer.Inner in = new Outer.Inner();
         在本类内部生成内部类对象的方式：
            Inner in = new Inner();  
  
      成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列
         在内部类中可以直接访问外部类的私有属性。
         内部类和外部类的实例变量允许命名冲突。
            在内部类中访问实例变量：this.属性
            在内部类访问外部类的实例变量：外部类名.this.属性
         在外部类的外部，要创建一个成员内部类对象，要首先建立一个外部类对象，然后再创建一个成员内部类对象。
            Outer out = new Outer();
            Outer.Inner in = out.new Inner();
         在本类内部生成内部类对象的方式：
            在静态方法中：Inner in = new Outer().new Inner();
            在非静态方法中：Inner in = this.new Inner();
         成员内部类不可以有静态成员，这是因为静态属性是在加载类的时候创建，这个时候内部类还没有被创建。
           
      局部内部类：在外部类的方法中定义的内部类
         与局部变量类似，在局部内部类前不可以加修饰符public和private，其作用域为定义它的代码块。
         局部内部类不仅可以访问外部类的实例变量，还可以访问外部类的局部变量，但要求外部类的局部变量必须为final的。
         配合接口使用，来做到强制弱耦合。
         在外部类的外部不可创建局部内部类对象，只能在局部内部类所在的方法中创建：
            Inner in = new Inner();
        
      匿名内部类：一种特殊的局部内部类
         没有名字，也没有class、extends、implements关键字
         用一种隐含的方式实现一个接口或继承一个类，并且只能创建一次实例。
         实现方式：在某个语句中，new 父类/父接口名字(){ 类体中实现方法 }
            例如：
               TreesSet ts = new TreeSet(new Comparator(){
                  public int compare(Object o1, Object o2){
                     return 0;
                  }
               });
         匿名内部类属于局部内部类，那么局部内部类的所有限制都对其生效。
         匿名内部类是唯一一种无构造方法的类，因为构造器的名字必须合类名相同，而匿名内部类没有类名。
4.异常：
   异常的分类
      Java会将所有的异常封装成对象，其根本父类为Throwable。
      Throwable有两个子类：Error 和Exception。
     
      Error：一个Error对象表示一个程序错误，指的是底层的低级的不可恢复的严重错误
         遇到Error，程序一定会退出，因为已经失去了运行所必须的物理环境。
         对于Error我们无法进行处理，因为我们是通过程序来应对错误的，可是程序已经退出了。
        
      Exception：由特定因素，导致程序无法继续，但不影响虚拟机的正常执行。
         未检查异常(Runtime Exception)：
            是因为程序员没有进行必要的检查，由于程序员的疏忽而引起的异常。
            对于未检查异常可以不处理，编译可以通过，应对未检查异常的方法就是养成良好的检查习惯
         已检查异常(非Runtime Exception)：
            是不可避免的，对于已检查异常必须处理，否则编译不通过。

   异常处理的机制：
      当一个方法中有一条语句出现了异常，它就会throw（抛出）一个异常对象（throw 异常对象），然后后面的语句不会执行，而返回上一级方法，其上一级方法接受到了异常对象之后，有可能对这个异常进行处理(进行处理则不会上抛)，也可能将这个异常传到它的上一级，如果最上一级(main方法)不处理就会传给虚拟机，虚拟机就会终止程序的运行。

   异常的处理方式：throws和try-catch方法
      try-catch处理方式：
            try{      //一个
           
               (1)可能出现异常的语句
              
            } catch(XxxException e /*捕获的异常*/){   //0或n个
           
               (2)处理异常的代码
              
            } finally{      //0或1个
           
               (3)必须要执行的代码
              
            }
            (4)方法中的其他代码
              
         如果代码正确，那么程序不经过catch语句直接向下运行；
         如果代码不正确，则将返回的异常对象和e进行匹配，如果匹配成功，则处理其后面的异常处理代码。
         try中如果发现错误，即跳出try块去匹配catch，那么try后面的语句就不会被执行。
         一个try可以跟多个catch语句，用于处理不同情况，但是不能将父类型的exception的位置写在子类型的excepiton之前。
         在try-catch后还可以再跟一子句finally。其中的代码语句论有没有异常都会被执行(因为finally子句的这个特性，所以一般将释放资源，关闭连接的语句写在里面)。
         finally中的代码和try-catch中的代码冲突时，finally中的代码一定会被执行且会忽略try-catch中的代码。但是如果try-catch中有System.exit(0);(虚拟机退出语句)，则不会去执行fianlly中的代码。
     
      throws/throw处理方式：
         throw 写在方法内，后面跟一个异常对象。
         throws 在方法的定义中说明方法可能抛出的异常，后面跟异常类的名字，声明这个方法将不处理异常，把异常交给上一级方法处理。
         调用时，调用者不能抛出范围更小的异常。
         对于方法a，如果它定义了throws Exception。那么当它调用的方法b返回异常对象时，方法a并不处理，而将这个异常对象向上一级返回，如果所有的方法均不进行处理，返回到主方法，如主方法也不进行处理，则到虚拟机中，程序中止。
         如果在方法的程序中有一行throw new Exception()，那么其后的程序不执行，如果没有对这个可能出现的检查结果进行处理，那么程序就会报错。
         throws和throw没有必然的联系。
  
      注意：
         方法的覆盖中，如果子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类无法覆盖父类。
         子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型，或者子类型不抛出例外。
         如果父类型无throws时，子类型也不允许出现throws。此时只能使用try catch。

      自定义异常：
         a. 使其继承Exception或者RuntimeException。
         b. 写构造器，直接调用父类的构造器
        
断言(assert)：用来调试、测试代码
   格式：
      assert 布尔表达式: 字符串  (如果布尔表达式为false时，这个字符串才会显示)
   注意：
      assert默认是关闭的，使用时需要使用" -ea "进行开启，" -da "是关闭，如：java -ea 类名。
      断言是以异常方式去执行的，当断言的布尔表达式为假时，会中断代码。
      不能继承性的打开(java -ea:类名  这样只能打开该类，如果存在父类，不会去打开父类)
5.图形界面：
   AWT：抽象窗口工具(Abstract Window Toolkit)
      组件：图形界面中所有能看到的，比如按钮等。
      容器：用来管理其他组件的对象
      布局管理器：布置组件在容器中的位置和大小
     
   Swing：AWT的一个增强版
     
   构造图形界面的步骤：
      选择一个容器
      设置容器的布局管理器
      向容器中添加组件
      事件的监听
     
   容器(Container)：用于管理其他的组件的对象，组件必须放到容器里
      JFrame：一个最顶层的窗体容器，所有其他的组件必须放在顶层容器里。
      JPanel：不是顶层容器，必须放在顶层容器中，是透明的（默认）。
      容器的方法：
         add(Component com)  将组件加入容器。
         setLayout(LayoutManager manager)  设置布局管理器。     
         setSize(int width,int height)  设置窗口大小
         setVisible(boolean b)  显示或隐藏此组件
         setDefaultCloseOperation(int operation)  设置关闭窗体上时默认执行的操作

   布局管理：布置组件在容器中的位置和大小
      FlowLayout：流式布局管理，Panel和JPanel的默认布局管理就是FlowLayout
         三种构造方式：
            FlowLayout()
               构造一个新的 FlowLayout，居中对齐，默认的水平和垂直间隙是 5 个单位。
            FlowLayout(int align)
               构造一个新的 FlowLayout，对齐方式是指定的，默认的水平和垂直间隙是 5 个单位。
            FlowLayout(int align, int hgap, int vgap)
               创建一个新的流布局管理器，具有指定的对齐方式以及指定的水平和垂直间隙。
              
      BorderLayout：按方位进行布局管理，不明确指定，就会默认加载在中间，Frame和JFrame默认的布局管理器是BorderLayout
         两种构造方式：
            BorderLayout()
                      构造一个组件之间没有间距的新边界布局。
            BorderLayout(int hgap, int vgap)
                      用指定的组件之间的水平间距构造一个边界布局。

      GridLayout：网格布局，通过行列、间距来用网格分割，把组件放入网格中，先行后列摆放组件。
         三种构造方式：
            GridLayout()
               创建具有默认值的网格布局，即每个组件占据一行一列。
            GridLayout(int rows, int cols)
               创建具有指定行数和列数的网格布局。
            GridLayout(int rows, int cols, int hgap, int vgap)
               创建具有指定行数和列数的网格布局，并将水平和垂直间距设置为指定值。
        
   组件：图形界面中所有能看到的
      JButton ：按钮
      JTextField：单行文本域
      JTextArea：多行文本区
      JLabel：标签
6.图形界面：
   布局管理器：
      CardLayout：卡片布局，面板重叠放置，只能看到一个，最先添加的会被显示出来，可以进行翻动
         两种构造方法：
            CardLayout()
                      创建一个间隙大小为 0 的新卡片布局。
            CardLayout(int hgap, int vgap)
                      创建一个具有指定的水平和垂直间隙的新卡片布局。
                常用的方法：
            previous(Container parent)
                      翻转到指定容器的前一张卡片。
                   show(Container parent, String name)
                      翻转到已添加到此布局的具有指定 name 的组件
                   next(Container parent)
                      翻转到指定容器的下一张卡片。
                   first(Container parent)
                      翻转到容器的第一张卡片。  
                   last(Container parent)
                      翻转到容器的最后一张卡片。
                     
             GridBagLayout：增强版的网格布局，组件可以跨行跨列的进行布局。
                构造方法：
                   GridBagLayout()
                      创建网格包布局管理器。
                注意：
                   该布局管理器的具体实现需要借助GridBagConstraints类，利用GridBagConstraints类的属性对组件进行设置，具体内容查看API文档。
                  
   菜单项：
      JMenuBar：菜单栏的实现，将JMenu对象添加到菜单栏以构造菜单
         构造方法：
            JMenuBar()
                      创建新的菜单栏。
                     
      JMenu：菜单的该实现是一个包含JMenuItem的弹出窗口
         构造方法：
            JMenu(String s)
                      构造一个新JMenu，用提供的字符串作为其文本。
                     
      JMenuItem：菜单中的项的实现，菜单项本质上是位于列表中的按钮
         构造方法：
            JMenuItem(String text)
                      创建带有指定文本的JMenuItem。
7.AWT事件模型：
   事件模型的三要素：
      事件源(Object)：事件的产生者。
      事件(EventObject)：描述发生了什么事情。 
      事件监听(EventListener)：事件的处理者
      关系：
         事件只与事件源有关，与事件监听无关
         一个事件源可以注册多个事件监听。
         一个事件监听器可以在多个事件源中注册。
         一个事件源可以就同一类事件注册多个事件监听。
  
   事件处理机制：委派式的处理机制(是一种松耦合)
      组件自身会产生事件对象，但本身不一定负责处理，而是交给一个监听者去处理
     
   实现监听的步骤：
      a. 实现监听接口implements XxxxListener
      b. 重写方法actionPerformed(ActionEvent e)
      c. 注册监听addXxxxListener(ActionListener l)
     
   适配器：一个重写了所有接口中方法的类
      在java.awt.event包中，会有一些适配器，也就是把相应的XxxxListener，换成XxxxAdapter就是适配器。
      在AWT中经常用匿名内部类来继承适配器做监听
8.JFC：java基础类库(具体的类可以查看API文档)

观察者模式：
   事件监听者对事件源进行监听，事件源会发生某些事件，监听者需要对事件作出相应的处理。
  
   事件监听者(Observer)：  
      处理事件
     
   事件对象(Observable)：
      注册监听
      取消监听
      通知监听
     
   编程步骤：
      a. 定义一个监听者，使其实现Observer接口，实现其中的方法update(Observable o, Object arg)。
      b. 定义一个事件对象，使其继承Observable类，定义一个产生事件的方法，在方法里去注册监听addObserver(Observer o)、标志改变setChanged()（如果不写，则说明该事件没有发生，监听者不会反映）、启动监听notifyObservers()。
         注意：注册监听和标志改变不分先后，但标志改变和启动监听是不能互换的。
        
   应用：当某事物发生变化，需要采取行动，则可以采用观察者模式。
  
适配器模式：
   Adapter适配器模式是一种结构型模式，将两个互不兼容的类纠合在一起。
  
   主要应对：由于应用环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是，新环境要求的接口是现存对象所不满足的。
  
   作用：在不改变源代码的情况下实现需求。

java.math.BigDecimal：不可变的、任意精度的有符号十进制数。
   必须用String类型进行构造，才能实现精确计算