C#复习追踪

分手后的思念是犯贱 2023-02-22 13:54 4阅读 0赞

棒！！！三天后考C\#

既然这么闲那就顺便写篇博客把自己复习C\#的过程记录下（免得自己划水）

首先确定一点，对于未接触过JAVA的同学而言，没什么关系，接触过的话，不用怀疑，它就是抄JAVA的，可以理解为C+JAVA

由于只考：数组、类（各种类成员）、接口、继承、委托、lambda、LINQ

所以我只复习这些（我是FW）

BB完了 开始水知识点

FIRST ONE

当然是hello world了

using System;//包
    namespace HelloWorldApplication//名称空间，java里面相当于文件名，这里两者可以区别开
    {
        /* 类名为 HelloWorld  */
        class HelloWorld
        {
            /* main函数 */
            static void Main(string[] args)
            {
                /* 我的第一个 C# 程序 */
                Console.WriteLine("Hello World!");//输出+换行
                Console.ReadKey();//输入任意键退出
            }
        }
    }
    //所有c#程序都是这个格式    主函数在一个类中

Write就是只输出不换行

ReadLine（）录入一行

Read（）读取一个字符

基本变量什么都跳过吧！ 直接上自定义类

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);/// {1}，表示逗号后的地址个变量值放入该处
              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();
            }
        }
    }

常用的类型转换

int->string str=a.ToString()

string->int a= int.Parse(str)

string->double a=double.Prase(str)

