C#概述
C#是Miscrosoft在2000年7月推出.NET Framwork的第一版时提供的一种全新语言。
C#是微软公司在2000年7月发布的一种全新且简单、安全、面向对象的程序设计语言，是专门为.net的应用而开发的语言，并且作为Unity脚本语言之一。
它吸收了C++、VisualBasic、Delphi、Java等有语言的优点、体现了当今最新的程序设计技术的功能和精华，C#继承了C语言的语法风格，同时又继承了C++的面向对象的特性。
C#语言主要用于开发可以在.net平台（一种构建下一代英特网的集成开发环境）上运行的应用程序，并作为。net平台的首选开发语言，甚至可以这么说，C#语言就是为了.Net平台而产生的语言。C#的语言体系是构建在.net框架基础上的，他是从C、C++/jiava派生而来的一种简单，现代、面向对象和类型安全的编程语言、并且能够与、net框架完美结合。
C#语言及特点
1. 语法简洁。
2. 彻底的面向对象设计。
3. 与Web紧密结合。
4. 强大的安全性机制。
5. 兼容性。
6. 灵活的版本处理技术。
7. 完善的错误、异常处理机制。
第一个C#程序
告诉编译器使用System命名空间中的类型
声明一个新的命名空间，名字为Simple,下面的类属于这个命名空间
声明一个新的类类型，名字叫做Program
声明一个方法，名称为Main，Main方法就是类的一个成员
Main是一个特殊函数，编译器把它作为程序的起始点
标识符
标识符是一种字符串，用来命名如变量 方法 参数和许多后面要讲解的程序结构
标识符不能和关键字重复
字母 下划线 可以用在任何位置
数字不能放在首位
@字符只能放在标示符的首位
命名规范
Camel命名法
首个单词的首字母小写，其余单词的首字母大写(enemyHp)
Pascal命名规范
每个单词的第一个字母都大写(EnemyHp)
如果使用到英文单词的缩写，全部使用大写(PI HP MP)
变量使用Camel命名，方法和类使用Pascal命名规范
关键字
用来定义C#语言的字符串记号
关键字不能被用来做变量名或者其他形式的标识符，除非以@字符开始
所有C#关键字全部由小写字母组成
Main方法
每个C#程序必须带一个Main方法（函数）
每个C#程序的可执行起始点在Main中的第一条指令
Main方法首字母大写
Main方法最简单的形式：
static void Main(){
}什么是语句？
语句是描述一个类型或告诉程序去执行某个动作的一条源代码指令，语句以分号结束。
int var1 = 5;
System.Console.WriteLine("The value of var1 is {0}",var1);什么是块？
块是一个由大括号包围起来的0条或多条语句序列，它在语法上相当于一条语句。
{
int var1 = 5;
System.Console.WriteLine("The value of var1 is {0}",var1);
}块的内容：
1，某些特定的程序结构只能使用块
2，语句可以以分号结束，但块后面不跟分号
从程序中输出文本
控制台窗口是一个简单的命令提示窗口，允许程序显示文本并从键盘接受输入。BCL提供一个Console的类（在System命名空间下）,该类包含了输入和输出到控制台窗口的方法。
Write
Write是Console类的成员，它把一个文本字符串发送到程序的控制台窗口。最简单的使用，Write把文本的字符串字面量发送到窗口，字符串必须使用双引号括起来。
实例：
Console.Write("This is a trivial text.");
WriteLine
WriteLine是Console的另外一个成员，它和Write实现相同的功能，但会在每个输出字符串的结尾添加一个换行符。
System.Console.WriteLine("Hello world1.");
System.Console.WriteLine("Hello world2.");
System.Console.WriteLine("Hello world3.");格式化字符串
当利用Write和WriteLine方法输出的时候，可以对字符串进行格式化输出，什么是格式化输出呢？
Console.WriteLine("两个数相加{0}+{1}={2}",3,34,34);
多重标记和值
下面的语句使用了3个标记，但只有两个值
Console.WriteLine("Three integers are {1},{0} and {1}",3,5);
但是记住标记不能引用超出替换值列表长度以外位置的值
变量
为什么使用变量?
计算机程序的运行其实就是对数据的操作，数据是什么？比如数字，文字，图片这些在计算机中都是数据，那么数据怎么在计算机中存储呢？
答案：通过变量
你可以把计算机内存中的变量，当成一个盒子，盒子里面存储着东西，可以放入或者取出
变量的声明
声明就是创建，如何创建变量？
声明变量需要指定类型和变量名
<type> <name>;
type表示使用什么类型的盒子，来存储数据
name表示存储这个盒子的名字
实例:(每一个声明都是一条语句，语句以；结束)
int age;
int hp;
string name;简单类型-整数
简单类型-小数
简单类型-非数值类型
字面值
表示文本和数字的
字面值列表
char和string
类型介绍
char表示一个字符，字母 数字 @#￥%……&*（）一个汉字
string是一个char的数组，数组以后介绍，现在先把string认为字符的集合
转义字符列表
转义字符是有特殊功能的字符
字符的Unicode值的作用
Unicode是一个16进制的数字，表示这个字符在内存中以哪个数字存储，也可以使用Unicode来代表一个转义字符 (\u加上十六进制值)
"I\'s siki!"
"I\u0027s siki!"
使用@不识别转义字符
如果我们不想去识别字符串中的转义字符，可以在字符串前面加一个@符号（除了双引号其他转义字符都不在识别）
举例："I'm a good man. \n You are bad girl!",使用两个引号表示一个引号
@字符的两个作用示例：
1，默认一个字符串的定义是放在一行的，如果
想要占用多行
2，用字符串表示路径
"c:\\xxx\\xx\xxx.doc"
使用@"c:\xxx\xx\xxx.doc"更能读懂
变量的声明和赋值
变量的声明
int age ;
变量的赋值
age = 25;
变量的声明和赋值可以放在一个语句中
int age = 25;多变量声明和赋值
我们可以使用一条语句声明多个类型一样的变量
string name1,name2;
在多变量声明中，可以在变量后面跟上=，对其中的一个变量或者部分或者全部变量进行初始化
注意事项
变量在使用之前必须初始化
怎么判断变量有没有使用，当你从变量的盒子里面取东西的时候，就是要使用这个变量的时候，初始化就是先往这个盒子里面放入东西，才能去取
第一次给变量赋值，就叫做初始化
表达式
前面说了如何创建变量，下面就是处理他们了，C#包含了许多进行这类处理的运算符。
把变量和字面值和运算符组合起来就是表达式
运算符的分类
一元运算符 处理一个操作数
二元运算符 处理两个操作数
三元运算符 处理三个操作数
数学运算符
关于数学运算符的结果类型
当两边的操作数类型一致的时候，返回的结果跟操作数的类型一样
当两边的操作数类型不一致的时候，返回的结果跟类型大的操作数保持一致，这样做编译器是为了保证结果可以存的下，因为如果其中有一个类型大的操作数，很可能结果也是一个比较大的数值这样小类型是存不下的。
接受用户输入的字符串，整数和小数
至今为止，我们一直使用Console.Write和Console.WriteLine方法向控制台显示东西，那么我们如何从键盘上得到用户输入的
内容呢
通过Console.ReadLine()方法，这个方法可以从键盘上读取一行的字符串输入，返回的是一个字符串
赋值运算符
用来向变量盒子存东西的运算符
运算符的优先级
var1 = var2+var3;
var1 = var2 + var3*var4;
var1 = (var2+var3)*var4;
括号可以用来重写优先级 括号内的优先级最高
访问修饰符
访问修饰符：
1.public：公有的 所有的类都可以访问
2.private：私有的 当前类内部可访问
3.protected：受保护的 当前类以及继承他的子类可访问
4.internal:内部的 只限于本项目内访问，其他的不能访问。
5.protected internal：内部保护访问 只能是本项目内部或子类访问 其他类不能访问
访问级别约束：
1.父类子类访问修饰符要保持一致
2.方法的访问修饰符要和方法参数的访问修饰符 保持一致
常量
常量就是其值固定不变的量，而且常量的值在编译时就已经确定了。常量的类型只能为下列类型之一：sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、decimal、bool、string等。
使用关键字const来创建常量，并且在创建常量时必须设置它的初始值。
常量就相当于每个公民的身份证号，一旦设置就不允许修改。
声明一个正确的常量，同时再声明一个错误的常量，以便读者对比参考，代码如下。
const double PI = 3.1415926; //正确的声明方法
const int MyInt; //错误：定义常量时没有初始化
常量的成员
const：声明的时候就要赋值
Readonly：声明的时候可以不赋值，但是一但赋值就不能更改
流程控制语句
三种结构：顺序结构，选择结构、循环结构
什么是流程控制
为什么使用流程控制
我们至今写的代码都是一行接着一行，自上而下进行。但是有的时候我想根据程序中当时的环境执行不同的代码，或者有的时候需要重复执行某段代码。这两种方法就是需要用到流程控制中的分支和循环。
分支：有条件的执行代码
循环：重复执行相同的代码
选择语句（if-else）
if-else语句是最常用的选择语句，它根据布尔表达式的值来判断是否执行
后面的内嵌语句。
if-else语句的基本语法：
if (布尔表达式 )
真值运算; //表达式为真时运算
else
假值运算;
注意：
1、不是所有的if语句都有else匹配；如果仅有if语句，当布尔表达式为真时，执行”真值运算“；否则，跳过if语句，执行if后面的语句；
2、if语句可以嵌套使用
选择语句（switch-case）
一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。
switch 语句必须遵循下面的规则：
1.switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。
2.在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量。
3.当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
4.不是每一个 case 都需要包含 break。如果 case 语句为空，则可以不包含 break，控制流将会
继续 后续的 case，直到遇到 break 为止。
5.C# 不允许从一个 case 部分继续执行到下一个 case 部分。如果 case 语句中有已经执行，则必须包含 break 或其他跳转语句。
6.一个 switch 语句可以有一个可选的 default 语句，在 switch 的结尾。default 语句用于在上面所有 case 都不为 true 时执行的一个任务。default 也需要包含 break 语句，这是一个良好的习惯。
7.C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用 goto 一个 switch-case 或 goto default。
for循环
一个 for 循环是一个允许您编写一个执行特定次数的循环的重复控制结构。
语法
for ( init; condition; increment )
{
statement(s);
}
init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。
接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。
在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。
条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。
foreach循环
使用foreach可以迭代数组或者一个集合对象。
枚举（enum）
枚举类型的定义：
enum <typeName>{
<value1>,
<value2>,
<value3>,
.....
<valueN>
}
枚举类型声明：<type> <varName>;
枚举类型的赋值：<varName>=<typeName> .<value>;
为什么使用枚举
枚举（enum），enum 关键字用于声明枚举，即一种由一组称为枚举数列表的命名常量组成的独特类型。
例如，我们声明一个代表星期的枚举类型的变量：
enum WeekDay
{ Sunday，Monday，Tuesday，Wednesday，Thursday，Friday，Saturday }
WeekDay day;
枚举类型的变量在某一时刻只能取枚举中某一个元素的值，如day这个表示“星期”的枚举类型的变量，它的值要么是Sunday，要么是Monday或其
它的星期元素
跳转语句
return语句：
终止它出现在其中的方法的执行，并将控制权返回给调用方法。
如果方法为void 类型，则可以省略 return 语句。
break语句：
用于终止最近的封闭循环或它所在的 switch 语句。控制权传递给终
止语句后面的语句。
continue语句：
将控制权传递给它所在的封闭迭代语句的下一次迭代
递归方法调用
一个方法可以自我调用。这就是所谓的 递归。下面的实例使用递归函数计算一个数的阶乘：using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num)
{
/* 局部变量定义 */
int result;
if (num == 1)
{
return 1;
}
else
{
result = factorial(num - 1) * num;
return result;
}
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
//调用 factorial 方法
Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));
Console.WriteLine("7 的阶乘是： {0}", n.factorial(7));
Console.WriteLine("8 的阶乘是： {0}", n.factorial(8));
Console.ReadLine();
}
}
}数组（Array）
数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。
声明数组变量并不是声明 number0、number1、...、number99 一个个单独的变量，而是声明一个就像 numbers 这样的变量，然后使用 numbers[0]、numbers[1]、...、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。
所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素，最高的地址对应最后一个元素
声明数组
语法：
datatype[] arrayName;
其中，datatype 用于指定被存储在数组中的元素的类型。
[ ] 指定数组的秩（维度）。秩指定数组的大小。
arrayName 指定数组的名称。
例如：
double[] balance;
初始化数组
声明一个数组不会在内存中初始化数组。当初始化数组变量时，您可以赋值给数组。
数组是一个引用类型，所以您需要使用 new 关键字来创建数组的实例。
例如：
double[] balance = new double[10];赋值给数组
您可以通过使用索引号赋值给一个单独的数组元素，比如：
double[] balance = new double[10];
balance[0] = 4500.0;
您可以在声明数组的同时给数组赋值，比如：
double[] balance = { 2340.0, 4523.69, 3421.0};
您也可以创建并初始化一个数组，比如：
int [] marks = new int[5] { 99, 98, 92, 97, 95};
在上述情况下，你也可以省略数组的大小，比如：
int [] marks = new int[] { 99, 98, 92, 97, 95};
您也可以赋值一个数组变量到另一个目标数组变量中。在这种情况下，目标和源会指向相同的内存位置：
int [] marks = new int[] { 99, 98, 92, 97, 95};
int[] score = marks;
当您创建一个数组时，C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。例如，int 数组的所有元素都会被初始化为 0。
访问数组元素
using System;
namespace ArrayApplication
{
class MyArray
{
static void Main(string[] args)
{
int [] n = new int[10]; /* n 是一个带有 10 个整数的数组 */
int i,j;
/* 初始化数组 n 中的元素 */
for ( i = 0; i < 10; i++ )
{
n[ i ] = i + 100;
}
/* 输出每个数组元素的值 */
for (j = 0; j < 10; j++ )
{
Console.WriteLine("Element[{0}] = {1}", j, n[j]);
}
Console.ReadKey();
}
}
}一维数组的声明
一维数组即数组的维数为1，其声明语法如下：
type[]arrayName;
þ type：数组存储数据的数据类型。
þ arrayName：数组名称。
一维数组的使用：需要存储多个值时，可以使用一维数组，而且可以通过使用foreach语句或数组的下标将数组中的元素值读出来。
对数组中元素进行初始化使用new运算符
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Test01
{
class Program
{
static void Main(string[] args)
{
int[] arr = { 1, 2, 3, 4, 5 }; //定义一个一维数组，并为其赋值
foreach (int n in arr) //使用foreach语句循环遍历一维数组中的元素
Console.WriteLine("{0}", n + " ");
Console.WriteLine();
}
}
}二维数组的声明
二维数组的声明语法如下。
type[,]arrayName;
其中：type表示数组存储数据的数据类型；arrayName表示数组名称。
例1：
int[,]arr=newint[2,2];
例2：
int[,]arr=newint[2,2]{{1,2},{3,4}};
例3：
int[,]arr=newint[,]{{1,2},{3,4}};值类型
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。
值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。
引用类型
引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。
换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。
内置的 引用类型有：object、dynamic 和 string。
int [] l={1,2,3};
int [] l2=1;
l[0]=9;
Console.WriteLine("l2[0]"+l2[0]);数据类型的转换
隐式转换:小范围数值转换成大范围数值
显示转换：大范围数值转换成小范围数据，需要强制转换
object age1 = 10;
int age2 = (int)age1;
C#面向对象三大特性：
封装
什么是封装
定义：把一个或多个项目封闭在一个物理的或者逻辑的包中。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。
封装的优点
1. 隔离性，安全性。被封装后的对象（这里的对象是泛指代码的编程单元，一般指：程序集，命名空间，类，方法，属性，变量等）其外部对象是无法直接访问对象的内部实现细节，内部实现细节的的改动不会影响到外部对象的访问原则。
2. 可读性。被封装的对象的名称恰当的话，可以不看具体实现的情况下，了解该对象的作用
3. 良好的封装能够减少耦合（比如实现界面和逻辑分离）
4. 类具有清晰的对外接口，使用者只需调用，无需关心内部
5. 因为封装的类功能相对独立，因此能更好的实现代码复用
访问修饰符包含的类型
C# 封装根据具体的需要，设置使用者的访问权限，并通过访问修饰符来实现。
一个访问修饰符定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：
public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
protected：只有该类对象及其子类对象可以访问
internal：同一个程序集的对象可以访问；
protected internal：访问限于当前程序集或派生自
默认访问修饰符
在命名空间内部或编译单元顶部的所有类型（class、struct、abstract class、interface、delegate、enum），默认是internal，可以人为改为public
类中所有的成员，默认均为private
抽象类的所有成员，默认均为private类型，但抽象方法不能用private修饰
接口的所有成员，默认均为public类型，而且不能手动添加访问修饰符
结构的所有成员，默认均为private类型，而且只能是public、internal、private这三种类型
命名空间，枚举类型成员默认public，也不可能是其他访问修饰符
委托，默认internal
继承
什么是继承
定义：继承是面向对象编程语言中的一个重要特性，当一个类A能够获取另一个类B中所有非私有的数据和操作的定义作为自己的部分或全部成分时，就称这两个类之间具有继承关系。被继承的类B称为父类或基类，继承了父类的类A称为子类或派生类。
继承的优点
1. 减少代码冗余
2. 提供代码重用
3. 减少代码量以及提高代码可读性
4. 代码易于管理以及可划分父类和子类
5. 通过子类重写父类的功能可支持代码扩展
继承的缺点
1. 父类变，子类不得不变，继承会破坏包装。父类实现细节暴露给子类，其实是增大了两个类之间的耦合性
2. 在继承结构中，很多数据成员仍然没有被使用，分配给他们的内存没有被利用；因此，如果你没有正确地使用继承，将影响程序性能
继承的特点
1. 密封seald 类和密封方法不能被继承，静态类和普通类的静态成员也不能被继承
2. 派生类除了继承父类的特性外，还可以有自己独有特性
3. 子类不能拥有父类的私有成员
4. 子类可以以自己的方式实现父类的功能（即方法重写）
继承的特性
单根性：一个子类只能有一个父类
传递性：由A:B B:C=>A:C
实现继承
如果要声明派生自另一个类的一个类，就可以使用下面的语法 :
class MyDerivedClass: MyBaseClass
{
// functions and data members here
}
如果类(或结构)也派生自接口，则用逗号分隔列表中的基类和接口 :
public class MyDerivedClass: MyBaseC1ass, IInterface1, IInterface2
{
// etc.
}
对于结构，语法如下 :
public struct MyDerivedstruct: IInterface1, IInterface2
{
// etc.
}多重继承
多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类别只可以继承自一个父类。
C# 不支持多重继承。但是，可以使用接口来实现多重继承。
要点：
子类不仅继承了父类的公有成员，同时继承了父类的私有成员，只是父类的私有成员在子类中不可被访问；
C#只允许单继承，一个类只能继承于一个父类；
被“sealed”关键字修饰的类将不能被继承；
被“protected”修饰的成员或者数据可以直接被派生类访问，属于“可以在家族里分享的秘密”。
善用“base”关键字，显示调用合适的自定义基类构造函数而不是使用默认构造函数。
继承需要合理使用才能发挥最佳效果，一般情况下适用于“is a”关系，不适用“has a”关系。
System.Object是所有类型的基类
C#中继承的写法，class A:B{ }
构造方法不能继承
多态
什么是多态
公司最近为了陶冶情操，养了几种动物（Animal）,有猫(Cat)、狗(Dog)、羊（Sheep），这些动物都有共同的特性，会吃(Eat)、会叫(Shout)，但是它们吃的不同，叫的也不同。既然这样，我们能不能设计一个动物类(Animal)和它的成员(Eat方法、Shout方法)来表示这些动物的共同特征，而当我们关注猫时，猫来实现这两个成员（吃鱼、喵喵叫）；当我们关注狗时，狗来实现这两个成员（吃肉和汪汪叫）。
上述例子就是一个典型的多态，就是父类的一些成员，子类继承后去重写从而实现不同的功能。
定义：
同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。这就是多态，这种特性称为多态性。
多态的优缺点
好处：
简化了编程接口。它容许在类和类之间重用一些习惯性的命名，而不用为每一个新加的函数命名一个新名字。
简化代码。如果函数/方法参数中使用的是父类的类型，可以传入父类、子类的对象
局限性：
父类类型的变量，不能直接调用子类特有的方法。必须强转为子类类型的变量，才能直接调用子类特有的方法
注意：子类中如果重写了父类的方法(多态)，那么父类中的这个方法将不会再调用。
多态的分类
多态性分为两种，一种是编译时的多态性，一种是运行时的多态性。
编译时的多态性（重载）：
编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
运行时的多态性（重写）：
运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中运行时的多态性是通过覆写虚成员实现。
多态的实现
编译时多态：重载（overload）
重载（overload）：重载指的是同一个类中有两个或多个名字相同但是参数（参数签名）不同的方法，(注:返回值不能区别函数是否重载)，重载没有关键字。
注意：
A.从重载的定义来看，重载是一种编译时多态
B.重载不需要事先定义可重载的方法，即没有关键字
C.重载只是针对一个类内部的几个参数不同，名称相同的方法。
实例说明
/// <summary>
/// 狗(多态：重载事例)
/// </summary>
class Dog
{
/// <summary>
/// 叫
/// </summary>
public void Shout()
{
Console.WriteLine("汪!");
}
/// <summary>
/// 叫(重载方法)
/// </summary>
public void Shout(int count)
{
int i = 0;
string shout = "";
do
{
shout += "汪！";
i++;
} while (i <= count);
Console.WriteLine(shout);
}
}
扫一扫
1981
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
