一、C 风格（C-style）强制转型如下：

    (T) expression // cast expression to be of type T
    函数风格（Function-style）强制转型使用这样的语法：
    T(expression) // cast expression to be of type T
    这两种形式之间没有本质上的不同，它纯粹就是一个把括号放在哪的问题。我把这两种形式称为旧风格（old-style）的强制转型。

   二、 C++的四种强制转型形式：

　　C++ 同时提供了四种新的强制转型形式（通常称为新风格的或 C++ 风格的强制转型）：
const_cast(expression)
dynamic_cast(expression)
reinterpret_cast(expression)
static_cast(expression)

　　每一种适用于特定的目的：

　　·dynamic_cast 主要用于执行“安全的向下转型（safe downcasting）”，也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不能用旧风格语法执行的强制转型，也是唯一可能有重大运行时代价的强制转型。
   
    ·static_cast 可以被用于强制隐型转换（例如，non-const 对象转型为 const 对象，int 转型为 double，等等），它还可以用于很多这样的转换的反向转换（例如，void* 指针转型为有类型指针，基类指针转型为派生类指针），但是它不能将一个 const 对象转型为 non-const 对象（只有 const_cast 能做到），它最接近于C-style的转换。
   
·const_cast 一般用于强制消除对象的常量性。它是唯一能做到这一点的 C++ 风格的强制转型。

　　·reinterpret_cast 是特意用于底层的强制转型，导致实现依赖（implementation-dependent）（就是说，不可移植）的结果，例如，将一个指针转型为一个整数。这样的强制转型在底层代码以外应该极为罕见。

旧风格的强制转型依然合法，但是新的形式更可取。首先，在代码中它们更容易识别（无论是人还是像 grep 这样的工具都是如此），这样就简化了在代码中寻找类型系统被破坏的地方的过程。第二，更精确地指定每一个强制转型的目的，使得编译器诊断使用错误成为可 能。例如，如果你试图使用一个 const_cast 以外的新风格强制转型来消除常量性，你的代码将无法编译。

== 
==  dynamic_cast .vs. static_cast
==

    即dynamic_cast可用于继承体系中的向下转型，即将基类指针转换为派生类指针，比static_cast更严格更安全。 dynamic_cast在执行效率上比static_cast要差一些,但static_cast在更宽上范围内可以完成映射,这种不加限制的映射伴随 着不安全性.static_cast覆盖的变换类型除类层次的静态导航以外,还包括无映射变换,窄化变换(这种变换会导致对象切片,丢失信息),用 VOID*的强制变换,隐式类型变换等…

==
==  static_cast .vs. reinterpret_cast
==

    reinterpret_cast是为了映射到一个完全不同类型的意思,这个关键词在我们需要把类型映射回原有类型时用到它.我们映射到的类型仅仅是为了故弄玄虚和其他目的,这是所有映射中最危险的.(这句话是C++编程思想中的原话)

    static_cast 和 reinterpret_cast 操作符修改了操作数类型. 它们不是互逆的; static_cast 在编译时使用类型信息执行转换, 在转换执行必要的检测(诸如指针越界计算, 类型检查). 其操作数相对是安全的. 另一方面, reinterpret_cast 仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换, 例子如下:

   int n=9; double d=static_cast < double > (n);

    上面的例子中, 我们将一个变量从 int 转换到 double. 这些类型的二进制表达式是不同的. 要将整数 9 转换到 双精度整数 9, static_cast 需要正确地为双精度整数 d 补足比特位. 其结果为 9.0. 而reinterpret_cast 的行为却不同:

    int n=9;
    double d=reinterpret_cast<double & > (n);

方法一：

int main()
{
  int  ival, n = 0;
  char bin[32];
  scanf("%d", &ival);
  while(ival > 0) {
    bin[n++] = ival % 2;
    ival /= 2;
  }
  for(n–; n >= 0; n–)
    printf("%d", bin[n]);
  printf("n");
  getch();
}

方法二：

int main()
{
  int  ival, n = 0;
  char bin[32];
  scanf("%d", &ival);
  while(ival > 0) {
    bin[n++] = ival & 0x01;
    ival >>= 1;
  }
  for(n–; n >= 0; n–)
    printf("%d", bin[n]);
  printf("n");
  getch();
}

一朋友说：“女人有四种境界：浅而清澈型；浅 而混浊型；深而混浊型；深而清澈型”，其中属第四种境界最高，不禁觉得精辟，索性拿来一谈，其实爱情与品德有关。

浅而清澈型的女人比较可爱，简单且又真 诚，纯粹且又单纯，她们没有太多的欲望，没有太多的奢求，只有一颗面对生活与爱情的真诚的心。既没有太多的城府，也没有太多的计较，虽然没有知性女人的聪 慧，却与其相处犹如童年的梦幻，因为简单，所以快乐。若能遇上这等女人，那便会有一个简单且活泼的生活。

浅而混浊型的女人在这个物欲横流的社会比较常见， 浅是说头脑简单，阅历稀少，浑浊是说欲望颇多，奢望强烈，自己都搞不清楚自己需要什么。这类女人一经接触便很容易了解，由于比较粗浅，言语内外，动静之 间，便把那份浑浊暴露的体无完肤，可悲的是这类女人却还比较自爱，常常把自己的打扮得简单而看起来单纯，且故作纯粹，只是举止之间，总是摆脱不了那份复杂 混浊矛盾的内心，给人不舒服的感觉。若是遇上这等女人，那便会有一个劳碌奔波的生活。

