Gatsby's Blog

简介

引出：如何将线程与变量绑定，以解决多线程安全问题？

首先，在Thread解读中提到，每个线程都有一个线程栈，该栈里的数据只能该线程访问。这样一看，貌似线程里创建的变量就天然是线程隔离的，不存在多线程安全问题，
实际上，栈空间只是存的方法局部变量，所以如果需要变量与线程全程绑定，这是不可行的。

摘要

简介

“一切皆Socket！”

简介

多继承

java中一个类不能直接继承两个类

比如说这样：class A extends B,C
不能这样写，因为java不支持多继承，但是你可以像下面这样实现继承多个类
class A extends B
class C extends A

这样C就同时继承了B和A两个类。

在C++中，这个多继承就好解决的多了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class A{
    public:virtual void foo(){
        printf("A");
    }
}
calss B{
    public:virtual void foo(){
        printf("B");
    }
}

class x:public A,public B,...{
    void foo() 
        printf("X");
    }
}

菱形继承问题——python

Python是支持多重继承的，但为了解决多重继承的方法查找顺序问题（被称为MRO），有一场苦难史。

传统模式

直接使用深度优先算法（并且，从左向右），每个类选择其第一次出现的位置。如：

1
2
3
4
5
6
7
8
9
10
11
12
13

class A:
  def save(self): 
    pass
    
class B(A): 
    pass
    
class C:
  def save(self): 
    pass
    
class D(B, C): 
    pass

作为D类的实例，成员搜索顺序为D=>B(=>A)=>C

解释：

• 默认优先搜索当前类，然后搜索父类，所以D优先级最高，其次B的优先级高于A。
• 因为继承有先后顺序，所以B的优先级高于C。
• 综上，搜索顺序为D=>B(=>A)=>C。

但如果是下面的情况，就会出现菱形继承问题。

1
2
3
4
5
6
7
8
9
10

class A:
  def save(self): 
    pass
class B(A): 
    pass
class C(A):
  def save(self): 
    pass
class D(B, C): 
    pass

问题：

这种情况的问题就是在D类调用save方法时，究竟是调用的谁的实现？

分析：

根据传统模式，D的实例调用save方法时最终会调用A类下的save方法，而B类中的方法时永远也不会有被调用的机会。而这样的特性，也会在设计上变得异常复杂和难以处理。

new-style class——新式类

关键字:广度优先

新式类是python为解决菱形问题而提出的解决方案。Python2.2中引进了new-style class，说白了就像java一样，所有类都继承自最根本的object类。这就让“菱形继承”变成十分普遍，于是只能改变MRO策略。仍然使用深度优先搜索、从左向右，但是每个类选择其最后一次出现的位置。这样一来，对上面的“菱形继承”就处理比较完美了，形成的顺序是：D、B、C、A，越是公用基础类，越放在后面。

交叉继承问题:
> 后续补充
#### C3算法
> 后续补充

接口继承

Java的接口继承功能，既实现了静态语言的多重继承性，又避免了多重继承的数据构造的冲突和类层次的复杂性。但是，我们并不能说接口是解决问题的完美方案。接口也有不能共享实现的缺点。本来只是为了跨越继承层次来共享代码，现在却需要另外生成一个独立对象，而且每次方法调用都要委派给这个对象，这实在是不太合理，而且执行的效率也不高。
——《松本行弘的程序世界》

总结：
>* 内部类的出现，正是Java为避免多继承而引出的难题而采用了单继承的设计模式，以及接口在多继承上特性上的不足而提出的一个新的概念。
>* 在程序设计中有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

作用——《Thinking in java》

• 1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立
• 2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
• 3、创建内部类对象的时刻并不依赖于外围类对象的创建。

  待考证。

• 4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
• 5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

内部类基础

暂时不讨论反射对内部类的影响。

定义及使用

回顾一下类的定义语法

• 一个java文件有且只有一个公有类。
• 一个公有类仅且只能有一个main方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//公有类
public class Outter {
	//内部类
	public class InnnerOfOuter {
		public void func(){
			//局部内部类
			class InnerOfFunc{
				public void func(){
					//匿名内部类
					new Runnable(){
						@Override
						public void run() {
							System.out.println("annoymous class");
						}
					};
				}
			}
		}
	}
}
class Outter1{
}

解读：

• Outter为公有类，可以被任何引入的地方调用。

  1	Outter outter = new Outter();

