java基础总结(二)

                 集合

1集合概述

为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

数组和集合类同是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

2 Collection接口概述

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

3 Collection接口常用成员方法

boolean add(E e)

boolean remove(Object o)

void clear()

boolean contains(Object o)

boolean isEmpty()

int size()

boolean addAll(Collection c)

boolean removeAll(Collection c)

boolean containsAll(Collection c)

boolean retainAll(Collection c)

4Collection集合的遍历方式

Object[] toArray()

把集合转成数组，可以实现集合的遍历

Iterator iterator()

迭代器，集合的专用遍历方式

5 Iterator接口概述

对 collection 进行迭代的迭代器

依赖于集合而存在

成员方法

booleanhasNext()     E next()

6 List接口概述

有序的Collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

与 set 不同，列表通常允许重复的元素。

 成员方法:

void add(int index,E element)

E remove(int index)

E get(int index)

E set(int index,E element)

ListIterator listIterator()

ListIterator接口的成员方法    boolean hasPrevious()        E previous()

7 List常用子类概述

ArrayList类概述

底层数据结构是数组，查询快，增删慢

线程不安全，效率高

Vector类概述

底层数据结构是数组，查询快，增删慢

线程安全，效率低

LinkedList类概述

底层数据结构是链表，查询慢，增删快

线程不安全，效率高

LinkedList类特有功能

public void addFirst(E e)及addLast(E e)

public E getFirst()及getLast()

public E removeFirst()及public EremoveLast()

8 Set接口概述

一个不包含重复元素的 collection

9Set常用子类概述

HashSet类概述

不保证 set 的迭代顺序

特别是它不保证该顺序恒久不变。

HashSet如何保证元素唯一性

底层数据结构是哈希表(元素是链表的数组)

哈希表依赖于哈希值存储

添加功能底层依赖两个方法：

int hashCode()

boolean equals(Object obj)

 

LinkedHashSet类概述

元素有序唯一

由链表保证元素有序

由哈希表保证元素唯一

 

TreeSet类概述

使用元素的自然顺序对元素进行排序

或者根据创建 set 时提供的 Comparator 进行排序

具体取决于使用的构造方法。

TreeSet是如何保证元素的排序和唯一性的

