JAVA语言关键字集合

1:Super 超类 (Java编程语言）

超类：用java术语来讲，被继承的类称为超类，继承的类称为子类。
面向对象编程的最重要的特色之一就是能够使用以前创建的类的方法和域。通过简单的类来创建功能强大的类，可以大幅地节省编程时间，更重要的是，这样做可以减少代码出错的机会。要在以前的类上构造新类，就必须在类声明中扩展这个类。
通过扩展一个超类，可以得到这个类的一个新副本，并且可以在其上添加其他功能。如果对这个新类并不做任何添加工作，那么，它的工作情况与超类完全相同，新类中会含有超类所声明和继承的、具有访问权限的所有方法和域。
对于超类，应该确切地理解this和super关键字的使用，下图演示了这两个关键字的使用。
import java.awt.*;
public class TestThisSuper extends Frame
{
int b;
public TestThisSuper(String a)
{
this (a,0);
}
public TestThisSuper(String a,int b)
{
super(a);
this.b= b;
}
}

2:计算机语言中的break

break在一些计算机语言中是保留字，其作用大多情况下是终止上一层的循环，以C语言来说，break在switch（开关语句）中在执行一条case后跳出语句的作用。
计算机DOS命令：设置或清除DOS系统的扩展ctrl+c检测
（1）这个命令是为了与DOS系统的兼容而保留的，在Windows XP里不起作用
（2）如果命令扩展名被启用，并且操作平台是Windows XP，BREAK命令会在被调试程序调试时输入一个硬代码中断点
C语言中的break
break语句
break语句通常用在循环语句和开关语句中。当break用于开关语句switch中
时，可使程序跳出switch而执行switch以后的语句；如果没有break语句，则会
从满足条件的地方（即与switch（表达式）括号中表达式匹配的case）开始执行，
直到switch结构结束。break在switch 中的用法已在前面介绍开关语句时
的例子中碰到，这里不再举例。
当break语句用于do-while、for、while循环语句中时，可使程序终止循环
而执行循环后面的语句，通常break语句总是与if语句联在一起。即满足条件时
便跳出循环。
例：
main()
{
int i=0;
char c;
while（1） /*设置循环*/
{
c='\0'; /*变量赋初值*/
while(c!=13&&c!=27） /*键盘接收字符直到按回车或Esc键*/
{
c=getch();
printf("%c\n",c);
}
if(c==27）
break; /*判断若按Esc键则退出循环*/
i++;
printf("The No. is %d\n",i);
}
printf("The end");
}
注意：
1. break语句对if-else的条件语句

不起作用。
2. 在多层循环中，一个break语句只向外跳一层。
Linux下GDB调试
设置断点（BreakPoint）
我们用break命令来设置断点。正面有几点设置断点的方法：break
在进入指定函数时停住。C++中能使用class::function或function(type,type）格式来指定函数名。
break
在指定行号停住。
break +offset
break -offset
在当前行号的前面或后面的offset行停住。offiset为自然数。
break filename:linenum
在源文件filename的linenum行处停住。
break filename:function
在源文件filename的function函数的入口处停住。
break *address
在程式运行的内存地址处停住。
break
break命令没有参数时，表示在下一条指令处停住。
break ... if
...能是上述的参数，condition表示条件，在条件成立时停住。比如在循环境体中，能设置break if i=100，表示当i为100时停住程式。
查看断点时，可使用info命令，如下所示：（注：n表示断点号）
info breakpoints [n]
info break [n]Extend

extends 继承　类X 通过extend 类Y来添加功能，或者添加变量，或者添加方法，或者覆盖类Y的方法。一个接口extends另外一个接口来添加方法。
范例
在 B 类别 (定义如下) 中，会自动插入一个以 A 类别之建构函式作为对象的呼叫，作为 B 建构函式的第一行陈述式，这是因为该处并未存在任何呼叫的缘故。 (也就是说，这个呼叫在范例中被注解化。)
class B extends class A
{
function B() { // 此为建构函式
// super(); // 选择性；如果忽略，则在编译时插入
}
function m():Number {return 25;}
function o(s:String):Void {trace(s);}
}
另一个简单的例子：
假如这样定义：
class A{
int i;
void f(){}
}
class B extends A{
int j;
void f(){}//重写
void g(){}
}
然后：
B b = new B();
b就是子类对象的实例，不仅能够访问自己的属性和方法，也能够访问父类的属性和方法。诸如b.i,b.j,b.f(),b.g()都是合法的。此时b.f()是访问的B中的f()
A a = new B();
a虽然是用的B的构造函数，但经过upcast，成为父类对象的实例，不能访问子类的属性和方法。a.i,a.f()是合法的，而a.j,a.g()非法。此时访问a.i,a.f()是访问A中变量与方法。

3:C语言Long

long 关键字表示一种整型，该类型根据下表显示的大小和范围存储值。
类型范围大小 .NET Framework 类型
long
-2,147,483,648 to 2,147,483,647,
有符号 32位整数
System.Int32
所占4个字节(Byte)
标识符
可如下例所示声明并初

始化 long 类型的变量：
复制代码
long long1 = 4294967296;如果整数没有后缀，则其类型为以下类型中可表示其值的第一个类型：int、uint、long、ulong。在上例中，它是 long 类型，因为它超出了 uint 的范围（有关整型的存储大小，请参见整型表（C# 参考））。
还可以像下面这样，在 long 类型中使用后缀 L：
复制代码
long long2 = 4294967296L;当使用后缀 L 时，将根据整数的大小确定它的类型为 long 还是 ulong。在此例中，它是 long，因为它小于 ulong 的范围的下限。
此后缀常用于调用重载方法。以下面使用 long 和 int 参数的重载方法为例：
复制代码
public static void SampleMethod(int i) {}
public static void SampleMethod(long l) {}使用后缀 L 可保证调用正确的类型，例如：
复制代码
SampleMethod(5); // Calling the method with the int parameter
SampleMethod(5L); // Calling the method with the long parameter可在同一个表达式中同时使用 long 类型和其他数值整型，这时表达式的计算结果为 long（在关系表达式或布尔表达式中为 bool）类型。例如，下列表达式计算为 long：
复制代码
898L + 88注意
也可用小写字母“l”作后缀。但是，因为字母“l”容易与数字“1”混淆，会生成编译器警告。为清楚起见，请使用“L”。
有关兼用浮点型和整型的算术表达式的信息，请参见 float 和 double。
转换
存在从 long 到 float、double 或 decimal 的预定义隐式转换。其他情况下必须使用显式转换。例如，不使用显式类型转换时，下列语句将产生编译错误：
复制代码
int x = 8L; // Error: no implicit conversion from long to int
int x = (int)8L; // OK: explicit conversion to int存在从 sbyte、byte、short、ushort、int、uint 或 char 到 long 的预定义隐式转换。
还请注意，不存在从浮点型到 long 类型的隐式转换。例如，除非使用显式强制转换，否则以下语句将生成一个编译器错误：
复制代码
long x = 3.0; // Error: no implicit conversion from double
long y = (long)3.0; // OK: explicit conversion
Long 数据类型－－Visual Basic 2008 参考
保存 32 位（4 字节）有符号整数。范围：－9223372036854775808～9223372036854775807。
用于保存超出 Integer 类型范围的整数。默认值 0。在 6.0 以前版本中，是 32 位的。
其可以转换为 Single、Double、Decimal 而不会溢出。
在文本（如 2.5，3）后追加类型字符“L”将会将其强制转换为 Long，其标示符类型字符为“&”。
Long 对应于 .NET 的类型为 System.Int64 结构。
备注
.NET 具有 Ulong 数据类型，用于存储无符号的 64 位整数

。

4:C语言程序语句
Switch用在编程中，如C语言中它经常跟Case一起使用，是一个判断选择代码。其功能就是控制业务流程流转的。
直线翻译：switch语句，即“切换”语句；case即“情况”。
switch语句的语法如下(switch，case和default是关键字)：
switch ( controllingExpression )
{
case constantExpression1 :
case constantExpression2 :
case constantExpression3 :
statements; /*当满足constantExpression1、constantExpression2、constantExpression3任何一个都执行statements */
break;
case constantExpression :
statements ;
break;
...
default :
statements ;
break;
}
遵守switch语句规则
switch语句非常有用，但在使用时必须谨慎。所写的任何switch语句都必须遵循以下规则：
只能针对基本数据类型使用switch，这些类型包括int、char等。对于其他类型，则必须使用if语句。
switch()的参数类型不能为实型。
case标签必须是常量表达式(constantExpression)，如42或者"42"。如果需要在运行时计算case标签的值，必须使用if语句。
case标签必须是惟一性的表达式；也就是说，不允许两个case具有相同的值。
C语言switch应用例子：
例一：
#include
int main()
{
double score;
printf("请输入分数：\n");
scanf("%lf",&score);
switch((int)(score/10))//switch((int)score/10)出现严重错误
{
case 10:
case 9:printf("A(最好)\n");break;
case 8:printf("B(优秀)\n");break;
case 7:printf("C(良好)\n");break;
case 6:printf("D(及格)\n");break;
case 5:
case 4:
case 3:
case 2:
case 1:
case 0:printf("E(不及格)\n");break;
default:printf("Error!\n");
}
}
例二：
#include
int main()
{
char rank;
printf("请输入分数等级：(A、B、C、D、E)\n");
scanf("%c",&rank);
switch(rank)//switch((int)score/10)出现严重错误，switch(((int)score)/10)出现严重错误，
{
case 'A':printf("A(90~100)\n");break;
case 'B':printf("B(80~89)\n");break;
case 'C':printf("C(70~79)\n");break;
case 'D':printf("D(60~69)\n");break;
case 'E':printf("E(0~59)\n");break;
default:printf("error!\n");break;
}
}
例三：
输入年月日，判断这一天是这一年的第几天。
#include
int main()
{
int year,month,date,leap,days=0;
scanf("%4d%2d%2d",&year,&month,&date);
leap=(year%4==0&&year%100!=0||year%400==0);
switch(month)
{
case 12:days+=30;
case 11:days+=31;
case 10:days+=30;
case 9:days+=31;
case 8

:days+=31;
case 7:days+=30;
case 6:days+=31;
case 5:days+=30;
case 4:days+=31;
case 3:days+=28+leap;
case 2:days+=31;
case 1:days+=date;break;
}
printf("%4d年%2d月%2d日是这一年的第%d天。\n",year,month,date,days);
}

5:byte
C语言中的一种字符类型
效果等同于 unsigned char型
typedef unsigned char BYTE
定义一种新类型BYTE，它其实就是unsigned char

6:计算机高级编程语言

Java和AS3.0关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
可以修饰的对象:
final 域
final 方法
final 类
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

7:Native Method

简单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数。
"A native method is a Java method whose implementation is provided by non-java code."
在定义一个native method时，并不提供实现体（有些像定义一个java interface），因为其实现体是由非java语言在外面实现的。，下面给了一个示例：
public class IHaveNatives
{
native public void Native1( int x ) ;
native static public long Native2() ;
native synchronized private float Native3( Object o ) ;
native void Native4( int[] ary ) throws Exception ;
}
这些方法的声明描述了一些非java代码在这些java代码里看起来像什么样子（view）.
标识符native可以与所有其它的java标识符连用，但是abstract除外。这是合理的，因为native暗示这些方法是有实现体的，只不过这些实现体是非java的，但是abstract却显然的指明这些方法无实现体。native与其它java标识符连用时，其意义同非Native Method并无差别，比如native static表明这个方法可以在不产生类的实例时直接调用，这非常方便，比如当你想用一个native method去调用一个C的类库时。上面的第三个方法用到了native synchronized，JVM在进入这个方法的实现体之前会执行同步锁机制（就像java的多线程。

）
一个native method方法可以返回任何java类型，包括非基本类型，而且同样可以进行异常控制。这些方法的实现体可以制一个异常并且将其抛出，这一点与java的方法非常相似。当一个native method接收到一些非基本类型时如Object或一个整型数组时，这个方法可以访问这非些基本型的内部，但是这将使这个native方法依赖于你所访问的java类的实现。有一点要牢牢记住：我们可以在一个native method的本地实现中访问所有的java特性，但是这要依赖于你所访问的java特性的实现，而且这样做远远不如在java语言中使用那些特性方便和容易。
native method的存在并不会对其他类调用这些本地方法产生任何影响，实际上调用这些方法的其他类甚至不知道它所调用的是一个本地方法。JVM将控制调用本地方法的所有细节。需要注意当我们将一个本地方法声明为final的情况。用java实现的方法体在被编译时可能会因为内联而产生效率上的提升。但是一个native final方法是否也能获得这样的好处却是值得怀疑的，但是这只是一个代码优化方面的问题，对功能实现没有影响。
如果一个含有本地方法的类被继承，子类会继承这个本地方法并且可以用java语言重写这个方法（这个似乎看起来有些奇怪），同样的如果一个本地方法被final标识，它被继承后不能被重写。
本地方法非常有用，因为它有效地扩充了jvm.事实上，我们所写的java代码已经用到了本地方法，在sun的java的并发（多线程）的机制实现中，许多与操作系统的接触点都用到了本地方法，这使得java程序能够超越java运行时的界限。有了本地方法，java程序可以做任何应用层次的任务。

8:synchronized的4种用法

1.方法声明时使用，放在范围操作符(public等)之后，返回类型声明(void等)之前。即一次只能有一个线程进入该方法，其他线程要想在此时调用该方法，只能排队等候，当前线程（就是在synchronized方法内部的线程）执行完该方法后，别的线程才能进入。
例如：
public synchronized void synMethod() {
//方法体
}
2.对某一代码块使用，synchronized后跟括号，括号里是变量，这样，一次只有一个线程进入该代码块。例如：
public int synMethod(int a1){
synchronized(a1) {
//一次只能有一个线程进入
}
}
3.synchronized后面括号里是一对象，此时，线程获得的是对象锁。例如：
public class MyThread implements Runnable {
public static void main(String args[]) {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt, "t1");
Thread t2 = new Thread(mt, "t2");
Thread t3 = new Thread(mt, "t3");
Thread t4 = new Thread(mt, "t4");
Thread t5 = new Thread(mt, "t5");
Thread t6 = n

ew Thread(mt, "t6");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
public void run() {
synchronized (this) {
System.out.println(Thread.currentThread().getName());
}
}
}
对于3,如果线程进入，则得到对象锁，那么别的线程在该类所有对象上的任何操作都不能进行。在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：
class FineGrainLock {
MyMemberClass x, y;
Object xlock = new Object(), ylock = new Object();
public void foo() {
synchronized(xlock) {
//access x here
}
//do something here - but don‘t use shared resources
synchronized(ylock) {
//access y here
}
}
public void bar() {
synchronized(this) {
//access both x and y here
}
//do something here - but don‘t use shared resources
}
}
4.synchronized后面括号里是类。例如：
class ArrayWithLockOrder{
private static long num_locks = 0;
private long lock_order;
private int[] arr;
public ArrayWithLockOrder(int[] a)
{
arr = a;
synchronized(ArrayWithLockOrder.class) {//-----------------------------------------这里
num_locks++; // 锁数加 1。
lock_order = num_locks; // 为此对象实例设置唯一的 lock_order。
}
}
public long lockOrder()
{
return lock_order;
}
public int[] array()
{
return arr;
}
}
class SomeClass implements Runnable
{
public int sumArrays(ArrayWithLockOrder a1,
ArrayWithLockOrder a2)
{
int value = 0;
ArrayWithLockOrder first = a1; // 保留数组引用的一个
ArrayWithLockOrder last = a2; // 本地副本。
int size = a1.array().length;
if (size == a2.array().length)
{
if (a1.lockOrder() > a2.lockOrder()) // 确定并设置对象的锁定
{ // 顺序。
first = a2;
last = a1;
}
synchronized(first) { // 按正确的顺序锁定对象。
synchronized(last) {
int[] arr1 = a1.array();
int[] arr2 = a2.array();
for (int i=0; i value += arr1[i] + arr2[i];
}
}
}
return value;
}
public void run() {
//...
}
}
对于4,如果线程进入，则线程在该类中所有操作不能进行，包括静态变量和静态方法，实际上，对于含有静态方法和静态变量的代码块的同步，我们通常用4来加锁。
以上4种之间的关系：
锁是和对象相关联的，每个对象有一把锁，为了执行synchronized语句，线程必须能够获得synchronized语句中表达式指定的对象的锁，一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁，线程在执行完synchronized语句后，将获得锁交还给对象。
在方法前面加

上synchronized修饰符即可以将一个方法声明为同步化方法。同步化方法在执行之前获得一个锁。如果这是一个类方法，那么获得的锁是和声明方法的类相关的Class类对象的锁。如果这是一个实例方法，那么此锁是this对象的锁。synchronzied块后面跟类的具体详细例子、public class DB2_JDBCFactory {private static DB2_JDBCFactory instance = null; public static final ThreadLocal threadLocal = new ThreadLocal(); private DB2_JDBCFactory() {
} public static DB2_JDBCFactory getInstance() {
if(instance == null) {
synchronized(DB2_JDBCFactory.class) { //synchronized后面跟一个类
instance = new DB2_JDBCFactory();
}
}
return instance;
} public Connection getConnection_JNDI_localhost(){
Connection c = (Connection) threadLocal.get();
try {
if (c == null || c.isClosed()) {
InitialContext ctx = new InitialContext();
DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/localhost");
c = ds.getConnection();
threadLocal.set(c);
}
} catch (Exception ex) {
System.err.println("getConnection_JNDI Initial failed. " + ex);
return null;
}
return c;
}}外面的对象访问这个类的需要通过调用它的getInstance()

9:JAVA中的finally语句块

finally在异常处理时提供finally块来执行所有清除操作。主要与try-catch-finally配合使用。
finally语句块的作用是无论出现什么情况，finally块中的语句一定会被执行，并且是在return之前执行。根据JAVA规范，如果try-finally或者catch-finally中都有return，则2个return都执行并最终返回调用者那里的是finally中的return，如果finally中没有return则返回的是catch中的return，但是finally中的代码也是要执行的。

10:float CSS属性

float为CSS中指定对象是否及如何浮动的属性。
以往这个属性总应用于图像，使文本围绕在图像周围，不过在 CSS 中，任何元素都可以浮动。浮动元素会生成一个块级元素，而不论它本身是何种元素。元素对象设置了float属性之后，它将不再独自占据一行。浮动块可以向左或向右移动，直到它的外边缘碰到包含它的框或另一个浮动块的边框为止。
float属性有四个可用的值：Left 和Right 分别浮动元素到各自的方向，None (默认的) 使元素不浮动，Inherit 将会从父级元素获取float值。

11:package:假设我们在d盘下的新建一个文件夹（pack1），在pack1文件夹内包含两个java程序一个是Showmethod.java和Testshow.java；
Showmethod.java
package pack1;//在这里把Showmethod类纳入到pack1包内
class Showmethod{
public void show(){
System.out.println("I'm a show method() of Showmethod class");
}
}
Testshow.java；
package pack1;//在这里把Testshow类也纳入到pack1包内
public class Testsh

ow{
public static void main(String args[]){
Showmethod sm=new Showmethod();
sm.show();
}
}
下面我们就先来看一下如何编译这两个位于同一个包内的java程序，
1:javac pack1\Showmethod.java
2:javac pack1\Testshow.java
这就是编译的方法　pack1是包名，包名后面跟的就是我们要编译的那个类名，编译好后pack1目录下会生成两个class文件，
运行方法：
java pack1.Testshow
注意运行时要指出包名，包名后有一个点"．"然后是类名，
例二
下面我们来看一下如何访问不在同一个包内的类，
在D盘分别建立pack1,pack2两个文件，
建立好之后将Showmethod.java放到pack1包内，
Showmethod.java的代码如下：
package pack1;
public class Showmethod{
public void show(){
System.out.println("I'm a show method() of Showmethod class");
}
}
将Testshow.java放到pack2包内
Testshow.java的代码如下：
package pack2;
public class Testshow{
public static void main(String args[]){
pack1.Showmethod sm=new pack1.Showmethod();
sm.show();
}
}由于此类需要调用位于pack1包中的Showmethod类的show方法，所以这里pack1.Showmethod sm=new pack1.Showmethod();这样写，我们还可以使用import 语句将pack1包内的Showmethod方法导入进来，这样这个地方pack1.Showmethod sm=new pack1.Showmethod();我们就可以这样写了Showmethod sm=new Showmethod（）；对于import我们下一范例进行说明，
还有一点我们必须注意，在访问不同　package里的类时，被访问的类必须被声明为public（就是公有类型的），否则在编译会报告错误，
编译方法"
1javac pack1\Showmethod.java
2: javac pack2\Testshow.java
编译好之后pack1,pack2目录下会分别产生一个．class文件，
运行方法：
java pack2.Testshow
使用import导入package；

12:Throw 声明
throw 声明的作用是创建 exception（异常）。你可以把这个声明与 try...catch 声明配合使用，以达到控制程序流并产生精确错误消息的目的。
语法：
throw(exception)exception 可以是字符串、整数、逻辑值或者对象。
注意：使用小写字母编写 throw。使用大写字母会出错！
用于描述错误信息可与Try、Catch配合声明。

13:classMATLAB中的class简介

class具有类型的意思。matlab中class可以返回一个表征变量类型的字符串。在matlab的命令窗口中输入doc class或者help class就可以获得相关帮助信息。
浮点型：single、double
整型：int8, uint8, int16, uint16,int32, uint32,int64,uint64
字符型：char
逻辑型：logical
元胞数组：cell
函数句柄：

function_handle
结构体：struct
程序示例
clc
clear
result = sum(single([2 5 8]))
class(result)
输出：single

14:protected关键字 (Java)

protected 表明被它修饰的成员变量为保护类型，在同一个包里和 public 类型是一样的，也是能够访问到的。但是如果在不同包里的 protected 类型的成员变量就只能通过子类来访问，这个修饰符是区别于其他的修饰符的。
示例
package a;
class door {
protected String color ;
protected void openDoor()
{
System.out.println("protected 类型的成员变量，只能在不同包外的子类访问到！");
}
}
public class wood_Door extends door {
public static void main(String[] args)
{
wood_Door wd = new wood_Door ();
wd.openDoor();
}
}
代码解析：
door 的成员变量方法 openDoor 修饰为 protected 类型，只能通过在不同包下的子类来访问。如果 wood_Door 在同一个包下，那么和 public 类型是一样的了。如果其他类要访问 door 的方法，方法 openDoor 是访问不到的，因为对其他类而言相当于 private 类型的。
JAVA语言public、protected和private的区别
（1）在java中有public、protected、private、package-private（无修饰符）四种访问级别
（2）在子类中的方法如果重载了父类的方法，那么该方法的可见级别应更高或者相同，如父类中的方法是protected，那么子类中方法可以是public，但不能是private。
（3）在java中，一般来说，变量成员最好是private，对它们的访问可以通过public的方法，在这些方法中可以做些控制以保证数据的一致性。这些方法名一般以get和set做为前缀。

16:Public 语句声明的变量在所有应用程序的所有没有使用OptionPrivate Module 的模块的任何过程中都是可用的；若该模块使用了 OptionPrivate Module，则该变量只是在其所属工程中是公用的。
小心不能在类模块中使用Public 语句来声明一个定长的字符串变量。
使用Public 语句可以声明变量的数据类型。例如，下面的语句声明了一个 Integer 类型的变量。
Public NumberOfEmployees As Integer 也可以使用Public 语句来声明变量的对象类型。下面的语句为工作表的新实例声明了一个变量。
Public X As New Worksheet 如果在定义对象变量时没有使用New 关键字，则在使用该变量之前，必须使用 Set 语句将一个已有的对象赋给这个引用对象的变量。在被赋值之前，所声明的这个对象变量有一个特定值 Nothing，这个值表示该变量没有指向任何对象的实例。
可以用带空圆括号的Public 语句来声明动态数组。在声明了动态数组之后，可以在过

程内用 ReDim 语句来定义该数组的维数和元素。如果试图在 Private、Public 或 Dim 语句中重定义一个已被显式定义了大小的数组的维数，就会发生错误。
如果不指定数据类型或对象类型，且在模块中没有使用Deftype 语句，则按缺省情况该变量为 Variant 类型。
当初始化变量时，数值变量被初始化为 0，变长的字符串被初始化为一个零长度的字符串 ("")，而定长的字符串则用 0 填充。Variant 变量被初始化为 Empty。用户自定义类型的变量的每个元素都作为各自独立的变量进行初始化。
Public 语句示例
该示例在标准模块的模块级（通用部分）使用Public 语句，来显式声明公用的变量，指如果没有使用 Option Private Module，则在所有应用程序的所有模块的所有过程中都可以使用的变量。
Public Number As Integer '公用的整数变量。
Public NameArray(1 To 5) As String '公用的字符串数组变量。
'多个声明，两个变体型变量，以及一个整数型变量，都是公用的。
Public MyVar, YourVar, ThisVar As Integer
附加说明
public在程序语言中基本都表示全局变量或者全局函数，他的本意是“公共的”的意思，他表示某个变量或者函数是全局函数，例如:public int a 表示a这个整型变量是全局变量，再例如，声明一个全局函数：
public function checked()
........
end function
表示checked这个函数是全局函数

17:private编程应用

Private 语句在模块级别中使用，用于声明私有变量及分配存储空间。
语法Private [WithEvents] varname[([subscripts])] [As [New] type] [,[WithEvents] varname[([subscripts])] [As [New] type]] . . .
Private 语句的语法包含下面部分：
WithEvents，可选的。关键字，说明 varname 是用来响应由 ActiveX 对象所触发的事件的对象变量。只有在类模块中才是合法的。使用 WithEvents，可以定义任意个所需的单变量，但不能用 WithEvents 创建数组。New 和 WithEvents 不能一起使用。
varname必需的。变量的名称；遵循标准的变量命名约定。
subscripts可选的。数组变量的维数；最多可以定义 60 维的多维数组。subscripts 参数的使用语法如下： [lower To] upper [,[lower To] upper] . . . 如果不显式指定 lower，则数组的下界由 Option Base 语句控制。如果没有 Option Base 语句则下界为 0。
New可选的。使其可以隐式地创建对象的关键字。如果使用 New 声明对象变量，则在第一次引用该变量时创建该对象的新实例，因此不必使用 Set 语句来对该对象引用赋值。New 关键字不能声明任何内部数据类型的变量以及从属对象的实例，也不能与 WithEvents 一起使用。
type可选的。变

量的数据类型；可以是 Byte、Boolean、Integer、Long、Currency、Single、Double、Decimal（目前尚不支持）、Date、String（对可变长的字符串）、String * length（对定长的字符串）、Object、Variant、用户定义类型或对象类型。所声明的每个变量都要一个单独的 As type 子句。
说明：Private 变量只能在包含其声明的模块中使用。可以使用 Private 语句声明变量的数据类型。例如，下面的语句声明了一个 Integer 类型的变量：“Private NumberOfEmployees As Integer”　也可以使用 Private 语句来声明变量的对象类型。
下面的语句为工作表的新实例声明了一个变量。Private X As New Worksheet如果在定义对象变量时没有使用 New 关键字，则在使用该变量之前，必须使用 Set 语句将一个已有的对象赋给该引用对象的变量。
在赋值之前，所声明的这个对象变量有一个特定值 Nothing，这个值表示该变量没有指向任何对象的实例。如果不指定数据类型或对象类型，且在模块中没有使用 Deftype 语句，则按缺省情况该变量为 Variant 类型。可以用带空圆括号的 Private 语句来声明动态数组，然后可以在过程内用 ReDim 语句来定义该数组的维数和元素。如果试图在 Private，Public 或 Dim 语句中重新定义一个已显式定义了大小的数组的维数，就会发生错误。当初始化变量时，数值变量被初始化为 0，变长的字符串被初始化为一个零长度的字符串 ("")，而定长的字符串则用 0 填充。Variant 变量被初始化为 Empty。用户自定义类型的变量的每个元素作为各自独立的变量进行初始化。注意当在过程中使用 Private 语句时，通常将 Private 语句放在过程的开始。
区分：private，空，protected，public 权限
使用private修饰符可以完全隐藏类的成员，使得不能从类外直接访问它们。
不使用修饰符允许同一个包里的任何类直接访问类的成员，但是其他包中的类不可以。
使用protected修饰符允许任何包中的子类或同一包的类的成员。
使用public修饰符允许任何类访问类的成员。

18:char是C/C++整型数据中比较古怪的一个，其它的如int/long/short等不指定signed/unsigned时都默认是signed，但char在标准中是unsigned，编译器可以实现为带符号的，也可以实现为不带符号的，有些编译器如pSOS的编译器，还可以通过编译开关来指定它是有符号数还是无符号数。

19:
Java语言中的for语句格式

Java语言
Java的for语句形式有两种：一种是和C语言中的for语句形式一样，另一种形式用于在集合和数组之中进行迭代。有时候把这种形式称为增强的for(enhanced for)语句，它可以使循环更加紧凑和容易阅读。

示例
为了演示，参考下面的数组，它保存数字1到10：
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
下面的程序EnhancedForDemo使用增强for循环遍历这个数组：
class EnhancedForDemo{
public static void main(String[] args){
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
for(int item:numbers){
System.out.println("Count is:" + item);
}
}
}
在这个例子中，变量item保存从数字数组获得的当前值。这个程序的输出和当前一个程序相同：
Count is ：1
Count is ：2
Count is ：3
Count is ：4
Count is ：5
Count is ：6
Count is ：7
Count is ：8
Count is ：9
Count is ：10
建议在情况允许的条件下，使用for语句的这种形式，而不使用其一般形式。

20:throws
1、throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。如下面例子所示：
public class Shoot { 创建类
static void pop() throws NegativeArraySizeException {
//定义方法并抛出NegativeArraySizeException异常
int [] arr = new int[-3];//创建数组
}
public static void main(String[] args) {//主方法
try {
pop(); //调用pop()方法
} catch (NegativeArraySizeException e) {
System.out.println("pop()方法抛出的异常");//输出异常信息
}
}
}

2、throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要跑出的异常；如果要捕捉throw抛出的异常，则必须使用try—catch语句。举例如下：
class MyException extends Exception { //创建自定义异常类
String message; //定义String类型变量
public MyException(String ErrorMessagr) { //父类方法
message = ErrorMessagr;
}
public String getMessage(){ //覆盖getMessage()方法
return message;
}
}
public class Captor { //创建类
static int quotient(int x,int y) throws MyException{//定义方法抛出异常
if(y < 0){ //判断参数是否小于0
throw new MyException("除数不能是负数");//异常信息
}
return x/y;//返回值
}
public static void main(String args[]){ //主方法
try{ //try语句包含可能发生异常的语句
int result = quotient(3,-1);//调用方法quotient()
}catch (MyException e) { //处理自定义异常
System.out.println(e.getMessage()); //输出异常信息
}
catch (ArithmeticException e) {
//处理ArithmeticException异常
System.out.println("除数不能为0");//输出提示信息
}

catch (Exception e) { //处理其他异常
System.out.println("程序发生了其他的异常");
//输出提示信息
}
}
}

21:C/Java/AS中
if 语句的3种形式
1. if(表达式）语句　(单分支if语句)
#include
int main()
{int x=1;
int y=2;
if(x fflush(stdin);
getchar();
}
2 if(表达式）语句1 else 语句2 (双分支if语句)
#include
int main()
{int x=1;int y=2;
if(x>y) printf("%d",x);
else printf("%d",y);
fflush(stdin);
getchar();
}
3 if(表达式1）语句1
else if (表达式2）语句2
else if （表达式3) 语句3
……
else if （语句m) 语句
else 语句n (if的嵌套)
#include
int main()
{
int a,c;
char b;
scanf("%d%c%d",&a,&b,&c);
if(b=='+')printf("=%d",a+c);
else if (b=='-')printf("=%d",a-c);
else if (b=='*')printf("=%d",a*c);
else if (b=='/')printf("=%d",a/c);
fflush(stdin);
getchar();
}

22:　java try组合
名称：try
解释：监视，考验，审问
用法：try块用来监视所有又可能发生异常的代码，它可以和catch块组合，也可以和final块组合，也可以和catch块，final块一起组合使用。
例子：
public class Test{
public static void main(String[] args){
int i = 10;
try{
System.out.println(i/0);
}
catch(ArithmeticException ame){
ame. printStackTrace();
}
}
}

23:continue

C、Java，MATLAB语言中，continue语句一般形式为"continue;"
其作用为结束本次循环。即跳出循环体中下面尚未执行的语句，对于while循环，继续求解循环条件。而对于for循环程序流程接着求解for语句头中的第三个部分expression表达式。　continue语句和break语句的区别是：
continue语句只结束本次循环，而不终止整个循环的执行。而break语句则是结束整个循环过程，不再判断执行循环的条件是否成立。
continue语句的作用是跳过循环本中剩余的语句，并到循环末尾。
continue语句只用在for、while、do-while等循环体中, 常与if条件语句一起使用, 用来加速循环。
示例(C语言)
　#include
int main()
{
int n;
for(n=1;n<=10;n++)
{
if(n%3==0)
continue;
printf("%d\t",n);
}
}
//其作用是:结束本次循环,即跳过循环体下面尚未执行的语句,接着进行下一次是否执行循环的判断.
输出结果
1 2 4 5 7 8 10

24:　implements是一个类实现一个接口用的关键字，它是用来实现接口中定义的抽象方法。

还有几点需要注意：
(1)接口可以被多重implements,抽象类只能被单一extends
(2)接口只有定义,抽象类可以有定义和实现
(3)接口的字段定义默认为:public static final, 抽象类字段默认是"friendly"(本包可见)
详解
比如：people是一个接口，他里面有say这个方法。public interface people(){ public void say();}但是接口没有方法体。只能通过一个具体的类去实现其中的方法体。比如chinese这个类，就实现了people这个接口。
public class chinese implements people{ public void say() {System.out.println("你好！");}}
在java中extends表示子类继承父类，如类A继承类B写成
class A extends B
{
//.....
}
implements 的意思更接近“实现”比如实现一个接口的方法。
编辑本段
与Extends的区别

extends，可以实现父类，也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。这样的好处就是：架构师定义好接口，让工程师实现就可以了。整个项目开发效率得到提高，且开发成本大大降低。
implements，实现父类，子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数，也会被父类取代掉。
这两种实现的具体使用，是要看项目的实际情况，需要实现，不可以修改implements，只定义接口需要具体实现，或者可以被修改扩展性好，用extends。

25: 关于C语言中return的一些总结

return是C++预定义的语句，它提供了种植函数执行的一种放大。当return语句提供了一个值时，这个值就成为函数的返回值.
说到return,有必要提及主函数的定义,下面是从网络上找到的资料,好好消化吧,对了解主函数中返回值的理解有很大的帮助.
很多人甚至市面上的一些书籍，都使用了void main( ) ，其实这是错误的。C/C++ 中从来没有定义过void main( ) 。C++ 之父 Bjarne Stroustrup 在他的主页上的 FAQ 中明确地写着 The definition void main( ) { /* ... */ } is not and never has been C++, nor has it even been C.（ void main( ) 从来就不存在于 C++ 或者 C ）。下面我分别说一下 C 和 C++ 标准中对 main 函数的定义。
1. C
在 C89 中，main( ) 是可以接受的。Brian W. Kernighan 和 Dennis M. Ritchie 的经典巨著 The C programming Language 2e（《C 程序设计语言第二版》）用的就是 main( )。不过在最新的 C99 标准中，只有以下两种定义方式是正确的：
int main( void )
int main( int argc, char *argv[] )
（参考资料：ISO/IEC 9899:1999 (E) Programming languages — C 5.1.2.2.1 Program startup）
当然，我们也可以做一点小小的改动。例如：char *argv[] 可以写成 char **argv；argv 和 argc 可以改

成别的变量名（如 intval 和 charval），不过一定要符合变量的命名规则。
如果不需要从命令行中获取参数，请用int main(void) ；否则请用int main( int argc, char *argv[] ) 。
main 函数的返回值类型必须是 int ，这样返回值才能传递给程序的激活者（如操作系统）。
如果 main 函数的最后没有写 return 语句的话，C99 规定编译器要自动在生成的目标文件中（如 exe 文件）加入return 0; ，表示程序正常退出。不过，我还是建议你最好在main函数的最后加上return 语句，虽然没有这个必要，但这是一个好的习惯。注意，vc6不会在目标文件中加入return 0; ，大概是因为 vc6 是 98 年的产品，所以才不支持这个特性。现在明白我为什么建议你最好加上 return 语句了吧！不过，gcc3.2（Linux 下的 C 编译器）会在生成的目标文件中加入 return 0; 。
2. C++
C++98 中定义了如下两种 main 函数的定义方式：
int main( )
int main( int argc, char *argv[] )
（参考资料：ISO/IEC 14882(1998-9-01)Programming languages — C++ 3.6 Start and termination）
int main( ) 等同于 C99 中的 int main( void ) ；int main( int argc, char *argv[] ) 的用法也和 C99 中定义的一样。同样，main 函数的返回值类型也必须是int。如果main函数的末尾没写return语句，C++98 规定编译器要自动在生成的目标文件中加入 return 0; 。同样，vc6 也不支持这个特性，但是 g++3.2（Linux 下的 C++ 编译器）支持。
3. 关于 void main
在 C 和 C++ 中，不接收任何参数也不返回任何信息的函数原型为“void foo(void);”。可能正是因为这个，所以很多人都误认为如果不需要程序返回值时可以把main函数定义成void main(void) 。然而这是错误的！main 函数的返回值应该定义为 int 类型，C 和 C++ 标准中都是这样规定的。虽然在一些编译器中，void main 可以通过编译（如 vc6），但并非所有编译器都支持 void main ，因为标准中从来没有定义过 void main 。g++3.2 中如果 main 函数的返回值不是 int 类型，就根本通不过编译。而 gcc3.2 则会发出警告。所以，如果你想你的程序拥有很好的可移植性，请一定要用 int main 。
4. 返回值的作用
main 函数的返回值用于说明程序的退出状态。如果返回 0，则代表程序正常退出，否则代表程序异常退出。下面我们在 winxp 环境下做一个小实验。首先编译下面的程序：
int main( void )
{
return 0;
}
然后打开附件里的“命令提示符”，在命令行里运行刚才编译好的可执行文件，然后输入“echo %ERRORLEVEL%”，回车，就可以看到程序的返回值为 0 。假设刚才编译好的文件是 a.exe ，如果输入“a && dir”，则会列出

当前目录下的文件夹和文件。但是如果改成“return -1”，或者别的非 0 值，重新编译后输入“a && dir”，则 dir 不会执行。因为 && 的含义是：如果 && 前面的程序正常退出，则继续执行 && 后面的程序，否则不执行。也就是说，利用程序的返回值，我们可以控制要不要执行下一个程序。这就是 int main 的好处。如果你有兴趣，也可以把 main 函数的返回值类型改成非 int 类型（如 float），重新编译后执行“a && dir”，看看会出现什么情况，想想为什么会出现那样的情况。顺便提一下，如果输入 a || dir 的话，则表示如果 a 异常退出，则执行 dir 。
5. 那么 int main(intargc,char*argv[],char*envp[])呢？
这当然也不是标准 C 里面定义的东西！char*envp[] 是某些编译器提供的扩展功能，用于获取系统的环境变量。因为不是标准，所以并非所有编译器都支持，故而移植性差，不推荐使用。
到了这里,你应该了解为什么主函数定义为 int返回类型,而且函数体里面有return 0;这个语句了吧.
下面具体说说我对return的应用的理解。
只要一个函数的返回值是数字型的,那么就可以返回0(即return 0),其实你返回多少都没问题。一般情况下，C++做出来的函数都要求返回一个值，当函数执行正常，且达到了一般情况下的目的，那么就返回0表示正确的调用了该函数，这个0就是返回给主调函数以通知没有出错的；如果函数调用中出错，或者没有按照一般情况执行，那么就返回1，以告知主调函数采取响应策略；如果你在某个函数所在类的定义所在的头文件中定义了一组状态值（一般都是负整数），那么函数就可以返回不同的值以告之主调函数具体发生了什么异常或错误，这种情况一般用于函数功能独立性较差的的情况。所以一般不鼓励把函数返回类型定义为void，至少返回应该是int，而在函数的最后加上return 0.语句：
int func(参数列表)
{
……
……
……
Return 0;
}
在函数中，如果碰到return 语句，那么程序就会返回调用该函数的下一条语句执行，也就是说跳出函数的执行，回到原来的地方继续执行下去。但是如果是在主函数中碰到return语句，那么整个程序就会停止，退出程序的执行。
如果你定义一个函数有返回类型，可以想下面那样调用：
int func()
{
int value;
……
……
……
return value;
}
int main()
{
int intvalue;
intvalue=func();
……
……
return 0;
}
return语句后面具体是什么内容，这就要具体情况具体分析了：
（1）在返回类型是char的函数

中，return后应该是char类型的值；
（2）在返回类型是int的函数中，如果是要停止函数的调用，最好应该为0；其他的按照你的目的而定，只要是int 类型就行了
（3）在返回类型是结构类型的函数中，return后应该是结构的一个实例对象。
总之，函数定义为什么样的返回类型，该函数中return后就应该是相应类型的值。

26:void含义

void的字面意思是“无类型”，void *则为“无类型指针”，void *可以指向任何类型的数据。
void几乎只有“注释”和限制程序的作用，定义一个void变量没有意义，不妨试着定义：
void a;
这行语句编译时会出错，提示“illegal use of type 'void'”。不过，即使void a的编译不会出错，它也没有任何实际意义。
void真正发挥的作用在于：
（1）对函数返回的限定；
（2）对函数参数的限定。
众所周知，如果指针p1和p2的类型相同，那么我们可以直接在p1和p2间互相赋值；如果p1和p2指向不同的数据类型，则必须使用强制类型转换运算符把赋值运算符右边的指针类型转换为左边指针的类型。
例如：
float*p1;
int *p2;
p1 = p2;
其中p1 = p2语句会编译出错，提示“'=' : cannot convert from 'int *' to 'float *'”，必须改为：
p1 = (float *)p2;
而void *则不同，任何类型的指针都可以直接赋值给它，无需进行强制类型转换：
void *p1;
int *p2;
p1 = p2;
但这并不意味着，void *也可以无需强制类型转换地赋给其它类型的指针。因为“无类型”可以包容“有类型”，而“有类型”则不能包容“无类型”。道理很简单，我们可以说“男人和女人都是人”，但不能说“人是男人”或者“人是女人”。下面语句编译出错：
void *p1;
int *p2;
p2 = p1;
提示“'=' : cannot convert from 'void *' to 'int *'”。
编辑本段
void的使用

下面给出void关键字的使用规则：
规则一
如果函数没有返回值，那么应声明为void类型
在C语言中，凡不加返回值类型限定的函数，就会被编译器作为返回整型值处理。但是许多程序员却误以为其为void类型。例如：
add ( int a, int b )
{
returna + b;
}
int main(int argc, char* argv[])
{
printf ( "2 + 3 = %d", add ( 2, 3) );
}
程序运行的结果为输出：
2 + 3 = 5
这说明不加返回值说明的函数的确为int函数。
林锐博士《高质量C/C++编程》中提到：“C++语言有很严格的类型安全检查，不允许上述情况（指函数不加类型声明）发生”。可是编译器并不一定这么认定，譬如在Visual C++6.0

中上述add函数的编译无错也无警告且运行正确，所以不能寄希望于编译器会做严格的类型检查。
因此，为了避免混乱，在编写C/C++程序时，对于任何函数都必须一个不漏地指定其类型。如果函数没有返回值，一定要声明为void类型。这既是程序良好可读性的需要，也是编程规范性的要求。另外，加上void类型声明后，也可以发挥代码的“自注释”作用。代码的“自注释”即代码能自己注释自己。
规则二
如果函数无参数,那么应声明其参数为void。
在C++语言中声明一个这样的函数：
int function(void)
{
return 1;
}
则进行下面的调用是不合法的：
function(2);
因为在C++中，函数参数为void的意思是这个函数不接受任何参数。
在Turbo C 2.0中编译：
#include "stdio.h"
fun()
{
return 1;
}
main()
{
printf("%d",fun(2));
getchar();
}
编译正确且输出1，这说明，在C语言中，可以给无参数的函数传送任意类型的参数，但是在C++编译器中编译同样的代码则会出错。在C++中，不能向无参数的函数传送任何参数，出错提示“'fun' : function does not take 1 parameters”。
所以，无论在C还是C++中，若函数不接受任何参数，一定要指明参数为void。
规则三
小心使用void指针类型
按照ANSI(American National Standards Institute)标准，不能对void指针进行算法操作，即下列操作都是不合法的：
void * pvoid;
pvoid++; //ANSI：错误
pvoid += 1; //ANSI：错误
//ANSI标准之所以这样认定，是因为它坚持：进行算法操作的指针必须是确定知道其指向数据类型大小的。
//例如：
int *pint;
pint++; //ANSI：正确
pint++的结果是使其增大sizeof(int)。( 在VC6.0上测试是sizeof(int)的倍数)
但是大名鼎鼎的GNU(GNU's Not Unix的缩写)则不这么认定，它指定void *的算法操作与char *一致。
因此下列语句在GNU编译器中皆正确：
pvoid++; //GNU：正确
pvoid += 1; //GNU：正确
pvoid++的执行结果是其增大了1。( 在VC6.0上测试是sizeof(int)的倍数)
在实际的程序设计中，为迎合ANSI标准，并提高程序的可移植性，我们可以这样编写实现同样功能的代码：
void * pvoid;
(char *)pvoid++; //ANSI：正确；GNU：正确
(char *)pvoid += 1; //ANSI：错误；GNU：正确
GNU和ANSI还有一些区别，总体而言，GNU较ANSI更“开放”，提供了对更多语法的支持。但是我们在真实设计时，还是应该尽可能地迎合ANSI标准。
规则四
如果函数的参数可以是任意类型指针，那么应声明其参数为void *
典型的

如内存操作函数memcpy和memset的函数原型分别为：
void * memcpy(void *dest, const void *src, size_tlen);
void * memset ( void * buffer, int c, size_t num );
这样，任何类型的指针都可以传入memcpy和memset中，这也真实地体现了内存操作函数的意义，因为它操作的对象仅仅是一片内存，而不论这片内存是什么类型。如果memcpy和memset的参数类型不是void *，而是char *，那才叫真的奇怪了！这样的memcpy和memset明显不是一个“纯粹的，脱离低级趣味的”函数！
下面的代码执行正确：
//示例：memset接受任意类型指针
int intarray[100];
memset ( intarray, 0, 100*sizeof(int) ); //将intarray清0
//示例：memcpy接受任意类型指针
int intarray1[100], intarray2[100];
memcpy ( intarray1, intarray2, 100*sizeof(int) ); //将intarray2拷贝给intarray1
有趣的是，memcpy和memset函数返回的也是void *类型，标准库函数的编写者是多么地富有学问啊！
规则五
void不能代表一个真实的变量
下面代码都企图让void代表一个真实的变量，因此都是错误的代码：
void a; //错误
function(void a); //错误
void体现了一种抽象，这个世界上的变量都是“有类型”。
void的出现只是为了一种抽象的需要，如果你正确地理解了面向对象中“抽象基类”的概念，也很容易理解void数据类型。正如不能给抽象基类定义一个实例，我们也不能定义一个void（让我们类比的称void为“抽象数据类型”）变量。
编辑本段
总结

小小的void蕴藏着很丰富的设计哲学，作为一名程序设计人员，对问题进行深一个层次的思考必然使我们受益匪浅。
不论什么类型的指针(void*, char*, int*, float*...)在Debug模式编译时，默认初始值都是0xCCCCCCCC（是由编译器决定的，主要目的是为了添加调试的辅助代码用于及时发现错误），在Release模式编译，则是不是确定的值。
#include
#include
//#include
void main()
{
void *p1;
int a = 10;
int *p2 = &a;
cout << p1 << endl;
cout << (int)*p2 << endl;
p1 = p2;
cout << *(int*)p1 << endl;//!!!!!!! 用空类型操作输出值！
cout << (int)*p2 << endl;
}
/* 输出：
0xCCCCCCCC
10
10
10
*/
在声明同时赋值NULL，在delete后立即设置为NULL。
在debug版本下指针默认初始值为0xCCCCCCCC，在Release版本下初始值为0x0000000A，（在我电脑上VC6.0）。对于指针如果暂时没有合适的初始化值，就应该把它置为NULL（0）。
对于好的编程习惯来说，declare一个指针，则初始化为NULL，如果是类成员则在构造函数