C#-面向对象编程、接口、泛型
面向对象设计原则:
1 开闭原则：对扩展开放，对修改（old Code）关闭 2 类的单一职责：每个类有且只有一个改变它的原因 3 优先使用组合而非继承: 避免耦合度过高 4 面向接口编程而非面向过程: 定义一个类的时候,先思考对外提供什么功能,定义一个对外的接口 5 依赖倒置: 依赖抽象代码，因为具体实现容易改变 6 接口隔离：尽量定义小而精的接口，类实现多个功能，继承多个接口 7 里式替换：父类可以被子类替换掉 8 迪米特法则 : 类之间数据传递越少越好
C#中抽象类与接口
相同点: 1.可被继承, 不可被实例化,都是抽象的 不同: 1.抽象类可以继承类或接口 接口只能继承接口 2.抽象成员在子类中的实现方式不同,abstract的要用override实现,interface的实现不用 3.抽象类可包含已实现的成员, 接口只能出现抽象的成员 4.接口可以实现多继承,抽象类只能被单继承,基类必须在接口之前 5.接口中的方法必须被子类实现,抽象类中的方法不用,抽象方法必须被实现
面向对象的三大特性：封装，继承，多态
封装：组织代码的过程 继承：对概念和代码的复用 继承中的构造函数：构造函数不被继承，子类创建对象的时候，先调用父类的构造函数，再调用自己的构造函数，在父类没有无参的构造函数的时候，子类通过Base关键字指定调用调用哪个父类的构造函数。 多态：隐藏、重写、重载 隐藏：在子类中使用new关键字实现隐藏父类的方法 重写：父类方法不适用或者父类的抽象方法，子类中必须重写。可以重写的方法：虚方法、重写方法、抽象方法。 虚方法：用virtual修饰的方法，子类中可以不重写，抽象类和抽象方法都是用abstract修饰，抽象方法必须出现在抽象类中，子类必须重写抽象方法。
接口
接口目的为了提高代码的复用性我们用接口来定义行为 定义一组规范的数据结构,C#中为类提供某些功能 接口不能添加Public外的访问修饰符，接口中所有成员默认Public。接口中不能包含字段和已实现的方法。只能包含属性、未实现的方法、事件。 命名规范：一般接口的命名以"I"开头 实现方式两种： 隐式实现：通过方法名实现方法，方法前加public 显示实现（少用）：通过“接口.方法名”的形式实现。显示实现可以避免二义性，访问显示实现的接口要创建对应接口的类，来进行访问。
namespace 接口
{
//定义接口: 接口命名以大写I开头 , 后面单词首字母大写
//接口可以直接声明,但是不能被new
//接口中的成员也是抽象的
interface IMyInterface
{
void Add(int i, int j);
}
//接口是抽象的概念,创建接口对象,需要声明接口new子类
//接口可以被继承
//实现接口的方法不需要 override
class MyClass : IMyInterface
{
public void Add(int a, int b)
{
Console.WriteLine(a + b);
}
}
//抽象类,成员可以是非抽象的
abstract class MyAbstractClass
{
public abstract void Add(int i, int j);
}
class MyClass2 : MyAbstractClass
{
public override void Add(int i ,int j)
{
Console.WriteLine(i + j);
}
}
class Program
{
static void Main(string[] args)
{
IMyInterface myInterface = new MyClass();
myInterface.Add(2, 2);
}
}
}显式实现接口和隐式实现接口
//定义接口: 接口命名以大写I开头 , 后面单词首字母大写
//接口可以直接声明,但是不能被new
//接口中的成员也是抽象的
interface IMyInterface
{
void Cal(int i, int j);
string Name { get; set; }
void Print();
}
interface ICal
{
void Cal(int i, int j);
}
//接口是抽象的概念,创建接口对象,需要声明接口new子类
//接口可以被继承
//实现接口的方法不需要 override
class MyClass : IMyInterface, ICal
{
private string name;
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
//隐式实现接口
public void Print()
{
Console.WriteLine(Name);
}
//显示实现接口
//想调用显式接口,需要声明父接口才可以调用
void IMyInterface.Cal(int i, int j)
{
Console.WriteLine(i + j);
}
void ICal.Cal(int i, int j) {
Console.WriteLine(i - j);
}
public void Cal(int a, int b)
{
Console.WriteLine(a * b);
}
}Struct 结构体
我们要复用一些数据时可以使用结构体来直接定义数据的集合
泛型
将类型作为参数，在使用的时候再具体决定 泛型参数可以是多个,一般使用大写的T开头 反省参数一般可以使用在方法 类 委托等
namespace 泛型
{
class Program
{
static void Main(string[] args)
{
//泛型 C#2.0 推出的一种新机制 , 简化 面向对象开发代码
//栈
MyStack<int> myStack = new MyStack<int>();
myStack.Push(233);
myStack.Push(1);
Console.WriteLine(myStack.Pop());
Console.WriteLine(myStack.Pop());
}
}
class MyStack<T>
{
static int cap = 4;
T[] intStack = new T[cap];
static int currentIndex = 0;
public T Pop()
{
currentIndex--;
return intStack[currentIndex];
}
public void Push(T i)
{
if(currentIndex >= intStack.Length)
{
cap *= 2;
T[] newStack = new T[cap];
for(int j = intStack.Length; j < intStack.Length; j++)
{
newStack[j] = intStack[j];
}
intStack = newStack;
}
intStack[currentIndex] = i;
currentIndex ++;
}
}
}第二种写法
//类型: 不安全的栈 会有拆装箱操作
class MyStack2 {
public void Push<T>(T t) { }
}进行泛型约束: 约束条件为接口是,将泛型参数类型为接口或者接口的实现类
MyStack2 xixi = new MyStack2();
xixi.Push<SubCard>(new SubCard());
}
}
class Card
{
}
class SubCard : Card
{
}
//类型: 不安全的栈 会有拆装箱操作
class MyStack2 {
//将T约束为某一类型,或其子类型
public void Push<T>(T t) where T:Card
{ }
}使用接口作为泛型约束的实例 对任意可比较类型数据进行升序排序(冒泡)
class MyClass02 : IComparable
{
public int i;
public int CompareTo(object obj)
{
return i.CompareTo((obj as MyClass02).i);
}
}
//对任意可比较类型数据进行升序排序
class MyClass01
{
public T[] ArraySort<T>(T[] t) where T : IComparable
{
if (t.Length > 1)
{
for (int n = 0; n < t.Length; n++)
{
for (int m = 0; m < t.Length - n - 1; m++)
{
//如果前者大于后者
if (t[m].CompareTo(t[m + 1]) >= 0)
{
T temp = t[m + 1];
t[m + 1] = t[m];
t[m] = temp;
}
}
}
}
return t;
}
}
class Program
{
static void Main(string[] args)
{
MyClass02[] c1 = new MyClass02[3];
c1[0] = new MyClass02();
c1[0].i = 11110;
c1[1] = new MyClass02();
c1[1].i = 230;
c1[2] = new MyClass02();
c1[2].i = 10;
MyClass01 c3 = new MyClass01();
c1 = c3.ArraySort<MyClass02>(c1);
Console.WriteLine(c1[0].i);
Console.WriteLine(c1[1].i);
Console.WriteLine(c1[2].i);
}
}泛型约束
1.引用类型约束
where T:class 引用类型用class表示约束，约束必须为一个类，可以是接口interface
2.值类型约束
where T:struct int、char类型都是struct
3.构造函数类型约束
where T:new() 指定类型T必须有构造函数
4.转换类型约束
就是我们可以通过装箱或者强制类型转换成目标类型的 类型都可以用于类型参数传入。