底层数据结构是红黑树(红黑树是一种自平衡的二叉树

 

10泛型

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。

泛型类

把泛型定义在类上

格式:public class 类名<泛型类型1,…>

注意:泛型类型必须是引用类型

泛型方法

把泛型定义在方法上

格式:public <泛型类型> 返回类型方法名(泛型类型 .)

泛型接口

把泛型定义在接口上

格式:public  interface 接口名<泛型类型1…>

泛型通配符

任意类型，如果没有明确，那么就是Object以及任意的Java类了

? extends E

向下限定，E及其子类

? super E

向上限定，E及其父类

11Map

Map接口概述

将键映射到值的对象

一个映射不能包含重复的键

每个键最多只能映射到一个值

Map接口和Collection接口的不同

Map是双列的,Collection是单列的

Map的键唯一,Collection的子体系Set是唯一的

Map集合的数据结构值针对键有效，跟值无关

  Collection集合的数据结构是针对元素有效

Map成员方法:

V put(K key,V value)

V remove(Object key)

void clear()

boolean containsKey(Object key)

boolean containsValue(Object value)

boolean isEmpty()

int size()

V get(Object key)

Set keySet()

Collection values()

Set> entrySet()

Map遍历方式

方式1：根据键找值

获取所有键的集合

遍历键的集合，获取到每一个键

根据键找值

Set keySet = map.keySet();

                   for(String string : keySet) {

           String value = map.get(string);

           System.out.println(string+value);

                   }

方式2：根据键值对对象找键和值

获取所有键值对对象的集合

遍历键值对对象的集合，获取到每一个键值对对象

根据键值对对象找键和值

Set>entrySet = map.entrySet();

                   for(Entry entry : entrySet) {

                            System.out.println(entry.getKey()+entry.getValue());

                   }

12Map常用子类

HashMap类概述

键是哈希表结构，可以保证键的唯一性

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。(除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。)此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap案例

HashMap

HashMap

HashMap

HashMap

 

LinkedHashMap类概述

Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。

TreeMap类概述

键是红黑树结构，可以保证键的排序和唯一性

TreeMap案例

HashMap

HashMap

 

HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

HashMap 非线程安全 TreeMap 非线程安全

 

线程安全

在Java里，线程安全一般体现在两个方面：

1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。如ArrayList和Vector，HashMap和Hashtable

（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element，问题就出现了。

 

2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。

1.AbstractMap抽象类和SortedMap接口

AbstractMap抽象类：(HashMap继承AbstractMap)覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。

SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图(子集)，包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。

 

2.两种常规Map实现

HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。

(1)HashMap(): 构建一个空的哈希映像

(2)HashMap(Map m): 构建一个哈希映像，并且添加映像m的所有映射

(3)HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像

(4)HashMap(int initialCapacity, floatloadFactor): 构建一个拥有特定容量和加载因子的空的哈希映像

TreeMap：基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。

(1)TreeMap():构建一个空的映像树

(2)TreeMap(Map m): 构建一个映像树，并且添加映像m中所有元素

(3)TreeMap(Comparator c): 构建一个映像树，并且使用特定的比较器对关键字进行排序

(4)TreeMap(SortedMap s): 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序

 

3.两种常规Map性能

HashMap：适用于在Map中插入、删除和定位元素。

Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

 

4.总结

HashMap通常比TreeMap快一点(树和哈希表的数据结构使然)，建议多使用HashMap，在需要排序的Map时候才用TreeMap。

 

13 Collections类概述

针对集合操作的工具类

Collections成员方法

public static voidsort(List list)

public static intbinarySearch(List list,T key)

public static T max(Collection coll)

public static void reverse(Listlist)

public static void shuffle(Listlist)

 

 

IO流

1File类的概述

文件和目录路径名的抽象表示形式

构造方法

public File(String pathname)

public File(String parent,String child)

public File(File parent,String child)

成员方法

创建功能

public boolean createNewFile()

public boolean mkdir()

public boolean mkdirs()

删除功能

public boolean delete()

重命名功能

public boolean renameTo(File dest)

判断功能

public boolean isDirectory()

public boolean isFile()

public boolean exists()

public boolean canRead()

public boolean canWrite()

public boolean isHidden()

基本获取功能

public String getAbsolutePath()

public String getPath()

public String getName()

public long length()

public long lastModified()

高级获取功能

public String[] list()

public File[] listFiles()

2递归

方法定义中调用方法本身的现象

递归注意实现

要有出口，否则就是死递归

次数不能太多，否则就内存溢出

构造方法不能递归使用

3IO流

用来处理设备之间的数据传输上传文件和下载文件

Java对数据的操作是通过流的方式

Java用于操作流的对象都在IO包中

字节流的抽象基类：

InputStream ，OutputStream。

字符流的抽象基类：

Reader ， Writer。

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。

如：Reader的子类FileReader。

字节流写数据的方式

FileOutputStream的构造方法

FileOutputStream(File file)

FileOutputStream(String name)

public void write(int b)

public void write(byte[] b)

public void write(byte[] b,int off,int len

字节流读数据的方式

FileInputStream

把刚才写的数据读取出来显示在控制台

FileInputStream的构造方法

FileInputStream(File file)

FileInputStream(String name)

FileInputStream的成员方法

public int read()一次读取一个字节

public int read(byte[] b)一次读取一个字节数组

字节缓冲流

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流

字节缓冲输出流

BufferedOutputStream

字节缓冲输入流

BufferedInputStream

由于字节流操作中文不是特别方便，所以，java就提供了转换流。

字符流=字节流+编码表。

编码表

由字符及其对应的数值组成的一张表

常见编码表

ASCII/Unicode 字符集ISO-8859-1 GB2312/GBK/GB18030 BIG5  UTF-8

 

OutputStreamWriter 字符输出流 简化写法FileWriter

public OutputStreamWriter(OutputStream out)

public OutputStreamWriter(OutputStreamout,String charsetName)

InputStreamReader 字符输入流  简化写法FileReader

public InputStreamReader(InputStream in)

public InputStreamReader(InputStreamin,String charsetName)

字符缓冲流

BufferedWriter基本用法

BufferedReader基本用法

特殊功能

BufferedWriter

void newLine()

BufferedReader

String readLine()

4序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。

主要用于存储对象状态为另一种通用格式，比如存储为二进制、xml、json等等，把对象转换成这种格式就叫序列化，而反序列化通常是从这种格式转换回来。

使用序列化主要是因为跨平台和对象存储的需求，因为网络上只允许字符串或者二进制格式，而文件需要使用二进制流格式，如果想把一个内存中的对象存储下来就必须使用序列化转换为xml（字符串）、json（字符串）或二进制（流）

序列化的前提条件

对象所属的类实现了序列化接口(Serializable)

序列化流

ObjectOutputStream

反序列化流

ObjectInputStream

 

多线程

1多线程概述

进程：

正在运行的程序，是系统进行资源分配和调用的独立单位。

每一个进程都有它自己的内存空间和系统资源。

线程：

是进程中的单个顺序控制流，是一条执行路径

一个进程如果只有一条执行路径，则称为单线程程序。

一个进程如果有多条执行路径，则称为多线程程序。

2Java程序运行原理

java 命令会启动 java 虚拟机，启动 JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程” ，然后主线程去调用某个类的main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。

jvm虚拟机的启动是单线程的还是多线程的? 

    多线程的。 

    原因是垃圾回收线程也要先启动,否则很容易会出现内存溢出。 

现在的垃圾回收线程加上前面的主线程,最底启动了两个线程,所以,jvm的启动是多线程的。

3多线程实现方式

(1)继承Thread类

Thread类的基本获取和设置方法

public final String getName()

public final void setName(String name)

public static Thread currentThread()

这样就可以获取任意方法所在的线程名称

(2)实现Runnable接口

如何获取线程名称

如何给线程设置名称

实现接口方式的好处

可以避免由于Java单继承带来的局限性。

适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

4线程调度与控制

抢占式调度模型   优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

Java使用的是抢占式调度模型。

public final int getPriority()

public final void setPriority(intnewPriority)

线程休眠 public static void sleep(long millis)

线程加入 public final void join()

线程礼让 public static void yield()

后台线程 public final void setDaemon(boolean on)

中断线程 public final void stop()   publicvoid interrupt()

5线程生命周期图

6线程安全问题

是否是多线程环境是否有共享数据 是否有多条语句操作共享数据

如何解决多线程安全问题呢?

把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。

同步代码块

格式：

                   synchronized(对象){需要同步的代码;}

同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

 

同步方法

就是把同步关键字加到方法上

同步方法的锁对象是什么呢?

如果是静态方法，同步方法的锁对象又是什么呢?

那么，我们到底使用谁?

如果锁对象是this，就可以考虑使用同步方法。

否则能使用同步代码块的尽量使用同步代码块。

 

JDK5以后提供了一个新的锁对象Lock

Lock

void lock()

void unlock()

 

7死锁问题

同步弊端效率低 如果出现了同步嵌套，就容易产生死锁问题

死锁问题及其代码

是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象

 

8关于wait()暂停的是持有锁的对象，所以想调用wait()必须为：对象.wait();

notify()唤醒的是等待锁的对象，调用:对象.notify();

如下：

Object obj = newObject();

synchronized(obj){

　　　　try{　　

　　　　　　obj.wait();

　　　　　　}catch(Exception e){}

　　　　　　obj.notify();

　　}

注意：wait(),notify(),notifyAll()都必须使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步 才具有锁。

为什么这些操作线程的方法要定义在object类中呢？

简单说：因为synchronized中的这把锁可以是任意对象，所以任意对象都可以调用wait()和notify()；所以wait和notify属于Object。

专业说：因为这些方法在操作同步线程时，都必须要标识它们操作线程的锁，只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法是定义在object类中。

 

设计模式

1面向对象思想设计原则

单一职责原则

”高内聚，低耦合”

也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。在设计模式中，所有的设计模式都遵循这一原则。

 

开闭原则

核心思想是：一个对象对扩展开放，对修改关闭。

其实开闭原则的意思就是：对类的改动是通过增加代码进行的，而不是修改现有代码。

也就是说软件开发人员一旦写出了可以运行的代码，就不应该去改动它，而是要保证它能一直运行下去，如何能够做到这一点呢?这就需要借助于抽象和多态，即把可能变化的内容抽象出来，从而使抽象的部分是相对稳定的，而具体的实现则是可以改变和扩展的

 

里氏替换原则

子类可以扩展父类的功能，但不能改变父类原有的功能。它包含以下4层含义：

子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

子类中可以增加自己特有的方法。

当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

 

依赖注入原则

在应用程序中，所有的类如果使用或依赖于其它的类，则都应该依赖于这些其它类的抽象类，而不是这些其它类的具体实现类（面向接口编程思想）。抽象层次应该不依赖于具体的实现细节，这样才能保证系统的可复用性和可维护性。为了实现这一原则，就要求开发人员在编程时针对接口编程，而不针对实现编程

 

接口分离原则

核心思想：不应该强迫程序依赖它们不需要使用的方法。

其实就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。

 

迪米特原则

一个对象应该对其他对象保持最少的了解

类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。

 

2设计模式

设计模式概述

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

 

创建型模式：简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式，单例模式。(6个)

结构型模式：外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)

行为型模式：模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)