(C++)auto=(C\#)var

if else for while 和C一样 还有三元运算符也是

foreach(int i in a) Console.WriteLine(i) ; 这个方式很像迭代器访问

c\#中的方法/函数 可以作为名称空间实例化对象的内部函数调用 举个例子

using System;
    
    namespace CalculatorApplication
    {
       class NumberManipulator
       {
          public int FindMax(int num1, int num2)
          {
             /* 局部变量声明 */
             int result;
             if (num1 > num2)
                result = num1;
             else
                result = num2;
    
             return result;
          }
          static void Main(string[] args)
          {
             /* 局部变量定义 */
             int a = 100;
             int b = 200;
             int ret;
             NumberManipulator n = new NumberManipulator();
    
             //调用 FindMax 方法
             ret = n.FindMax(a, b);
             Console.WriteLine("最大值是： {0}", ret );
             Console.ReadLine();
          }
       }
    }

**数组的定义**  int \[\] a=new int \[100\] 支持下标访问

**字符串String** 支持+运算符 不支持下表访问单个元素（只有C++是可以的）

str.Length() 返回长度

Substring()切割字符串

结构体和C++一样

**类Class**

C\#所有类都有一个共有基类，但是隐藏，这个基类有个方法叫做ToString 重写这个方法可以直接输出类成员

重写格式 public override string ToString()\{return "";\}

类内部静态变量 第一次实例化类时初始化静态变量，之后不再初始化（可直接在定义时赋初值（和c++不同））

类内部静态函数（只能访问静态成员的函数）

类定义+继承+父类构造函数赋值

using System;
    namespace RectangleApplication
    {
       class Rectangle
       {
          // 成员变量
          public double length{set;get;};//可读写 可加大括号自定义读写方式
          public double width;
          public Rectangle(double l, double w)
          {
             length = l;
             width = w;
          }
          
       }
       class Tabletop : Rectangle
       {
          private double cost;
          public Tabletop(double l, double w) : base(l, w)
          { }
         
       }
       class ExecuteRectangle
       {
          static void Main(string[] args)
          {
             Tabletop t = new Tabletop(4.5, 7.5);
             t.Display();
             Console.ReadLine();
          }
       }
    }

对于前两个类在不在第三个类中间无所谓的

多态

静态多态性 由函数重载实现

动态多态性 抽象类和虚函数实现

抽象类定义关键词 Class前加abstract（前加sealed表明为密封类无法继承）

虚方法public virtual int area（） 子类需前加override 同样位置（重写方法内部）（这个格式好点，用的也多）

重载运算符+例子

using System;
    
    namespace OperatorOvlApplication
    {
        class Box
        {
           private double length;      // 长度
           private double breadth;     // 宽度
           private double height;      // 高度
         
           public double getVolume()
           {
             return length * breadth * height;
           }
          public void setLength( double len )
          {
              length = len;
          }
    
          public void setBreadth( double bre )
          {
              breadth = bre;
          }
    
          public void setHeight( double hei )
          {
              height = hei;
          }
          // 重载 + 运算符来把两个 Box 对象相加
          public static Box operator+ (Box b, Box c)
          {
              Box box = new Box();
              box.length = b.length + c.length;
              box.breadth = b.breadth + c.breadth;
              box.height = b.height + c.height;
              return box;
          }
         
          public static bool operator == (Box lhs, Box rhs)
          {
              bool status = false;
              if (lhs.length == rhs.length && lhs.height == rhs.height
                 && lhs.breadth == rhs.breadth)
              {
                  status = true;
              }
              return status;
          }
          public static bool operator !=(Box lhs, Box rhs)
          {
              bool status = false;
              if (lhs.length != rhs.length || lhs.height != rhs.height
                  || lhs.breadth != rhs.breadth)
              {
                  status = true;
              }
              return status;
          }
          public static bool operator <(Box lhs, Box rhs)
          {
              bool status = false;
              if (lhs.length < rhs.length && lhs.height
                  < rhs.height && lhs.breadth < rhs.breadth)
              {
                  status = true;
              }
              return status;
          }
    
          public static bool operator >(Box lhs, Box rhs)
          {
              bool status = false;
              if (lhs.length > rhs.length && lhs.height
                  > rhs.height && lhs.breadth > rhs.breadth)
              {
                  status = true;
              }
              return status;
          }
    
          public static bool operator <=(Box lhs, Box rhs)
          {
              bool status = false;
              if (lhs.length <= rhs.length && lhs.height
                  <= rhs.height && lhs.breadth <= rhs.breadth)
              {
                  status = true;
              }
              return status;
          }
    
          public static bool operator >=(Box lhs, Box rhs)
          {
              bool status = false;
              if (lhs.length >= rhs.length && lhs.height
                 >= rhs.height && lhs.breadth >= rhs.breadth)
              {
                  status = true;
              }
              return status;
          }
          public override string ToString()
          {
              return String.Format("({0}, {1}, {2})", length, breadth, height);
          }
       
       }
       
       class Tester
       {
          static void Main(string[] args)
          {
            Box Box1 = new Box();          // 声明 Box1，类型为 Box
            Box Box2 = new Box();          // 声明 Box2，类型为 Box
            Box Box3 = new Box();          // 声明 Box3，类型为 Box
            Box Box4 = new Box();
            double volume = 0.0;   // 体积
    
            // Box1 详述
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);
    
            // Box2 详述
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
    
           // 使用重载的 ToString() 显示两个盒子
            Console.WriteLine("Box1： {0}", Box1.ToString());
            Console.WriteLine("Box2： {0}", Box2.ToString());
           
            // Box1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("Box1 的体积： {0}", volume);
    
            // Box2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("Box2 的体积： {0}", volume);
    
            // 把两个对象相加
            Box3 = Box1 + Box2;
            Console.WriteLine("Box3： {0}", Box3.ToString());
            // Box3 的体积
            volume = Box3.getVolume();
            Console.WriteLine("Box3 的体积： {0}", volume);
    
            //comparing the boxes
            if (Box1 > Box2)
              Console.WriteLine("Box1 大于 Box2");
            else
              Console.WriteLine("Box1 不大于 Box2");
            if (Box1 < Box2)
              Console.WriteLine("Box1 小于 Box2");
            else
              Console.WriteLine("Box1 不小于 Box2");
            if (Box1 >= Box2)
              Console.WriteLine("Box1 大于等于 Box2");
            else
              Console.WriteLine("Box1 不大于等于 Box2");
            if (Box1 <= Box2)
              Console.WriteLine("Box1 小于等于 Box2");
            else
              Console.WriteLine("Box1 不小于等于 Box2");
            if (Box1 != Box2)
              Console.WriteLine("Box1 不等于 Box2");
            else
              Console.WriteLine("Box1 等于 Box2");
            Box4 = Box3;
            if (Box3 == Box4)
              Console.WriteLine("Box3 等于 Box4");
            else
              Console.WriteLine("Box3 不等于 Box4");
    
            Console.ReadKey();
          }
        }
    }
    程序输出
    Box1： (6, 7, 5)
    Box2： (12, 13, 10)
    Box1 的体积： 210
    Box2 的体积： 1560
    Box3： (18, 20, 15)
    Box3 的体积： 5400
    Box1 不大于 Box2
    Box1 小于 Box2
    Box1 不大于等于 Box2
    Box1 小于等于 Box2
    Box1 不等于 Box2
    Box3 等于 Box4

