知识汇总（C与C#）

1.面向过程和面向对象

1.1面向过程：

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

int main(){

过程1；

过程2；

...}

1.2面向对象：

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

1.21六大原则

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();
       }
    }
}            

3.基本数据类型

3.1值类型

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

3.2引用类型（C#）

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

3.21对象类型

对象（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];

3.22动态类型

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

dynamic d = 20;

3.23字符串类型

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

3.24接口

3.3指针类型

C和C#一致

3.4集合

3.41Array

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

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

3）数组的数据类型统一

3.43ArrayList

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<list.Count;i++)
  {  
      Console.WriteLine(list[i]);
      //若将对象打印出来，打印的是对象的类名空间
  }//根据下标查找元素 
}}

3.42List

1)List长度可以任意改变

2）类型统一，

List<int> list = new List<int>();
list.Add(1);
list.Add(2);

3.43Dictionary

1）dictionary<,>类型固定

2）长度不固定

Dictionary<int,string> dic==new Dictionary<int,string>();
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<int,string> 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);