3简单工厂模式概述

又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

优点

客户端不需要在负责对象的创建，从而明确了各个类的职责

缺点

这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

4工厂方法模式概述

工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

优点

客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

缺点

需要额外的编写代码，增加了工作量

5单例设计模式概述

单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。

优点

在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

缺点

没有抽象层，因此扩展很难。

职责过重，在一定程序上违背了单一职责

6装饰设计模式概述

装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案

优点

使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能

缺点

正因为可以随意组合，所以就可能出现一些不合理的逻辑

7代理模式

提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法

8观察者模式

使用场景

关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。

事件多级触发场景。

跨系统的消息交换场景，如消息队列、事件总线的处理机制。

优点

解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点

在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。

 

网络编程

1网络编程概述

计算机网络

         是指将地理位置不同的具有独立功能的多台计算机及其外部设备，

        通过通信线路连接起来，在网络操作系统，网络管理软件及网络通

        信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程

         就是用来实现网络互连的不同计算机上运行的程序间可以进行数据

        交换。

2网络通信三要素

IP地址:InetAddress

         网络中设备的标识，不易记忆，可用主机名 要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接受数据的计算机和识别发送的计算机，在TCP/IP协议中，这个标识号就是IP地址。

那么，我们如果获取和操作IP地址呢？为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress 供我们使用。

