<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[wangwangfish的专栏]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/wangwangfish</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; wangwangfish]]></copyright><item><title><![CDATA[c++对象序列化初步探讨]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8112974</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8112974</guid><author>wangwangfish</author><pubDate>Thu, 25 Oct 2012 21:34:58 +0800</pubDate><description><![CDATA[什么是序列化
程序员在编写应用程序的时候往往需要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化”（Deserialization）。
简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化相对的是]]></description><category></category></item><item><title><![CDATA[深入c++输入输出流]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8112878</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8112878</guid><author>wangwangfish</author><pubDate>Thu, 25 Oct 2012 21:09:10 +0800</pubDate><description><![CDATA[C++文件流
  在C++中，有一个stream这个类，所有的I/O都以这个“流”类为基础的，包括我们要认识的文件I/O，stream这个类有两个重要的运算符：
  1、插入器(
  向流输出数据。比如说系统有一个默认的标准输出流(cout)，一般情况下就是指的显示器，所以，cout就表示把字符串"Write Stdout"和换行字符('n')输出到标准输出流。
  2、析取器(>>)]]></description><category></category></item><item><title><![CDATA[c/c++输入输出总结]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8112746</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8112746</guid><author>wangwangfish</author><pubDate>Thu, 25 Oct 2012 20:33:13 +0800</pubDate><description><![CDATA[C++ I/O
C++支持两种I/O，第一种是从C语言继承来的，一种是由C++定义的面向对象I/O系统。
  从c语言继承来的
1、int getchar(void);返回一个整数值，也可以指定这个值为char变量，因为这个字符包含于低位字节中(高位字节通常为0)，如果有错，getchar()返回EOF。但是他有一个潜在的问题，正常情况下，getchar()缓存输入，直到键入了回车键(这个大]]></description><category></category></item><item><title><![CDATA[java、c\c++的函数比较]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8108866</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8108866</guid><author>wangwangfish</author><pubDate>Wed, 24 Oct 2012 21:32:49 +0800</pubDate><description><![CDATA[C++ Java
虚函数 -------- 普通函数
纯虚函数 -------- 抽象函数
抽象类 -------- 抽象类
虚基类 -------- 接口]]></description><category></category></item><item><title><![CDATA[c++-虚拟继承、虚基类]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8108836</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8108836</guid><author>wangwangfish</author><pubDate>Wed, 24 Oct 2012 21:24:43 +0800</pubDate><description><![CDATA[虚拟继承与虚基类实际上是说了同一件事，只是不同的书表达不同，在这里还是推荐虚拟继承这种说法（因为有人总问虚基类是什么，这里可以解释为虚基类就是虚拟继承，一种继承的方式，有的书偏要把一个动作写成一个名词，不负责任）。虚拟继承是C++继承的一个特殊方法，用来达到特殊的目的。要达到什么目的呢？那就是避免继承机制下的二义性问题(二义性：程序产生两种或多种可能，把编译器搞的不知所措)

继承机制下的二义]]></description><category></category></item><item><title><![CDATA[理解java多态性]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8105675</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8105675</guid><author>wangwangfish</author><pubDate>Wed, 24 Oct 2012 10:24:08 +0800</pubDate><description><![CDATA[深入理解java多态性
（一）相关类


class
 A ...{
        
public String show(D obj)...{
               
return ("A and D");
         }

        
public String show(A obj)...{
               
return (]]></description><category></category></item><item><title><![CDATA[java-截取字符串的substring和substr]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8096874</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8096874</guid><author>wangwangfish</author><pubDate>Mon, 22 Oct 2012 08:42:30 +0800</pubDate><description><![CDATA[java里截取字符串的方法有substring和substr，它俩的区别和各自的用法具体是什么呢？现在总结如下：
1.substring方法
,yM.M\ lt.`B Y0
　　定义和用法
　　substring 方法用于提取字符串中介于两个指定下标之间的字符。
　　语法
　　stringObject.substring(start,stop)
　　参数     描述]]></description><category></category></item><item><title><![CDATA[java-浅层复制和深层复制]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8093281</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8093281</guid><author>wangwangfish</author><pubDate>Sat, 20 Oct 2012 16:04:22 +0800</pubDate><description><![CDATA[测试目标：
1、  什么是浅层复制
2、  什么是深层复制
浅层复制 
1、  创建一个TestObj对象，然后给此对象赋值。
2、  再生成一个克隆对象，比较此克隆对象与被克隆的对象各属性值。
新建测试入口类TestCloneable.java：
public class TestCloneable{

private static TestCloneable testClonea]]></description><category></category></item><item><title><![CDATA[java-多线程发展史]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8091146</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8091146</guid><author>wangwangfish</author><pubDate>Fri, 19 Oct 2012 19:42:02 +0800</pubDate><description><![CDATA[转载http://raychase.iteye.com/blog/1679131

引言

首先问这样一个问题，如果提到Java多线程编程，你会想到什么？




volatile、synchronized关键字？
竞争和同步？
锁机制？
线程安全问题？
线程池和队列？

好吧，请原谅我在这里卖的关子，其实这些都对，但是又不足够全面，如果我们这样来谈论Java多线程会]]></description><category></category></item><item><title><![CDATA[java-非阻塞算法简介]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8091143</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8091143</guid><author>wangwangfish</author><pubDate>Fri, 19 Oct 2012 19:39:39 +0800</pubDate><description><![CDATA[在不只一个线程访问一个互斥的变量时，所有线程都必须使用同步，否则就可能会发生一些非常糟糕的事情。Java 语言中主要的同步手段就是
synchronized 关键字（也称为内在锁），它强制实行互斥，确保执行 synchronized 块的线程的动作，能够被后来执行受相同锁保护的
synchronized 块的其他线程看到。在使用得当的时候，内在锁可以让程序做到线程安全，但是在使用锁定保护短的代]]></description><category></category></item><item><title><![CDATA[java-正确使用volatile变量]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8091069</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8091069</guid><author>wangwangfish</author><pubDate>Fri, 19 Oct 2012 18:57:15 +0800</pubDate><description><![CDATA[Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与
synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。本文介绍了几种有效使用 volatile 变量的模式，并强调了几种不适合使用 volatile 变量的情形。

锁提供了两种主要特]]></description><category></category></item><item><title><![CDATA[java-sleep()和wait()的区别]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8090979</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8090979</guid><author>wangwangfish</author><pubDate>Fri, 19 Oct 2012 18:18:57 +0800</pubDate><description><![CDATA[1、这两个方法来自不同的类分别是Thread和Object
　　2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
　　3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
　　任何地方使用(使用范围)
　　synchronized(x){
　　x.notify()
　　//或者w]]></description><category></category></item><item><title><![CDATA[java-内部类]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8076371</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8076371</guid><author>wangwangfish</author><pubDate>Tue, 16 Oct 2012 11:38:30 +0800</pubDate><description><![CDATA[重新来认识一下内部类的区别
1
Static member class（静态成员类）
类声明中包含“static”关键字的内部类。如以下示例代码，
Inner1/Inner2/Inner3/Inner4就是Outer的四个静态成员类。静态成员类的使用方式与一般顶层类的使用方式基本相同。

public 
class  Outer{
    //just like static me]]></description><category></category></item><item><title><![CDATA[java-适配器模式]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8075931</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8075931</guid><author>wangwangfish</author><pubDate>Tue, 16 Oct 2012 10:22:35 +0800</pubDate><description><![CDATA[有三种：类适配器模式、对象适配器模式、缺省适配器模式
适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

--------------------------------------------------------------------------------
适配器模式的用途
　　用电器做例子，笔记本电脑的插头]]></description><category></category></item><item><title><![CDATA[java-组合接口中的名字冲突问题]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8075735</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8075735</guid><author>wangwangfish</author><pubDate>Tue, 16 Oct 2012 09:53:06 +0800</pubDate><description><![CDATA[组合接口时的名字冲突

===========================组合接口时的方法冲突========================
在实现多重继承时，可能会碰到一个小陷阱：当一个类同时implements 接口1与接口2时，假如接口1与接口2同时都有一个相同方法签名（即方法的名字，参数，不包括返回类型）的方法时，如果在类中没有再定义该方法，编译器就会报错！
看个例子：
i]]></description><category></category></item><item><title><![CDATA[c/c++-虚函数和重载]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8075402</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8075402</guid><author>wangwangfish</author><pubDate>Tue, 16 Oct 2012 08:38:35 +0800</pubDate><description><![CDATA[1. 重载
1.1 简单重载
      在C++中，是允许同名函数的存在


int add(int
 i,int j);
float add(float i,float);
      而在c中，函数名是唯一的，所以为了区分int和float版本的add，你需要给它们起不同的名字，比如将int的命名为add_int,将float的命名为add_float，这样做的坏处就是程序员]]></description><category></category></item><item><title><![CDATA[算法-寻找第K大的数的方法总结]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8074838</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8074838</guid><author>wangwangfish</author><pubDate>Mon, 15 Oct 2012 21:36:14 +0800</pubDate><description><![CDATA[转载：http://www.cnblogs.com/zhjp11/archive/2010/02/26/1674227.html
今天看算法分析是，看到一个这样的问题，就是在一堆数据中查找到第k个大的值。
      名称是：设计一组N个数，确定其中第k个最大值，这是一个选择问题，当然，解决这个问题的方法很多，本人在网上搜索了一番，查找到以下的方式，决定很好，推荐给大家。
      所谓“]]></description><category></category></item><item><title><![CDATA[java-深入理解java GC与 finalize（）]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8068220</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8068220</guid><author>wangwangfish</author><pubDate>Sat, 13 Oct 2012 20:31:10 +0800</pubDate><description><![CDATA[基本预备相关知识

1 java的GC只负责内存相关的清理，所有其它资源的清理必须由程序员手工完成。要不然会引起资源泄露，有可能导致程序崩溃。

2 调用GC并不保证GC实际执行。
   GC不保证资源在任何特定的时间都能释放，除非调用 Close 方法或Dispose 方法。

3 finalize抛出的未捕获异常只会导致该对象的finalize执行退出。
  protected]]></description><category></category></item><item><title><![CDATA[java-垃圾回收]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8068192</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8068192</guid><author>wangwangfish</author><pubDate>Sat, 13 Oct 2012 20:28:24 +0800</pubDate><description><![CDATA[垃圾回收分为两大步骤：识别垃圾 和 回收垃圾
识别垃圾有两大基本方法
1.计数器法
每个对象有一个相应的计数器，统计当前被引用的个数，每次被引用或者失去引用都会更新该计数器。
优点：识别垃圾快，只需判断计数器是否为零。
缺点：增加了维护计数器的成本，无法在对象互相引用的情况下识别垃圾
因此，适用于对实时性要求非常高的系统。
2.追踪法
从根对象（例如局部变量）出发，逐一遍历它的引用]]></description><category></category></item><item><title><![CDATA[java-哪些东西会被JVM回收]]></title><link>https://blog.youkuaiyun.com/wangwangfish/article/details/8068070</link><guid>https://blog.youkuaiyun.com/wangwangfish/article/details/8068070</guid><author>wangwangfish</author><pubDate>Sat, 13 Oct 2012 19:17:03 +0800</pubDate><description><![CDATA[對於不再有用的物件，Java有自動回收資源的機制。哪些東西會被垃圾收集器（Garbage Collector）認定為不再有用的物件？簡單地說，無法被JVM中任何執行緒透過參考名稱循線參考到的物件，就是GC認定的垃圾。

在啟動JVM之後，JVM中就會有一些執行緒，最基本的，就是執行程式進入點的主執行緒（main thread），基本上，這條執行緒是你要關心物件是否成為垃圾的起點。

假設你]]></description><category></category></item></channel></rss>