C#基础，C#基础知识点，基础知识点迅速巩固

一、方法（结构、数组、冒泡排序、3个参数重载）

1将string转换为int类型

Convert.ToInt32(); int.Parse() ; int.TryParse()三种方式。

2 结构：可以帮助我们一次性声明多个不同类型的变量。

public struct JG
{
    public string name;
    public int age;
}
static void Main(string[] strag)
{
    JG jg=new JG();
    jg.name=”张三”;
    jg.age=;
}

3 数组：一次性存储多个相同类型的变量。

4冒泡排序：

            int[] nums = { , , , , ,  };
           // 冒泡排序第一个元素依次和后面的元素比较
            //如果大于他就把值给他
            for (int i = ; i < nums.Length - ; i++)
            {
                for (int j = ; j < nums.Length -  - i; j++)
                {
                    if (nums[j] < nums[j + ])
                    {
                        int temp = nums[j];
                        nums[j] = nums[j + ];
                        nums[j + ] = temp;
                    }

                }
            }

5.三个高级参数out、ref、parmas

• Out参数：侧重于在一个方法中返回（免使用return）多个不同类型的值
• ref：能够将一个变量带入一个方法中进行改变，改变完成后，再将改变后的带出方法。
• Params：声明参数的时候使用params，可以在调用的时候直接传入params修饰的参数的元素。

注：多个参数时，params参数需要放在最后一个位置.

•  1         static void Main(string[] args)
   2         {
   3             //求方法的最大、最小、总和、平均值
   4             int[] numbers = { 1, 2, 3, 4, 5, 6, 7 };
   5
   6             int max = 0;
   7             int min = 0;
   8             int sum = 0;
   9             int avg = 0;
  10             GetManMinSumAvg(numbers,out max,out min, out sum ,out avg);
  11
  12
  13             Console.WriteLine(max);
  14             Console.WriteLine(min);
  15             Console.WriteLine(sum);
  16             Console.WriteLine(avg);
  17
  18             Console.ReadKey();
  19         }
  20
  21         public static void GetManMinSumAvg(int[] nums, out int max, out int min, out int sum, out int avg)
  22         {
  23             int[] res = new int[4];
  24             //假设res[0]最大 1最小 2 总和 3平均
  25             max = nums[0];//Max
  26             min = nums[0];//MIn
  27             sum = 0;//
  28             for (int i = 0; i < nums.Length; i++)
  29             {
  30                 if (nums[0] < nums[i])
  31                 {
  32                     max = nums[i];
  33                 }
  34                 if (nums[0] > nums[i])
  35                 {
  36                     min = nums[i];
  37                 }
  38                 sum += nums[i];
  39             }
  40             avg = sum / nums.Length;
  41         }

  Out参数

           static void Main(string[] args)
           {
               int n1 = ;
               int n2 = ;
               //传入参数前必须赋值
               Ss(ref n1,ref n2);
               Console.WriteLine(n1);
               Console.WriteLine(n2);
               Console.ReadKey();
           }
  
           public static void Ss(ref int n1,ref int n2)
           {
               n1 = n1 - n2;
               n2 = n1 + n2;
               n1 = n2 - n1;//调换两个参数的值
           }

  ref参数

           static void Main(string[] args)
           {
               int gg = Get(, , , , , , , );
               Console.WriteLine(gg);
               Console.ReadKey();
           }
           public static int Get(params int[] ss)
           {
               int sum = ;
               for (int i = ; i < ss.Length; i++)
               {
                   sum += ss[i];
               }
               return sum;
           }

  params

6.方法的重载

概念：指的是方法的名称相同，但是参数不同。

1） 参数的个数相同，那么参数的类型就不能相同。

2） 参数的类型相同，那么参数的个数就不能相同。

7.方法的递归

方法自己调用自己。但是也得有一个条件让他自己不在循环≠死循环。

注：每调一次递归函数，就相当于进入一个门。最后return 的时候会在一层一层的返回。

8.静态变量

public static  int i=0;

可以选择将字段声明为 static。 这使得调用方在任何时候都能使用字段，即使类没有任何实例。

二、面向对象基础

1.基本语法

1.类概念：我们把这些具有相同属性和相同方法的对象进行进一步的封装，抽象出来。

类就是一个模子，确定了对象应该具有的属性和方法。

对象是根据类创建出来的。

public class 类名

｛

         字段；   存储数据。

　　　属性；  

　　   方法；   描述对象的行为。

｝

类的实例化：写好了类之后，我们需要创建这个类的对象，那么，我们管创建这个类的对象过程称之为类的实例化。

this关键字：代表当前类的对象。

注：类是不占内存的，对象是占内存的。字段会有一个默认的初值，会在内存中开辟空间。

结构和类的区别：结构是面向过程的，类是面向对象的。关键字一个是class和struct。

结构不具备类（特征）的：封装、继承和多态。

2.属性：

属性的作用就是保护字段、对字段的赋值和取值进行限定。

注：属性的本质就是两个方法。get，set方法。

3.静态与非静态

.看有没有被static标记

被static标记为静态；

没有static标记为非静态；

1） 在非静态类中，既可以有实例成员，也可以有静态成员。

2） 在调用实例成员的时候，需要使用对象名.示例名。

再调用静态成员的时候，需要使用类名.静态成员名。

。总结：静态成员必须使用类名去调用，而实例成员使用对象名调用。

静态函数中，只能访问静态成员，不允许访问实例成员。

实例函数中，既可以使用静态成员，也可以使用实例成员。

使用：

