1、什么是接口？ 功能特性？ 实现代码？
接口就是使用interface关键字定义的，由类的成员的组合组成的，描述一些功能的一组规范。在c#中可以看到，系统的一些接口都是这样命名的：icomparable（类型的比较方法）、icloneable（支持克隆）、idisposable（释放资源）等等，i表示接口，able则反映了接口的特性:“能... ...”，表明这一组规范能干什么。
（1）、接口实现
public interface IPrintAble
{
void PrintString();
void PrintInt();
void PrintBool();
}
public interface IComputeAble
{
void HandlerString();
void HandlerInt();
void HandlerBool();
}
public class MyInplementInterface : IPrintAble, IComputeAble
{
//隐式实现
public void PrintString()
{
Console.WriteLine(@"1");
}
public void PrintInt()
{
Console.WriteLine(1);
}
public void PrintBool()
{
Console.WriteLine(true);
}
public void HandlerString()
{
Console.WriteLine(@"1" + "1");
}
public void HandlerInt()
{
Console.WriteLine(1 + 1);
}
public void HandlerBool()
{
Console.WriteLine(true || false);
}
//显示实现
//void IComputeAble.HandlerString()
//{
// throw new NotImplementedException();
//}
//void IComputeAble.HandlerInt()
//{
// throw new NotImplementedException();
//}
//void IComputeAble.HandlerBool()
//{
// throw new NotImplementedException();
//}
}
class Program
{
static void Main(string[] args)
{
MyInplementInterface imple = new MyInplementInterface();
imple.PrintString();
imple.PrintInt();
imple.PrintBool();
imple.HandlerString();
imple.HandlerInt();
imple.HandlerBool();
Console.ReadLine();
}
}结果：
（2）实现专用接口，即C#已经定义好的接口
例：
public class ImplementSysInterface : IComparable
{
public int CompareTo(object obj)
{
//可以根据需要实现自己的比较方法
return 0;
}
private void UsingMenthod()
{
//报错，因为NoIDisposeableClass没有实现IDisposable接口，所以不支持using
//using (NoIDisposeableClass my = new NoIDisposeableClass())
//{
//}
//实现IDisposable接口后，可以使用using
using (IDisposeableClass my = new IDisposeableClass())
{
}
}
}
public class NoIDisposeableClass
{
}
public class IDisposeableClass : IDisposable
{
#region IDisposable 成员
public void Dispose()
{
}
#endregion
}接口有如下特性：
a、接口类似于抽象基类，不能直接实例化接口；接口中的方法都是抽象方法，实现接口的任何非抽象类型都必须实现接口的所有成员：
b、当显式实现该接口的成员时，实现的成员不能通过类实例访问，只能通过接口实例访问。
例如：
public class MyInplementInterface2 : IComputeAble
{
void IComputeAble.HandlerString()
{
Console.WriteLine(@"1" + "1");
}
void IComputeAble.HandlerInt()
{
Console.WriteLine(true || false);
}
void IComputeAble.HandlerBool()
{
Console.WriteLine(true || false);
}
}
class Program
{
static void Main(string[] args)
{
IComputeAble imple2 = new MyInplementInterface2();
imple2.HandlerString();
Console.ReadLine();
}
}c、当隐式实现该接口的成员时，实现的成员可以通过类实例访问，也可以通过接口实例访问，但是实现的成员必须是公有的。
d、接口不能包含常量、字段、运算符、实例构造函数、析构函数或类型、不能包含静态成员。
e、接口成员是自动公开的，且不能包含任何访问修饰符。
f、接口自身可从多个接口继承，类和结构可继承多个接口，但接口不能继承类。
2、什么是泛型？ 泛型有哪些优点？
所谓泛型，是将类型参数的概念引入到.NET，通过参数化类型来实现在同一份代码上操作多种数据类型。是引用类型，是堆对象。
其实，一开始学泛型，是在学习java的时候，当时没有搞明白，我一直都觉得泛型纯属多此一举，用object一样可以搞定。比如，如下，比如，有人以类型的值，都要打印出来，于是object实现：
public class Test
{
private object model;
public object Model
{
get
{
return model;
}
set
{
model = value;
}
}
public Test(object model)
{
this.Model = model;
}
public void ShowRecord()
{
Console.WriteLine(model);
}
}
class Program
{
static void Main(string[] args)
{
int recordI = 2;
bool recordB = true;
Test testI = new Test(recordI);
testI.ShowRecord();
Test testB = new Test(recordB);
testB.ShowRecord();
Console.ReadLine();
}
}但是当学的多了，就会发现还是有一定的问题的。首先，就是装箱问题，int是值类型，赋值给object类型时，要完成一次装箱操作。什么是装箱？就是把recordI值复制到新的object分配的空间。浪费了时间和性能。所以泛型还是有作用的，那么，用泛型来实现：
public class TestGeneric{ private T model; public T Model { get { return model; } set { model = value; } } public TestGeneric(T model) { this.Model = model; } public void ShowRecord() { Console.WriteLine(model); } } class Program { static void Main(string[] args) { int recordI = 2; bool recordB = true; TestGeneric testGI = new TestGeneric (recordI); testGI.ShowRecord(); TestGeneric testGB = new TestGeneric (recordB); testGB.ShowRecord(); Console.ReadLine(); } }
这样，当TestGeneric
当然泛型不仅仅是要解决装箱问题，功能特性如下：
a、避免装箱拆箱，提高了性能；
b、提高了代码的重用性；
c、类型安全的，因为在编译的时候会检测；
d、可以创建自己的泛型接口、泛型类、泛型方法、泛型事件和泛型委托。
以上就是C#基础知识整理：C#类和结构（4）的内容，更多相关内容请关注PHP中文网（www.php.cn）！
