1.if条件语句：

一个if语句由保留字if、布尔表达式和位于其后的语句构成，其基本语法如下：
if(表达式){方法体}else if(表达式){方法体}else{方法体}
下面用代码演示。
if (a > 3)
条件成功的方法体
语法解释：
if语句的执行条件是，当表达式值为true时，执行方法体的部分。
如果表达式值为false，执行else if的部分或else部分的方法体。

if语句的用法有好几种，下面列举if语句的几种形式。
简写形式：if ...
一般形式：if ... else
完整形式：if ... else if ... else

 例1：

public class Test
{
	public static void main(String args[])
	{
		int n = 7;
		if (n > 3)
			System.out.println("variable n > 3");
	}
}

例2：

public class Test01
{
	public static void main(String args[])
	{
		int i = 3;
		if (i > 5)
		{
			System.out.println("variable i > 5");
		}
		else if (i > 4)
		{
			System.out.println("variable i < 4");
		}
		else
		{
			System.out.println("others");
		}
	}
	
}

2.switch语句：

switch语句和if-else-if语句相似，但是switch要比if-else-if语句要优越，它是根据条件表达式的值来判断执行的程序语句。

switch分支语句要比if语句复杂得多。但当判断的条件很多时，switch分支语句要比if语句要方便很多。

switch分支语句的表达式的使用有一定的条件，不是什么类型都能使用的。一般能使用的条件是具体的整型数值和一些有顺序的数列。也就是switch表达式中只能是整数类型和有顺序的数列。

例1：

public class Test02
{
	public static void main(String args[])
	{
		int i = 3;
		char c = 4;

		switch(i)
		{
		case 3:
		{
			System.out.println("The executive branch is case 3 branch");
			break;	
		}
		default:
			System.out.println("other branch");
		}

		switch (c)
		{
		case 4:
			System.out.println("The executive branch is case 4 branch");
			break;	
		default:
			System.out.println("others branch");
		}
	}
}

 例2：

//定义一个枚举类型
enum testEnum{one, two, three, four}
//测试Switch分支语句
public class testSwitch3
{
	public static void main(String args[])
	{	
		//switch分支语句，表达式为一个枚举类型
		switch(testEnum.two)
		{
			//具体的条件分支
			case one:
			{
				System.out.println("所执行的分支是case one分支");
				break;
			}
			case two:
			{
				System.out.println("所执行的分支是case two分支");
				break;
			}
			case three:
			{
				System.out.println("所执行的分支是case three分支");
				break;
			}
			case four:
			{
				System.out.println("所执行的分支是case four分支");
				break;
			}
			default:
				System.out.println("其他分支语句");
		}
	}
}

3.while循环语句：

while循环时Java中的一种循环形式，就是先进行判断再进行循环的语句。通过判断表达式的值，来决定具体的循环次数。下面先介绍while循环语句的语法并举例说明。

所谓do...while循环语句，就是先进行循环，再进行表达式的判断，如果表达式不成立就退出循环。有时候即使表达式的值为假，也需要执行一遍循环体的内容，这时就需要使用到do…while循环。下面先介绍do...while循环语句的语法并举例说明。

例1：

public class testWhile
{
	public static void main(String args[])
	{
		int i = 0;
		//当整型i小于3的时候结果循环
		while (i < 3)
		{
			System.out.println(i);
			//每次递增整型变量i,在下次循环的时候进行判断.
		i++;
		}
	}
}

例2：

//testWhile2类,所描述的是一个9*9乘法表
public class testWhile2
{
	public static void main(String args[])
	{
		//定义整型变量
		int i = 9; 
		int j = 9; 
		//当变量i大于或等于1的时候执行循环
		while(i >= 1)
		{ 
			while((j <= i) && (j > 0))
			{ 
				System.out.print(i + "*" + j + "=" + j * j +" "); 
				j--; 
			} 
			System.out.println(" "); 
			i--; 
			//把每次循环后的j值赋值给i
			j = i; 
		} 
	}
}

4.for循环语句：

所谓for循环语句，就是明确了循环的次数，再进行循环的。如果已经知道需要执行语句块的次数，就需要使用for循环。下面先介绍for循环语句的语法并举例说明。

for循环语句通过判断表达式的成立与否，来决定循环的次数。其基本语法如下：
for(变量初始化，表达式，循环表达式)
{
方法体
}

例1:9*9乘法表格：

//testFor2类,所描述的是一个9*9乘法表
public class testFor2
{
	public static void main(String args[])
	{
		for (int i = 1; i < 10; i++)
		{
			for (int j = 1; j < 10; j++)
			{
				if (j <= i)
				{
					System.out.print(i + "*" + j + "=" + (i * j) + " ");
				}
			}
			System.out.println(" ");
		}
	}
}

例2：下面介绍for循环语句的其他用法，并解释其含义。
【代码解析】本程序使用到了多个for循环，读者应该非常细心地分析该程序，分清每一个for循环的作用。对该程序全面了解后，就可以自己来编写一个输出倒三角的程序。如果读者能够写出这个程序，证明已经把for循环彻底掌握了。

public class testFor3
{
	public static void main(String args[])
	{
		int i;
		int j;
		int input = 10;
		System.out.println("正三角：");
		for (i = 1; i <= input; i++)
		{
			for (j = i; j < input; j++) 
		  	{
				System.out.print(" ");
		 	}
		  	//打印左半边三角
	    		for (j = i; j >= 1; j--) 
	    		{
	    			if (j >= 10)
	    				System.out.print("*");//大于9的数字用*符号表示
				else
				  	System.out.print(j);//如果要全部打印*号，此处将j用"*"代替，下边程序做相同改动。
		  	}
			//打印右半边三角
		  	for (j = 2; j <= i; j++) 
		  	{
		  		if (j >= 10)
		  			System.out.print("*");
				else
					System.out.print(j);
		  	}
		  	System.out.println();
		}
	}
}

//testFor2类,所描述的是一个9*9乘法表
public class testFor2
{
	public static void main(String args[])
	{
		for (int i = 1; i < 10; i++)
		{
			for (int j = 1; j < 10; j++)
			{
				if (j <= i)
				{
					System.out.print(i + "*" + j + "=" + (i * j) + " ");
				}
			}
			System.out.println(" ");
		}
	}
}

Item 4：避免无用的缺省构造函数  

没有缺省构造函数会导致：

1.无法创建该类的数组形式。

2.无法在许多基于模板的容器类里使用。 

设计虚基类时所面临的要提供缺省构造函数还是不提供缺省构造函数的两难决策：

1.不提供缺省构造函数的虚基类，很难与其进行合作。因为几乎所有的派生类在实例化时都必须给虚基类构造函数提供参数。

2.提供无意义的缺省构造函数也会影响类的工作效率。 

class BST { ... };
class BalancedBST: public BST { ... };

void printBSTArray(ostream& s,const BST array[], int numElements)
{
    for (int i = 0; i < numElements; )
    {
        s << array[i]; //假设 BST 类重载了操作符<<
    }
} 

         编译器原先已经假设数组中元素与 BST 对象的大小一致，但是现在数组中每一个对象大小却与 BalancedBST 一致。派生类的长度通常都比基类要长。我们料想 BalancedBST 对象长度的比 BST 长。如果如此的话，printBSTArray 函数生成的指针算法将是错误的，没有人知道如果用 BalancedBST 数组来执行 printBSTArray 函数将会发生什么样的后果。不论是什么后果都是令人不愉快的。

        值得注意的是如果你不从一个具体类（concrete classes） （例如 BST）派生出另一个具体类（例如 BalancedBST），那么你就不太可能犯这种使用多态性数组的错误。