1） 如果你想要类，当做一个工具类去使用，这个时候可以把类写成静态类。

2） 静态类中在整个项目中资源共享。

4.构造函数

作用：帮助我们初始化对象（给对象的每个属性依次的赋值）；

构造函数是一个特殊的方法。

方便我们快捷的给一个对象初始化。

5.New关键字

new帮助我们做了3件事：

1）、在内存中开辟一块空间

2）、在开辟空间中创建对象

3）、调用对象的构造函数进行初始化对象

6.this关键字

这段代码多次重复数赋值字段。构成了冗余

1.含义

1）代表当前类的对象。

2）在类中显示的调用本类的构造函数  ：this

         public Person(string name, int ages, string gender, string linkway)
         {
             this.Name = name;
             this.Ages = ages;
             this.Gender = gender;
             this.Linkway = linkway;
         }
         public Person(string name, int age):this(name,age,"","")
         { 

         }

7.析构函数

~类名（）

｛

//不用调用，自己执行。

｝

三、继承

1.命名空间

概念：可以解决类的重名问题。可以看作类的文件夹。

2.值类型和引用类型

区别：

1.内存中的分配的空间是不一样的。

2.传递的方式也是不同的。（值传递和引用传递）

内存空间认为的分为5块：

注：程序员常用的是：堆、栈、静态存储区域

值类型：int、double、struct、bool、char、decimal、enum

引用类型：引用类型：string 数组、自定义类、集合、object、接口

注：值类型在复制的时候，传递的是这个值得本身。

引用类型在复制的时候传递的时候是对对象的引用。

3.字符串不可变性

1.当你给一个字符串重新赋值后，老值并没有销毁，儿时重新开辟了一个空间存储新值。栈的地址会得到更新。

当程序结束后，GC扫描整个内存，如果发现有的空间没有指向，则立即把它销毁。

StringBuilder 一般是没有再新开空间。

4.继承

封装概念：把常用的东西封装起来。

继承概念：我们可能会在一些类中，写一些重复的成员，我们可以将这些重复的成员单独的封装到一个类中，作为这些类的父类。

student、Teacher、   子类  派生类

Person                          父类   基类

子类继承了父类，继承了父类的属性和方法。私有字段不会继承过来。不会继承构造函数，但是会调用。

注：子类继承了父类，先会去调用父类无参数的构造函数。

创建父类对象。让子类可以使用父类中的成员。

父类中重写了一个有参的构造函数，父类无参的构造函数就被干掉了。

解决办法：

办法1.在父类中重写一个无参的构造函数。（不推荐）

办法2.直接让子类调用父类有参的。

     public class Person
     {
         public string Name
         {
             get;
             set;
         }
         public int Ages
         {
             get;
             set;
         }
         public string Gender
         {
             get;
             set;
         }
         public string Linkway
         {
             get;
             set;
         }
         public Person(string name, int ages, string gender, string linkway)
         {
             this.Name = name;
             this.Ages = ages;
             this.Gender = gender;
             this.Linkway = linkway;
         }
         public Person(string name, int age)
             : this(name, age, "", "")
         {

         }
     }
     public class Chines : Person
     {
         /// <summary>
         /// 父类没有该字段
         /// </summary>
         public DateTime? Creatre
         {
             get;
             set;
         }
         /// <summary>
         /// 继承父类的构造函数
         /// </summary>
         public Chines(string name, int age, DateTime create)
             : base(name, age)
         {
             //需要自己赋值
             this.Creatre = create;
         }
     }

this、base、构造函数

父类中有的字段，在子类调用构造函数的时候，可以直接用，写父类没有的。

. base关键字

创建父类对象，让子类可以使用父类中的成员。

所以，如果在父类中重新写了一个有参数的构造函数之后，那个无参数的就被干掉了，

子类就调用不到了，所以子类会报错。

解决办法：

1)、在父类中重新写一个无参数的构造函数。

2)、在子类中显示的调用父类的构造函数，使用关键字:base()

5.new 关键字（二）

使用new关键字隐藏，父类的成员。

父类和子类中，有同名的方法，子类只能调用自己的成员，这时候报警告线，可以new关键字屏蔽父类的成员。

     public class Person
     {
         public static void Get()
         {
             Console.WriteLine("父类。");
         }
     }
     public class Chines : Person
     {
         public new void Get()
         {
             Console.WriteLine("子类");
         }
     }

6.里氏转换

1）子类可以复制给父类

2）如果父类中装的是子类对象，那么父类可以强转为子类对象。

7.is和as关键字

Is：标识类型转换，如果能够转换成功，则返回一个true，否则返回一个flase

as：表示类型转换，如果能够转换则返回对应的对象。

8.访问修饰符

修饰符	用途
访问修饰符 public private internal protected	指定声明的类型和类型成员的可访问性。
abstract	指示某个类只能是其他类的基类。
const	指定无法修改字段或局部变量的值。
event	声明事件。
extern	指示在外部实现方法。
new	从基类成员隐藏继承的成员。
override	提供从基类继承的虚拟成员的新实现。
partial — 部分	在整个同一程序集中定义分部类、结构和方法。
readonly	声明一个字段，该字段只能赋值为该声明的一部分或者在同一个类的构造函数中。
sealed	指定类不能被继承。
static	声明属于类型本身而不是属于特定对象的成员。
unsafe	声明不安全的上下文。
virtual	在派生类中声明其实现可由重写成员更改的方法或访问器。
volatile	指示字段可由操作系统、硬件或并发执行线程等在程序中进行修改。

9集合：ArrayList和HashTable

未完待续……