没有构造方法，那么如何使类提供的功能呢？

         1.类中的方法都是静态方法

         2.类中有一个方法返回的是该类的对象

         3.单例模式

要掌握的功能

                   获取任意主机：getByName         

                   主机名：getHostName

                   主机Ip地址：getHostAddress

 

端口号

         用于标识进程的逻辑地址，不同进程的标识

A:每个网络程序都会至少有一个逻辑端口

         B:用于标识进程的逻辑地址，不同进程的标识

         C:有效端口：0~65535，其中0~1024系统使用或保留端口。

传输协议

         通讯的规则

         常见协议：TCP，UDP

UDP

将数据源和目的封装成数据包中，不需要建立连接；每个数据报的大小在限制在64k；因无连接，是不可靠协议；不需要建立连接，速度快

DatagramSocket与DatagramPacket

建立发送端，接收端。

建立数据包。

调用Socket的发送接收方法。

关闭Socket。

发送端与接收端是两个独立的运行程序。

 

TCP

建立连接，形成传输数据的通道；在连接中进行大数据量传输；通过三次握手完成连接，是可靠协议；必须建立连接，效率会稍低

Socket和ServerSocket

建立客户端和服务器端

建立连接后，通过Socket中的IO流进行数据的传输

关闭socket

同样，客户端与服务器端是两个独立的应用程序。

 

