{
215 | }
216 | ```
217 | 我们想去用一个类继承这个Base，在Base中完成实例化P和M，我们可以借助反射去实现()
218 | ```java
219 |
220 | protect P p；
221 | protect M m;
222 | p=getT(this,0);
223 | m=getT(this,1);
224 | public static
243 | （1）能够运行时动态获取类的实例，大大提高系统的灵活性和扩展性。
244 | （2）与Java动态编译相结合，可以实现无比强大的功能
245 | 缺点：
246 | （1）使用反射的性能较低
247 | （2）使用反射相对来说不安全
248 | （3）破坏了类的封装性，可以通过反射获取这个类的私有方法和属性
249 |
250 |
251 |
252 |
253 |
254 |
--------------------------------------------------------------------------------
/Java/java String.md:
--------------------------------------------------------------------------------
1 | [string常用的API](http://www.apihome.cn/api/java/String.html)
2 | [原文链接ｓｔｒｉｎｇ中常见的１０个问题](http://www.programcreek.com/2013/09/top-10-faqs-of-java-strings/)
3 |
4 | #### 1. 字符串比较,使用 "==" 还是 equals() ?
5 | 简单来说, "==" 判断两个引用的是不是同一个内存地址(同一个物理对象).
6 | 而 equals 判断两个字符串的值是否相等.
7 | 除非你想判断两个string引用是否同一个对象,否则应该总是使用 equals()方法.
8 | 如果你了解 字符串的驻留 ( String Interning ) 则会更好地理解这个问题
9 |
10 | #### 2. 对于敏感信息,为何使用char[]要比String更好?
11 | String是不可变对象, 意思是一旦创建,那么整个对象就不可改变. 即使新手觉得String引用变了,实际上只是(指针)引用指向了另一个(新的)对象.
12 | 而程序员可以明确地对字符数组进行修改,因此敏感信息(如密码)不容易在其他地方暴露(只要你用完后对char[]置0).
13 |
14 | #### 3. 在switch语句中使用String作为case条件?
15 | 从 JDK7 开始,这是可以的,啰嗦一句,Java 6 及以前的版本都不支持这样做.
16 | ```java
17 | // 只在java 7及更高版本有效!
18 | switch (str.toLowerCase()) {
19 | case "a":
20 | value = 1;
21 | break;
22 | case "b":
23 | value = 2;
24 | break;
25 | }
26 | ```
27 | #### 4. 转换String为数字
28 | 对于非常大的数字请使用Long,代码如下
29 | ```java
30 | int age = Integer.parseInt("10");
31 | long id = Long.parseLong("190"); // 假如值可能很大.
32 | ```
33 | #### 5. 如何通过空白字符拆分字符串
34 | String 的 split()方法接收的字符串会被当做正则表达式解析,
35 | "\s"代表空白字符,如空格" ",tab制表符"\t", 换行"\n",回车"\r".
36 | 而编译器在对源代码解析时,也会进行一次字面量转码,所以需要"\\s".
37 | ```java
38 | String[] strArray = aString.split("\\s+");
39 | ```
40 |
41 | #### 6. substring() 方法内部是如何处理的?
42 | 在JDK6中,substring()方法还是共用原来的char[]数组,通过偏移和长度构造了一个"新"的String。
43 | 想要substring()取得一个全新创建的对象,使用如下这种方式:
44 | ```java
45 | String sub = str.substring(start, end) + "";
46 |
47 | ```
48 | "hamburger".substring(4, 8) returns "urge"
49 | "smiles".substring(1, 5) returns "mile
50 |
51 | 当然 Java 7 中,substring()创建了一个新的char[] 数组,而不是共用.
52 | 想要了解更多,请参考: JDK6和JDK7中substring()方法及其差异
53 |
54 | #### 7. String vs StringBuilder vs StringBuffer
55 | StringBuilder 是可变的,因此可以在创建以后修改内部的值.
56 | StringBuffer 是同步的,因此是线程安全的,但效率相对更低.
57 |
58 |
59 | #### 8. 如何重复拼接同一字符串?
60 | 方案1: 使用Apache Commons Lang 库的 StringUtils 工具类.
61 | ```java
62 | String str = "abcd";
63 | String repeated = StringUtils.repeat(str,3);//abcdabcdabcd
64 | ```
65 |
66 | 方案2:
67 | 使用 StringBuilder 构造. 更灵活.
68 | ```java
69 | String src = "name";
70 | int len = src.length();
71 | int repeat = 5;
72 | StringBuilder builder = new StringBuilder(len * repeat);
73 | for(int i=0; i
23 | 1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
24 | 2） 在网络上传送对象的字节序列。
25 |
26 |
27 |
28 | 因为不对对象序列化的化容易出现很多问题，所以引入了序列化解决了这些问题。
29 |
30 |
31 |
32 | 对象序列化包括如下步骤：
33 | 1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
34 | 2） 通过对象输出流的writeObject()方法写对象。
35 | 对象反序列化的步骤如下：
36 | 1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
37 | 2） 通过对象输入流的readObject()方法读取对象。
38 | 下面让我们来看一个对应的例子，类的内容如下：
39 |
40 |
41 |
42 | serialVersionUID作用：
43 | 序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
44 | 有两种生成方式：
45 | 一个是默认的1L，比如：private static final long serialVersionUID = 1L;
46 | 一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：
47 | private static final long serialVersionUID = xxxxL;
48 |
49 | 当你一个类实现了Serializable接口，如果没有定义serialVersionUID，Eclipse会提供这个提示功能告诉你去定义 。
50 | ### 7、final, finally, finalize的区别。
51 | final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
52 | finally是异常处理语句结构的一部分，表示总是执行。
53 | ### 8、final
54 | * 根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
55 | * final类不能被继承，没有子类，final类中的方法默认是final的。
56 | * final方法不能被子类的方法覆盖，但可以被继承。
57 | * final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
58 | * final不能用于修饰构造方法。
59 | * 注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
60 |
61 | ####final类
62 | final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
63 | ####final方法
64 | 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
65 | 使用final方法的原因有二：
66 | 第一、把方法锁定，防止任何继承类修改它的意义和实现。
67 | 第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
68 | ####final变量（常量）
69 | 用final修饰的成员变量表示常量，值一旦给定就无法改变！
70 | final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
71 | 从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
72 | 另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
73 | ####final参数
74 | 当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值
75 | 二、static
76 |
77 | * static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
78 |
79 | * 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
80 |
81 | * 用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。
82 |
83 | * static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。
84 |
85 | * static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
86 | 类名.静态方法名(参数列表...)
87 | 类名.静态变量名
88 | 用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。
89 |
90 | #### 1、static变量
91 | 按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
92 | 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
93 | 对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
94 |
95 | #### 2、静态方法
96 | 静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
97 | 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
98 | ### static和final一块用表示什么
99 | static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
100 | 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
101 | 对于方法，表示不可覆盖，并且可以通过类名直接访问。
102 |
103 | 特别要注意一个问题：
104 | 对于被static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象，这一点在编程中用到很多。
105 |
106 | ### 如果要对一个特别大的（如100位）数进行相加，在java中如何计算：
107 | [相关链接](http://ly5633.iteye.com/blog/1218724)
108 | 在Java中针对比较大的数字，有大数类型来进行表示。即BigInteger和BigDecimal两个类。
109 | 以BigDecimal为例：
110 | ```java
111 | BigDecimal bigDecimalA = new BigDecimal("1234567890123456789012345678901");
112 | BigDecimal bigDecimalB = new BigDecimal("1234567890123456789012345678902");
113 | // 加 +
114 | bigDecimalA = bigDecimalA.add(bigDecimalB);
115 | // 减 -
116 | bigDecimalA = bigDecimalA.subtract(bigDecimalB);
117 | // 乘 *
118 | bigDecimalA = bigDecimalA.multiply(bigDecimalB);
119 | // 除 /
120 | bigDecimalA = bigDecimalA.divide(bigDecimalB);
121 | ```
122 | // ......其他的类似，API里很详细，不再赘述了。
123 |
--------------------------------------------------------------------------------
/Java/java多线程.md:
--------------------------------------------------------------------------------
1 |
2 | ## 多线程的安全问题
3 | ```java
4 | class Ticket implements Runnable{
5 | private int ticket =100;
6 | public void run(){
7 | while(true){
8 | if(ticket>0){
9 | System.out.System.out.println(ticket--);
10 | }
11 | }
12 | }
13 |
14 | }
15 | ```
16 | #### 问题的原因
17 | 当多个线程同时获取获取cpu执行权的时候，都会执行ticket--;多条语句在操作同一个线程的时候，一个线程堆多条语句只执行了一部分，还没有执行完，另一个线程参与进来，导致共享数据
18 | #### 解决办法
19 | 对于多条操作共享的数据的时候，只能让一个线程执行完，其他线程不可以参加执行
20 | #### java对于多线程的安全问题提供了解决方案
21 | 就是同步代码块
22 | synchronized(对象){
23 | 需要被同步的代码
24 | }
25 | 可以重入，一个线程获取了锁之后，在当前类的其他方法中也能获取锁，若果出现异常，锁和会自动释放。同步不具有继承性
26 | #### 对象(监视器，锁)
27 | 判断的条件，当线程获得执行权之后执行同步代码，进入之后讲对象关闭。直到上一个线程执行完同步代码。对象打开，这个时候各个线程又开始争取执行权。eg:厕所的门把手；改之后的代码如下：
28 |
29 | ```java
30 | class Ticket implements Runnable{
31 | private int ticket =100;
32 | Object obj=new Object();
33 | public void run(){
34 | while(true){
35 | synchronized (obj) {
36 | if(ticket>0){
37 | System.out.System.out.println(ticket--);
38 | }
39 | }
40 | }
41 | }
42 |
43 | }
44 | ```
45 | #### 同步的前提：
46 | * 必须要有两个或者两个以上的线程
47 | * 必须多个线程使用同一个锁
48 | * 必须保证同步中有一个线程在运行
49 |
50 | #### 好处 :解决多线程同步问题
51 | #### 弊端 :每次都在判定锁,消耗了资源
52 | ## 生产者消费者问题
53 | ```java
54 | /**
55 | * 生产者
56 | */
57 | public class Product{
58 | private Condition condition;
59 | private ReentrantLock reentrantLock;
60 |
61 | public Product(ReentrantLock reentrantLock,Condition condition) {
62 | super();
63 | this.condition = condition;
64 | this.reentrantLock = reentrantLock;
65 | }
66 | public void setValue(){
67 | try {
68 | reentrantLock.lock();
69 | while (!StringObject.value.equals("")){
70 | condition.await();
71 | }
72 | String value = System.currentTimeMillis()+""+System.nanoTime();
73 | System.out.println(Thread.currentThread().getName()+"set value = "+value);
74 | StringObject.value = value;
75 | condition.signalAll();
76 |
77 | } catch (InterruptedException e) {
78 | e.printStackTrace();
79 | }finally {
80 | reentrantLock.unlock();
81 | }
82 | }
83 | }
84 | /**
85 | * 消费者
86 | */
87 | public class Consumer {
88 | private ReentrantLock reentrantLock;
89 | private Condition condition;
90 |
91 | public Consumer(ReentrantLock reentrantLock, Condition condition) {
92 | this.reentrantLock = reentrantLock;
93 | this.condition = condition;
94 | }
95 | public void getValue(){
96 | try {
97 | reentrantLock.lock();
98 | while (StringObject.value.equals("")){
99 | condition.await();
100 | }
101 | System.out.println(Thread.currentThread().getName()+"get value = "+StringObject.value);
102 | StringObject.value = "";
103 | condition.signalAll();
104 | } catch (InterruptedException e) {
105 | e.printStackTrace();
106 | } finally {
107 | reentrantLock.unlock();
108 | }
109 |
110 | }
111 | }
112 | public class ConThread extends Thread {
113 | private Consumer consumer;
114 |
115 | public ConThread(Consumer consumer) {
116 | this.consumer = consumer;
117 | }
118 |
119 | @Override
120 | public void run() {
121 | while (true){
122 | consumer.getValue();
123 | }
124 | }
125 | }
126 | public class ProThread extends Thread {
127 | private Product p;
128 | public ProThread(Product p){
129 | super();
130 | this.p = p;
131 | }
132 | @Override
133 | public void run() {
134 | while (true){
135 | p.setValue();
136 | }
137 | }
138 | }
139 |
140 | public class Client {
141 | public static void main(String[] args) {
142 | ReentrantLock reentrantLock = new ReentrantLock();
143 | Condition condition = reentrantLock.newCondition();
144 |
145 | for (int i = 0; i < 3 ; i++) {
146 | ConThread conThread = new ConThread(new Consumer(reentrantLock,condition));
147 | ProThread proThread = new ProThread(new Product(reentrantLock,condition));
148 |
149 | conThread.start();
150 | proThread.start();
151 | }
152 | }
153 | }
154 |
155 | ```
156 | ###### 这里是多生产多消费的代码，注意的地方使用signalAll而不是signa，如果是单生产单消费的话不用注意这个问题，但是多生产的话如果不适用All则会造成假死，由于当前生产线程有好多，在生产完一个之后唤醒了下一个生产者线程接着等待，导致所有的生产者线程都处于等待状态，消费者线程也会有同样的问题，所以造成了假死。使用while的原因是因为如果两个线程在wait之后被唤醒会继续往下执行，会发生越界异常
157 |
158 |
--------------------------------------------------------------------------------
/Java/java注解.md:
--------------------------------------------------------------------------------
1 |
2 | ### 概念
3 | java提供了一种原程序中的元素关联任何信息和任何元数据的途径和方法
4 |
5 |
6 |
7 | ### Java中常见的注解
8 | #### jdk注解
9 | * @Override覆盖父类的方法
10 | * @Deprecated过时的方法
11 | * @SuppressWarnings("deprecation")对过时的方法进行描述
12 |
13 | ### 注解的分类
14 | #### 按照运行机制来分
15 | * 源码注解 注解只存在在源码中，编译成.class文件就不存在了
16 | * 编译时注解 注解在源码和.class都存在的注解（jdk的注解）
17 | * 运行时注解 在运行阶段还起作用，甚至会影响运行逻辑
18 |
19 | #### 按照来源来分
20 | * 来自jdk的注解
21 | * 来自第三方的注解
22 | * 自己定义的注解
23 |
24 | ### 自定义注解
25 | #### 语法要求
26 | ```java
27 | //@interface 进行注解的定义
28 | public @interface Description {
29 |
30 | //成员以无参无异常形式声明,这里并不是方法
31 | String desc();
32 |
33 | String author();
34 | //给成员定义默认的值
35 | int age()default 18;
36 |
37 | }
38 | ```
39 | * 成员类型是受限制的，合法的类型包括原始类型和String，Class，Annotation，Enumeration
40 | * 如果注解只有一个成员，则成员必须取名为value(),在使用时候可以忽略成员名和复制号（=）
41 | * 注解类可以没有成员，没有成员的注解称为标识注解
42 |
43 | #### 元注解
44 | ##### @Target()注解的定义域
45 | * ElementType.CONSTRUCTOR 构造方法声明
46 | * ElementType.FIELD 字段声明
47 | * ElementType.LOCAL_VARABLE 局部变量声明
48 | * ElementType.METHOD 方法声明
49 | * ElementType.PACKAGE 包声明
50 | * ElementType.PARAMETER 参数声明
51 | * ElementType.TYPE 类，接口
52 |
53 | ##### @Retention()
54 | * RetentionPolicy.SOURCE 只在源码显示，编译时会丢弃
55 | * Retention.CLASS 编译时会记录到class中，运行时候忽略
56 | * RetentionPolicy.RUNTIME 运行时候存在，可以通过反射读取
57 |
58 | ##### @Inherited()
59 | 允许子类继承 实现接口继承没有用，只能是class，而且只能继承类名上面的注解
60 |
61 | ##### @Documented
62 | 生成Javadoc时包含注解
63 |
64 | #### 使用自定义注解的语法
65 | @<注解名>(<成员名1>=<成员值1>,<成员名2>=<成员值2>,........)
66 | @Description(desc = "hello",author = "world",age = 18)
67 |
68 | ### java8和注解
69 |
70 | * @Repeatable
71 | 说明该注解标识的注解可以多次使用到同一个元素的声明上。 看一个使用的例子。首先我们创造一个能容纳重复的注解的容器：
72 |
73 | ```java
74 | \
75 | /**
76 | * Container for the {@link CanBeRepeated} Annotation containing a list of values
77 | */
78 | @Retention( RetentionPolicy.RUNTIME )
79 | @Target( ElementType.TYPE_USE )
80 | public @interface RepeatedValues
81 | {
82 | CanBeRepeated[] value();
83 | }
84 | ```
85 | 接着，创建注解本身，然后标记@Repeatable
86 |
87 | ```java
88 | @Retention( RetentionPolicy.RUNTIME )
89 | @Target( ElementType.TYPE_USE )
90 | @Repeatable( RepeatedValues.class )
91 | public @interface CanBeRepeated
92 | {
93 | String value();
94 | }
95 | ```
96 | 最后，我们可以这样重复地使用：
97 |
98 | ```java
99 | @CanBeRepeated( "the color is green" )
100 | @CanBeRepeated( "the color is red" )
101 | @CanBeRepeated( "the color is blue" )
102 | public class RepeatableAnnotated
103 | {
104 |
105 | }
106 | ```
107 | * 自Java8开始，我们可以在类型上使用注解。由于我们在任何地方都可以使用类型，包括 new操作符，casting，implements，throw等等。注解可以改善对Java代码的分析并且保证更加健壮的类型检查。这个例子说明了这一点：
108 |
109 | ```java
110 | @SuppressWarnings( "unused" )
111 | public static void main( String[] args )
112 | {
113 | // type def
114 | @TypeAnnotated
115 | String cannotBeEmpty = null;
116 |
117 | // type
118 | List<@TypeAnnotated String> myList = new ArrayList
4 | 1.父类的static属性；
5 | 2.父类的static块；
6 | 3.子类的static属性；
7 | 4.子类的static块；
8 | 5.父类的普通属性；
9 | 6.父类的构造块；
10 | 7.父类的构造函数；
11 | 8.子类的普通属性；
12 | 9.子类的构造块；
13 | 10.子类的构造函数；
14 |
15 |
16 |
17 |
18 | ### 抽象类可以有构造函数，但是不能实例化。
19 | 子类实例化必须要调用父类构造函数(默认调用父类的无参构造函数)。如果父类定义了有参构造函数，则子类必须显示调用父类的该构造函数
20 | ### 面向对象编程有三个特征，即封装、继承和多态。
21 |
22 | #### 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。
23 |
24 | #### 继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？
25 |
26 | 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。
27 | #### 要理解多态性，首先要知道什么是“向上转型”。
28 | 我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过
29 | Cat c = new Cat()
30 | 实例化一个Cat的对象，这个不难理解。但当我这样定义时
31 | Animal a = new Cat()
32 | #### 这代表什么意思呢？
33 | 很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。看下面这段程序：
34 |
35 | ```java
36 | class Father{
37 | public void func1(){
38 | func2();
39 | }
40 | //这是父类中的func2()方法，因为下面的子类中重写了该方法
41 | //所以在父类类型的引用中调用时，这个方法将不再有效
42 | //取而代之的是将调用子类中重写的func2()方法
43 | public void func2(){
44 | System.out.println("AAA");
45 | }
46 | }
47 | class Child extends Father{
48 | //func1(int i)是对func1()方法的一个重载
49 | //由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用
50 | //所以在下面的main方法中child.func1(68)是不对的
51 | public void func1(int i){
52 | System.out.println("BBB");
53 | }
54 | //func2()重写了父类Father中的func2()方法
55 | //如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法
56 | public void func2(){
57 | System.out.println("CCC");
58 | }
59 | }
60 | public class PolymorphismTest {
61 | public static void main(String[] args) {
62 | Father child = new Child();
63 | child.func1();//打印结果将会是什么？
64 | }
65 | }
66 | ```
67 |
68 | 上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。那么该程序将会打印出什么样的结果呢？很显然，应该是“CCC”。
69 |
70 | #### 对于多态，可以总结它为：
71 |
72 | * 使用父类类型的引用指向子类的对象；
73 | * 该引用只能调用父类中定义的方法和变量；
74 | * 如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
75 | * 变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。
76 | *********************************************************************
77 |
78 | ### 多态详解(整理)多态是通过:
79 |
80 | * 接口 和 实现接口并覆盖接口中同一方法的几不同的类体现的
81 | * 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.
82 |
83 | ### 一、基本概念
84 | 多态性：发送消息给某个对象，让该对象自行决定响应何种行为。
85 | 通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。
86 | java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
87 | * 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。
88 | * 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。
89 | ### 二、Java多态性实现机制
90 | SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针：
91 | 一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）；
92 | 另一个指针指向一块从java堆中为分配出来内存空间。
93 | ### 、总结
94 |
95 | #### 1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。
96 |
97 | DerivedC c2=new DerivedC();
98 | BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类
99 | a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法
100 | 分析
101 |
102 | * 为什么子类的类型的对象实例可以覆给超类引用？
103 | 自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；
104 | * a.play()将执行子类还是父类定义的方法？
105 | 子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。
106 | 在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。
107 |
108 |
109 | #### 2、不能把父类对象引用赋给子类对象引用变量
110 | BaseClass a2=new BaseClass();
111 | DerivedC c1=a2;//出错
112 | 在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
113 | c1=(DerivedC)a2; 进行强制转化,也就是向下转型.
114 |
115 | #### 3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
116 | 你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
117 | 其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
118 | 例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()）
119 | 分析：
120 | 当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
121 | 这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。
122 | #### 4、Java与C++多态性的比较
123 | jvm关于多态性支持解决方法是和c++中几乎一样的，
124 | 只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。
125 | Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
126 | 虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。
127 | Java的所有函数，除了被声明为final的，都是用后期绑定。
128 | ### 四. 1个行为,不同的对象,他们具体体现出来的方式不一样,
129 | 比如: 方法重载 overloading 以及 方法重写(覆盖)override
130 | ```java
131 | class Human{
132 | void run(){输出 人在跑}
133 | }
134 | class Man extends Human{
135 | void run(){输出 男人在跑}
136 | }
137 | 这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子)
138 | class Test{
139 | void out(String str){输出 str}
140 | void out(int i){输出 i}
141 | }
142 | ```
143 | 这个例子是方法重载,方法名相同,参数表不同
144 | ok,明白了这些还不够,还用人在跑举例
145 | Human ahuman=new Man();
146 | 这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象
147 | 意思是说,把 Man这个对象当 Human看了.
148 | 比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! "
149 | 这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,
150 | 这个大熊猫对象,你把它当成其父类 动物看,这样子合情合理.
151 | 这种方式下要注意 new Man();的确实例化了Man对象,所以 ahuman.run()这个方法 输出的 是 "男人在跑 "
152 | 如果在子类 Man下你 写了一些它独有的方法 比如 eat(),而Human没有这个方法,
153 | 在调用eat方法时,一定要注意 强制类型转换 ((Man)ahuman).eat(),这样才可以...
154 | 对接口来说,情况是类似的...
155 | 实例:
156 | ```java
157 | package domatic;
158 | //定义超类superA
159 | class superA {
160 | int i = 100;
161 | void fun(int j) {
162 | j = i;
163 | System.out.println("This is superA");
164 | }
165 | }
166 | // 定义superA的子类subB
167 | class subB extends superA {
168 | int m = 1;
169 | void fun(int aa) {
170 | System.out.println("This is subB");
171 | }
172 | }
173 | // 定义superA的子类subC
174 | class subC extends superA {
175 | int n = 1;
176 | void fun(int cc) {
177 | System.out.println("This is subC");
178 | }
179 | }
180 | class Test {
181 | public static void main(String[] args) {
182 | superA a = new superA();
183 | subB b = new subB();
184 | subC c = new subC();
185 | a = b;
186 | a.fun(100);
187 | a = c;
188 | a.fun(200);
189 | }
190 | }
191 | /*
192 | * 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b,
193 | * c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：
194 | * "为什么(1)和(2)不输出：This is superA"。
195 | * java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
196 | * 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
197 | * 但是这个被调用的方法必须是在超类中定义过的,
198 | * 也就是说被子类覆盖的方法。
199 | * 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
200 | * 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),
201 | * 它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun()。
202 | * 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
203 | * 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。
204 | * 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
205 | * 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
206 | */
207 | 以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法-----------重写父类方法
208 | 1.JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：
209 | //父类
210 | public class Father{
211 | //父类有一个打孩子方法
212 | public void hitChild(){
213 | }
214 | }
215 | //子类1
216 | public class Son1 extends Father{
217 | //重写父类打孩子方法
218 | public void hitChild(){
219 | System.out.println("为什么打我？我做错什么了！");
220 | }
221 | }
222 | //子类2
223 | public class Son2 extends Father{
224 | //重写父类打孩子方法
225 | public void hitChild(){
226 | System.out.println("我知道错了，别打了！");
227 | }
228 | }
229 | //子类3
230 | public class Son3 extends Father{
231 | //重写父类打孩子方法
232 | public void hitChild(){
233 | System.out.println("我跑，你打不着！");
234 | }
235 | }
236 | //测试类
237 | public class Test{
238 | public static void main(String args[]){
239 | Father father;
240 | father = new Son1();
241 | father.hitChild();
242 | father = new Son2();
243 | father.hitChild();
244 | father = new Son3();
245 | father.hitChild();
246 | }
247 | }
248 | 都调用了相同的方法，出现了不同的结果！这就是多态的表现！
249 | ```
250 |
251 |
--------------------------------------------------------------------------------
/Java/jvm.md:
--------------------------------------------------------------------------------
1 | ### 四中引用类型
2 | 
3 | #### 强引用:只要引用存在，对象就永远不会被回收，我们平时用到嘴对的就是强应用，就算内存溢出也不会被回收、Object o = new Object()
4 | #### 软引用:用来描述一些有用但是非必须的对象，在内存溢出之前，会被这些对象列进回收范围内，之后进行回收
5 | ```java
6 | SoftReference softReference = new SoftReference(s);
7 | if (softReference.get() != null) {
8 | sN = (String) softReference.get();
9 | }else {
10 | s = new String("hello");
11 | softReference = new SoftReference(s);
12 | }
13 | ```
14 | #### 弱引用：用来描述一些非必须对象，只能存活在下一次垃圾回收之前,当下一次垃圾回收之前无论内存是不是够，都会回收
15 | #### 虚引用：也成为幻影引用，一个对象是否有幻影应用都不会影响他的生存时间，也无法通过一个虚引用来获取一个对象，唯一的作用，就是在垃圾回收的时候获取一个通知虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。
16 | ```java
17 | ReferenceQueue queue = new ReferenceQueue ();
18 | PhantomReference pr = new PhantomReference (object, queue);
19 | ```
20 | 程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
21 | https://blog.csdn.net/coding_or_coded/article/details/6603549
22 |
--------------------------------------------------------------------------------
/Java/线程池.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # StudyNotes
2 | > **一起学习，一起交流**
3 | Q Q：[Einsame](http://sighttp.qq.com/msgrd?v=3&uin=478214853&site=&menu=yes)
4 | 邮箱：[478214853@qq.com](mailto:478214853@qq.com)
5 | 主页：[http://lovehaodong.cn](http://lovehaodong.cn)
6 |
7 | ## Java
8 |
9 | * [Java 基础知识](https://github.com/yanghaodong/StudyNotes/blob/master/Java/java%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md)
10 | * [Java 面向对象](https://github.com/DreamYHD/StudyNotes/blob/master/Java/java%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1.md)
11 | * [Java 集合](https://github.com/yanghaodong/StudyNotes/edit/master/Java/java集合.md)
12 | * [Java String](https://github.com/yanghaodong/StudyNotes/blob/master/Java/java%20String.md)
13 | * [Java 异常](https://github.com/DreamYHD/StudyNotes/blob/master/Java/java%20%E5%BC%82%E5%B8%B8.md)
14 | * [Java 多线程](https://github.com/yanghaodong/StudyNotes/edit/master/Java/java多线程.md)
15 | * [Java 线程池](https://github.com/yanghaodong/StudyNotes/edit/master/Java/线程池.md)
16 | * [Java io流](https://github.com/DreamYHD/StudyNotes/blob/master/Java/java%20io.md)
17 | * [Java 注解](https://github.com/DreamYHD/StudyNotes/blob/master/Java/java%E6%B3%A8%E8%A7%A3.md)
18 | * [Java 反射](https://github.com/DreamYHD/StudyNotes/blob/master/Java/Java%20%E5%8F%8D%E5%B0%84.md)
19 |
20 |
21 | ## DesignPattern
22 | * [代码区](https://github.com/DreamYHD/DesignPatterns)
23 | * [chapter01 - 面向对象六大原则](https://github.com/yanghaodong/StudyNotes/master/DesignPattern/chapter01-面向对象六大原则.md)
24 | * [chapter02 - 单例模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter02-单例模式.md)
25 | * [chapter03 - Builder模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter03-Builder模式.md)
26 | * [chapter04 - 原型模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter04-原型模式.md)
27 | * [chapter05 - 工厂方法模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter05-工厂方法模式.md)
28 | * [chapter06 - 抽象工厂模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter06-抽象工厂模式.md)
29 | * [chapter07 - 策略模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter07-策略模式.md)
30 | * [chapter08 - 状态模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter08-状态模式.md)
31 | * [chapter09 - 责任链模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter09-责任链模式.md)* [chapter10 - 解释器模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter10-解释器模式.md)
32 | * [chapter11 - 命令模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter11-命令模式.md)
33 | * [chapter12 - 观察者模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter12-观察者模式.md)
34 | * [chapter13 - 备忘录模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter13-备忘录模式.md)
35 | * [chapter14 - 迭代器模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter14-迭代器模式.md)
36 | * [chapter15 - 模板方法模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter15-模板方法模式.md)
37 | * [chapter16 - 访问者模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter16-访问者模式.md)
38 | * [chapter17 - 中介者模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter17-中介者模式.md)
39 | * [chapter18 - 代理模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter18-代理模式.md)
40 | * [chapter19 - 组合模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter19-组合模式.md)
41 | * [chapter20 - 适配器模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter20-适配器模式.md)
42 | * [chapter21 - 装饰模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter21-装饰模式.md)
43 | * [chapter22 - 享元模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter22-享元模式.md)
44 | * [chapter23 - 外观模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter23-外观模式.md)
45 | * [chapter24 - 桥接模式](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter24-桥接模式.md)
46 |
47 |
48 |
49 |
50 | ## Android
51 | #### 以下内容为学习《Android开发艺术探索》笔记
52 | * [Part01 - Activity生命周期和启动模式](https://github.com/yanghaodong/StudyNotes/master/DesignPattern/chapter01-面向对象六大原则.md)
53 | * [Part02 - IPC机制](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter02-单例模式.md)
54 | * [Part03 - Drawable](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter03-Builder模式.md)
55 | * [Part04 - Android的线程和线程池](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter04-原型模式.md)
56 | * [Part05 - Bitmap的加载和Caches](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter05-工厂方法模式.md)
57 | * [Part06 - View的事件体系](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter07-策略模式.md)
58 | * [Part07 - View的工作原理](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter08-状态模式.md)
59 | * [Part08 - 理解Windows和WindowManger](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter09-责任链模式.md)
60 | * [Part09 - RemoteViews](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter11-命令模式.md)
61 | * [Part10 - 动画](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter12-观察者模式.md)
62 | * [Part11 - 四大组件的工作原理](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter06-抽象工厂模式.md)
63 | * [Part12 - Android的消息机制](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter13-备忘录模式.md)
64 | * [Part13 - JNI和NDK编程](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter14-迭代器模式.md)
65 | * [Part14 - Android性能优化](https://github.com/onlylemi/notes/blob/master/DesignPattern/chapter15-模板方法模式.md)
66 |
67 |
68 |
69 |
70 | ## RxJava
71 |
72 | * [RxJava概述](http://lovehaodong.cn/2017/03/11/RxJava%20%E5%AE%B6%E6%97%8F/)
73 | * [RxJava基础](http://lovehaodong.cn/2017/03/19/RxJava%20RxJava/)
74 | * [RxJava Permissions](http://lovehaodong.cn/2017/03/16/RxJava%20RxPermissions/)
75 | * [RxJava RxLifecyle](http://lovehaodong.cn/2017/03/14/RxJava%20RxLifecycle/)
76 | * [RxJava RxBus基础](http://lovehaodong.cn/2017/03/13/RxJava%20RxBus/)
77 | * [RxJava RxBus进阶](http://lovehaodong.cn/2017/04/09/RxJava%20RxBusTwo/)
78 | * [RxJava RxBinding](http://lovehaodong.cn/2017/03/11/RxJava%20RxBinding/)
79 |
80 | ## Linux
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
--------------------------------------------------------------------------------