知识汇总（C与C#）

将代码分解成若干个过程（按计算机的思维编程）

int main(){

过程1；

过程2；

...}

将代码按不同功能封装、分类（按人的思维编程）

1）单一职责原则：

一个类只实现一个功能（高内聚）

2）开闭式原则：

生成一个对象可以对该对象的功能进行扩展，但不能修改原有的功能

3）迪米特原则：

一个软件实体尽可能少地和其他实体发生相互作用，以减少耦合

4）里氏替换原则：

基类出现的地方，子类一定可以出现

5）依赖倒置原则：

通过抽象（抽象类或接口）让服务使用者不直接依赖服务提供者，而是服务使用者通过实现自身接口继承自服务提供者的服务

6）接口隔离原则：

为客户提供尽可能小地单独接口，以增加可用性

简单看一个C#代码，需要创建一个矩形对象，具有长宽属性，且可以显示长宽及面积：

using System;
namespace RectangleApplication
{
    class Rectangle
    {
       //成员变量
       double length;
       double width;
       public void Acceptdetails()
       {
          length=4.5;
          width=3.5;
       }
       public double GetArea()
       {
          return length*width;
       }
       public void Display()
       {
          Console.WriteLine("Length:{0}",length);
          Console.WriteLine("Width:{0}",width);
          Console.WriteLine("Area:{0}",GetArea());
       }
    }
    class ExecuteRectangle
    {
       static void Main(string[] args)
       {
          Rectangle r =new Rectangle();//创建实例对象
          r.Acceptdetails();
          r.Display();
          Console.ReadLine();
       }
    }
}            

C#与C类似，可以用sizeof获取长度

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。

对象（Object）类型 是 C#中所有数据类型的基类，对象类型可以被分配任何其他类型的值；

装箱：值类型被转换成对象类型

拆箱：对象类型转换为值类型

装箱和拆箱需要存在继承关系，使用会影响系统性能；

int val=8;
object obj=val;//装箱
int newVal=(int) obj;//拆箱

C#的数组是对象类型

声明数组变量时，数组的大小不是声明的一部分，实际创建数组实例的时候，才需要指定数组的大小。

int[] pins;
int size = int.Parse(Console.ReadLine());
int[] pins = new int[size];

编译时不发生，运行时才发生

dynamic d = 20;

string str = "abc";
//注意与char区别
//char ='a';

C和C#一致

1）数组必须在实例化前定义长度（C#中数组声明时不需要定义长度）

2）数组实例化后长度不可变，插入和删除比较麻烦，但查找和修改容易

3）数组的数据类型统一

1）集合不需要定义长度

2）集合的类型不需要统一

3）所有元素被添加到集合后都转为Object类型（封箱），转出来需要拆箱

class Program
{
  static void Main(string[] args)
  {//1.数组长度不可变2.类型单一
     ArrayList list =new ArrayList();
     list.Add(11)；//object任何类型的父类，可以放任何类型
                   //无论添加什么类型，都进行装箱操作
     list.Add("abc");
     list.AddRange(new int[] {1,2,3,4,5});//添加集合元素（array，list...）
     list.Remove(11);
  for(int i=0;i 
3.42List 
1)List长度可以任意改变
 
2）类型统一，
 
List list = new List();
list.Add(1);
list.Add(2);
 
3.43Dictionary 
1）dictionary<,>类型固定
 
2）长度不固定
 
Dictionary dic==new Dictionary();
dic.Add(1,"zhangsan");
dic.Add(2,"lisi");
dic[1]="zhangshan";
foreach(var item in dic.Keys)
{
 Console.WriteLine("{0}---{1}",item,dic[item]);
}
foreach(KeyValuePair kv in dic)
{
 Console.WriteLine("{0}---{1}",kv.Key,kv.Value);
}
 
4.面向对象的三大特性 
4.1封装 
把一个或多个项目封闭在包中，封装是通过访问修饰符来实现的。
 
用途：
 
1防止被破坏
 
2只需要了解如何通过类的接口使用类，不需要关心数据结构和数据组织方法
 
3减少耦合（即物体之间的关联）
 
4能在实现的子类扩展功能
 
4.11属性封装 
class Person
{
   private int age;
   
   public int Age {
      get {
          return age;
      }
      set {
          if(value>=10&&value<=20)
          age = value;
      }
}
 
get和set在属性中的作用：
 
属性和普通变量的区别：属性可以通过设置访问器的权限（get/set）来控制属性的访问权限
 
4.12方法封装 
class Program
    {
        static void Main(string[] args)
        {
            Sum dd = new Sum();
            dd.sum1();
        }
    }

class Sum {
        public void sum1() {
            int[] ayr = { 1, 2, 3, 4 };//初始化一个数组
            int count = 0;
            Console.WriteLine("数组为:{0},{1},{2},{3}",ayr[0],ayr[1],ayr[2],ayr[3]);
            for (int i = 0; i < ayr.Length; i++)//遍历出数组中的每个值
            {
                count += ayr[i];
            }
            Console.WriteLine("数组之和为:{0}",count);
            Console.ReadLine();
        }
    }
 
4,C#方法中的传参也是值传递，但是可以通过在参数前加ref，让原地址中的变量直接被修改
 
int TestRef(int val,ref int val1){
   val1--;
   return val+1;
int val=0;
int val1=3;
int val2=TestRef(val,ref cal1);
//val=0;val1=2;val2=1;
 
4.2继承 
4.21虚方法 
实例化后才存在于内存
 
public virtual void Attack(){
     Console.WriteLine($"{name}发动攻击{skill}");
}
 
4.22抽象方法（纯虚方法） 
抽象类必须被继承,抽象方法必须被重写
 
public abstract void Attack()；
 
4.21抽象类(有至少一个抽象方法） 
封装固定的成员，把可以改变的成员设为抽象方法：
 
public abstract class Vehicle{
    public void stop(){
        Console.WriteLine("stop");
    }
    public abstract void run(){
    
    }
}
 
所有抽象方法必须被override重写或new覆盖：
 
（override表示所有类该方法都被重写，new表示该类及子类的该方法被重写，但是基类该方法不变）
 
class car:Vehicle{
    public override void run(){
         Console.WriteLine("run");
    }
}
 
4.24接口（纯抽象类） 
interface Vehicle{
    abstract void stop();
    abstract void run();//不需要写public，默认
}
 
 接口必须要被子类继承，且所有方法都要重写：
 
class MyProgram:Vehicle{
    public void stop(){
     
    }
    public void run(){
    
    }
}
 
4.3多态 
同一个类在不同情况下表现出不同的行为特征
 
多态的前提1：是继承2：要有方法的重写
 
父类引用指向子类对象,如：Animal a = new Cat();
 
编译看左边，运行看右边
 
4.31 静态变量和实例变量 
实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间：
 
public class DynamicClass{
   public string name="yyh";
} 
 
静态变量(类变量)属于类，只要程序启动静态变量就会被分配空间，静态变量就可以被使用了：
 
public static class StaticClass{
    public static string name="hyy";
}
 
实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用:
 
Console.WriteLine(StasticClass.name);
DynamicClass Dy=new DynamicClass();
Console.WriteLine(Dy.name);