“补充说明”通常是在求职简历的结束部分，可以填写，也可以空着。不过，如果能够善于利用它，求职成功率将会大大提高。毕竟，作为求职简历的最后部分，它是表现自我的最后机会。

　　在“补充说明”中填写的最佳信息因人而异，这取决于求职者的职业目标和背景。请记住，求职简历是自我营销的手段，其中的信息应当有助于向用人单位推销自己，以实现自己的职业目标。可以这样考虑问题：如果这是向潜在的用人单位推销自己的最会机会，你会说些什么？

　　以下是一些填写“补充说明”的思路，供大家参考：

　　能力或业绩总结

　　在补充说明对自己的能力和职业生涯进行总结。在能力或业绩总结中要突出自己主要的“卖点”和成功案例——这一切都应当与你想要应聘的职位有关系。

　　获奖情况

　　用列举自己的获奖情况作为求职简历的结束，会给用人单位留下深刻印象。

　　证明书或推荐信

　　你是否收到过对于你的工作情况表示满意的推荐信或业绩评估证明？如果有，可以摘选其中的精采部分作为“补充说明”。

　　发表作品

　　如果在报刊、杂志上发表过作品，可以考虑在“补充说明”里罗列出来。

　　专利

　　如果拥有专利（包括正在申请的），请在“补充说明”中列出。

　　演讲能力

　　许多职位要有演讲能力才能胜任。列举自己参加过的演讲、主题发言会给用人单位留下好印象。

　　计算机运用技能

　　在“补充说明”中列举自己在计算机操作系统、网络和硬件等方面的技能，多多益善。

　　培训情况

　　在“补充说明”中列出自己参加过的专业培训和继续教育。

　　再次强调工作地点

　　在“补充说明”中再次强调工作地点不失为结束求职简历的好办法。

　　说明自己愿意出差

　　如果愿意出差，可以在补充说明中加以说明，用人单位或许会因为这一点而看上你。

　　应该省略的内容

　　补充说明不要涉及婚姻状况、年龄、有多少个孩子等情况，如果兴趣爱好与工作无关，最好也不要提及。

 来源:中华英才网 

[转]自天极网

1使用不带参数的存储过程

　　使用 JDBC 驱动程序调用不带参数的存储过程时，必须使用 call SQL 转义序列。不带参数的 call 转义序列的语法如下所示：

　　

以下是引用片段： {call procedure-name}

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下存储过程：

　　

以下是引用片段： CREATE PROCEDURE GetContactFormalNames 　　AS 　　BEGIN 　　 SELECT TOP 10 Title + ' ' + FirstName + ' ' + LastName AS FormalName 　　 FROM Person.Contact 　　END

此存储过程返回单个结果集，其中包含一列数据(由 Person.Contact 表中前十个联系人的称呼、名称和姓氏组成)。

　　在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，然后使用 executeQuery 方法调用 GetContactFormalNames 存储过程。

 

以下是引用片段： 　　public static void executeSprocNoParams(Connection con) ...{ 　　 try ...{ 　　 Statement stmt = con.createStatement(); 　　ResultSet rs = stmt.executeQuery("{call dbo.GetContactFormalNames}"); 　　 　　 while (rs.next()) ...{ 　System.out.println(rs.getString("FormalName")); 　　} 　　rs.close(); 　　stmt.close(); 　 } 　　catch (Exception e) ...{ 　　e.printStackTrace(); 　　} 　　}

　　2使用带有输入参数的存储过程

　　使用 JDBC 驱动程序调用带参数的存储过程时，必须结合 SQLServerConnection 类的 prepareCall 方法使用 call SQL 转义序列。带有 IN 参数的 call 转义序列的语法如下所示：

　　

以下是引用片段： {call procedure-name[([parameter][,[parameter]]...)]}

　　构造 call 转义序列时，请使用 ?(问号)字符来指定 IN 参数。此字符充当要传递给该存储过程的参数值的占位符。可以使用 SQLServerPreparedStatement 类的 setter 方法之一为参数指定值。可使用的 setter 方法由 IN 参数的数据类型决定。

　　向 setter 方法传递值时，不仅需要指定要在参数中使用的实际值，还必须指定参数在存储过程中的序数位置。例如，如果存储过程包含单个 IN 参数，则其序数值为 1。如果存储过程包含两个参数，则第一个序数值为 1，第二个序数值为 2。

　　作为如何调用包含 IN 参数的存储过程的实例，使用 SQL Server 2005 AdventureWorks 示例数据库中的 uspGetEmployeeManagers 存储过程。此存储过程接受名为 EmployeeID 的单个输入参数(它是一个整数值)，然后基于指定的 EmployeeID 返回雇员及其经理的递归列表。下面是调用此存储过程的 Java 代码：

　　

 

