三天入门C#系列之修饰关键字概述C#基础概述C#修饰符概述（超详细）（接上期）

我们来接着上期的内容，这期讲解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 我思故我在

  											—————————笛卡尔

多思考，多练习，才能在人生的道路上走得更远，不然存在的意义是什么呢？