Socket套接字：

网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

Socket原理机制：

通信的两端都有Socket。

网络通信其实就是Socket间的通信。

数据在两个Socket间通过IO传输。

 

反射

1类的加载器

类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

加载

就是指将class文件读入内存，并为之创建一个Class对象。

任何类被使用时系统都会建立一个Class对象。

连接

验证是否有正确的内部结构，并和其他类协调一致

准备负责为类的静态成员分配内存，并设置默认初始化值

解析将类的二进制数据中的符号引用替换为直接引用

类加载器

负责将.class文件加载到内在中，并为之生成对应的Class对象。

虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。

类加载器的组成

Bootstrap ClassLoader 根类加载器

也被称为引导类加载器，负责Java核心类的加载

比如System,String等。在JDK中JRE的lib目录下rt.jar文件中

Extension ClassLoader 扩展类加载器

负责JRE的扩展目录中jar包的加载。

在JDK中JRE的lib目录下ext目录

Sysetm ClassLoader 系统类加载器

负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

2类的初始化时机

创建类的实例

访问类的静态变量，或者为静态变量赋值

调用类的静态方法

使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

初始化某个类的子类

直接使用java.exe命令来运行某个主类

3反射      

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

获取构造方法 getConstructors    getDeclaredConstructors

获取所有成员 getFields,getDeclaredFields

获取单个成员 getField,getDeclaredField

修改成员的值 set(Object obj,Object value)

获取所有方法 getMethods       getDeclaredMethods

获取单个方法 getMethod       getDeclaredMethod

暴力访问    method.setAccessible(true);

4动态代理

代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。

动态代理：在程序运行过程中产生的这个对象

而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib

Proxy类中的方法创建动态代理类对象

public static ObjectnewProxyInstance(ClassLoader loader,Class[]interfaces,InvocationHandler h)

最终会调用InvocationHandler的方法

InvocationHandler

Object invoke(Object proxy,Methodmethod,Object[] args)

                  XML

1  XML:(ExtensibleMarkup Language) 可扩展标记语言.是以.xml格式的文件

XML 的设计宗旨是传输数据，而非显示数据

XML 标签没有被预定义 使用约束的XML文档设计具有自我描述性。

XML 是 W3C 的推荐标准

2文档格式

必须有XML声明语句

必须有且仅有一个根元素

标签大小写敏感

属性值用双引号

标签成对

元素正确嵌套

Xml文件中的注释采用：“” 格式。

2 XML约束

在XML技术里，可以编写一个文档来约束一个XML文档的书写规范，这称之为XML约束。

常用的约束技术

XML DTD    XML Schema

DTD约束即可以作为一个单独的文件编写，也可以在XML文件内编写

DTD(Document Type Definition)，全称为文档类型定义。

XML Schema是用一套预先规定的XML元素和属性创建的，这些元素和属性定义了XML文档的结构和内容模式。 XML Schema规定XML文档实例的结构和每个元素/属性的数据类型

Schema相对于DTD的明显好处是，XMLSchema文档本身也是XML文档，而不是像DTD一样使用自成一体的语法