接口 抽象类（只负责定义成员和方法，具体实现由派生类定义）

using System;
    interface IParentInterface
    {
        void ParentInterfaceMethod();
    }
    interface IMyInterface : IParentInterface
    {
        void MethodToImplement();
    }
    class InterfaceImplementer : IMyInterface
    {
        static void Main()
        {
            InterfaceImplementer iImp = new InterfaceImplementer();
            iImp.MethodToImplement();
            iImp.ParentInterfaceMethod();
        }
        public void MethodToImplement()
        {
            Console.WriteLine("MethodToImplement() called.");
        }
        public void ParentInterfaceMethod()
        {
            Console.WriteLine("ParentInterfaceMethod() called.");
        }
    }

委托=函数指针（实例化时绑定函数，使用该变量名=使用绑定函数）关键词delegate

using System;
    delegate int NumberChanger(int n);
    namespace DelegateAppl
    {
       class TestDelegate
       {
          static int num = 10;
          public static int AddNum(int p)
          {
             num += p;
             return num;
          }
          public static int MultNum(int q)
          {
             num *= q;
             return num;
          }
          public static int getNum()
          {
             return num;
          }
          static void Main(string[] args)
          {
             // 创建委托实例
             NumberChanger nc1 = new NumberChanger(AddNum);
             NumberChanger nc2 = new NumberChanger(MultNum);
             // 使用委托对象调用方法
             nc1(25);
             Console.WriteLine("Value of Num: {0}", getNum());
             nc2(5);
             Console.WriteLine("Value of Num: {0}", getNum());
             Console.ReadKey();
          }
       }
    }

lambda表达式 （形参表）=> 函数体

LINQ

LINQ查询表达式必须以from子句开头，以select或group子句结束

eg: var ans2 = from i in racers where i.Wins > 25 select i;返回数组集合

var ans5 = from i in racers where i.Cars.Contains("Ferrari") select new\{i.FirstName,i.LastName,i.Wins,i.Starts\};//建立新类并返回

var res = from m in masterList
                          where m.Level > 8 && m.Menpai == "丐帮" 
                          //orderby m.Age descending  // 默认从小到大，加上descending从大到小
                          orderby m.Level, m.Age //按照多个字段进行排序，如果字段的属性相同，就按照第二个属性排序
                          select m;//表示m的结果结合返回

sort自定义类成员排序规则 类需要继承IComparable接口

class Person : IComparable
        {
            public Person(string name, int age)
            {
                Name = name; Age = age;
            }
            public string Name { get; set; }
            public int Age { get; set; }
           public  int CompareTo(object obj)  //实现该比较方法即可
            {
                if (obj is Person)
                {
                    Person p = obj as Person;
                    return this.Age.CompareTo(p.Age);
                }
                
            }
        }

泛型=模板

ArrayList和 List<T>的区别和联系

定义

ArrayList num = new ArrayList();

List<int> num =new List<int>();

第一个是集合 可以放入不同类型的数据 这些数据会变为object的引用

第二个定义时选的是int 只能放int类型数据 比前者略快

空间部分都是类似C++的vector