[TOC]
```
<访问标识符，默认internal> class 类名><:基类>
{
// 成员变量
<访问标识符，默认private> <变量数据类型> variable1;
<访问标识符，默认private> <变量数据类型> variable2;
...
<访问标识符，默认private> <变量数据类型> variableN;
// 成员方法
<访问标识符，默认private> <返回类型> method1(parameter_list)
{
// method body
}
<访问标识符，默认private> <返回类型> method2(parameter_list)
{
// method body
}
...
<访问标识符，默认private> <返回类型> methodN(parameter_list)
{
// method body
}
}
```
```
using System;
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
// 派生类
class Rectangle: Shape
{
public int getArea()
{
return (width * height);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
Rect.setWidth(5);
Rect.setHeight(7);
// 打印对象的面积
Console.WriteLine("总面积： {0}", Rect.getArea());
Console.ReadKey();
}
}
}
```
# **封装**
* public：所有对象都可以访问；
* private：对象本身在对象内部可以访问；
* protected：只有该类对象及其子类对象可以访问
* internal：同一个程序集的对象可以访问；
* protected internal：访问限于当前程序集或派生自包含类的类型。
**Internal 访问修饰符**
Internal 访问修饰符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。
```
using System;
namespace RectangleApplication
{
class Rectangle
{
//成员变量
internal double length;
internal double width;
double GetArea()
{
return length * width;
}
public void Display()
{
Console.WriteLine("长度： {0}", length);
Console.WriteLine("宽度： {0}", width);
Console.WriteLine("面积： {0}", GetArea());
}
}//end class Rectangle
class ExecuteRectangle
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
r.length = 4.5;
r.width = 3.5;
r.Display();
Console.ReadLine();
}
}
}
```
**Protected Internal 访问修饰符**
Protected Internal 访问修饰符允许在本类,派生类或者包含该类的程序集中访问。这也被用于实现继承。
# **继承：`class 派生类:基类`**
# **多态**
## **静态多态性**
### **函数重载**
函数名相同，参数不同或者参数类型不同
```
using System;
namespace PolymorphismApplication
{
public class TestData
{
public int Add(int a, int b, int c)
{
return a + b + c;
}
public int Add(int a, int b)
{
return a + b;
}
void print(int i)
{
Console.WriteLine("输出整型: {0}", i );
}
void print(double f)
{
Console.WriteLine("输出浮点型: {0}" , f);
}
void print(string s)
{
Console.WriteLine("输出字符串: {0}", s);
}
}
class Program
{
static void Main(string[] args)
{
TestData t = new TestData();
int add1 = t.Add(1, 2);
int add2 = t.Add(1, 2, 3);
Console.WriteLine("add1 :" + add1);//add1 :3
Console.WriteLine("add2 :" + add2);//add2 :6
//调用print
t.print(1);//输出整型: 1
t.print(1.23);//输出浮点型: 1.23
t.print("Hello Runoob");//输出字符串: Hello Runoob
Console.ReadKey();
}
}
}
```
### **运算符重载：operator运算符**
重载运算符是具有特殊名称的函数，是通过关键字**operator**后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表
函数为用户自定义的类 Box 实现了加法运算符（+）。它把两个 Box 对象的属性相加，并返回相加后的 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;
}
```
运算符重载
```
using System;
namespace OperatorOvlApplication
{
class Box
{
private double chang; // 长度
private double kuan; // 宽度
private double gao; // 高度
public double getVolume()
{
return chang * kuan * gao;
}
public void setChang( double len )
{
chang = len;
}
public void setKuan( double bre )
{
kuan = bre;
}
public void setGao( double hei )
{
gao = hei;
}
// 重载 + 运算符来把两个 Box 对象相加
public static Box operator+ (Box b1, Box b2)
{
Box box = new Box();
box.chang = b1.chang + b2.chang;
box.kuan = b1.kuan + b2.kuan;
box.gao = b1.gao + b2.gao;
return box;
}
}
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
double volume = 0.0; // 体积
// Box1 详述
Box1.setChang(6.0);
Box1.setKuan(7.0);
Box1.setGao(5.0);
// Box2 详述
Box2.setChang(12.0);
Box2.setKuan(13.0);
Box2.setGao(10.0);
// Box1 的体积
volume = Box1.getVolume();//5.0 * 6.0 * 7.0=210
Console.WriteLine("Box1 的体积： {0}", volume);
// Box2 的体积
volume = Box2.getVolume();//12 * 13 * 10 = 1560
Console.WriteLine("Box2 的体积： {0}", volume);
// 把两个对象相加
Box3 = Box1 + Box2;
// Box3 的体积
volume = Box3.getVolume();// (6+12) * (7+13) * (5+10) = 18 * 20 * 15= 5400
Console.WriteLine("Box3 的体积： {0}", volume);
Console.ReadKey();
}
}
}
```
## **动态多态性（通过抽象类**和**虚方法**实现）**
**动态多态性**是通过**抽象类**和**虚方法**实现的
虚方法是使用关键字**virtual**声明的。
虚方法可以在不同的继承类中有不同的实现。
对虚方法的调用是在运行时发生的。
动态多态性是通过**抽象类**和**虚方法**实现的。
以下实例创建了 Shape 基类，并创建派生类 Circle、 Rectangle、Triangle， Shape 类提供一个名为 Draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。
```
using System;
using System.Collections.Generic;
public class Shape
{
public int X { get; private set; }
public int Y { get; private set; }
public int Height { get; set; }
public int Width { get; set; }
// 虚方法
public virtual void Draw()
{
Console.WriteLine("执行基类的画图任务");
}
}
class Circle : Shape
{
public override void Draw()
{
Console.WriteLine("画一个圆形");
base.Draw();
}
}
class Rectangle : Shape
{
public override void Draw()
{
Console.WriteLine("画一个长方形");
base.Draw();
}
}
class Triangle : Shape
{
public override void Draw()
{
Console.WriteLine("画一个三角形");
base.Draw();
}
}
class Program
{
static void Main(string[] args)
{
// 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
var shapes = new List<Shape>
{
new Rectangle(),
new Triangle(),
new Circle()
};
// 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法
foreach (var shape in shapes)
{
shape.Draw();
}
Console.WriteLine("按下任意键退出。");
Console.ReadKey();
}
}
```
结果：
~~~
画一个长方形
执行基类的画图任务
画一个三角形
执行基类的画图任务
画一个圆形
执行基类的画图任务
按下任意键退出。
~~~
下面的程序演示通过虚方法 area() 来计算不同形状图像的面积：
```
using System;
namespace PolymorphismApplication
{
class Shape
{
protected int width, height;
public Shape( int a=0, int b=0)
{
width = a;
height = b;
}
public virtual int area()
{
Console.WriteLine("父类的面积：");
return 0;
}
}
class Rectangle: Shape
{
public Rectangle( int a=0, int b=0): base(a, b)
{
}
public override int area ()
{
Console.WriteLine("Rectangle 类的面积：");
return (width * height);
}
}
class Triangle: Shape
{
public Triangle(int a = 0, int b = 0): base(a, b)
{
}
public override int area()
{
Console.WriteLine("Triangle 类的面积：");
return (width * height / 2);
}
}
class Caller
{
public void CallArea(Shape sh)
{
int a;
a = sh.area();
Console.WriteLine("面积： {0}", a);
}
}
class Tester
{
static void Main(string[] args)
{
Caller c = new Caller();
Rectangle r = new Rectangle(10, 7);
Triangle t = new Triangle(10, 5);
c.CallArea(r);
c.CallArea(t);
Console.ReadKey();
}
}
}
```
结果：
~~~
Rectangle 类的面积：
面积：70
Triangle 类的面积：
面积：25
~~~
- Visual Studio 2022安装到非C盘
- .net平台区别
- 常用单词
- 关键字
- 操作符（运算符）
- 标识符（命名规范）
- 开始
- 变量
- 常量
- 数据类型
- 值类型
- 变量数据类型
- 枚举类型enum(常量集合)
- 结构类型struct（结构体）
- 元组类型
- 可null类型(T?)
- 引用类型
- 数组(array)
- 集合（List）
- 内置引用类型
- object
- string
- Dynamic(动态类型)
- delegate委托(代理)类型
- 自定义引用类型
- 接口(interface)
- 类class
- record（定义一个引用类型）
- 指针类型(仅用于非安全代码)
- get和set访问器
- delegate委托
- delegate实现发布订阅与事件
- 类型转换
- 合并操作符??
- 类相关
- Partial 部分类
- 类定义以及访问修饰符(封装)
- abstract抽象类与sealed密封类
- virtual虚方法
- 接口interface
- C# 预处理器指令
- C#技术栈
- 判断（流程控制）与三元运算
- if
- switch
- 三元运算
- 循环
- while 循环
- for循环
- foreach循环
- do...while 循环
- 文件操作
- 其他
- 多开