XML Schema 文件自身就是一个XML文件，但它的扩展名通常为.xsd

3xml解析

DOM-文档对象模型(DocumentObject Module)

         基于树和节点的文档对象模型成为DOM

        DOM解析器会将xml文档转换为一个包含其内容的树，可以对树进行遍历。开发人员只需要掌握DOM方式常用的API就可以十分便捷的添加和修改树中的元素。

     DOM树在内存中是持久的，可以对其数据和结构进行修改。

         但是DOM解析器会将全部文档内容加载到xml文件中，所以对性能和内存要求比较高。

         处理大型文件时性能很低，是由于DOM树结构造成的，这种结构占用内存较多，而且DOM必须在解析文件之前把整个文档转载到内存中。

4DOM4J

DOM4J是dom4j.org出品的一个开源XML解析包，是jdom的升级品，用来读写XML文件的。dom4j是一个十分优秀的JavaXMLAPI，具有性能优异、功能强大和极其易使用的特点，它的性能超过sun公司官方的dom技术，同时它也是一个开放源代码的免费软件。

解析步骤:

(1)导入dom4j 的jar包 导入相应的类

(2)指定要解析的XML文件 File f=newFile(fileName);

(3)把XML 文件转换成Document对象

SAXReader saxReader=new SAXReader();

Document document=saxReader.read(f);

(4)获取节点属性或文本值

Stringtext=memberElm.getText();

Stringtext=attribute.getText();

补充知识

1正则表达式

正则表达式类:Pattern

1.字符:

      x 字符 x      任意一个字母都可以用它本身来表示

      \\ 反斜线字符     \:转义字符,如果要表示\在正则中需要\\

      \n 新行（换行）符 ('\u000A')

          \r 回车符 ('\u000D')

2.字符类:

        [abc] a、b 或 c（简单类）

                   [^abc] 任何字符，除了 a、b 或 c（否定）

                   [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） :所有的英文字母

                   [1-9]:表示数字1-9,不包含0

                  

3.预定义字符类

        . 任何字符（与行结束符可能匹配也可能不匹配）

                   \d 数字：[0-9]

                   \w 单词字符：[a-zA-Z_0-9]

4.边界匹配器

        ^ 行的开头

                   $ 行的结尾

                   \b 单词边界

                         举例:helloworld:java,android

5.数量词

        X? X,一次或一次也没有

                   X* X，零次或多次

                   X+ X，一次或多次

                   X{n} X，恰好 n 次

                   X{n,} X，至少 n 次

                   X{n,m} X，至少 n 次，但是不超过 m 次

                                 

                          

  [x] : 表示的是只出现了一次                        

             

判断功能public boolean matches(String regex)

分割功能public String[] split(String regex)

替换功能public String replaceAll(String regex,String replacement)

 

2枚举

枚举类型是Java 5中新增特性的一部分，它是一种特殊的数据类型，之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。

在定义枚举类型时我们使用的关键字是enum，与class关键字类似，只不过前者是定义枚举类型，后者是定义类类型。值一般是大写的字母，多个值之间以逗号分隔。同时我们应该知道的是枚举类型可以像类(class)类型一样，定义为一个单独的文件，当然也可以定义在其他类内部

可以创建一个enum类，把它看做一个普通的类。除了它不能继承其他类了。(java是单继承，它已经继承了Enum),可以添加其他方法，覆盖它本身的方法

 

switch()参数可以使用enum

 

values()方法是编译器插入到enum定义中的static方法，所以，当你将enum实例向上转型为父类Enum是，values()就不可访问了。解决办法：在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍然可以通过Class对象取得所有的enum实例

 

无法从enum继承子类，如果需要扩展enum中的元素，在一个接口的内部，创建实现该接口的枚举，以此将元素进行分组。达到将枚举元素进行分组。

 

enum允许程序员为eunm实例编写方法。所以可以为每个enum实例赋予各自不同的行为。