突然之间想到把之前的笔记都翻出来,毕竟是自己刚入门的时候真正付出过时间和经历的东西,比较有意义.
不多说..之间发出来(话说之前都是用的txt写比较,too young too navie,500多行)
我们导入到jar包，当要使用其中的类时，jvm是直接装载该类的字节码文件，还是要先编译下.java的源文件，然后生成一个新的字节码文件？
给我们的jar包里面是只有字节码文件还是只有java文件，还是二者都有；
貌似只有.class文件，因为我们要查看源代码，还要有src包；
要养成写注释的好习惯，但是注释要写的精炼恰当；既要让人看的懂，又不显得那么繁琐；乱七八糟；即该要的必须有，不该要的不要有；
注释三部曲：
1 需求：
2 思路：
3 步骤：
Java中函数的重载只和参数列表有关，跟返回值没有任何关系，也即只要函数名相同，参数列表（参数类型和参数个数）不同就算重载，当然前提是在同一个类中；
栈内存中的定义的变量会自动销毁，堆内存中的数据会由垃圾回收机制回收；
内存泄露的示例：
1：Set set=new HashSet();
Student student=new Student();
student.setName("小强");
set.add(student);
student.setName("小宝");
set.delete(student);//删除不成功，因为，hash值改变了；
也就是说一个对象的hash值跟他的属性值有关，属性值改变了，hash值就变了；
内存泄露还有一种情况；
就是我们使用匿名的流，使用了一次，但是没法关；
即 new FileOutputStream("filename");
Java中有五种内存形式：栈内存（int arr定义出来的），堆内存（new出来的）；方法区（数据区，共享区），本地方法区，寄存器，
定义Boolean型的数组，其默认值为false，
Java中有数据类型在大地方面分为两种：基本数据类型比如，boolean和int，short，long，float,double,char byte等8种；
和引用数据类型，如数组，枚举，类类型等，而且只有引用数据类型才能给其赋值为null，基本数据类型是不能被赋值为null的；
关于基本数据类型和String类型的常量，在编译时会发生代换；
数组越界异常是运行时异常，运行时异常RuntimeException是Exception的子类；
堆内存中的对象都有一个初始化值，即null
在定义类中的成员时，首先考虑到该成员是否需要被共享，即该数据并不需要给每个对象都定义一个，
而是所有的对象共享该成员，那么就要把它定义成静态，在内存中对应的是方法区中；而非静态成员定义在堆内存中；
一个类会不会被加载要看它是否被使用，即要使用到该类中的内容，而仅仅是创建该类对象的引用不能说是使用到该类，
因为仅仅是创建该类对象的引用，该引用存在于栈内存中，并没有指向堆内存和方法区；
当然我们也可手动加载该类，同过Class.forName();方法；
构造代码块中可以引用非静态变量；
对于对象及成员的初始化问题;静态代码块，默认初始化，构造代码块，构造函数，这是一个类中都有的东西，当我们在另一个类中new它 的时候，具体的执行步骤为：
1 首先该类的字节码被加载进内存，同时静态代码块执行。
2 当新建该对象时，在堆内存中开辟内存空间，同时执行构造代码块中的内容
3 为成员变量进行默认初始化；
4 为成员变量进行显示初始化
5 调用构造函数进行初始化，如果构造函数内部还有更细节化的构造函数初始化，则
调用更细节的构造函数进行初始化；（父类）
虽然静态方法也可以被覆盖，但是这种操作一般不建议使用，
子类覆盖父类的方法有一定的前提，
1即子类要覆盖父类中的方法，该方法不能是私有权限，
即父类应该对外提供该方法，否则子类不知道有该方法，就不存在覆盖；
2 子类方法的权限要大于等于父类方法的权限；
保护权限高于默认权限；
子类覆盖父类的方法的最低权限只能是protected权限，这时父类可以是protected权限；
抽象类中可以不定义抽象方法，abstract关键字可以修饰类和方法，不能修饰变量；如果我们希望某个类不创建对象，就可以加上抽象化；
同时我们可以在该类中定义抽象类的引用，并new一个其匿名的实现类；算是匿名类的高级应用吧。。。
模板设计模式：
基本思想，我们要定义处理某一类问题的模板方法，当下次使用时，可以直接使用，而不用再去定义；
核心思想是我们要定义这类问题都要用到底代码，并暴露出去，如果不希望子类复写，可以使用final修饰；
而需要子类自己定义的内容，我们可以定义好或者干脆把他定义成抽象的；由子类去复写；
而且可以在子类中定义公共的内容，并使用到抽象的内容，即需要子类复写的内容；
子类继承父类，如果父类中有静态成员，子类同样可以继承过来使用该静态成员；该成员包括成员变量和成员函数；
接口之间可以多继承
多态情况下，成员变量不管是运行还是编译都看左边，同时静态成员都是看左边；
实现多线程技术最好使用实现Runnable接口，为什么呢？
因为Java只支持多实现，不支持多继承。如果一旦继承了Thread类，
那么他就不能在继承其他类的；也就是出现了局限性；
同时使用继承抽象类和实现接口的区别：
1 使用抽象类可以使用部分父类已经写好的方法，那么子类可以使用，如果不想使用也可以覆盖掉，而且并不是所有的方法都是抽象的（抽象类中的方法可以全部都是非抽象的），
那么子类使用起来就相当顺手；但是使用继承的话，就只能继承这一个，而不能再去继承其他类；对于非抽象方法子类可以选择是否覆盖，决定权在程序员；
2 实现接口的话，可以多实现。将要被线程执行的代码放到一个对象中，更加的面向对象；
即将启动线程和要被线程执行的代码分开存放；
同时注意的是：Java面向的第一原则是面向接口编程；所以提倡用接口去实现；
匿名类也可以是非抽象类的子类；
线程的五种状态：
创建；
冻结
阻塞
启动
消亡：
线程结束：被多线程执行的代码结束线程就消亡了，比如run方法，如果run方法中的代码执行结束线程就结束了；
毕老师说的改变标记，其实就是要让run方法执行结束；因此可以说，线程的生命周期是run方法执行的周期；
比如 new Thread()
{
}.start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
//22222222
System.out.println(Thread.currentThread().getName()
+ "thread ...");
}
}
}) {
public void run() {
while (true) {
//1111
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "haha");
}
}
}.start();
上面这个代码中会执行1111还是2222处的代码呢？
经过分析我们知道，上面的代码可以理解成这样；
子类中覆盖了父类中的方法，执行时当然是找子类的方法；
或者可以理解为是用了直接继承Thread类的方式创建并启动线程；
Thread实现了Runnable接口；因此，实现了Runnable接口的类和Thread是平级的；
Thread牛就牛在了可以启动系统资源来启动一个线程；
多线程技术会提高程序的运行效率吗？那为什么还会有多线程下载呢?
多线程是不会提高程序的运行效率，反而会影响程序执行效率，至于为什么会有多线程下载呢？这是因为我们在下载时；
给用户提供下载的服务器为每个人都分配一定的带宽，如果是单线程，就只分配一份带宽（）；
而如果是多线程呢就会分配多份带宽，相比之下，一个用户获得了更多的带宽
这就是多线程下载的好处；并不是多线程会使执行效率变高；
---------------------------------------------------------------------------------是这样的吗
多线程实现方式有两种：
1：一种是直接继承Thread类，覆盖该类的run方法，将要被线程调用的代码封装进run方法中；
然后调用start启动线程；
2
然后调用start方法启动线程；
用代码来体现就是；
//第一种方式：
new Thread()
{
public void run()
{
//多线程执行代码；
}
}.start();
//2 第二种方式：
new Thread(
new Runnable()
{public void run()
{
//多线程执行代码；
}}
).start();
我们一般建议使用第二种方式，即实现Runnable接口方式，为什么呢？
因为这种方式不会有局限性，因为Java中只支持多实现不支持多继承，一旦该类继承了Thread类，就不能继承其他类，
而我们实现Runnable接口，就没有这个局限性；
线程间通信机制：等待唤醒机制：阻塞队列可以实现，jdk1.5并发库中提供了好多比较实用的操作线程类；
我们判断是否会出现线程安全问题的标准有两个：
1 是否是多线程情况，并访问了共享数据；
2 各线程对共享数据的访问限制所使用的锁是否相同；
即线程的互斥；我们对于线程安全问题是使用了sychronied代码块或者函数封装体对
可能出现问题的代码进行封装，要保证使用的锁是同一个，静态中我们使用的是类的字节码文件对象，非静态中一般用的都是this指针，具体情况可以参照懒汉式单例模式；jdk1.5并发库提供了condition和Lock对象，对sychronized进行替代；
对于多线程需要访问和操作的数据，我们用面向对象的思想思考，既然我们要对访问的数据要用到多线程，
即涉及到多线程的访问安全问题，我们对于这个问题把他考虑下，这个可以归结为我们使用到的数据对象，即我们使用到的数据对象他应该考虑到这个问题，这个我们要
对其进行封装，我们只要使用就可以了，即我们用的时候他已经是安全的，不会出现线程安全问题了；
这里我们用到面向对象的思想考虑，即我们的对象要不要被多线程访问？我们考虑到，这个我们必须要对其进行封装，
我们用的时候就可以不要担心线程安全问题，比如StringBuffer和
StringBuilder，前者是线程安全的，就是其内部对多线程进行了处理；我们使用时无需考虑到线程安全问题，
但是线程安全了，其内部使用到了同步代码块，也就是有锁；每次执行都会有判断锁的操作，大大的影响力程序执行效率，
所以我们推荐使用StringBuilder,虽然其内部并没有解决多线程安全问题，但是程序执行效率高，如果我们要保证线程安全，
可以自己添加同步代码块；来解决；
但是我们在开发程序时要有个这样的思想，就是我们设计一个类时，该类就应该有一些功能，
对外提供他应该提供的方法，解决使用者都要解决的问题，就是说我们使用你这个类没有太多的麻烦需要解决；直接就可以用；
比如集合框架工具类：Collections；
定时器功能
new Timer();
Lock Condition;
JDK1.5并发库中的接口；
Java中的集合框架有两大体系：collection 和map；
Collection 分为两大块：list和set；
list：中元素是可以相同的，有序的，因为集合中有元素的索引；
set:中元素不可以相同，是无序的；
对于集合框架中的Set，Map，List的理解
如果说把List比作是一个单身汉的话，那么他就是一个没有结过婚的单身汉；
而Map是结过婚的，有键值对，是成双成对出现的，虽然键值对有点可以为空，但是这样没有意义，因此不做考虑；
而Set就是离了婚的单身汉，因为他底层使用到的技术就是Map技术，只是把值给去掉，只留下键；
查看Java的源代码：
list和set集合中都有iterator方法；apache-commons包中有扩展的集合，Map
该方法是各集合中的内部类中的方法，由于内部类访问容器中的成员非常容易，而且其对访问方式进行了封装，
外部根本不需要知道，也不能知道其内部的访问方式，同时由于每个集合中都需要有类似的获取元素的方法，
而且每个集合中对访问方式都有不同，所以对这些访问方式进行抽取，形成一个接口，即Iterator接口，
也就是说每个集合中获取元素的访问方式的封装体都是Iterator的实现类，其覆盖了Iterator中的方法，
至于怎么封装的我们无需知道；
对于List集合：当我们使用集合里的方法去操作时，将不能使用迭代器去操作集合，会发生并发修改异常，
因此我们要使用Iterator去迭代时，只能获取和删除，不能修改和添加，但是List的子接口弥补了这一局限；
ListIterator中有添加和修改的方法，但是该接口只对List集合有效；
原因是由于List集合是带角标的；
List有三个子类：
ArrayList：底层是数组数据结构，删除增加慢，但是查找速度快；虽然不是线程安全的，但是Java中有工具提供了解决方案，推荐使用
该集合，当我们不知道要选择什么集合是，ArrayList是首选；
LinkedList:底层数据结构是链表结构，增加删除快，但是查找慢；
对于他，1.6之前，对集合的取出等一系列操作，如果集合为空，这抛出NoSuckElementException；
1.6升级之后对其进行改进，poll×，peek*,offer×等，如果集合为空，他返回的是null，而不抛出异常，大大提高了程序的健壮性；
Vector:底层是数组数据结构，是线程安全的，但是增加和删除，查找都很慢，已经被ArrayList替代；但是他里面有枚举
，是其特有的取出方式；JDK1.0 开始的
Set集合：是无序的，元素不能重复的；底层用的是hash算法来的；
子类----HashSet
保证元素的唯一性是hashCode()的返回值，如果hashSet是相同的，再比较equals方法，
要存入该集合中的元素必须具有可比性，
第一种方式：
即要实现Comparable接口，覆盖compareTo方法，这也叫做元素的自然排序，也叫默认排序；
他保证元素唯一性的方式是compareTo返回0表示相同，返回大于零的数表示大于，返回小于零的数表示小于；
其底层原理是二叉树，左边的是小的，右边的是
大的，他是这样保证元素的有序性，那么他是怎么保证元素的唯一性呢？？
但是事实并不是如此，直接使用的是compareTo方法，如果compareTo方法返回值为0，则不存入；从而保证了其唯一性；
List list = new ArrayList();
list.add(33);
list.add(323);
list.add(313);
for (int i : list) {
System.out.println(i);
}
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
// list.remove(0);
}
for (int i : list) {
System.out.println(i);
//注意这里是遍历不出来的，原因我个人认为是由于访问到了最后一个角标；
//因为我们知道增强for循环底层是用的数组结构，由于上面listIterator.hasNext();已经遍历到结尾了
//所以后面的才遍历不到；
}
--------------------------------------------------注意下上面的这段代码--------？？？？？？？？？？？
第二种方式：传入一个比较器； 实现Comparator接口；
覆盖其中的compare方法，
需要注意到是其实set集合底层使用的就是Map集合，也就是说Set集合基于Map集合
Map集合的特点：是一个键值对形式的，有两个量，即键和值；
子类：
HashTable：是线程同步的，jdk1.0开始就有，键值都不能为空，效率比较低；底层是hash表数据结构
，存入的元素对象需要覆盖hashCode和equals方法；用作键的对象必须实现 hashCode 方法和 equals 方法。
他有一个子类叫Properties，在操作properties配置文件时很有用；
HashMap：底层是hash表数据结构，键值可以为空，但是这样的做法，意义不大，线程是不同步的；
TreeMap:底层是二叉树数据结构（也叫红黑数）；键值虽然可以为空，但是意义不大；
集合之间是可以嵌套的；集合框架看自己的需求而选取使用；
Collections类是操作集合的工具类，该类中包含了许多实用的方法，如sort方法，还有解决线程同步问题的方法等等
反正只要我们有面向对象的思想，想要什么功能都可以去找方法使用，找不到自己造一个出来；一句话，
面向对象的思想要有；
关于集合与数组间的转换，
数组转集合后有局限，不能使用集合的增加删除方法；
//这是为什么呢？我知道会发生一个不支持这种操作的异常，可理由何在，难道又得去看源代码----------------？？？？
而集合转数组要看实际需求，一般只要我们的集合不需要被增加或删除元素可以转换；
Runtime类可以执行一些字符串指令，他采用单例设计模式；是个比较重要的命令；
他能执行哪些指令呢？比如。。。。
Process：进程类；
Date的替代品，calendar类；
记住要仔细查看这些API文档：
1 集合框架，IO(文件和字符)Socket，多线程，定时器，线程类，正则表达式Pattern；
网络编程：Socket
对于Socket编程，是网络编程范畴，所有网络编程的原理都是基于这个，比如tomcat服务器，IE浏览器，等等网络应用；
这里我们定义一个Socket，不管是服务端还是客户端，都得指定端口号，客户端还得指定主机号，标识你所要访问的主机和该主机的哪个端口，比如tomcat服务器；
他走到是8080端口，http走到是80端口，还有FTP，以及邮件传输协议等等，都是走的端口，其底层都是用的Socket技术，只是对其进行了封装，添加了一些功能；
同时我们需要注意到是Socket偏向于传输层，而我们以后学到web开发，主要是应用层；
关于Socket，分为两大类；UDP和TCP，其区别是
UDP：是面向无连接的不可靠的，数据包不可大于64K，但是执行效率高，同时出错率也高，
Java中使用对UDP提供了DatagramSocket和DatagramPacket;也分为客户端和服务端，因此我们开发时两端都得指定相应的端口号，否则找不到指定的应用程序端口，
就好比不给你地址，你就会迷路；具体的应用程序是
QQ：有TCP,也有UDP；
TCP：是面向连接的，可靠的，需要三次握手确定建立连接，安全可靠，但是相应的执行效率也受到影响，一般我们下载都是用的这个TCP，
Java中提供的对象是ServerSocket和Socket，前者是服务端，后者是客户端，同样的需要指定端口，客户端还得指定主机号；
我们知道服务器是给客户端提供服务的，同一时刻有多个客户端连接，那么服务器是怎么解决这一问题的呢？
我们知道Java有多线程机制，因此我们可以使用多线程来实现，即Socket socket=serverSocket.accept();然后将这个socket传入，
将所有客户端都得执行的代码放入run方法中，即可实现多客户端的同时访问，否则单线程是致命的错误；
面向对象的思想一定要有，我们在写程序过程中，如果碰到一些经常用到的功能，或者说碰到什么问题？首先得想想Java有没有给我们提供对象来
解决这些问题？或者说有哪些开源jar包有这些功能，如果有就使用它，没有我们自己造一个，即自己创建一个；
同时对于一些共性代码，或者说经常使用到的做法，我们能否对其进行抽取封装，使我们使用时更方便快捷；
URL和URLConnection是很重要的两个类不管是3G还是web开发都得用到；
Timer可以实现自动启动某项任务；做手机开发需要用到的；
开源的工具可以实现这样的事情：quartz;这个工具貌似还蛮重要的。。。。
所谓将数据绑定到线程上 ，其实就是创建一集合，当然该集合是静态共享的，以线程对象为关键字，而以想要绑定到线程的数据为；
值，取出时，只需提供thread即可；类似于双列集合的存取；ThreadLocal可以实现这一功能；其底层就是用的map集合；
装饰设计模式:举例比如我们要将list集合体系中的元素实现去重复元素，即不可以出现相同的元素；
我们可以对List集合进行封装，底层使用List集合中的方法，只是加入我们去重复元素操作的代码；
这一过程就可以称之为使用了装饰设计模式；
如果我们想把某个类做成是绑定到当前线程的对象；使得使用者在使用时，只要get一下，就可以得到与当前线程绑定的对象；
这是我们根据面向对象的思想考虑得出来的；因为要将某个对象绑定到某个线程上，供他人使用，这个绑定到当前线程和获取绑定当前线程相关的对象；
这些动作只要是有需要的调用者都要用到，为了高类聚的考虑，我们将这个功能加在该类身上，使其被他人使用时就可以获取到与当前线程相关的
对象；这个也可以理解为一个装饰设计模式；
当我们要用多线程去访问共享数据时，容易出现线程安全问题；因此jdk1.5升级以后；
如果该共享数据是基本数据类型时；可以使用AtomicInteger类来解决；
在jdbc中，我们学过由于数据库连接要耗费极大的性能，如内存和执行效率，因此我们对于数据库的连接管理采用数据库连接池来管理；
dbcp和c3p0是这类数据库连接池的优秀代表，其工作的过程是根据当前需要的数据库连接数，以及可能会增加的连接来智能动态的创建
以及摧毁数据库连接，保证数据库连接够用，又不过大多消耗系统的资源；就好比铁道部加开临客和取消部分列车是同样的道理；
因此在多线程中，我们也有类似的技术，称之为线程池；Java给我们提供的类是:Executors,他可以创建一个线程池ExecutorService：
线程池分为固定线程池（newFixedThreadPool(int nThreads) ）；和缓存线程池以及单一线程连接池；具体可参看相关api文档；
该线程池可创建固定的线程数来完成相应的任务；
使用示例：
ExecutorsService threadPool=Executors.newFixedThreadPool(5);
threadPool.execute(Runnable task);//task表示要被某个线程执行的任务；
线程池还可以和定时器绑定或者说相关；
读写锁可以实现读写数据安全性，同时提高读写速率ReadWriteLock;可以实现这一功能；
Semaphore：信号灯，可以实现几个线程间交互；比如说我们有一个停车场，有三十个停车位，而有40辆车要停，而每当一辆车走时，另一辆车就可以进入停放；
而我们这个信号灯就是显示当前还有几辆车在等着停；
CyclicBarrier：线程集中等待出发机制：比如说多个线程组成一个序列，比如说线程池，这些线程一旦加入到CyclicBarrier的序列时，就同进退；
只有全部成员都到齐之后才可以一起出发，谁先到先等到；
CountDownLatch:可以实现一个线程给多个线程发布命令，或者说只有多个线程同时到时才能发表命令；
Exchanger:实现两个线程之间数据的交换，好比两个人去接头卖毒品，一个带着钱去换毒品，一个带着毒品去换钱，但是他们其中某个人先到，先到了先等，另一个到了，
马上交换，交换后就个回各家；
可阻塞队列ArrayBlockQueue
集合的并发访问：java.util.concurrent包中；提供了线程安全的集合；
集合的并发访问容易出现线程安全问题，Collections中有方法可以解决线程安全问题，其原理是，底层仍然调用这些集合的方法
只是在调用每个方法时都加上同步锁从而保证各方法之间的互斥；这也可以算是装饰设计模式；
HashSet和HashMap，其实HashSet底层用的就是HashMap
public class MyProxyFactory implements InvocationHandler {
private Object targetObject;// -------------A
public Object createProxyInstance(Object targetObject)//-------------B
{
this.targetObject = targetObject;//------------------C
return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),//-----D
this.targetObject.getClass().getInterfaces(), //----------E
this);//----------------H
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
BusinessServiceImpl service=(BusinessServiceImpl)this.targetObject;//------------F
Object result=null;
if(service.getUser()!=null){
result=method.invoke(this.targetObject, args);//---------------G
}
return null;
}
}
动态代理解析：
A：该处的targetObject，表示的是你要为哪个对象创建代理，即你要我代理，你要我代理什么啊，你得给我些东西我才知道你要我代理什么东西；
B：通过Proxy的newProxyInstance方法，他需要一个参数，由调用者传递，就是要我代理的对象是哪一个，我会把你传进来的对象赋值给targetObject；
C：将传递来的对象赋值给目标对象；他们两个其实是一样的，一个是形式参数，一个是接受者；
D：Proxy代理类的newProxyInstance()方法的第一个参数是需要目标类的类装载器；
E：newProxyInstance()方法的第二个参数是目标对象所实现的所有接口；
H：第三个参数是一个回调对象；由于本类是一个代理工厂，他实现了回调接口InvocationHandler;并实现了其invoke方法；因此this代表着一个回调对象；
回调的实现就是靠该对象；
F：将传递进来的目标对象强转为其原始类型，因为只有他原始的类型对象中才有参数来判断要不要执行某方法，代理对象要根据他提供的拦截条件来拦截；
而newProxyInstance接受的是一个Object对象；当然也可以定义泛型；
java5新特性中的可变参数底层用到的是一个数组，因此我们可以将该可变参数用数组的方式操作；
享元设计模式：
Integer var1=122；
Integer var2=122；
上面这两个是同一个对象；
Integer var3=134；
Integer var4=134；
上面这两个不是同一个对象；
上面var1和var2用的是享元设计模式；把在一个字节范围的数字缓存起来；flyweight；
之所以Java中不需要将if语句中if（null==user）来防止将其写成if(user=null)
是因为Java的判断语句中真假值只有false和true，而c++中非0就是真；
类的字节码文件对象使用的类装载器不同，那么他们就是两个不同的类，
相互转换的时候会发生类型转换异常。
用char数组存多个中文字符 比用string好在哪?
既然可以用一个Java类去模拟一个枚举，可不可以说枚举的底层实现原理就是用的普通Java类
String类是一个final类，不能被继承；
String str0="java";
String str1=new String("hello java");
第一中是一个引用指向了常量区中的一个常量："java";
而第二个是这样的，hello java仍然在常量区中，而new String（）：在堆内存中
他将常量区的 hello java复制到堆内存中；而str实际指向的是堆内存中的那个hello java
因此说，使用字符串用第一种方式比较优雅；
一个引用占4byte ，在32位系统上
Java中后置自加要到语句结束后改变值；比如
int count = 0;
输出结果是0；
可以这样理解：
int count = 0;
int temp=count++;//这里temp为0；
在apache-commons-collections包中；
有BidiMap，MapIterator等使用的数据结构和类；
类加载器的委托机制：先找基类，一级级的往下找；
但是也可以自己写一个类加载器，自己加载某个类；
模板方法设计模式：
父类--->loadClass，这是所有子类都得干的事，也就是说，先得找父类。
即类加载器的委托机制；
也就是说所有子类共有的东西放到父类中。而每个子类不同的功能都供
子类去实现；
java中类加载器,分为三个级别:
BootStrap:嵌套在JavaVM内核中的一段有c++语言写出来的二进制代码,负责加载 jre/lib/rt.jar中的类;
ExtClassLoader:用来加载jre下的/lib/ext/目录中的类;---他能用来加载资源文件吗?
AppClassLoader:用来加载classpath下的lib目录和资源;
委托加载机制:在java中,我们写的一个普通类,放在classpath目录下;
JVM在加载的时候,首先找AppClassLoader,,然后AppClassLoader将请求转发
去找他的上级ExtClassLoader:ExtClassLoader收到请求后,也是转发给他的上级:
BootStrap;由于BootStrap是顶级类加载器,他不能在转给上级,就只好在他的管辖范围内找
即rt.jar中找,找到就加载,如果没找到,继续转到下级,即ExtClassLoader;然后ExtClassLoader去自己的管辖范围中去找,即ext目录中找;找到就加载,没找到就继续转到下级,
即AppClassLoader,他也是到自己的管辖范围中去找,找到就返回找不到,他就不能在转给下级了,因为他可能有多个子类,所以就直接抛异常,即ClassNotFoundException;
这样的委托机制有利于集中管理;
因此我们是不能写一个java.lang.System类去替代jdk中的那个类的
原因就是类加载器的委托加载机制;但是我们可以自己去写一个类加载器,撇开类加载器的委托
加载机制;覆盖loadClass方法;
在类加载的时候,如果A类中引用了B类,
如果A类用的是哪个类加载器,那么B类也是用哪个类加载器进行加载;
有包名的类,不能调用无包名的类;
classpath:是指的什么;
PrintWriter中的write(String str);方法
没有对Str进行null校验,因此容易发生空指针异常,使用时尤其要注意;
静态方法不能在子类中被重写
抽象方法不能是静态的:
原因:因为静态方法不能在子类中被重写;其次静态方法可以直接用类名调用,而抽象方法是不能被调用的;
abstract不能与final并列修饰同一个类
方法加载的时候创建局部变量,不是,执行的时候;
条件运算符会将变量进行升级.三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果
由容量高的决定。99.9是double类型 而9是int类型，double容量高。
abstract:不能修饰字段;
对于动态代理的理解;
这里有三个牵涉的对象;
1 需要被代理的对象--目标对象;---Information类,假设该类中有一个printInfo();方法;
2 代理对象ProxyInstance--被JVM动态生成的和目标对象在同一个继承体系中的对象;因此创建一个代理对象时需要传递和目标对象
3 处理代理请求的类----代理请求处理类,即一个InvocationHandler;这个类为目标对象targe和代理对象,proxy进行牵线搭桥;
现在我想计算下printInfo方法执行所需要的时间,并且是我对外提供的;那么你可以用动态代理去实现;
过程如下;创建个Information的实现对象;把他当做目标类,调用Proxy的静态方法;并传递三个参数;
1 Information类使用的类装载器,通过 information.getClass().getClassLoader();获取;
2 Information类实现的所有接口,通过information.getClass().getInterfaces();获取;
3 以匿名内部类的形式创建InvocationHandler的实例对象;实现invoke方法;
也就是说你一旦创建好了一个代理对象,并将你需要插入的公共业务逻辑代码以对象参数的形式传入的时候;
Proxy.newProxyInstance();给你返回了一个目标对象的代理对象;
当你每次调用代理对象的某个方法,在这个方法执行前后都加入了你需要插入的公共逻辑代码;
类装载器就是用的这种单例模式;
构造函数保护;--
如果你想使得一个类不能被new,而且又不能被继承;
不能被new,即使在本类中也不能, 说明他是一个抽象类;--
不能被继承,说明他是一个final类;
但是abstract 和final在修饰类的时候不能同时存在,那么怎么办呢?
将该类定义为abstract,即抽象,因此不能被new;
同时将所有构造方法私有化,这样就会隐式的将一个类变为final类,而不能被其他类继承;
因为如果子类在初始化的时候必须调用父类的构造函数进行初始化,而由于父类中的构造函数都是私有的
不可见,因此不能继承;
另外一个理由:子类的默认构造函数的第一行会调用父类的默认构造函数;由于父类的默认构造函数私有,因此也不行;
Ognl类就是这么个工具类,不能被继承,也不能被new,但是方法都是静态的;这个方法我们可以借鉴;
hashMap的构造函数中接收一个指定容量大小的构造函数;
不指定初始容量大小,默认为16个;
java.util.AbstractMap:这个类是对map接口中不涉及到数据结构的方法都进行了实现
对涉及到数据结构的方法要么私有,要么在方法中直接抛出异常,也就是说子类必须去实现它;
这是一种模板方法设计模式;
public V put(K key, V value) {
throw new UnsupportedOperationExce
}
public abstract Set> entrySet();
如果你同时实现了Map接口,又继承了AbstractMap:
那么你只需要覆盖实现AbstractMap中的抽象方法即可;
我的疑问是为什么他还要实现Map接口;
895
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