深而混浊型的女人颇为矛盾，丰富的阅历与经历残酷的现实早已经麻木了 那份曾经纯粹的心，一方面渴望真诚且又单纯简单的生活与感情，一方面又不敢面对残酷与现实的生活，终日忐忑与现实与梦幻之间，忽而相信感情，追求生活，忽 而沉醉现实，自甘堕落。说其简单，却不简单，说其成熟，却不成熟。只能称之为矛盾且无奈。这类女人其实需要一份或者一片希望来走出自己的内心的阴暗，只是 繁华的都市阑珊的星光往往让人看不到希望的灯火。

深而清澈型的女人算得上女人中的极品，经历俗事的风雨与坎坷，经历感情的磨砺与奔波，还能保持一份纯粹的 心灵与灵魂，已经不能用任何语言去表达这类女人的美丽与唯美。其实爱情与修养有关，就像于丹讲论语一般，虽然不太赞成她的某些观点，但是总得思路还是对 的，每个人的生活品质，感情追求，其实其直接决定的原因是每个人的个人品味与修养。这个修养，包含太多，甚至看似不相关的素质都是包含其中，以前一直在谈 论修身养性的问题，现在看来是对的，人生就像一门经营哲学，感情，生活，事业都需要用自身的素质修养去驾驭的，每个人的生活的品质层次直接来源于他的个人 修养，没有抱怨，没有不公，那便是生活。你对爱情生活的认知程度，对责任义务的把握程序直接决定了你可以遇到一个什么样的人，不要去抱怨对方的问题，其实 那便是你自己的选择。中国有一句话：”物以类聚，人以群分”，还是真的有道理的。就像老百姓常说的，看看一个人的老公，或者老婆，便知道对方是什么人了

面向对象的三个基本特征是：封装、继承、多态。

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。 当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法 确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对 象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了――代码重用。而多态则是为了实现另一个目的――接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类
boolean –>Boolean
char —>Character
byte –>Byte
short –>Short
int –>Integer
long –>Long
float –>Float
double –>Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的 数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。同时为了面向对象操作的一致性，这些基本类型都有相应的封装类型：Integer、Short、 Long、Byte、Float、Double、Character等。      
因为封装类型是对象，所以可以进行相应的很多对象能力函数操作，这样就可以提供很多基本类型难以完成的工作的完成和实现。   
你可以通过以下方式来声明该类型。

int a，a为int类型的变量
char a，a为char类型的

String对象

1. 首先String不属于8种基本数据类型，String是一个对象。

　　因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

　　2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；

　　3. String str=”punkll”；

　　　String str=new String (“punkll”);的区别：

　　在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。

　　常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

　　看例1：

　　String s0=”punkll”;

　　String s1=”punkll”;

　　String s2=”punk” + “ll”;

　　System.out.println( s0==s1 );

　　System.out.println( s0==s2 );

　　结果为：

　　true

　　true

　　首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。

　　因为例子中的s0和s1中的”punkll”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”punk”和”ll” 也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是 常量池中”punkll”的一个引用。

　　所以我们得出s0==s1==s2;

　　用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

　　看例2：

　　String s0=”punkll”;

　　String s1=new String(”punkll”);

　　String s2=”punk” + new String(“ll”);

　　System.out.println( s0==s1 );

　　System.out.println( s0==s2 );

　　System.out.println( s1==s2 );

　　结果为：

　　false

　　false

　　false

　　例2中s0还是常量池中”punkll”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”punkll”的引用，s2因为有后半 部分new String(“ll”)所以也无法在编译期确定，所以也是一个新创建对象”punkll”的应用;明白了这些也就知道为何得出此结果了。

Bit意为“位”或“比特”，是计算机运算的基础，属于二进制的范筹；
Byte意为“字节”，是计算机文件大小的基本计算单位； 
这两者应用的场合不同。通常用bit来作数据传输的单位，因为物理层，数据链路层的传输对于用户是透明的，而这种通信传输是基于二进制的传输。在应 用层通常是用byte来作单位，表示文件的大小，在用户看来就是可见的数据大小。比如一个字符就是1byte,如果是汉字，则是2byte。
下面是2个具体应用实例：
Mbps=mega bits per second(兆位/秒)是速率单位，
MB=mega bytes(兆比、兆字节)是量单位，1MB/S（兆字节/秒）=8MBPS（兆位/秒）。
我们所说的硬盘容量是40GB、80GB、100GB，这里的B指是的Byte也就是“字节”。(与容量相关，应用层）
1 KB = 1024 bytes =2^10 bytes
1 MB = 1024 KB = 2^20 bytes
1 GB = 1024 MB = 2^30 bytes
USB2.0标准接口传输速率是480兆位/秒,即480MBps。这里的B指是的Bit也就是“位”。（与传输相关，底层）

注：另外，Byte通常简写为B(大写），而bit通常简写为b（小写）。可以这么记忆，用大写的就是数据值比较大的位，而小字的就是数据值比较小的字节，1B=8b。

<script src="http://widgets.twimg.com/j/2/widget.js"></script>
<script>
new TWTR.Widget({
version: 2,
type: ‘profile’,
rpp: 4,
interval: 6000,
width: 250,
height: 300,
theme: {
shell: {
background: ‘#333333’,
color: ‘#ffffff’
},
tweets: {
background: ‘#000000’,
color: ‘#ffffff’,
links: ‘#4aed05’
}
},
features: {
scrollbar: false,
loop: false,
live: false,
hashtags: false,
timestamp: false,
avatars: false,
behavior: ‘all’
}
}).render().setUser(‘sheng00’).start();
</script>