• Outter1为公有类的同级类，只能在当前class字节码中调用。
• InnerOfOutter为成员内部类，可以看做是类型为class的成员变量，根据修饰符也可以被外界引入，但其生命周期依赖于外部类。

  1 2	Outter outter = new Outter(); Outter.InnnerOfOuter innnerOfOuter = outter.new InnnerOfOuter();

• InnerOfFunc为局部内部类，存在于方法中。
• AnnoymousClass为匿名内部类，基本只出现在只使用一次的地方。

成员内部类

成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类

局部内部类

有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

下面是Thinking in java中的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class Parcel5 {
    public Destionation destionation(String str){
        class PDestionation implements Destionation{
            private String label;
            private PDestionation(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return new PDestionation(str);
    }
    
    public static void main(String[] args) {
        Parcel5 parcel5 = new Parcel5();
        Destionation d = parcel5.destionation("chenssy");
    }
}

匿名内部类

在做Swing编程中，我们经常使用这种方式来绑定事件，有点像临时定义了一个类及实例给调用者。

1
2
3
4
5
6
7

button2.addActionListener(  
    new ActionListener(){  
        public void actionPerformed(ActionEvent e) {  
            System.out.println("你按了按钮二");  
        }  
    }
);

注意:

• 1、 匿名内部类是没有访问修饰符的。
• 2、 new 匿名内部类，这个类首先是要存在的。没错，接口其实也是class字节码。
• 4、 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

静态内部类

静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

• 1、 它的创建是不需要依赖于外围类的。
• 2、 它不能使用任何外围类的非static成员变量和方法。

最后

到这里了我们需要明确一点，内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass 的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

问题:

• 1.静态内部类的实例会被GC回收吗？
• 2.为什么静态内部类不能包含静态变量？

参考

• 为什么Java类只能继承一个父类？
• java提高篇(八)—-详解内部类

摘要

简介

本次解读Exception与RunTimeException的源码，以及在流程控制中的使用细节。

简介

Object类是Java类体系的基础，所有的类包括数组都以它为父类，并实现了它的方法。可以这样讲，它是对所有实现类公共属性的抽象。

在面向对象的编程思想下，对实现不同功能的代码进行抽象和封装成一个个对象，而不同对象存在于内存空间的数据结构，就是对象的实例。对象只有在实例化后才有它的实际意义，其它情况下都只是class的不同结构的体现。

摘要

简介

之所以将这两个类放一起讲，是因为两者之间存在不可忽视的依赖关系，二者的低层实现也非常的相似。我之前通过HashSet这个类名判断该集合本质是数组实现，通过源码才发现设计者有他自己的考虑。

简介

Throwable类是整个异常体系类的父类，它实现了Serializable接口，表示它能够被序列化。它的子类主要是Error和Exception类，以及一个StackRecorder类（不常见）。

连表查询

1.交叉查询

1

SELECT * FROM table1,table2

返回的是两张表记录的笛卡尔积。

2.内连接(inner join)

隐式查询：不使用关键字

1
2

SELECT * FROM t1,t2
        WHRER t1.id=t2.t1Id

或者(非隐式查询):

1
2

SELECT * FROM t1 inner join t1
     on t1.id=t2.t1Id

3.外连接(outter join)

1.左外:返回满足连接条件的记录,同时返回左表中不满足条件的记录。

1
2

SELECT * FROM t1 left outter join t2
    on t1.id=t2.t1Id

2.右外连：返回满足连接条件的记录,同时返回右表中不满足条件的记录。

3.全外连

子查询/嵌套查询

1
2
3
4
5

SELECT * FROM t1
    where id in(
        SELECT id FROM t2
            where id=#{id}
    )

统计查询

1

select count(*) from t

1

select sum(colume_name)/count(*) from t

1

seletc avg(colume_name) from t

查询购买了哪些商品 ，并且该类总价大于100的商品

1
2
3

select product,sum(price) as total from order
    group by product
having total>100

1

select * from t limit (offset,nums)

数据库数据类型与JDBC数据类型对照表

多线程知识点

简介

Thread类是Java并发编程的基础，是对多线程编程的实现，底层大量使用了native调用C/C++实现的API，是jdk中也非常基础也非常重要的类。

关于字符串的两个问题

就在几年前夜幕时分的一场大雨中，出来商场购物的我来到一处衣店门口躲雨！却发现在不远处的被大雨淋湿的地面上匍匐着一处人影，那人右腿从小腿以下尽失、光着上半身，时不时扭动一下身躯，若重伤的”爬虫一般”，让人看后难免不升起一丝悲悯之情，而在身旁则放着空油漆罐，其喻味自然不言而喻。走过的路人不时有人留下少于钱币然后匆匆离去，可以想象罐中的钱币已然被雨水所侵湿！

此刻的我见此心中是翻滚的，按照学校里所宣扬的价值观，人不是应该有尊严的活着吗？即便右腿残疾，可他不仍拥有完好的双手，仍旧可以从事只需双手的劳动，以维持自己的生计，只要努力、为人正直、诚信……，至少可以过的有尊严，甚至是改变命运、在经济上独立！心里如此的难以理解，以致要冲上去逼问他:”为什么你不肯有尊严的活着而去祈求他人的施舍？为什你宁肯在这里忍受日晒雨淋也不愿努力用自己的”双手”来创造一个属于自己的未来？为什么？”但我还是忍住了，因为这就是社会，在社会面前我的一切不请都是徒劳！而对于那些在街上用自己的悲惨遭遇以祈求他人怜悯而施舍的行为，我任不齿，并有所看低！

而在今天的火车站，面对一些赤裸上身并挽起右腿裤脚以向他人表示自己遭受过严重创伤的右小腿——不难想象，那似乎被人挖去一大块肉的创口下就是森森白骨。我羞愧地低下头，带着些许怜悯，不敢自视那渴求他人怜悯的神情，曾为此而充满不平与愤慨的心再也无半点鄙晲！

这几年来，在对这一群体有了更深层次的了解后，我知道事情要比原本看起来复杂的多！

没有足够的经济能力，甚者吃穿都成问题；没有庞大的关系网，难以立身于大城市。由于自身所受教育的缺陷——自己当地教育资源严重匮乏，自然也难有长远的眼光与思维。迫于生计，对于日常小事总是斤斤计较，在农村，经常可以见到为蝇头小利做出让人鄙晲的举动，甚至大动干戈。

又如上小学五年级的我不慎出了车祸(当然只是被撞到并在路面连翻了几个滚，下午缺席课堂，当晚就继续上课。)，当交警赶来对现场做了处理后询问我身上那些地方疼或者不舒服，然后我就凭实际情况指出了背上几个地方。而我奶奶，知道后就责责备我怎么就只说了几个部位，并称我应该回答全身都疼。

再比如当下层出不穷的碰瓷事件。而这样的情形又悄然影响着整个社会，面对有人摔倒在地，没有人上前对其施与援助，甚至没人为此拨打120。即便有人上前帮忙，最后反落了个被讹了一大笔钱！

为什么？是人情冷漠？还是社会险恶？

不，对于”路人”来讲，面临两个选择，扶还是不扶，若扶，时候被人讹诈怎么办？自己家里还是有老有小，急等着用钱。若不扶，则可以不承担被讹的风险，更何况当下被类似事件比比皆是，事后也只需承担被他人道德上的一些责备，何况在这个年代又有谁会在乎那微不足道的道德，毕竟都是神州底层！

两者对比，绝大多数人都会选择对这样的事敬而远之，这也是路人”冷漠”的原因。
而对于”摔倒者”，也可指那些被碰到在地的人，又有恶意与非恶意之分，恶意者自身并未受到什么实质性伤害却又想借此获得一笔收益，对于此类恶意者我个人不想谈及！而非恶意者就是那些受到实质性伤害的一类，在被”路人”援助后又反过来讹”路人”。而这类其实也是神州底层劳动人民，在事后一想到自己要交医院的天价”治疗费”，也是心疼不已，也面临如”路人”一样的抉择。仔细想想也真是有趣，同是神州底层，因同样的想法想法上演这样的闹剧，不过也只有底层，这样的事才能层出不穷，毕竟没有哪个富裕家庭的人甘愿为这么一点小利而使自己颜面扫地！

而这些正是底层劳动人民的真实生活写照，由于社会财富分配严重不公而形成的写照，而这也就是当下社会的一面写照。人组成了社会，也时刻影响着社会，社会又反过来影响着我们！

现实并不是要说多么残酷才叫现实，也不需要什么批评或溢美之词！现实就是现实，它就在那里，无色无味！

阅读理解一篇

《资本论》是一部深刻的学术著作，《资本论》与现实的关系是复杂的，由于篇幅所限，我这里所谈的，仅仅只是问题的一个方面。在这篇拙作里，我所探讨的惟一问题正如标题所示。

原本想作为演讲稿子，但最后根本没有用上。现在看来，当时的想法在未真正了解社会之前，着实过于不切实际。