C#基础知识点

时间:2022-02-17 09:39:46

一、方法(结构、数组、冒泡排序、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参数需要放在最后一个位置.

//Out参数
static void Main(string[] args)
{
//求方法的最大、最小、总和、平均值
int[] numbers = { , , , , , , }; int max = ;
int min = ;
int sum = ;
int avg = ;
GetManMinSumAvg(numbers,out max,out min, out sum ,out avg); Console.WriteLine(max);
Console.WriteLine(min);
Console.WriteLine(sum);
Console.WriteLine(avg); Console.ReadKey();
} public static void GetManMinSumAvg(int[] nums, out int max, out int min, out int sum, out int avg)
{
int[] res = new int[];
//假设res[0]最大 1最小 2 总和 3平均
max = nums[];//Max
min = nums[];//MIn
sum = ;//
for (int i = ; i < nums.Length; i++)
{
if (nums[] < nums[i])
{
max = nums[i];
}
if (nums[] > nums[i])
{
min = nums[i];
}
sum += nums[i];
}
avg = sum / nums.Length;
}
//ref参数
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;//调换两个参数的值
}
//Params参数
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;
}

6.方法的重载

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

1) 参数的个数相同,那么参数的类型就不能相同。

2) 参数的类型相同,那么参数的个数就不能相同。

7.方法的递归

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

C#基础知识点

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

8.静态变量

public static  int i=0;

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

二、面向对象基础

1.基本语法

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

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

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

public class 类名

         字段;   存储数据。

   属性;  

     方法;   描述对象的行为。

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

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

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

结构和类的区别:结构是面向过程的,类是面向对象的。关键字一个是classstruct

结构不具备类(特征)的:封装、继承和多态

2.属性:

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

注:属性的本质就是两个方法。get,set方法。

3.静态与非静态

.看有没有被static标记

static标记为静态;

没有static标记为非静态;

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

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

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

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

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

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

使用:

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

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

4.构造函数

作用:帮助我们初始化对象(给对象的每个属性依次的赋值);

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

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

5.New关键字

new帮助我们做了3件事:

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

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

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

6.this关键字

C#基础知识点

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

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、接口

C#基础知识点

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

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

C#基础知识点

3.字符串不可变性

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

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

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

C#基础知识点

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

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

. 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.访问修饰符

C#基础知识点

修饰符

用途

访问修饰符

指定声明的类型和类型成员的可访问性。

abstract

指示某个类只能是其他类的基类。

const

指定无法修改字段或局部变量的值。

event

声明事件。

extern

指示在外部实现方法。

new

从基类成员隐藏继承的成员。

override

提供从基类继承的虚拟成员的新实现。

partial — 部分

在整个同一程序集中定义分部类、结构和方法。

readonly

声明一个字段,该字段只能赋值为该声明的一部分或者在同一个类的构造函数中。

sealed

指定类不能被继承。

static

声明属于类型本身而不是属于特定对象的成员。

unsafe

声明不安全的上下文。

virtual

在派生类中声明其实现可由重写成员更改的方法或访问器。

volatile

指示字段可由操作系统、硬件或并发执行线程等在程序中进行修改。

9集合:ArrayList和HashTable
C#基础知识点

未完,....