C#中using关键字用法
1、引用命名空间。
2、为命名空间或类型创建别名。
3、使用using语句。
1、引用命名空间，这样就可以直接在程序中引用命名空间的类型而不必指定详细的命名空间。
这个就不用说了吧，比如大家最常用的：using System.Text;
2、为命名空间或类型创建别名：
当同一个cs引用了不同的命名空间，但这些命名控件都包括了一个相同名字的类型的时候,可以使用using关键字来创建别名，这样会使代码更简洁。注意：并不是说两个名字重复，给其中一个用了别名，另外一个就不需要用别名了，如果两个都要使用，则两个都需要用using来定义别名的。
using System;
using aClass = NameSpace1.MyClass;
using bClass = NameSpace2.MyClass;
......
//使用方式
aClass my1 = new aClass();
Console.WriteLine(my1);
bClass my2 = new bClass();
Console.WriteLine(my2);
3、使用using语句，定义一个范围，在范围结束时处理对象。(不过该对象必须实现了IDisposable接口)。其功能和try ,catch,Finally完全相同。
比如:
using (SqlConnection cn = new SqlConnection(SqlConnectionString)){......}//数据库连接
using (SqlDataReader dr = db.GetDataReader(sql)){......}//DataReader
PS：这里SqlConnection和SqlDataReader对象都默认实现了IDisposable接口，如果是自己写的类，那就要自己手动来实现IDisposable接口。比如：
using (Employee emp = new Employee(userCode))
{
......
}
Emlpoyee.cs类：
public class Employee:IDisposable
{
实现IDisposable接口#region 实现IDisposable接口
/**////
/// 通过实现IDisposable接口释放资源
///
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/**////
/// 释放资源实现
///
///
protected virtual void Dispose(bool disposing)
{
if (!m_disposed)
{
if (disposing)
{
// Release managed resources
if(db!=null)
this.db.Dispose();
if(dt!=null)
this.dt.Dispose();
this._CurrentPosition = null;
this._Department = null;
this._EmployeeCode = null;
}
// Release unmanaged resources
m_disposed = true;
}
}
/**////
/// 析构函数
///
~Employee()
{
Dispose(false);
}
private bool m_disposed;
#endregion
}
使用using语句需要注意的几点：
3.1、对象必须实现IDisposeable接口，这个已经说过，如果没有实现编译器会报错误。
如：
using( string strMsg = "My Test" )
{
Debug.WriteLine( strMsg );//Can't be compiled
}
3.2、第二个using对象检查是静态类型检查，并不支持运行时类型检查，因此如下形式也会出现编译错误。
SqlConnection sqlConn = new SqlConnection( yourConnectionString );
object objConn = sqlConn;
using ( objConn )
{
Debug.WriteLine( objConn.ToString() );//Can't be compiled
}
不过对于后者，可以通过“as”来进行类型转换方式来改进。
SqlConnection sqlConn = new SqlConnection( yourConnectionString );
object objConn = sqlConn;
using ( objConn as IDisposable )
{
Debug.WriteLine( objConn.ToString() );
}
3.3、当同时需要释放多个资源时候，并且对象类型不同，可以这样写：
using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) ) using( SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn ) ) {
sqlConn.Open();//Open connection
/Operate DB here using "sqlConn"
sqlConn.Close();//Close connection
}
如果对象类型相同，可以写到一起：
using (Font MyFont = new Font("Arial", 10.0f), MyFont2 = new Font("Arial", 10.0f))
{
// use MyFont and MyFont2
} // compiler will call Dispose on MyFont and MyFont2
3.4、using关键字只是针对C#语句，对于VB等其他语言还没有对应的功能。
关于.Net资源释放问题，也就是对于非内存的资源，最好使用IDisposable接口提供的Dispose来释放。
很明显，Dispose方法是一个外部方法，系统并不会帮你调用。为了尽早释放对象所占用的资源，所以需要保证Dispose方法能尽早被执行。那么在.Net中提供了一个比较简便的方法，就是对于实现了IDisposable接口的类型对象提供了using语句。
就操作一个数据库这个例子来说，使用using语句可以如下：
using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) ) {
sqlConn.Open(); //Open connection
//Operate DB here using "sqlConn"
sqlConn.Close(); //Close connection
}
但是有时候当多个对象需要释放的候，例如：
SqlConnection sqlConn = new SqlConnection( yourConnectionString );
SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn );
using(sqlConn as IDisposable)
using(sqlComm as IDisposable)
{
sqlConn.Open(); //Open connection
sqlComm.ExecuteNonQuery(); //Operate DB here
}
这时候要特别注意，需要确保在发生异常的情况下，所有对象都能正常释放。显然，这段程序块，当构造“sqlComm”对象发生异常，会造成“sqlConn”对象无法及时被释放。虽说构造函数内部很少发生异常，或者说编写程序的时候要尽量避免从构造函数内向外散发异常。不过这里所说的意思是，要尽量把需要释放的对象放到using或者try-catch程序块，并作局部的异常处理，避免异常造成有些对象没有被释放。那么改进的方法，例如可以如下。 using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) ) using( SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn ) )
{
try
{
sqlConn.Open(); //Open connection
sqlComm.ExecuteNonQuery(); //Operate DB here
}
catch( SqlException err )
{
MessageBox.Show( err.Message );
}
catch( Exception err )
{
MessageBox.Show( err.Message );
}
}
（如上，即使在构造“sqlComm”出现异常，也会释放“sqlConn”对象。同时在这里多谢 lmtz 网友对文章提出的异议，从而使我重新审查此文，并进行修正。）
但是对于using程序块来说，它有两个限制。
第一个就是using所对应的对象必须继承IDisposable，如果此对象没有继承IDisposable接口的话，系统会提示编译错误。
例如：
using( string strMsg = "My Test" )
Debug.WriteLine( strMsg ); //Can't be compiled
第二个using对象检查是静态类型检查，并不支持运行时类型检查，因此如下形式也会出现编译错误。
SqlConnection sqlConn = new SqlConnection( yourConnectionString );
object objConn = sqlConn;
using ( objConn )
{
Debug.WriteLine( objConn.ToString() ); //Can't be compiled
}
不过对于后者，可以通过“as”来进行类型转换方式来改进。
SqlConnection sqlConn = new SqlConnection( yourConnectionString );
object objConn = sqlConn;
using ( objConn as IDisposable )
{
Debug.WriteLine( objConn.ToString() );
}
对于Dispose函数的调用来说，使用using程序块来完成只是最常用的方法，除此外，还可以用try-finally来完成，例如：
SqlConnection sqlConn = new SqlConnection( yourConnectionString );
try
{
sqlConn.Open();
//Operate DB here using "sqlConn"
}
finally
{
if( sqlConn != null )
sqlConn.Dispose();
}
为了及早释放对象所占用的非托管资源，因此要保证Dispose方法能在使用完对象后被调用，.Net提供了using程序块和try-finally程序块两个方法，两者并没有太大的区别，可能使用using能使程序看得比较简明，但是为了防止异常，需要在using中加入try-catch，这样反而不如try-finally看得舒服，不过这也只是我个人的看法。总的来说，只要把方法合理整合到应用程序当中才是最重要的。
public DataSet GetRoleList()
{
using(DataSet roles=RunProcedure("sp_Accounts_GetAllRoles",new IDataParameter[] {},"Roles"))
{
return roles;
}
}
using 的作用我记得是这样的。using后面的括号表示这里面有重要的资源产生，
using下面的 {}表示在这段代码运行完后释放掉那个
（注：可编辑下载，若有不当之处，请指正，谢谢!）
typedef用法 1、为现有数据类型定义同义词 typedef使用最多的地方是创建易于记忆的类型名，用它来归档程序员的意图。 例如： typedef int size; 此声明定义了一个int的同义字，名字为size。注意typedef并不创建新的类型。 它仅仅为现有类型添加一个同义字。你可以在任何需要int的上下文中使用size： void measure(size*psz); size array[4]; 2、typedef还可以掩饰复合类型，如指针和数组 z数组 例如：typedef char Line[81];表示使用Line代表具有81个元素的char类型数组。如果要生成类似的数据可以使用如下形式：Line text,secondline; 相当于char test[81];char secondline[81]; z隐藏指针语法 例如：typedef char*pstr; int mystrcmp(pstr,pstr);相当于 int mystrcmp(char*,char*); 注意：标准函数strcmp()有两个‘const char*'类型的参数。因此，它可能会误导人们象下面这样声明mystrcmp()， int mystrcmp(const pstr,const pstr); 这是错误的，‘const pstr'被解释为‘const char*‘（一个指向char的常量指针），而不是‘char*'（指向char的指针）。 修改：添加，typedef const c pstr; 记住：不管什么时候，只要为指针声明typedef，那么都要在最终的typedef 名称中加一个const，以使得该指针本身是常量，而不是对象 z链表中应用 例如： typedef struct node {
动名词的用法及练习 你听过英文语法有动词(verb)、名词(noun)；但你听过有动名词(gerund)吗 1. The girl is singing a song. 2. The girl singing now is my sister. 3. Singing is one of her hobbies(爱好). 一、名词性的动名词(Nominal Gerund) Nominal Gerund 可以加上定冠词(Definite article，如the)或不定冠词(Indefinite article，如a, an)，其他可加在动名词前的还有如：my, this, some, any, all, no 等等。举例如下： 1. The mellow(愉快地) singing of the birds announces the coming of spring. (singing前加定冠词the及形容词mellow；coming 前加the) 2. We knew the robber was near when we heard a faint rustling(沙沙声) in the bushes. (rustling 前加不定冠词a及形容词faint) 从上面的例子可看出如何将一个动词转成名词；但它和真正的名词还是有区别的，那就是没有单数或复数之分。不过，有一些动名词是可以变成真正名词的喔，如：saying, writing, opening, painting, cutting, heading, feeling, being,saving, surrounding, crossing, misunderstanding 等等。它们都可以有复数的喔，方法就是在它们的后面加个s，如：paintings。 二、动词性的动名词(Verbal Gerund) 看看下面的句子： Carelessly writing essays annoys the teacher. 上面的句子里的writing是动名词，但前面有副词carelessly（粗心地），后面又有受词(Object) essays。因此writing就有动词的特征。 注意：Verbal Gerund 这类动名词的前面可不能加上任何冠词(the, a, an ...)喔。 动名词的功能与用法 一、在句子中用作主语(Subject)或主语的补语(Subject Complement): 作主语 1. Listening to music gives me pleasure. (主语Listening ） 2. Running is good exercise. （主语running) 3. Walking to school is a good idea. (主语walking) 作主语的补语 1. My cat's favorite activity is sleeping. (补语sleeping) 2. Seeing is believing. (主语seeing, 补语believing) 主语置于句尾用It + be + ... +v-ing 句型 1. It is fun speaking English. 2. It is of great importance fighting against pollution(污染). 用It is 后接no use. no good, fun 等的句型 1. It is no use learning theory without practice. 2. It is no fun being lost in rain. 用It is 后接useless, nice, good, interesting, worthwhile 等的句型 1. It is worthwhile taking this into consideration. 用There + be + no + v-ing 的句型 1. There is no joking about such matters. 2. There is no getting along with him. (简直无法与他相处) 二、动名词也可以作宾语（Object) 作动词/动词短语的宾语(置于动词或动词短语的后面） 1. I cannot help laughing. （我禁不住笑了起来）（宾语laughing) 2. You should avoid quarrelling with your sister. (宾语quarrelling) 3. You should practice speaking English more. (宾语speaking) 注意：上面三个句子中的动词:help, avoid, practice 只能用动名词作宾语。这类动词还有：dislike 厌恶admit 接受repent 后悔acknowledge 承认
有不少做.net的程序员是从其他语言转过来的，开始用C#的时候可能这样连接数据库： using System; using System.Collections; using System.Configuration; using System.Data; using System.Data.SqlClient; using System.Linq; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.HtmlControls; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Xml.Linq; namespace WebApplication1 { public partial class _Default : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { SqlConnection cnn = null; try { cnn = cnn = new SqlConnection("ConnectionString"); // 创建数据库连接 cnn.Open(); // 打开数据库 // 操作数据库...... } finally { if (cnn != null) // 如果数据库连接不为空就关闭 { cnn.Close(); } } } } } 其实有一种简洁、美观的方式值得借签： using System;
C语言的32个关键字意义与用法 2009-11-20 13:19 1)auto 声明自动变量。可以显式的声明变量为自动变量，只要不是声明在所有函数文前的变量，即使没有加auto关键字，也默认为自动变量。并且只在声明它的函数内有效。而且当使用完毕后，它的值会自动还原为最初所赋的值。自动变量使用时要先赋值，因为其中包含的是未知的值例如:auto int name=1 2)static: 声明静态变量。可以显式的声明量为静态变量。也为局部变量。只在声明它的函数内有效。它的生命周期从程序开始起一直到程序结束。而且即使使用完毕后，它的值仍不还原。即使没有给静态变量赋值，它也会自动初始化为0，例：static int name=1 3)extern: 声明全局变量。用时声明在main函数之前的变量也叫全局变量。它可以在程序任何地方使用。程序运行期间它一直存在的。全局变量也会初始化为0，例：extern int name 4)register: 声明为寄存器变量。也为局部变量，只在声明它的函数内有效。它是保存寄存器中的，速度要快很多。对于需要频繁使用的变量，使用它来声明会提高程序运行速度。例： register int name=1 5)int: 声明量的类型。int为整数型。注意在16位和32位系统中它的范围是不用的。16位中占用2个字节；32位中占用4个字节。还可以显式的声明为无符号或有符号：unsigned int signed int.有符号和无符号的区别就是把符号也当作数字位来存储；也可以用short和long来声明为短整型或长整行例： int mum 6)float: 声明变量的类型。float浮点型，也叫实型。它的范围固定为4个字节。其中6位小数位，其他为整数位。例： float name 7)double: 声明为双精度类型。它的范围为8个字节，14位为小数位。也可使用更高精度的long double.它的范围则更大，达到10字节。例： double name 8)struct: 声明结构体类型。结构体可以包含各种不类型的量。比如可以把整型，字符型等类型的变量声明在同一个结构体种，使用的时候使用结构体变量直接可以调用。例： struct some{ int a=1; float b=1.1 double=1.1234567 }KKK;
学士后Java阶段测试-U1单元-笔试试卷1 考试时间 60分钟 选择题(共50题，每题2分，满分100分) 1) 在Java类中，使用以下（）声明语句来定义公有的int型常量MAX。 A. public int MAX = 100; B. final int MAX = 100; C. public static int MAX = 100; D. public static final int MAX = 100; 2) 在Java中，下列关于方法重载的说法中错误的是（）（多选）。 A. 方法重载要求方法名称必须相同 B. 重载方法的参数列表必须不一致 C. 重载方法的返回类型必须一致 D. 一个方法在所属的类中只能被重载一次 3) 给定Java代码如下所示，在横线处新增下列（）方法，是对cal方法的重 载。（多选） public class Test{ public void cal(int x, int y, int z) {} ________________ } A. public int cal(int x, int y, float z){ return 0; } B. public int cal(int x, int y, int z){ return 0; } C. public void cal(int x, int z){ } D. public void cal(int z, int y, int x){ } 4) 在Java中，下面对于构造函数的描述正确的是（）。 A. 类必须显式定义构造函数 B. 构造函数的返回类型是void C. 构造函数和类有相同的名称，并且不能带任何参数 D. 一个类可以定义多个构造函数 5) 下面Java代码的运行结果是（）。 class Penguin { private String name=null; // 名字 private int health=0; // 健康值 private String sex=null; // 性别 public void Penguin() { health = 10; sex = "雄"; System.out.println("执行构造方法。");
twist的用法总结大全 twist的用法你知道多少，今天给大家带来twist的用法，希望能够帮助到大家，下面就和大家分享，来欣赏一下吧。 twist的用法总结大全 twist的意思 vt. 扭成一束,搓，捻,绕，卷,连结，交结 vi. 被搓揉,蜿蜒，曲折,扭曲身体，扭动,旋转，转动 n. 揉搓之物,丝线,烟草卷,旋转 变形：过去式: twisted; 现在分词：twisting; 过去分词：twisted; twist用法 twist可以用作动词 twist的基本意思是指纺纱或捻线的一个程序,两股或多股细丝互相拧成纱或线。引申可指“盘绕”“旋转”“扭伤”。用于比喻可指“曲解(话、词等的)意义”。
twist可用作不及物动词,也可用作及物动词。用作及物动词时,接名词或代词作宾语。可用于被动结构。用作不及物动词时,主动形式可含有被动意义。 twist有时可接以形容词作补足语的复合宾语。 twist用作动词的用法例句 She twisted the long scarf round her head.她把那条长围巾围在头上。 Selecting the suitable twist factor in order to meet the needs of flax knitting yarn, it is the key to increase high_grade and productivity of flax knitting products.选择合理的捻系数以满足针织用纱的要求是提高亚麻针织产品档次和生产效率的关键。 We twisted the bed sheets into a rope and escaped by climbing down it.我们把床单搓成绳子，援绳下坠逃跑了。 twist用法例句 1、The battle of the sexes also took a new twist. 两性之争也出现了新的变数。 2、Twist the string carefully around the second stem with the other hand.
C#的New关键字的几种用法 2009年01月24日星期六 09:34 前段时间一个朋友问到C#的New关键字有几种用法，虽说在日常编程中经常用到这个小家伙，但它到底有几种用法还真没有留意过，现将从网上总结出的资料记下以供同仁学习。 (1)new 运算符用于创建对象和调用构造函数。 (2)new 修饰符用于隐藏基类成员的继承成员。 (3)new 约束用于在泛型声明中约束可能用作类型参数的参数的类型。 new 运算符 1.用于创建对象和调用构造函数 例：Class_Test MyClass = new Class_Test(); 2.也用于为值类型调用默认的构造函数 例：int myInt = new int(); myInt 初始化为 0，它是 int 类型的默认值。该语句的效果等同于：int myInt = 0; 3.不能重载 new 运算符。 4.如果 new 运算符分配内存失败，则它将引发 OutOfMemoryException 异常。 new 修饰符 使用 new 修饰符显式隐藏从基类继承的成员。若要隐藏继承的成员，请使用相同名称在派生类中声明该成员，并用 new 修饰符修饰它。 请看下面的类： 1 public class MyClass 2 3 { 4 5 public int x; 6 7 public void Invoke() {}
9 } 10 在派生类中用 Invoke 名称声明成员会隐藏基类中的 Invoke 方法，即： 1 public class MyDerivedC : MyClass 2 3 { 4 5 new public void Invoke() {} 6 7 } 8 但是，因为字段 x 不是通过类似名隐藏的，所以不会影响该字段。 通过继承隐藏名称采用下列形式之一： 1.引入类或结构中的常数、指定、属性或类型隐藏具有相同名称的所有基类成员。 2.引入类或结构中的方法隐藏基类中具有相同名称的属性、字段和类型。同时也隐藏具有相同签名的所有基类方法。 3.引入类或结构中的索引器将隐藏具有相同名称的所有基类索引器。 4.在同一成员上同时使用 new 和 override 是错误的。 注意：在不隐藏继承成员的声明中使用 new 修饰符将生成警告。 示例 在该例中，嵌套类 MyClass 隐藏了基类中具有相同名称的类。该例不仅说明了如何使用完全限定名访问隐藏类成员，同时也说明了如何使用 new 修饰符消除警告消息。 using System; public class MyBaseC { public class MyClass { public int x = 200; public int y;
typedef使用详解 1.再论typedef 1.1、如何轻松理解和应用typedef？ typedef用最简单的话去诠释他，那么就是给类型取别名。但是牠并没有你想象的那么简单！举例：typedef int size;//那么int就有一个别名叫size了，以后size就和int这个类型是一样的用法了。 看到这里，如果你仅仅认为typedef不过如此，不就是把第一个参数（类型名），等同于第二个参数，这么简单。那你可能就会陷入困境。 比如看下面这个例子： typedef char Line[81]; 你能说Line[81]就是char的别名吗？这显然不对。它真正的含义是：Line类型即代表了具有81个元素的字符数组。那么Line t；就等同于char t[81];看到这里读者是否晕了？我们尝试把它放在一起看看。 typedef int size; //typedef行 int i; //原型行 size i; //应用行 同理： typedef char Line[81]; //typedef行 char t[81]; //原型行 Line t; //应用行 再举一个函数指针的例子： typedef int (*fun_ptr)(int,int); //typedef行 int (*fp)(int,int); //原型行 fun_ptr fp; //应用行 以上3个例子都有以下几个共同点： 1、“typedef行”和“原型行”相比，“typedef行”仅仅多个typedef而已。就函数指针的例子来说，其次，“typedef行”和“原型行”的根本区别在于：fun_ptr是类的别名，fp是该类的变量。 2、“原型行”和“应用行”，它们的编译结果是一样的。就函数指针的例子来说，他们都是创建了一个类型为int (*)(int,int)的函数指针fp。只是fun_ptr fp（应用行）比int (*fp)(int,int)（原型行）这种形式更加简洁，便与书写和理解。形式越复杂typedef 的优势就越明显。 Typedef的定义应用和理解应该是一步到位的。 定义过程：只要我们能写出原型行，就能直接写出typedef行。应为形式上只差一个typedef。如：我们写出原型：char t[81]，那么加上一个typedef就能得到我们想要的定义，当然可以修改下类名，如：typedef char T[81]。 应用过程：T t;其中T是之前定义的类型，t是通过该类型定义的变量。 理解过程：如何理解“T t;”要想理解“T t;”就找到与之对应的“原型行”，但是“原型行”一般在程序中是不会出现，所以只能先找到“typedef行”，在通过“typedef行”推出“原型行”（推的过程就是去掉typedef而已）。 “T t;”的“typedef行”为typedef char T[81]，所以“T t”所表示的“原型行”就是char x[81]，而“原型行”和“应用行”（这里“T t;”就是应用行），的含义完全相同。那么对“T t;”的理解就是对char x[81]的理解。 在“T t”的定义中，T的typedef定义形式为：
使用super来引用父类的成分，用this来引用当前对象一、super关键字 在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另 外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。 1.1.super关键字测试 1package cn.galc.test; 2 3/** 4 * 父类 5 * @author gacl 6 * 7*/ 8class FatherClass { 9public int value; 10public void f() { 11 value=100; 12 System.out.println("父类的value属性值="+value); 13 } 14 } 15 16/** 17 * 子类ChildClass从父类FatherClass继承 18 * @author gacl 19 * 20*/ 21class ChildClass extends FatherClass { 22/**
23 * 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性， 24 * 也就是说，此时的子类拥有两个value属性。 25*/ 26public int value; 27/** 28 * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。 29*/ 30public void f() { 31super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法 32 value=200;//这个value是子类自己定义的那个valu，不是从父类继承下来的那个value 33 System.out.println("子类的value属性值="+value); 34 System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200 35/** 36 * 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时， 37 * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法， 38 * 即相当于是这个父类对象自己调用f()方法去改变自己的value 属性的值，由0变了100。 39 * 所以这里打印出来的value值是100。 40*/ 41 System.out.println(super.value); 42 } 43 } 44 45/** 46 * 测试类 47 * @author gacl 48 * 49*/ 50public class TestInherit { 51public static void main(String[] args) { 52 ChildClass cc = new ChildClass();
动名词的用法详解 今天给大家带来动名词的用法详解，我们一起来学习吧，下面就和大家分享，来欣赏一下吧。 英语语法：动名词的用法详解 动名词因同时拥有动词和名词两者的特点而拥有及其丰富 的用法，熟练的掌握这些用法不仅可以使口语表达更地道生动，也能在写作中增分添彩。 动名词主要有四种用法，做主语，作宾语，作表语，作定语，每种用法下又分小类别，是一个非常复杂庞大的系统，学习者们往往会理不清脉络，今天就为大家带来动名词的用法讲解。 一.作主语 1.直接位于句首 eg.Swimming is a good sport in summer. 2.用it作形式主语，把动名词(真实主语)置于句尾作后置主语。 eg.It is no use telling him not to worry.
.mportant，essential，necessary等形容词不能用于上述结构。 3.用于“There be”结构中 eg.There is no saying when hell come. 4.动名词的复合结构作主语: 当动名词有自己的逻辑主语时，常可以在前面加上一个名词或代词的所有格，构成动名词的复合结构,动名词疑问句通常使用这种结构做主语 eg.Their coming to help was a great encouragement to us. Does your saying that mean anything to him? 二.作宾语 1.作动词的宾语 某些动词后出现非限定性动词时只能用动名词作宾语，不能用不定式。不定式通常指某种特定的动作，但动名词表示泛指，常见的此类动词有： admit,appreciate,excuse,stand,advise,allow,permit,avoid,consider,e njoy,finish,give up,cannot help,imagine,include,keep,understand,keepon,mind,report,risk,mis s,put off,delay,practise,resist,suggest,depend on,think about,set about,succeed in,worry about,burst out,insist on,feel like,be used
用法三则 C# Using C#关键字的用法不单只有一种方法的。现在我总结了一下Using和New的用法，顺便也是为了帮助大家更好的理解C# using用法。 Using （1）引用命名空间 using作为引入命名空间指令的用法规则为： using Namespace; 在.NET程序中，最常见的代码莫过于在程序文件的开头引入System命名空间，其原因在于System命名空间中封装了很多最基本最常用的操作，下面的代码对我们来说最为熟悉不过：using System; 这样，我们在程序中就可以直接使用命名空间中的类型，而不必指定详细的类型名称。using 指令可以访问嵌套命名空间。 关于：命名空间 命名空间是.NET程序在逻辑上的组织结构，而并非实际的物理结构，是一种避免类名冲突的方法，用于将不同的数据类型组合划分的方式。例如，在.NET中很多的基本类型都位于System命名空间，数据操作类型位于System.Data命名空间， （2）创建命名空间别名 using为命名空间创建别名的用法规则为： using alias = namespace | type; 其中namespace表示创建命名空间的别名；而type表示创建类型别名。例如，在.NET Office 应用中，常常会引入Microsoft.Office.Interop.Word.dll程序集，在引入命名空间时为了避免繁琐的类型输入，我们通常为其创建别名如下： using MSWord = Microsoft.Office.Interop.Word; 这样，就可以在程序中以MSWord来代替Microsoft.Office.Interop.Word前缀，如果要创建Application对象，则可以是这样， 而且还有一个好处就是，在一个.CS文件中引入了不同的命名空间但是相同的类名的时候，用别名就可以解决这问题了。
public class HelloWorld { public static void main(String[] args) { Dog d=new Dog(); d.shout(); d.printName(); } } class Animal{ String name="动物"; void shout() { System.out.println("动物发出叫声"); } } class Dog extends Animal{ String name="犬类"; void shout() { super.shout();//使用super关键字访问父类的成员方法} public void printName() { System.out.println("它的名字是name="+https://www.doczj.com/doc/a410575831.html,); //使用super关键字访问父类的成员变量
} public class HelloWorld { public static void main(String[] args) { Dog d=new Dog(); } } class Animal{ String name="动物"; public Animal(String name){ System.out.println("它是一只"+name); } void shout() { System.out.println("动物发出叫声"); } } class Dog extends Animal{ String name="犬类"; public Dog() { super("二哈");
doing allow，permit，advise，forbid sb to do 有这样几道题： a. We don’t allow __________ in the office. b. We don’t allow people __________ in the office. c. People are not allowed __________ in the office. A. smoking B. to smoke C. smoked D. smoke 此题答案为a句选 A，b句和c句均选 B。一般说来，动词allow(允许)之后应接动名词作宾语，但是若其后接有名词或代词作宾语，则其宾语后的补足语应用不定式，而不是动名词(注意：c句与b句同义，只是c句为b句的被动形式)。 类似以上用法的动词还有 permit，advise，forbid等： 1. a. We don’t permit _________ on the grass. b. We don’t perm it people _________ on the grass. c. People are not permitted _________ on the grass. A. walk B. to walk C. walking D. walked 2. a. He advised _________ early. b. He advised us _________ early. c. We were advised _________ early. A. leave B. to leave C. leaving D. left 3. a. We forbid __________ a noise. b. We forbid people __________ a noise. c. People are forbidden __________ a noise. A. make B. to make C. making D. made
[编辑本段] C语言中typedef用法 1. 基本解释 typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。 在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。 至于typedef有什么微妙之处，请你接着看下面对几个问题的具体阐述。 2. typedef & 结构的问题 当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？莫非C语言不允许在结构中包含指向它自己的指针吗？请你先猜想一下，然后看下文说明：typedef struct tagNode { char *pItem; pNode pNext; } *pNode; 答案与分析： 1、typedef的最简单使用 typedef long byte_4; 给已知数据类型long起个新名字，叫byte_4。 2、typedef与结构结合使用 typedef struct tagMyStruct { int iNum; long lLength; } MyStruct; 这语句实际上完成两个操作： 1) 定义一个新的结构类型 struct tagMyStruct { int iNum; long lLength; }; 分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。
我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMy Struct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。 2) typedef为这个新的结构起了一个名字，叫MyStruct。 typedef struct tagMyStruct MyStruct; 因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct var Name来定义变量。 答案与分析 C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。 根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNo de。 解决这个问题的方法有多种： 1)、 typedef struct tagNode { char *pItem; struct tagNode *pNext; } *pNode; 2)、 typedef struct tagNode *pNode; struct tagNode { char *pItem; pNode pNext; }; 注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。 3)、规范做法： struct tagNode { char *pItem; struct tagNode *pNext; }; typedef struct tagNode *pNode; 3. typedef & #define的问题
如果子类中定义的成员变量和父类中成员变量同名时，子类就隐藏了从父类继承的成员变量。当子类中定义了一个方法，并且这个方法的名字、返回类型、参数个数和类型和父类的某个方法完全相同盟时，子类从父类继承的这个方法将被隐藏。如果在子类中想使用被隐藏的成员变量或方法就可以使用关键字 super。 1 使用关键字super调用父类的构造方法 子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的关一条语句,如例子4.23所示. 例子4.23 class Student { int number; String name; public Student() { } public Student(int number,String name) { this.number=number; https://www.doczj.com/doc/a410575831.html,=name; System.out.println(" I am "+name+" my number is "+ number); } } class Univer_Student extends Student { boolean marry; public Univer_Student(int number,String name,boolean b) { super(number,name); marry=b; System.out.println("婚否=" + marry); }
} public static void Example4_23 { public static void main(String args[]) { Univer_Student zhang=new Univer_Student(9901,"和晓林",false); } } 运行结果： I am 和晓林my number is 9901 婚否=false; 需要注意的是：如果在子类的构造方法中，没有使用关键字super调用父类的某个构造方法，那么默认有 super(); 语句，即调用父类的不带参数的构造方法。 如果类时定义了一个或多个构造方法，那么Java不提供默认的构造方法（不带参数的构造方法），因此，当在父类中定义多个构造方法时，应当包括一个不带参数的构造方法，以防子类省略super时出现错 误。
高考重点英语语法之allow与permit的运 用 he rules of the club do not permit smoking. 这个俱乐部规定不准吸烟。 They shouldn’t allow parking here； the street is too narrow. 这儿不该允许停车，马路太窄了。 我们不许在池子里游泳。 正：We don’t allow swimming in the pool. 误：We don’t allow to swim i n the pool. 但是，它们虽然不能直接跟不定式作宾语，但可跟不定式的复合结构作宾语。如： We don’t allow [permit] students to eat in the classrooms. 我们不允许学生在教室吃饭。 两者均可后接双宾语。如： We allow passengers one item of hand luggage each. 我们允许每个乘客带一件手提行李。 As it was such a special occasion， she permitted herself a small glass of champagne. 由于那是一个很特别的场合，所以她。
两者均不能后接that引导的宾语从句。如： 我们不允许人们在大教室抽烟。 误：We don’t all [permit] that people smoke in the lecture room. 正：We don’t allow [permit] people to smoke in the lecture room. allow与allow的几点区别： （1） permit 通常指上级、规则或法令等表示的准许，其语气较重；而allow 通常指消极地不加反对，有时含有听任或默许之意，语气较轻：The nurse allowed him to remain there，though it was not permitted. 护士让他留在那儿，而按规定那是不许可的。 （2） permit可用于带形式主语it的被动结构，但allow不行。如： It is not permitted to smoke in the kitchen. 厨房内不准吸烟。
super 关键字的使用 super 关键字出现在子类中，主要功能就是完成子类调用父类中的内容，也就是调用父类中的属性或方法。 super 调用父类中的构造方法： class Person { String name; int age; public Person(String name,int age) { https://www.doczj.com/doc/a410575831.html,=name; this.age=age; } } class Student extends Person { String school; public Student() { super("张三",27); } } public class TestPersonStudentDemo { public static void main(String args[]) { Student s=new Student(); S.shchool=”北京”; System.out.println("我是:"+https://www.doczj.com/doc/a410575831.html,+",今年:"+s.age+"岁,学校:"+s.school) ; } } 输出结果为：我是张三，今年27岁，学校：北京 本程序在子类的构造方法中明确地指明了调用的是父类中有两个参数的构造方法，所以程序在编译时不再去找父类中无参的构造方法。 用super 调用父类中的构造方法，只能放在子类的第一行。 通过super 调用父类的属性和方法： class Person 父类构造方法 子类构造方法 调用父类构造方法
{ String name; int age; public Person() { } public String talk() { return "我是："+https://www.doczj.com/doc/a410575831.html,+",今年："+this.age+"岁"; } } class Student extends Person { String school; public Student(String name,int age,String school) { //在这里用super 调用父类中的属性 https://www.doczj.com/doc/a410575831.html,=name; super.age=age; //调用父类中的talk()方法 System.out.print(super.talk()); //调用本类中属性 this.school=school; } } public class TestPersonStudentDemo3 { public static void main(String args[]) { Student s=new Student("张三",27,"北京"); System.out.println(",学校："+s.school); } } 输出结果为： 我是：张三,今年：27岁,学校：北京 限制子类的访问 有些时候，父类并不希望子类可以访问自己的类中全部的属性或方法，所以需要将一些属性父类构造方法 子类构造方法 父类一般方法