以下是引用片段： 　　public static void executeSprocInParams(Connection con) ...{ 　　 try ...{ 　　 PreparedStatement pstmt = con.prepareStatement("{call dbo.uspGetEmployeeManagers(?)}"); 　　 pstmt.setInt(1, 50); 　　 ResultSet rs = pstmt.executeQuery(); 　　 while (rs.next()) ...{ 　　 System.out.println("EMPLOYEE:"); 　　 System.out.println(rs.getString("LastName") + ", " + rs.getString("FirstName")); 　　 System.out.println("MANAGER:"); 　　 System.out.println(rs.getString("ManagerLastName") + ", " + rs.getString("ManagerFirstName")); 　　 System.out.println(); 　　 } 　　 rs.close(); 　　 pstmt.close(); 　　 } 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

　　3使用带有输出参数的存储过程

　　使用 JDBC 驱动程序调用此类存储过程时，必须结合 SQLServerConnection 类的 prepareCall 方法使用 call SQL 转义序列。带有 OUT 参数的 call 转义序列的语法如下所示：

　　

以下是引用片段： {call procedure-name[([parameter][,[parameter]]...)]}

　　构造 call 转义序列时，请使用 ?(问号)字符来指定 OUT 参数。此字符充当要从该存储过程返回的参数值的占位符。要为 OUT 参数指定值，必须在运行存储过程前使用 SQLServerCallableStatement 类的 registerOutParameter 方法指定各参数的数据类型。

　　使用 registerOutParameter 方法为 OUT 参数指定的值必须是 java.sql.Types 所包含的 JDBC 数据类型之一，而它又被映射成本地 SQL Server 数据类型之一。有关 JDBC 和 SQL Server 数据类型的详细信息，请参阅了解 JDBC 驱动程序数据类型。

　　当您对于 OUT 参数向 registerOutParameter 方法传递一个值时，不仅必须指定要用于此参数的数据类型，而且必须在存储过程中指定此参数的序号位置或此参数的名称。例如，如果存储过程包含单个 OUT 参数，则其序数值为 1;如果存储过程包含两个参数，则第一个序数值为 1，第二个序数值为 2。

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下存储过程： 根据指定的整数 IN 参数 (employeeID)，该存储过程也返回单个整数 OUT 参数 (managerID)。根据 HumanResources.Employee 表中包含的 EmployeeID，OUT 参数中返回的值为 ManagerID。

　　在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，然后使用 execute 方法调用 GetImmediateManager 存储过程：

 

以下是引用片段： 　　public static void executeStoredProcedure(Connection con) ...{ 　　 try ...{ 　　 CallableStatement cstmt = con.prepareCall("{call dbo.GetImmediateManager(?, ?)}"); 　　 cstmt.setInt(1, 5); 　　 cstmt.registerOutParameter(2, java.sql.Types.INTEGER); 　　 cstmt.execute(); 　　 System.out.println("MANAGER ID: " + cstmt.getInt(2)); 　　 } 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

本示例使用序号位置来标识参数。或者，也可以使用参数的名称(而非其序号位置)来标识此参数。下面的代码示例修改了上一个示例，以说明如何在 Java 应用程序中使用命名参数。请注意，这些参数名称对应于存储过程的定义中的参数名称： CREATE PROCEDURE GetImmediateManager

　

以下是引用片段：  @employeeID INT, 　　 @managerID INT OUTPUT 　　AS 　　BEGIN 　　 SELECT @managerID = ManagerID 　　 FROM HumanResources.Employee 　　 WHERE EmployeeID = @employeeID 　　END

　　存储过程可能返回更新计数和多个结果集。Microsoft SQL Server 2005 JDBC Driver 遵循 JDBC 3.0 规范，此规范规定在检索 OUT 参数之前应检索多个结果集和更新计数。也就是说，应用程序应先检索所有 ResultSet 对象和更新计数，然后使用 CallableStatement.getter 方法检索 OUT 参数。否则，当检索 OUT 参数时，尚未检索的 ResultSet 对象和更新计数将丢失。

　　4 使用带有返回状态的存储过程

　　使用 JDBC 驱动程序调用这种存储过程时，必须结合 SQLServerConnection 类的 prepareCall 方法使用 call SQL 转义序列。返回状态参数的 call 转义序列的语法如下所示：

　

以下是引用片段： 　{[?=]call procedure-name[([parameter][,[parameter]]...)]}

　　构造 call 转义序列时，请使用 ?(问号)字符来指定返回状态参数。此字符充当要从该存储过程返回的参数值的占位符。要为返回状态参数指定值，必须在执行存储过程前使用 SQLServerCallableStatement 类的 registerOutParameter 方法指定参数的数据类型。

　　此外，向 registerOutParameter 方法传递返回状态参数值时，不仅需要指定要使用的参数的数据类型，还必须指定参数在存储过程中的序数位置。对于返回状态参数，其序数位置始终为 1，这是因为它始终是调用存储过程时的第一个参数。尽管 SQLServerCallableStatement 类支持使用参数的名称来指示特定参数，但您只能对返回状态参数使用参数的序号位置编号。

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下存储过程：

　　

以下是引用片段： CREATE PROCEDURE CheckContactCity 　　 (@cityName CHAR(50)) 　　AS 　　BEGIN 　　 IF ((SELECT COUNT(*) 　　 FROM Person.Address 　　 WHERE City = @cityName) > 1) 　　 RETURN 1 　　ELSE 　　 RETURN 0 　　END

　　该存储过程返回状态值 1 或 0，这取决于是否能在表 Person.Address 中找到 cityName 参数指定的城市。

　　在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，然后使用 execute 方法调用 CheckContactCity 存储过程：

　

以下是引用片段： 　public static void executeStoredProcedure(Connection con) ...{ 　　 try ...{ 　　 CallableStatement cstmt = con.prepareCall("{? = call dbo.CheckContactCity(?)}"); 　　 cstmt.registerOutParameter(1, java.sql.Types.INTEGER); 　　 cstmt.setString(2, "Atlanta"); 　　 cstmt.execute(); 　　 System.out.println("RETURN STATUS: " + cstmt.getInt(1)); 　　 } 　　 cstmt.close(); 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

　　5 使用带有更新计数的存储过程

　　使用 SQLServerCallableStatement 类构建对存储过程的调用之后，可以使用 execute 或 executeUpdate 方法中的任意一个来调用此存储过程。executeUpdate 方法将返回一个 int 值，该值包含受此存储过程影响的行数，但 execute 方法不返回此值。如果使用 execute 方法，并且希望获得受影响的行数计数，则可以在运行存储过程后调用 getUpdateCount 方法。

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下表和存储过程：

　　

以下是引用片段： CREATE TABLE TestTable 　　 (Col1 int IDENTITY, 　　 Col2 varchar(50), 　　 Col3 int); 　　 　　CREATE PROCEDURE UpdateTestTable 　　 @Col2 varchar(50), 　　 @Col3 int 　　AS 　　BEGIN 　　 UPDATE TestTable 　　 SET Col2 = @Col2, Col3 = @Col3 　　END;

在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，并使用 execute 方法调用 UpdateTestTable 存储过程，然后使用 getUpdateCount 方法返回受存储过程影响的行计数。

以下是引用片段： public static void executeUpdateStoredProcedure(Connection con) ...{ 　　 try ...{ 　　 CallableStatement cstmt = con.prepareCall("{call dbo.UpdateTestTable(?, ?)}"); 　　 cstmt.setString(1, "A"); 　　 cstmt.setInt(2, 100); 　　 cstmt.execute(); 　　 int count = cstmt.getUpdateCount(); 　　 cstmt.close(); 　　 　　 System.out.println("ROWS AFFECTED: " + count); 　　 } 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

[转]自天极网

1使用不带参数的存储过程

　　使用 JDBC 驱动程序调用不带参数的存储过程时，必须使用 call SQL 转义序列。不带参数的 call 转义序列的语法如下所示：

　　

以下是引用片段： {call procedure-name}

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下存储过程：

　　

以下是引用片段： CREATE PROCEDURE GetContactFormalNames 　　AS 　　BEGIN 　　 SELECT TOP 10 Title + ' ' + FirstName + ' ' + LastName AS FormalName 　　 FROM Person.Contact 　　END

此存储过程返回单个结果集，其中包含一列数据(由 Person.Contact 表中前十个联系人的称呼、名称和姓氏组成)。

　　在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，然后使用 executeQuery 方法调用 GetContactFormalNames 存储过程。

 

以下是引用片段： 　　public static void executeSprocNoParams(Connection con) ...{ 　　 try ...{ 　　 Statement stmt = con.createStatement(); 　　ResultSet rs = stmt.executeQuery("{call dbo.GetContactFormalNames}"); 　　 　　 while (rs.next()) ...{ 　System.out.println(rs.getString("FormalName")); 　　} 　　rs.close(); 　　stmt.close(); 　 } 　　catch (Exception e) ...{ 　　e.printStackTrace(); 　　} 　　}

　　2使用带有输入参数的存储过程

　　使用 JDBC 驱动程序调用带参数的存储过程时，必须结合 SQLServerConnection 类的 prepareCall 方法使用 call SQL 转义序列。带有 IN 参数的 call 转义序列的语法如下所示：

　　

以下是引用片段： {call procedure-name[([parameter][,[parameter]]...)]}

　　构造 call 转义序列时，请使用 ?(问号)字符来指定 IN 参数。此字符充当要传递给该存储过程的参数值的占位符。可以使用 SQLServerPreparedStatement 类的 setter 方法之一为参数指定值。可使用的 setter 方法由 IN 参数的数据类型决定。

　　向 setter 方法传递值时，不仅需要指定要在参数中使用的实际值，还必须指定参数在存储过程中的序数位置。例如，如果存储过程包含单个 IN 参数，则其序数值为 1。如果存储过程包含两个参数，则第一个序数值为 1，第二个序数值为 2。

　　作为如何调用包含 IN 参数的存储过程的实例，使用 SQL Server 2005 AdventureWorks 示例数据库中的 uspGetEmployeeManagers 存储过程。此存储过程接受名为 EmployeeID 的单个输入参数(它是一个整数值)，然后基于指定的 EmployeeID 返回雇员及其经理的递归列表。下面是调用此存储过程的 Java 代码：

　　

 

以下是引用片段： 　　public static void executeSprocInParams(Connection con) ...{ 　　 try ...{ 　　 PreparedStatement pstmt = con.prepareStatement("{call dbo.uspGetEmployeeManagers(?)}"); 　　 pstmt.setInt(1, 50); 　　 ResultSet rs = pstmt.executeQuery(); 　　 while (rs.next()) ...{ 　　 System.out.println("EMPLOYEE:"); 　　 System.out.println(rs.getString("LastName") + ", " + rs.getString("FirstName")); 　　 System.out.println("MANAGER:"); 　　 System.out.println(rs.getString("ManagerLastName") + ", " + rs.getString("ManagerFirstName")); 　　 System.out.println(); 　　 } 　　 rs.close(); 　　 pstmt.close(); 　　 } 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

　　3使用带有输出参数的存储过程

　　使用 JDBC 驱动程序调用此类存储过程时，必须结合 SQLServerConnection 类的 prepareCall 方法使用 call SQL 转义序列。带有 OUT 参数的 call 转义序列的语法如下所示：

　　

以下是引用片段： {call procedure-name[([parameter][,[parameter]]...)]}

　　构造 call 转义序列时，请使用 ?(问号)字符来指定 OUT 参数。此字符充当要从该存储过程返回的参数值的占位符。要为 OUT 参数指定值，必须在运行存储过程前使用 SQLServerCallableStatement 类的 registerOutParameter 方法指定各参数的数据类型。

　　使用 registerOutParameter 方法为 OUT 参数指定的值必须是 java.sql.Types 所包含的 JDBC 数据类型之一，而它又被映射成本地 SQL Server 数据类型之一。有关 JDBC 和 SQL Server 数据类型的详细信息，请参阅了解 JDBC 驱动程序数据类型。

　　当您对于 OUT 参数向 registerOutParameter 方法传递一个值时，不仅必须指定要用于此参数的数据类型，而且必须在存储过程中指定此参数的序号位置或此参数的名称。例如，如果存储过程包含单个 OUT 参数，则其序数值为 1;如果存储过程包含两个参数，则第一个序数值为 1，第二个序数值为 2。

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下存储过程： 根据指定的整数 IN 参数 (employeeID)，该存储过程也返回单个整数 OUT 参数 (managerID)。根据 HumanResources.Employee 表中包含的 EmployeeID，OUT 参数中返回的值为 ManagerID。

　　在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，然后使用 execute 方法调用 GetImmediateManager 存储过程：

 

以下是引用片段： 　　public static void executeStoredProcedure(Connection con) ...{ 　　 try ...{ 　　 CallableStatement cstmt = con.prepareCall("{call dbo.GetImmediateManager(?, ?)}"); 　　 cstmt.setInt(1, 5); 　　 cstmt.registerOutParameter(2, java.sql.Types.INTEGER); 　　 cstmt.execute(); 　　 System.out.println("MANAGER ID: " + cstmt.getInt(2)); 　　 } 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

本示例使用序号位置来标识参数。或者，也可以使用参数的名称(而非其序号位置)来标识此参数。下面的代码示例修改了上一个示例，以说明如何在 Java 应用程序中使用命名参数。请注意，这些参数名称对应于存储过程的定义中的参数名称： CREATE PROCEDURE GetImmediateManager

　

以下是引用片段：  @employeeID INT, 　　 @managerID INT OUTPUT 　　AS 　　BEGIN 　　 SELECT @managerID = ManagerID 　　 FROM HumanResources.Employee 　　 WHERE EmployeeID = @employeeID 　　END

　　存储过程可能返回更新计数和多个结果集。Microsoft SQL Server 2005 JDBC Driver 遵循 JDBC 3.0 规范，此规范规定在检索 OUT 参数之前应检索多个结果集和更新计数。也就是说，应用程序应先检索所有 ResultSet 对象和更新计数，然后使用 CallableStatement.getter 方法检索 OUT 参数。否则，当检索 OUT 参数时，尚未检索的 ResultSet 对象和更新计数将丢失。

　　4 使用带有返回状态的存储过程

　　使用 JDBC 驱动程序调用这种存储过程时，必须结合 SQLServerConnection 类的 prepareCall 方法使用 call SQL 转义序列。返回状态参数的 call 转义序列的语法如下所示：

　

以下是引用片段： 　{[?=]call procedure-name[([parameter][,[parameter]]...)]}

　　构造 call 转义序列时，请使用 ?(问号)字符来指定返回状态参数。此字符充当要从该存储过程返回的参数值的占位符。要为返回状态参数指定值，必须在执行存储过程前使用 SQLServerCallableStatement 类的 registerOutParameter 方法指定参数的数据类型。

　　此外，向 registerOutParameter 方法传递返回状态参数值时，不仅需要指定要使用的参数的数据类型，还必须指定参数在存储过程中的序数位置。对于返回状态参数，其序数位置始终为 1，这是因为它始终是调用存储过程时的第一个参数。尽管 SQLServerCallableStatement 类支持使用参数的名称来指示特定参数，但您只能对返回状态参数使用参数的序号位置编号。

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下存储过程：

　　

以下是引用片段： CREATE PROCEDURE CheckContactCity 　　 (@cityName CHAR(50)) 　　AS 　　BEGIN 　　 IF ((SELECT COUNT(*) 　　 FROM Person.Address 　　 WHERE City = @cityName) > 1) 　　 RETURN 1 　　ELSE 　　 RETURN 0 　　END

　　该存储过程返回状态值 1 或 0，这取决于是否能在表 Person.Address 中找到 cityName 参数指定的城市。

　　在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，然后使用 execute 方法调用 CheckContactCity 存储过程：

　

以下是引用片段： 　public static void executeStoredProcedure(Connection con) ...{ 　　 try ...{ 　　 CallableStatement cstmt = con.prepareCall("{? = call dbo.CheckContactCity(?)}"); 　　 cstmt.registerOutParameter(1, java.sql.Types.INTEGER); 　　 cstmt.setString(2, "Atlanta"); 　　 cstmt.execute(); 　　 System.out.println("RETURN STATUS: " + cstmt.getInt(1)); 　　 } 　　 cstmt.close(); 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

　　5 使用带有更新计数的存储过程

　　使用 SQLServerCallableStatement 类构建对存储过程的调用之后，可以使用 execute 或 executeUpdate 方法中的任意一个来调用此存储过程。executeUpdate 方法将返回一个 int 值，该值包含受此存储过程影响的行数，但 execute 方法不返回此值。如果使用 execute 方法，并且希望获得受影响的行数计数，则可以在运行存储过程后调用 getUpdateCount 方法。

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下表和存储过程：

　　

以下是引用片段： CREATE TABLE TestTable 　　 (Col1 int IDENTITY, 　　 Col2 varchar(50), 　　 Col3 int); 　　 　　CREATE PROCEDURE UpdateTestTable 　　 @Col2 varchar(50), 　　 @Col3 int 　　AS 　　BEGIN 　　 UPDATE TestTable 　　 SET Col2 = @Col2, Col3 = @Col3 　　END;

在下面的实例中，将向此函数传递 AdventureWorks 示例数据库的打开连接，并使用 execute 方法调用 UpdateTestTable 存储过程，然后使用 getUpdateCount 方法返回受存储过程影响的行计数。

以下是引用片段： public static void executeUpdateStoredProcedure(Connection con) ...{ 　　 try ...{ 　　 CallableStatement cstmt = con.prepareCall("{call dbo.UpdateTestTable(?, ?)}"); 　　 cstmt.setString(1, "A"); 　　 cstmt.setInt(2, 100); 　　 cstmt.execute(); 　　 int count = cstmt.getUpdateCount(); 　　 cstmt.close(); 　　 　　 System.out.println("ROWS AFFECTED: " + count); 　　 } 　　 catch (Exception e) ...{ 　　 e.printStackTrace(); 　　 } 　　}

--创建数据库
use master
go
if exists(select * from sysdatabases where name = 'BankDB')
drop database BankDB
go
exec xp_cmdshell 'md E:\朱矿龙',NO_OUTPUT
create database BankDB
go
use BankDB
--创建帐户信息表AccountInfo
if exists(select * from sysobjects where name = 'AccountInfo')
drop table AccountInfo
go
create table AccountInfo
(
CustID int identity(1,1) primary key,
CustName varchar(20) not null,
IDCard varchar(18) check(len(IDCard) = 15 or len(IDCard) = 18),
TelePhone varchar(13) check(len(TelePhone)=11 or len(TelePhone) like'[0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9][0-9][0-9][0-9]' or len(TelePhone) like'[0-9][0-9][0-9]-[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]') ,
Address varchar(50) default '地址不详'
)
go
--创建信用卡信息表CardInfo
if exists(select * from sysobjects where name = 'CardInfo')
drop table CardInfo
go
create table CardInfo
(
CardID varchar(19) check(len(CardID)=19) primary key,
CardPassWord varchar(6) default'888888',
CustID int references AccountInfo(CustID),
SaveType varchar(10) not null check(SaveType in('活期','定期')),
OpenDate datetime not null default(getdate()),
OpenMoney money not null check(OpenMoney >= 1),
LeftMoney money not null check(LeftMoney >= 1),
IsLoss varchar(2) not null check(IsLoss in('是','否')) default '否'
)
go
--创建交易信息表TransInfo
if exists(select * from sysobjects where name = 'TransInfo')
drop table TransInfo
go
create table TransInfo
(
CardID varchar(19) not null,
TransType varchar(4) not null check(TransType in('存入','支取')),
TransMoney money not null check(TransMoney > 0),
TransDate datetime default(getdate())
)
go

-------------------------------插入测试数据-------------------------------------
---为AccountInfo表插入测试数据
insert into AccountInfo values('孙悟空','422322123902140019','027-8888988','花果山')
insert into AccountInfo values('唐僧','422322001902140019','027-8536896','大唐')
insert into AccountInfo values('沙和尚','410334020157144719','13295654665','通天河')
---为CardInfo表插入测试数据
insert into CardInfo values('1027 3726 1536 1135',default,1,'定期',default,500.00,500.00,default)
insert into CardInfo values('1029 3526 1235 1235',default,2,'活期',default,1500.00,1500.00,default)
insert into CardInfo values('1324 7532 1536 1935',default,3,'活期',default,4500.00,4500.00,default)

---表的查看
select * from AccountInfo

select * from CardInfo

select * from TransInfo

-----------------T-SQL----------------------------
--孙悟空修改密码
update CardInfo set CardPassWord = 611234 where CustID = 1

--孙悟空取钱
--事务开始
begin transaction tran_Qu
--定义一个用于记录错误的变量
declare @tran_error int
set @tran_error = 0;
--将孙悟空交易进行记录
insert into TransInfo values('1027 3726 1536 1135','支取',200.00,getdate())
set @tran_error = @tran_error + @@error
--从孙悟空的帐户中减去200.00
update CardInfo set LeftMoney = LeftMoney - 200
where CardID = '1027 3726 1536 1135'
set @tran_error = @tran_error + @@error
if @tran_error <> 0
   begin
      --执行错误，回滚事务
      rollback transaction
      print '支取失败，交易已取消'
   end
else
  begin
    --没有发现错误，提交事务
    commit transaction
    print'交易成功，已保存新数据'
  end
go
select * from CardInfo where CustID = 1

--沙和尚存钱
begin transaction tran_bring
declare @tran_error int
set @tran_error = 0;
insert into TransInfo values('1324 7532 1536 1935','存入',1200.00,getdate())
set @tran_error = @tran_error + @@error
update CardInfo set LeftMoney = LeftMoney + 1200
where CardID = '1324 7532 1536 1935'
set @tran_error = @tran_error + @@error
if @tran_error <> 0
   begin
      rollback transaction
      print '存入失败，交易已取消'
   end
else
  begin
    commit transaction
    print'交易成功，已保存新数据'
  end
go
select * from CardInfo where CustID = 3

--唐僧卡丢失
update CardInfo set IsLoss='是' where CustID = 2

--查询最近10开户的银行卡信息
select * from CardInfo where datediff(dd,OpenDate,getdate()) <= 10

--查询最大交易的卡信息
declare @maxMoney money
select @maxMoney = max(TransMoney) from TransInfo
select * from CardInfo where CardID in(select CardID from TransInfo where TransMoney = @maxMoney)

--查询交易信息表中总的交易
declare @allMoney money
declare @QuMoney money
declare @CunMoney money
select @allMoney = sum(TransMoney) from TransInfo
select @QuMoney = sum(TransMoney) from TransInfo where TransType = '支取'
select @CunMoney = sum(TransMoney) from TransInfo where TransType = '存入'
print '总交易金额：' + convert(varchar(10),@allMoney)
print '支取交易金额：' + convert(varchar(10),@QuMoney)
print '存入交易金额：' + convert(varchar(10),@CunMoney)

--给交易信息表加上非聚集索引，并利用非聚集索引查询数据
if exists(select * from sysobjects where name = 'IX_CardID')
drop index BankDB.IX_CardID
go
create nonclustered index IX_CardID
on TransInfo(CardID)
with fillfactor = 30
go
select * from TransInfo with(index = IX_CardID) where CardID = '1324 7532 1536 1935'

--查询挂失的账户信息
select * from AccountInfo where CustID in(select CustID from CardInfo where IsLoss = '是')

--账户信息视图
if exists(select * from sysobjects where name = 'view_AccountCardInfo')
drop view view_AccountCardInfo
go
create view view_AccountCardInfo
as
select AccountInfo.CustID '帐户编号',CustName '帐户姓名',IDCard'身份证号码',TelePhone'客户电话',Address'客户地址',
        CardID'信用卡编号',SaveType'储蓄类型',OpenDate'开户日期',OpenMoney'开户金额',IsLoss'是否挂失'
from AccountInfo join CardInfo
on AccountInfo.CustID = CardInfo.CustID
go
select * from view_AccountCardInfo

--交易信息视图
if exists(select * from sysobjects where name = 'view_TransInfo')
drop view view_TransInfo
go
create view view_TransInfo
as
select CardID '卡号',TransType '交易类型',TransMoney '交易金额',TransDate '交易时间'
from TransInfo
go
go
select * from view_TransInfo

---------------第三阶段----------------
--------T-SQL-------------
if exists(select name from sysobjects where name = 'Tri_TransInfo_Insert')
drop trigger Tri_TransInfo_Insert
go
create trigger Tri_TransInfo_Insert on TransInfo for insert
as
 declare @TempTransType varchar(10)     --定义临时的变量存放交易类型
 declare @TempTransMoney money          --定义临时的变量存放交易金额
 declare @TempCardID varchar(19)        --定义临时的变量存放卡号
 declare @TempLeftMoney money           --定义临时的变量存放客户的余额
 
--从inserted临时表中取出数据赋值
select @TempTransType = TransType,@TempTransMoney = TransMoney,@TempCardID = CardID
from inserted
select @TempLeftMoney = LeftMoney from CardInfo where CardID = @TempCardID

if(@TempTransType = '支取')      
  begin
    if(@TempLeftMoney - @TempTransMoney >=1)  
       begin
          update CardInfo set LeftMoney = @TempLeftMoney - @TempTransMoney where CardID = @TempCardID
          print '交易成功！'
       end
     else
       begin
          rollback transaction
          print '余额不足，交易失败！'
       end
  end
else
  begin
    update CardInfo set LeftMoney = @TempLeftMoney + @TempTransMoney where CardID = @TempCardID
    print '交易成功！'
  end
select @TempLeftMoney = LeftMoney from CardInfo where CardID = @TempCardID  
print '卡号：' + convert(varchar(19),@TempCardID) + '  余额：' + convert(varchar(10),@TempLeftMoney)
go
set nocount on   --不显示语句影响记录行数
--测试触发器,沙和尚支取
insert into TransInfo(CardID,TransType,TransMoney) values('9645 9087 9371 4492','支取',500)
go

select * from TransInfo
select * from accountinfo
select * from CardInfo

--利用存储过程实现备份交易信息的业务
if exists(select *from sysobjects where name = 'Proc_Backup_TransInfo')
    drop procedure Proc_Backup_TransInfo
go
create procedure Proc_Backup_TransInfo
@BackupDate datetime
as
declare @MyError int
set @MyError = 0
print '开始备份......'
if exists(select * from sysobjects where name ='Back_TransInfo')
begin
 begin tran 
 insert into Back_TransInfo select * from TransInfo where datediff(dd,TransDate,getdate()) >=0
set @MyError = @MyError + @@error
if @MyError != 0
   begin
       rollback transaction
      print '备份失败'
   end
else
  begin
      commit transaction
       print'备份成功'
   end
  end
else
  begin
    begin tran 
    select * into Back_TransInfo from TransInfo where datediff(dd,TransDate,getdate()) >=0
    set @MyError = @MyError + @@error
if @MyError != 0
   begin
      rollback transaction
      print '备份失败!'
   end
else
   begin
      commit transaction
      print '备份成功!'
   end
end
go
insert into TransInfo values('1324 7532 1536 1935','支取',500.00,getdate()) 
insert into TransInfo values('1324 7532 1536 1935','支取',500.00,getdate())
insert into TransInfo values('1324 7532 1536 1935','支取',500.00,getdate())
declare @BackDate datetime
set @BackDate = getDate()
exec Proc_Backup_TransInfo '2008-10-31'
go
select * from Back_TransInfo

--实现银行卡的存储过程
if exists(select * from sysobjects where name = 'Proc_GetCardID')
    drop procedure Proc_GetCardID
go
create procedure Proc_GetCardID
@CardID varchar(19) output
as
declare @TempRand numeric(18,16)
declare @TempStr varchar(18)
set @TempRand = rand(datepart(ms,getdate())*10000)
set @TempStr = convert(varchar(18),@TempRand)
set @CardID = substring(@TempStr,3,4)+' '+substring(@TempStr,7,4)+' '+substring(@TempStr,11,4)+' '+substring(@TempStr,15,4)
go
declare @MyCardID varchar(19)
exec Proc_GetCardID @MyCardID output
print '产生的随即卡号是：' + @MyCardID
go

--实现开户的存储过程
if exists(select * from sysobjects where name = 'Proc_OpenAcount')
    drop procedure Proc_OpenAcount
go
create procedure Proc_OpenAcount
@CustName varchar(20),
@IDCard varchar(18),
@Telephone varchar(13),
@OpenMoney money = 1,
@SaveType varchar(10) = '活期',
@Address varchar(50)= '地址不详'
as
 declare @MyCardID varchar(19)
 declare @MyCustID int
 exec Proc_GetCardID @MyCardID output
while(1=1)
 begin
 if exists(select * from CardInfo where CardID = @MyCardID)
 exec Proc_GetCardID @MyCardID output
else
 break
 end
insert into AccountInfo values(@CustName,@IDCard,@TelePhone,@Address)  
select @MyCustID = CustID from AccountInfo where IDCard = @IDCard      
insert into CardInfo values(@MyCardID,default,@MyCustID,@SaveType,default,@OpenMoney,@OpenMoney,default)
print '尊敬的客户：' +@CustName +'开户成功，卡号为：'+@MyCardId

print '产生的随机卡号为：' + @MyCardID
exec Proc_OpenAcount '白骨精','245687556977812345','12478964568'
exec Proc_OpenAcount '嫦娥公主','745687476912812335','14796653141',@Address = '月亮'

----销户
if exists(select * from sysobjects where name = 'Proc_DropAcount')
    drop procedure Proc_DropAcount
go
create procedure Proc_DropAcount
 --@CardID varchar(19)
@IDCard varchar(18) --身份证号
as
declare @TempCustID int
declare @TempLeftMoney money
--select @TempCustID = CustID from CardInfo where CardID = @CardID 
--select @TempLeftMoney = LeftMoney from CardInfo where CardID = @CardID
print '该帐户余额：' +convert(varchar(10),@TempLeftMoney)+'正在取出。。。'
delete from CardInfo where custid in(select custid from accountinfo where IDCard=@IDCard)
delete from  AccountInfo where IDCard=@IDCard
go
declare @CardID varchar(19)
select @CardID = CardID from CardInfo where CustID in(select CustID from AccountInfo where CustName = '唐僧')
exec Proc_DropAcount '422322001902140019'--根据身份证号删除
go
---表的查看
select * from AccountInfo
select * from CardInfo

类和对象：
 类：主观抽象，是对象的模板，可以实例化对象
  习惯上类的定义格式：
   package xxx;  
   import xxx;  
   public class Xxxx{
    属性 ······;
    
    构造器 ······;
    
    方法 ······;
   }

  定义属性：实例变量
   格式：[ 修饰符 ]  类型 变量名  [ = ? ]
   实例变量定义在类中但在任何方法之外。
   实例变量有默认值：各种各样的0。(同数组)
   实例变量的作用域至少在本类内部，受访问控制符的限制。
   在重合作用域，实例变量和局部变量允许有命名冲突，“局部优先”。
   
  定义方法：
   格式： [ 修饰符 ]  返回类型 方法名( 参数列表 ) [ throws  异常 ] { ······ }
   java中所有参数都是值传递。
      当没有值返回时，返回类型必须被定义为void。
   返回类型必须与方法名相邻，其他修饰符可以调换位置。
   
  构造器：
   在创建对象的过程中调用的方法。
   构造器没有返回类型。
   构造器的名字与类名相同。
   格式为：[ 修饰符 ]  类名( 参数列表 ){  }，修饰符可以是private、 protected、 default、private
   在一个对象的生成周期中构造器只用一次，由系统自动调用，不允许手工调用。
   程序员没有提供一个构造器，系统会自动提供一个无参的构造器。
   获得对象的方式：
    通过new（在堆空间中申请分配空间），new 类名()，可以通过这种形式或的一个对象，这时的对象是无法使用，必须把他的地址存放进一个对象变量才能够使用。
    例如 ：
     Car c=new Car();
   注意：
    最好在写类时提供一个无参的构造器。
      
  this关键字：
   this是个隐式参数，代表当前对象;
    publie class Student{
     private String name;
     public void setName(String name){
      this.name=name;  //this.name为当前对象的成员变量
     }
    }
    
   如果某个构造方法的第一个语句具有形式this( ··· )，那么这个构造方法将调用同一类中的其他构造方法。
   
          注意：
           在构造器中this(...)必须放在该构造器的第一行。
    this不能出现在静态方法里面  
 
 类、对象、实例三者的关系：
  类：是对象的模板，可以实例化对象
  对象：类的个体
  实例：实现的对象
  student s; 
  s=new student();
   其中 Student为类，s为对象，new Student()为实例，s赋值后也是实例了。

方法重载：
 方法名相同，参数表不同，不考虑返回值类型(但最好还是使返回类型一致)。
 编译器根据参数，选择一个方法，如果没有完全匹配的，对于参数表采用“向上就近匹配原则”，但不允许模棱两可。
 方法重载屏蔽了一个对象的同一类方法由于参数不同所造成的差异。
   
封装：
 类的属性加private修饰符，来限制只能够在类的内部进行访问，有效的保护数据。
 对于类中的私有属性，要对其给出一对方法getXxx()，setXxx()访问私有属性，保证对私有属性的操作的安全性。
 方法公开的是方法的声明，即只须知道参数和返回值就可以调用该方法，隐藏方法的实现的细节。
 一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。
  
继承：
 父类到子类是从一般到特殊的关系。
  泛化：将不同子类中的共性抽象成父类的过程。
  特化：在原有父类的基础上加入一些个性的过程。
  原则：父类放共性，子类放个性。
 继承的关键字：extends
 Java只支持单继承：一个类最多只有一个直接的父类。

      方法覆盖：
  方法名：相同
  参数表：相同
  访问限制符：相同或者更宽
  返回值类型：相同或者子类返回的类型是父类返回的类型的子类（在JDK5.0以后）
  抛出的异常：不能比父类更宽。
    
      super关键字：
  super()表示调用父类的构造器
  super()也和this()一样必须放在方法的第一句
  super()和this()不能同时出现        
  super可以屏蔽子类属性和父类属性重名时带来的属性遮盖，super. 表示调用父类的方法或属性
  在子类的构造器中如果没有指定调用父类的哪一个构造器，那么就会调用父类的无参构造器，即super()
  
 注意：
  父类的构造器不能被子类继承
  方法和属性可以被继承，权限不限制能否继承过来，限制的是能否直接访问
  先构造父类，后构造子类，先this后super
  
多态：
 多态分为两种：编译时多态和运行时多态。
  编译时类型：主观概念，把它看作什么。
  运行时类型：客观概念，实际它是什么。
    例：Animal a=new Dog();
         指着狗问，这个动物是什么？
         
      运行时多态的三原则：
  对象类型不变。
  只能对对象调用编译时类型中定义的方法。
  在程序的运行时，根据对象的运行时类型，找覆盖后的方法来调用。（运行时动态类型绑定）
  
      强制类型转换： 一定没有新对象生成。(父类的引用赋值给子类的引用需要进行强制类型转换)
      关键字：instanceof
           用法：引用  instanceof  类名    判断这个引用所指向的对象是否属于这个类。
    用在强制转换之前，避免类型转换异常。
   if(a instanceof Dog){
    Dog d=(Dog)a;
   }
   
 多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

局部变量：不是声明在类体括号里面的变量
 (1)必须要先赋值，后使用，否则通不过编译，局部变量没有默认初始化值
 (2)作用范围：定义开始到定义它的代码块结束
 (3)同一范围内，不允许2个局部变量命名冲突

 参数传递时，简单类型进行值转递 (参数进行传递时都会先去栈中生成一个副本的，使用结束后释放)
 
自动类型提升：
 byte a = 1;
 byte b = 2;
 a = a+b;          //编译出错自动类型提升成int
 a += b;       //自加没有自动类型提升问题
 类型自动提升规则：
  a和b作某种运算
  a和b中有double，结果就是double
  a和b中有float，结果就是float
  a和b中有long，结果就是long
  除此之外，结果都是int
 把高字节转成低字节,需要作强制类型转换. byte c=(byte)a+b;
 
移位运算符：效率最高
 >>   有符号右移，补符号位
  移负数位，则将该数值加32后再进行移位
  数值的2进制是按照补码保存的
 >>>  右移后高位都补0
 
逻辑运算符：
 &/|也可以作为逻辑运算符
 && 先判断前面一个条件，如果为假，则不用计算后一个条件
 || 先判断前面一个条件，如果为真，则不用计算后一个条件
 
" + "运算符：
 两个操作的对象是数值时，是加法
 如果有一个是字符串时，则是字符串的连接
 
流程控制语句：
 同Core C++
 switch中的变量类型只能是byte、 short、int、char四种类型
 
数组：
 声明数组：  
  数组能以下列形式声明：
   类型[] array;
   类型 array[]; 
  注：
   JAVA中推荐用：类型[] array;
   一个数组是一个对象
   声明一个数组没有创建一个对象
   声明时不用指定长度
   
 创建数组：
  创建基本数据类型数组：int[] i = new int[2];
  创建引用数据类型数组：Student[] s = new Student[100];
  数组创建后其中的元素有初始值
   类型                     黙认值
   byte                      0
   short                     0
   int                       0
   long                      0l
   float                     0.0f
   double                   0.0d
   char                      \u0000
   boolean                 false
   reference types     null
  注：
   创建时一定要指定长度
   int[] i2=new int[];            //error
   
 初始化数组：
  声明、创建、初始化分开：
   int[] i;   //定义数组
   i = new int[2];  //分配空间
   i[0] = 0;    //初始化
   i[1] = 1;
   
  声明、创建、初始化在同一时间 ：
   int[] i = {0,1};   //显示初始化  {}中有几个值,则数组长度为几
   Student[] s = {new Student(),new Student()};
   
  注： int[] i=new int[]{1,2,3};      //后面[]中不可以写数值
   int[] i1=new int[3]{1,2,3};    //error
   
 二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组)
  int[][] i1 = new int[2][3];
  int[][] i4 = {{1,1,1},{2,2,2},{3,3,3}};
  int[][] i3 = new int[][3];  //不允许高维没分配空间而先给低维分配空间
  int[][] i2 = new int[2][];
  i2[0] = new int[2];
  i2[1] = new int[3];    
  
 数组长度：
  数组的属性length
  数组长度一旦确定,不可改变    
  int[] i = new int[5]; 则i.length= 5
  
 数组拷贝：
  系统类System提供的
  static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
   src： 源数组  
   srcPos： 从源数组哪个位置开始拷贝(位置指的是元素的下标)
   dest： 目标数组
   destPos： 拷贝的元素放到目标数组的起始位置
   length： 拷贝多少个
   
 数组排序：
  自己实现一个排序方法来进行排序
  或者调用java.util.Arrays.sort(Object o)

JAVA_HOME：配置JDK的目录
 CLASSPATH：指定到哪里去找运行时需要用到的类代码（字节码）
 PATH：指定可执行程序的位置
 
 LINUX系统（在" .bash_profile "下的环境变量设置）
  JAVA_HOME=/opt/jdk1.5.0_06
  CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar
  PATH=$PATH:$JAVA_HOME/bin:.
  export JAVA_HOME CLASSPATH PATH     (将指定的环境变量声明为全局的)
   
 windows系统：
  右击我的电脑-->属性-->高级-->环境变量
  
Java的运行过程：
 编译：生成可执行文件，如C++中利用g++生成a.out，效率高，但不跨平台
 解释：解释器把源文件逐行解释，跨平台但效率不高
 
 在java中：先编译后解释，把.java文件编译成.class字节码文件
  Java源代码文件(.java文件)--->
  Java编译器(javac)--->
  Java字节码文件(.class文件，平台无关的)--->
  Java解释器(java)，执行Java字节码

Java的垃圾回收：
 由一个后台线程gc进行垃圾回收
 虚拟机判定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收
 缺点：不能够精确的去回收内存
 java.lang.System.gc(); 建议回收内存，但系统不一定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收
 内存中什么算是垃圾：
  不在被引用的对象(局部变量，没有指针指向的)
  
java的安全性：
 沙箱机制：只能做沙箱允许的操作
 通过下面环节，实现安全
  加载有用的类文件，不需要的不加载
  校验字节码，查看允许的操作
   查看代码和虚拟机的特性是否相符
   查看代码是否有破坏性
   查看是否有违规操作，如越界
   查看类型是否匹配，类型转换是否能正确执行
   
源程序：
 package mypack;  //相当于一个目录
 
 public class HelloWorld{
  public static void main(String[] args){
   System.out.println(“Hello World”);
  }
 }
 注：
  1、文件名必须和public修饰的类名一致，以.java作为文件后缀，如果定义的类不是public的，则文件名与类名可以不同。
  2、一个.java文件中可以有多个class，但是只有一个public修饰的类。
  3、java源代码文件编译后，一个类对应生成一个.class文件
  4、一个java应用程序应该包含一个main()方法，而且其签名是固定的，它是应用程序的入口方法，可以定义在任意一个类中，不一定是public修饰的类
  编译：javac -d . HelloWorld.java
   含有包的类，在编译的时候最好用上面的格式，-d指的是让该类生成的时候按照包结构去生成，" . "指的是在当前路径下生成
   如果不用上面的格式，也可以用javac HelloWorld.java，但是需要注意的是包结构就要由自己去建立，然后将生成的.class文件放到该目录下
  执行：java mypack.HelloWorld
   将字节码文件交给Java虚拟机去解释执行
   需要注意的事，必须使用包名.类名去解释执行
   
包(package)：把源文件放在目录下
 由于工程的需要，将不同的源文件放在不同的目录下，从而引入了包。
 包可以看作就是一个存放java源文件的目录。
 在源码中声明一个包名：package p;(只能放在第一行，且最多只能是一行)
 如果指定多层包，那么在包名之间我们可以用.作为分隔符：package p1.p2.p3.p4;
 用“javac HelloWorld.java –d 绝对路径”，编译后生成的字节码文件就会放在指定的包结构下
 执行该程序需要用" java 包名.类名 "
 引进包中的某个类：import 包名.类名;
 引进包中的所有类：import 包名.*;
   
注释：
 // 单行注释， 到本行结束的所有字符会被编译器忽略
 /* */ 多行注释，  在/*  */之间的所有字符会被编译器忽略
 /**  */   文档注释， java特有的，在/**  */之间的所有字符会被编译器忽略
 可以用javadoc把java源程序中这种注释抽取出来形成html页面(只有写在包，类，属性，方法，构造器，引入之前的注释才可以进行抽取)
    
标识符：
 命名规则：
  (1) 由字母、数字、下划线、$组成，不能以数字开头
  (2) 大小写敏感
  (3) 不得使用java中的关键字和保留字
 
 关键字：都是小写的，jdk1.2多了strictfp(经准浮点型)，关键字 jdk1.4多了assert(断言)关键字，  jdk1.5多了enum(枚举) 关键字
  随着学习进度，会慢慢接触到的
  true、false、null严格说不应该算关键字，应称其为保留字更合适
 
 习惯：
  (1) 标识符要符合语义信息
  (2) 包名所有字母小写
  (3) 类名每个单词首字母大写，其它小写 //TarenaStudent
  (4) 变量和方法：第一个单词小写，从第二个单词开始首字母大写 //tarenaStudent
  (5) 常量：所有字母大写，每个单词之间用" _ "连接
  
基本数据类型：8种
 1) 整型
  byte       1B  8位       -128到127
  short      2B  16位      -2^15到(2^15)-1
  int          4B  32位      -2^31到(2^31)-1
  long        8B  64位      -2^63到(2^63)-1
 2) 浮点类型
  float        4B   32位      
  double     8B   64位
 3) 字符类型
    char       2B 16位  
 4) 布尔型  1B
  boolean    false/true
  
 注：
  1、Java中的自动类型提升问题。
   1)、正向过程：从低字节到高字节可以自动转换。
    byte->short->int->long->float->double
   2)、逆向过程：从高字节到低字节用强制类型转换。
    例：int a = (int)4.562；
    注：逆向转换将丢失精度。
   2、boolean：只有true和false。
   3、char：Java中用" \u四位十六进制的数字 (即使在注释中出现\u，后面如果跟的不是4个数字，也会报错)"表示将字符转换成对应的unicode编码，字符类型要用单引号括起来。
   4、黙认浮点类型为double，float数据类型有一个后缀为" f "或" F "。
   5、long类型有一个后缀，为" l " 或者" L "
 
