我们来接着上期的内容,这期讲解C#中的修饰关键字
建议你在阅读这篇博客之前,先阅读我们上期的内容——————>链接
在你阅读这篇博客之前,你需要注意的是,这篇博客都是博主的个人理解,并不是官方的说法,如果有更好的建议可以私信博主,如果有什么地方看不懂也可以私信博主。
为了避免丢失,关注——>获得后续更新。
下面我们进入正题
修饰关键字(又称修饰符)可以分为以下几类(自己的理解)
- 访问修饰符
- 方法修饰符
- 约束修饰符
- 其他修饰符
我们仅仅接绍一些常用的修饰符
访问修饰符
private(私有;类型)
私有修饰符修饰的内容不能被外界访问,也就是不能被其他类访问,但是在内部依旧可以访问
public class A{
public int a=1;
public void a1(){
//省略........
}
}
private class B{
private int b=1;
public void b1(){
//省略........
}
}
如上图所示类B是私有的,所以不能被外界实例化,int类型的b是私有的,所以不能被外界读取,方法b1()也是私有的,因此也不能被调用。同时private 是默认的修饰符
如果一个类型,方法,没有访问修饰符,那么默认是私有的即private。
public(公开;类型)
公开修饰符修饰的内容能被外界访问,也就是能被其他类访问,他对外界公开。
public class A{
public int a=1;
public void a1(){
//省略........
}
}
如上图所示类A是公开的,所以能被外界实例化,int类型的a是公开的,所以能被外界读取和写入,方法a1()也是公开的,因此能被外界调用。
protected(受保护;类型)
受保护修饰符修饰的内容不能被外界访问,也就是不能被其他类访问,但是他对子类公开,要想创建一个子类,只需要在类名后面+:+父类名。
protected class B{
protected int b=1;
protected void b1(){
//省略........
}
}
class A : B{
public void a1(){
b1();
}
}
class C{
public void c1(){
}
}
如上图所示,类A继承了类B所以能调用b1方法,但是在C中C因为没有继承B,无法调用收保护类型的b1();
方法修饰符
方法修饰符有以下几类:
- in
- ref
- out
- virtual
- override
- sealed
in修饰符
in修饰的方法参数将不能被修改,为只读类型,而且传入方式变为引用传递
public class A{
public void a(in int b){
//b=10;这条语句是无效的因为参数已经被in修饰了
}
}
如上图所示,a()方法内部不允许修改b的值。
ref修饰符
ref修饰的方法参数能被修改,而且传入方式变为引用传递,并且以后调用的时候必须加上ref关键字
public class A{
public void a(ref int b){
b=10;//这条语句是有效的因为参数已经被ref修饰了
}
}
如上图所示,a()方法内部允许修改b的值。
定义完以后,可以这样调用a()方法
a(ref 10);
out 修饰符
out 修饰的方法参必须被此方法修改,而且传入方式变为引用传递,并且以后调用的时候必须加上out 关键字
public class A{
public void a(out int b){
b=10;//必须修改参数b的值已经被out修饰了
}
}
如上图所示,a()方法内部需要修改b的值。
定义完以后,可以这样调用a()方法
int b;
a(out b);
如上图所示,定义int类型的参数并且传入a方法
out ,ref和in不同之处在于 in 参数无法通过调用的方法进行修改。 out 参数必须由调用的方法进行修改,这些修改在调用上下文中是可观察的,而 ref 参数是可以修改的。
virtual修饰符
方法可以定义为virtual表示这个方法可以被重写
public class A{
public virtual void a(){
//省略......
}
}
上述定义的a方法运行被子类重写
override修饰符
方法可以定义为override表示这个方法重写了父类的方法
public class A{
public virtual void a(){
//省略
}
}
public class B : A{
public override void a(){
//省略
}
}
上述定义的B类继承了A,并且重写了方法a()。
sealed修饰符
sealed密封修饰符表示该重写了父类方法的方法之后将不可以被重写,一个方法需重写了一次方法以后才可以被定义为sealed的如果你一开始就不希望方法被重写就不要将他定义为virtual方法。
public class A{
public virtual void a(){
//省略
}
}
public class B : A{
public override void a(){
//省略
}
}
public class C : B{
public sealed override void a(){
//省略
}
}
如上述代码,从C类开始,a()方法将不可被重写!!
约束修饰符
约束关键字主要有
- where
- when
Where修饰符
where关键字定义一个泛型的类型,如果你之前每天听说过泛型这里三言两语解释不清楚,建议点击左边的链接了解一下,如果看不懂可以私信博主,或者关注博主,我会在下次更新详细的解释。where语法如下所示:
public class A <TYPE> where TYPE : struct {
public void a(){
//省略
}
}
public class B<TYPE> where TYPE : class,new () {
public void a(){
//省略
}
}
上述代码的A类定义了一个名字为TYPE的泛型,此泛型可以为任何类型,我们通过where约束将他约束为struct供我们正确的使用。
而B类则把TYPE约束为class类型,且必须可以new的。,后面的new()约束即约束TYPE是可以new的。
when修饰符
当我们在try-catch类型时可以使用when约束来约束异常处理语句的行为
语法如下:
public class A{
public void a(){
try{
int i=10000000000;//声明1
int b=10000000000;//声明b
int c=checked(i*b);//i×b并判断结果是否溢出
}catch(Exception e) when (c > int.MaxValue){//如果c溢出了
c=0;//将c归零
}catch(Exception e) when (i > int.MaxValue){//如果i溢出了
i=0;//将i归零
}catch(Exception e) when (b > int.MaxValue){//如果b溢出了
b=0;//将b归零
}catch(Exception e){//否则
i=b=c=0;//全部归零
}
}
}
通过上述代码,我们可以对异常的问题进行分析,对症下药,降低了异常处理的难度
其他修饰符
由于C#关键字实在太多,我在这里挑一些有用的进行讲解。
abstract关键字
abstract关键字能将一个类修饰为抽象类,抽象的类不能实例,抽象的类可以拥有抽象方法,并且无需实现方法。
public abstract class A{
public abstract void a();
}
如上述代码,声明了一个抽象类A,和一个抽象方法,需要注意的是抽象方法并不是直接拿来用的,你也用不了,他需要交给其他的类来继承。
如:
public abstract class A{
public abstract void a();
}
public class B:A{
public override void a() {
//省略.........
}
}
继承类A以后可以用override关键字重写a()方法
const 关键字
使用 const 关键字来声明某个常量字段或常量局部变量。 常量字段和常量局部变量不是变量并且不能修改。 常量可以为数字、布尔值、字符串或 null 引用。 被声明的类型将不能被修改
const int X = 0;
readonly关键字
使用 readonly关键字来声明某个常量字段或常量局部变量。 常量字段和常量局部变量不是变量并且不能修改,但是可以通过构造方法来初始化它。
readonly int X = 0;
或者
public class A{
readonly int X;
public A() {
X=0;
}
}
static 关键字
使用 static (静态的)修饰符可声明属于类型本身而不是属于特定对象的静态成员。 static 修饰符可用于声明 static 类。static修饰的类型属于class本身而不属于对象,因此他只存在一个。而且他可以不可以被普通方法调用,只有静态方法可以调用静态方法。但是静态方法也可以调用普通方法。
static int X = 0;
而且在接口当做的数据成员必须被声明为static。
public interface A{
static int X=0;
}
unsafe关键字
unsafe指示一段代码是不安全的,使用不安全的上下文,可以在不安全代码中进行指针操作,提高性能
public unsafe void a(){
int* X=stackalloc int[1024];
}
上述代码为指针X分配了一个长度为1024的数组,这个数组分配在堆栈中。
partial关键字
partial关键字用来声明分布类,和分布方法,在大型项目中运用此关键字可以类似C++一样让方法声明和实现分离。
namespace PM
{
partial class A
{
partial void a(string s);
}
在另一个文件当中
namespace PM
{
partial class A
{
partial void a(String s)
{
Console.WriteLine("Something happened: {0}", s);
}
}
}
需要注意的是这两个类必须在同一个命名空间当中!
好了篇幅有限,这次就介绍到这里,如果有什么不懂的可以关注博主向博主私信,可以邮件联系等,当然也可以评论区留言。如果有什么没有讲到也可以私信我,我会在下一期补上。
I think therefore I am 我思故我在
—————————笛卡尔
多思考,多练习,才能在人生的道路上走得更远,不然存在的意义是什么呢?