引用数据类型：
 类、接口、数组
 引用类型 变量名 = new 引用类型名(参数);  //new后面一般跟的都是类的构造器
 成员：写在类体括号里面的
 
内存空间的分配：
 内存分为：
  栈：存放简单数据类型变量(值和变量名都存在栈中)，存放引用数据类型的变量名以及它所指向的实例的首地址
  堆：存放引用数据类型的实例

 

在中国，做软件是当今最时髦的事情，但做软件早已不仅仅是商业，而已经上升为一门艺术；早已经不是真正搞软件的人独占的地盘，而是融入房地产商、硬件厂商、服务商、各类投机者等三教九流无所不包的社会大棋局。　　显然，这是一次几十年不遇的政策机遇，其最大价值不在于真正的软件产业本身，不在于软件业务本身。因为真正的中国软件市场现在撑死也就200个亿，而且大部分(2／3以上)由国外软件公司所占有。但是，这次以软件为名义的热潮，其调动和转移的财富和资源，是千亿甚至万亿计的，是软件业本身的1～2个数量级以上，甚至也是几年前互联网热潮的2～3个数量级以上。这是所有试图把握软件机遇的人，必须首先判明的方向性问题。
　　我们借用围棋的术语，可以把商机划分为“金角银边草肚皮”，鲜明地分析如下：
　　1、金角：最软的高科技和最土的房地产，鲜花插牛粪也好，天造一双地配一对也好，反正今后今年他们都将如胶似漆！以软件的名义，全国各省市，各区县都将有成千上万亩的土地纷纷成为软件园，这无疑是房地产的大好机遇。因此，各地的软件园和软件学院，以及其他以软件名义腾出的地皮，是这场软件热潮的价值核心。
　　2、银边：政策效应的最根本特点就是全国上下会争先恐后，一齐跟进。上上下下都会响应号召，出台各种扶持政策。包括税收减免、资金投入以及其他优先政策，都可以形成不菲的政策资源。这些资源利用得当也可以及时转化为真金白银。因此，如果几年之内，全国的硬件公司、IT服务公司甚至其他行业的公司，全部或者大多都转变成软件公司，你也不要大惊小怪。只要真正有利益。软件业全国上下大繁荣，也是可以期待的。当然，这是中国“特色”的软件业，是远远超越了国际上一般标准的软件概念。
　　3、草肚皮：大获其利的很少是真正的软件公司。因为那些一门心思搞软件的人，大多笨手笨脚。热潮之下，供需严重失衡，软件人才几年后很可能沦为青菜萝卜一样。不过，那些真正一头扎进软件，真的做成软件公司，也可能不错的。虽然，随着软件公司迅速繁衍，真的假的都来争夺有限的市场，竞争进一步激化，十分辛苦。但是，现在哪一行不辛苦？如果定位准确，真的能够一不留神做成、做大，然后融资上市，也是一步登天。
　　由此，所有赶潮软件的人，从高到低，可以分为三类：最上等是“为地皮而软件”，中间是“为政策而软件”，最下等是“为软件而软件”，构成了食物链的金字塔。与国内其他行业的政策造市的基本规律没有本质差异。
　　面对软件热潮中的一些不和谐现象，我们没有必要只从消极和负面的角度来评判。毕竟，在这股热潮中，假作真时假也真，软件业之外的庞大资源肯定会有一小部分要转化到软件产业。由于资源总量庞大，有百分之一或者百分之几的转化，对于软件业来说，就是“久旱逢甘雨”，就是极大的支持。比如以国内软件园圈地最为成功的托普为例，它在全国的几十个软件园都是不错的房地产项目，运作得当，利润十分丰厚。拿出一小部分利润来投入软件，补贴软件，几年以后一不留神也会“培育”出真正的软件业务。毕竟，大家打的都是“软件”的旗号，完全没有软件，这个美妙的游戏也是难以为继的。这一切总比那些纯粹的房地产商要好一些！
　　因此，吃着房地产的剩饭，软件也可能一点点长大成人。走出过门，走向世界；挑战微软，打败印度，也不是完全没有可能。市场就是一个追逐利益最大化的棋局，消极的批评作用和意义不大。不如，我们正视现实，承认积极、正面的效应，坦然应对这场势不可当的大热潮。
　　总之，政策已经为我们布好了巨大的棋盘，至于如何布局和下子，那就是一个各显其能的时候。我们当然真诚希望，那些真正有心推动中国软件业发展的人士，能够认清形势，放开思路。在这场大规模的财富与资源转移中，不要太固守成见，应放开手脚，争取获得尽可能多的利益，使中国软件得到更好的推动。