null第七章第七章类目标目标类的声明
类的成员
类的构造函数和析构函数
方法
字段和属性
索性器体验体验编写一个类，用于计算圆、长方形、梯形的面积。
程序运行时创建一个计算面积的类的对象，通过调用对象的方法，实现面积的计算。
从现在开始，所有的程序都是通过面向对象的思想编写成的。类类类是一组具有相同数据结构和相同操作的对象的集合。类是对一系列具有相同性质的对象的抽象，是对对象共同特征的描述。语法：[其他修饰符][访问修饰符] class <类名>{
// 类的主体
}示例：
class Employee
{
// 类的主体
}// 成员变量
// 成员方法成员变量语法：
成员变量[访问修饰符]数据类型成员变量;privateprotectedinternalpublic_namestatus….userNameintchar….bool…
class Employee
{
private string _name;
private char _gender;
private int _sex;
private uint _salary;
}
…访问成员变量步骤 1：创建一个类的对象Employee objEmployee = new Employee();步骤 2：使用点号访问成员变量objEmployee._name = “张三";
objEmployee._name = 'M';访问修饰符 2-1访问修饰符 2-1Teacher 类private 成员protected 成员public 成员internal 成员Student 类不可访问不可访问可以访问只有 Student 类在 Teacher 类都在同一程序集中，才可访问internal成员访问修饰符 2-2访问修饰符 2-2其他类修饰词其他类修饰词字段和属性字段和属性保存类的实例的各种数据信息，C#提供了两种方法：字段和属性。
通过属性实现了良好的数据封装和数据隐藏字段字段字段表示类或结构中的对象或值
字段使类和结构可以封装数据
例：
public class Employee
{
private string _name; //字段
private uint _age; //字段
…
} 字段设计原则字段设计原则不要提供公共的或受保护的实例字段
对不会更改的常量使用常量字段//const
对预定义对象实例使用公共静态只读字段
不要将可变类型的实例指定给只读字段
属性2-1属性2-1属性是对现实世界中实体特征的抽象，它提供了对类或对象性质的访问。
C#中的属性更充分地体现了对象的封装性：不直接操作类的数据内容，而是通过访问器进行访问，它借助于get和set对属性的值进行读写。 属性2-2属性2-2属性结合了字段和方法的多个方面
例：
public class Employee
{
private string _name; //字段
private uint _age; //字段
…
public string Name //属性，可读写
{
set{ _name = value; } //value关键字，传递所赋值
get{ return _name;}
}
public uint Age //属性，只写
{
set{ _age = value;}
}
}
属性特征属性特征属性使类能够以一种公开的方法获取和设置值，同时隐藏实现或验证代码。
get属性访问器用于返回属性值，而set访问器用于分配新值。这些访问器可以有不同的访问级别。
value关键字用于定义由set索引器分配的值。
不实现set方法的属性是只读的，同样不实现get方法的属性是只写的。
除了使用了abstract修饰符的抽象属性，每个访问器的执行体中只有分号“；”，其它所有属性的get访问器都通过return来读取属性的值，set访问器都通过value来设置属性的值。类的继承声明类的继承声明类B继承类A：
class A {…}
class B: A {…}//冒号表示继承
如果还有接口IFace1，IFace2需要实现：
class B:A,IFace1,IFace2{…}
构造函数 2-1构造函数 2-1构造函数是类的一种特殊方法，每次创建类的实例都会调用它[访问修饰符]<类名>(){
// 构造函数的主体
}语法：public class Employee
{ …
// 默认构造函数
Employee()
{
_qualification = "研究生";
}
…
}示例：构造函数 2-2 static void Main(string[] args)
{ // 调用默认构造函数
Employee objEmployee = new Employee();
Console.WriteLine(“资格= " + objEmployee._qualification);
Console.WriteLine(“薪水= " + objEmployee._salary);
}
}构造函数 2-2class Employee
{ private string _name;
private char _gender;
private string _qualification;
private uint _salary; // 默认构造函数
private Employee()
{
_qualification = “研究生";
}参数化构造函数 2-1参数化构造函数 2-1[访问修饰符]<类名> (){
// 构造函数的主体
}语法：([参数列表])…
// 参数化构造函数
Employee(string strQualification)
{
_qualification = strQualification;
}
…示例：构造函数3-1构造函数3-1是类中的特殊类型的方法
是每次创建对象时要调用的函数
通常用于初始化
与类同名//？？？
不返回值
构造函数3-2构造函数3-2using System;
public class DaysInYear
{
private int days;
public DaysInYear()
{
days = 365;
}
static void Main(String[] args)
{
DaysInYear newDaysInYear=new DaysInYear();
Console.WriteLine(newDaysInYear.days);
}
}无构造函数输出
的结果是0有构造函数输出
结果是365带参数的构造函数3-3带参数的构造函数3-3
…
public class DaysInYear
{
private int days;
public DaysInYear()
{
days = 365;
}
public DaysInYear(int day)
{
days = day;
}
public DaysInYear(String dayOne)
{
days =Convert.ToInt32(dayOne);
}
public void setDay(int newDays)
{
days = newDays;
}
…
}传递不同个数的参数
传递个数相同但类型不同的参数
析构函数析构函数是用于执行清除操作的特殊方法~<类名>(){
// 析构函数的主体
}语法：…
~Employee()
{
}
…示例：析构函数特征析构函数特征不能在结构中定义析构函数，只能对类定义析构函数。
一个类只能有一个析构函数。
无法继承或重载析构函数。
无法调用析构函数，它们是被系统调用的。
析构函数既没有修饰符，也没有参数。方法方法接听响铃挂断PickUp()
{
….
//用于传送和接收信号的代码
}Ring()
{
….
//用于显示主叫号码的代码
}Hang()
{
….
//用于结束会话的代码
}对象的行为声明方法 2-1声明方法 2-1语法访问修饰符（可选），默认情况下为 private[访问修饰符] 返回类型 <方法名>([参数列表])
{
// 方法主体
}如果不需要返回任何值，方法可能返回 void 数据类型声明方法 2-2声明方法 2-2…..
class Point
{
int x;
int y;
void Assign()
{
System.Console.WriteLine(“输入点的值");
x = int.Parse(System.Console.ReadLine());
y = int.Parse(System.Console.ReadLine());
}
}
…..方法 Assign() 的定义 不返回任何值 (void)
不接收任何值 (Assign())Assign( ) 方法调用方法 2-1调用方法 2-1对象名.方法名([参数列表]);实例类中的方法点号语法调用方法 2-2调用方法 2-2return [表达式];return 语句 …
Number num = new Number();
int result = num.Sum(10,31);
…
public class Number
{
public int Sum(int x,int y)
{
int s = x + y;
return s;
}
}语法方法的参数方法的参数C#中方法的参数有四种类型：
值参数，不含任何修饰符。
引用型参数，以ref 修饰符声明。
输出参数，以out 修饰符声明。
数组型参数，以params 修饰符声明。值参数值参数当利用值向方法传递参数时，编译程序给实参的值做一份拷贝，并且将此拷贝传递给该方法。被调用的方法不会修改内存中实参的值，所以使用值参数时，可以保证实际值是安全的。
参见教材中示例7.7引用型参数 引用型参数 引用型参数和值参不同，引用型参数并不会开辟新的内存区域。
当利用引用型参数向方法传递形参时，编译程序将把实际值在内存中的地址传递给方法。
引用型参数一般是两种情况下存在
方法的形参本身就是引用类型。
参见示例7.8
通过声明ref关键字使参数按引用传递
参见示例7.9nullusing System;
class RefValueParamSample
{
static void Swap(ref int x, ref int y)
{
int temp = x;
x = y;
y = temp;
}
static void Main()
{
int i = 1, j = 2;
Swap(ref i, ref j);
Console.WriteLine("i = {0}, j = {1}", i, j);
}
}
输出参数 输出参数 与引用型参数类似，输出型参数也不开辟新的内存区域。
与引用型参数的差别在于，调用方法前无需对变量进行初始化。
输出型参数用于传递方法返回的数据。
out 修饰符后应跟随与形参的类型相同的类型声明
例：static void SplitPath(string path, out string dir, out string name){…..}
示例参见书中例7.10 nullusing System;
class OutSample
{
static void SplitPath(string path, out string dir, out string name)
{
int i = path.Length;
while (i > 0)
{
char ch = path[i - 1];//最后一个字符
if (ch == ‘\\’ || ch == ‘/’ || ch == ‘:’) break;//是反斜杠分割
i--;
}
dir = path.Substring(0, i);//0—i-1是目录
name = path.Substring(i);//从i—最后
}
static void Main()
{
string dir, name;
SplitPath("c:\\Windows\\System\\hello.txt", out dir, out name);
Console.WriteLine(dir);
Console.WriteLine(name);
}
}//形参和实参共用一个内存，数组型参数 数组型参数 形参表中包含了数组型参数，那么它必须在参数表中位于最后。
params关键字可以指定在参数数目可变处采用参数的方法参数。
在方法声明中的 params关键字之后不允许任何其他参数
在方法声明中只允许一个 params 关键字。
示例参见书中例7.11
nullusing System;
class ParamsSample
{
static void F(params int[] args)
{
Console.Write("Array contains {0} elements:", args.Length);
foreach (int i in args) Console.Write(" {0}", i);
Console.WriteLine();
}
public static void Main()
{
int[] a = { 1, 2, 3 };
F(a);
F(10, 20, 30, 40);
F();
}
}
this 关键字this 关键字this仅限于在构造函数、类的方法和类的实例中使用。
在类的构造函数中出现的this作为一个值类型，它表示对正在构造的对象本身的引用。
在类的方法中出现的this作为一个值类型，它表示对调用该方法的对象的引用。
在结构的构造函数中出现的this作为一个变量类型，它表示对正在构造的结构的引用。
在结构的方法中出现的this作为一个变量类型，它表示对调用该方法的结构的引用。
经常在构造函数或者类方法中，如果传入参数和类字段同名，一定需在类字段前加上this。this示例this示例using System;
class A
{
private int x;
public A(int x)
{
this.x = x;
}
public void PrintX()
{
x = 5;
Console.WriteLine("The value of x is: {0}", x);
Console.WriteLine("The value of this.x is: {0}", this.x);
}
public static void Main()
{
A a = new A();
a.PrintX();
}
}静态成员和非静态成员静态成员和非静态成员将类中的某个成员声明为static，该成员称为静态成员。
类中的成员要么是静态，要么是非静态的。
静态成员是属于类所有的，非静态成员则属于类的实例——对象。 静态示例静态示例using System;
class StaticSample
{
int x;
static int y;
void F()
{
x = 1; // 正确,等价于this.x = 1
y = 1; // 正确,等价于Test.y = 1
}
static void G()
{
//x = 1; // 错误不能访问 this.x
y = 1; // 正确,等价于Test.y = 1
}static void Main()
{
StaticSample t = new StaticSample();
t.x = 1; // 正确
// t.y = 1; // 错误不能在类的实例中访问静态成员
//StaticSample.x = 1; // 错误不能按类访问非静态成员
StaticSample.y = 1; // 正确
}
}
常量常量[访问修饰词] const 数据类型 常量名（一般大写） = 数值
例：
class A
{
public const double X = 1.0;
public const double Y = 2.0;
public const double Z = 3.0;
}
用一条语句同时声明多个常量，上例可写成：
class A
{
public const double X = 1.0, Y = 2.0, Z = 3.0;
}方法重载方法重载重载方法有两种方式
指定不同个数的参数
指定不同类型的参数不同参数个数的方法重载不同参数个数的方法重载using System;
public class Area
{
private int areaVal;
public void AreaCal(int radius)
{
areaVal = (22/7)* radius*radius;
}
public void AreaCal(int length, int breadth)
{
areaVal = length*breadth;
}
public void AreaCal(int length, int breadth, int height)
{
areaVal = length*breadth*height;
}
…
}参数的类型相同
参数个数不同不同参数类型的方法重载不同参数类型的方法重载...
public void AreaCal(int radius)
{
areaVal = (22/7)* radius*radius;
}
public void AreaCal(string shapeName)
{
Console.WriteLine("{0} 的面积没有计算",shapeName);
}
...
方法中参数个数相等,参数类型不同索引器索引器索引器是 C# 的简单组件
为数组创建索引器后，可以通过从类对象指定索引来直接访问数组元素
可以用索引数组的方式索引对象
可以像访问数组一样访问类的成员
示例 定义索引器的规则定义索引器的规则必须指定至少一个索引器参数
应当为索引器参数赋值
索引器与数组的比较4-1索引器与数组的比较4-1索引器不指向内存位置
索引器可以有非整数的下标（索引）
可以重载索引器
索引器与数组的比较4-2索引器与数组的比较4-2索引器与数组的比较4-3索引器与数组的比较4-3using System.Collections;
class StrIndex
{
public Hashtable studentList = new Hashtable();
public int this[string name]
{
get
{
return (int) studentList[name];
}
set
{
studentList[name] = value;
}
}
}class Test
{
static void Main()
{
StrIndex objIndex = new StrIndex();
objIndex["Sam"] = 232676;
objIndex["Tom"] = 455464;
System.Console.WriteLine("Sam 的电话号码是 {0}，Tom 的电话号码是 {1}", objIndex["Sam"],objIndex["Tom"]);
}
} 索引器可以有非整数下标
而数组不能有 索引器与数组的比较4-4索引器与数组的比较4-4using System.Collections;
class IndexerExample
{
public string[] stringList=new string[10];
public string this[int index]
{ get
{ return stringList[index]; }
set
{ stringList[index] = value.ToString();
} }
public Hashtable studentList =
new Hashtable();
public int this[string number]
{
get
{return (int) studentList[number];}
set
{ studentList[number] = value;
}
}
}class Test
{
static void Main()
{
IndexerExample indexTest = new IndexerExample();
indexTest.stringList[1]="Sam";
indexTest[2]="Tom";
indexTest["Sam"] = 232;
indexTest["Tom"] = 455;
}
} 一个类可以有多个索引器
但必须通过指定不同的
索引类型重载索引器 在索引器中使用多个参数在索引器中使用多个参数可以指定多个索引器参数
接口中的索引器接口中的索引器索引器可在接口（interface）上声明。接口索引器的访问器与类索引器的访问器具有以下方面的不同：
（1）接口访问器不使用修饰符。
（2）接口访问器没有体。
因此，访问器的用途是指示索引器是读写、只读还是只写。
例：public interface ISomeInterface
{
string this[int index]
{
get;
set;
}
}索引器的设计原则索引器的设计原则考虑使用索引器提供对存储在内部数组中的数据的访问。
考虑对表示项的集合的类型提供索引器。
避免使用具有多个参数的索引属性。
如果一个索引器需要多个参数，请重新评估该属性是否确实表示对逻辑集合的访问。如果不是，则改用方法，并考虑选择以Get或Set开头的方法名。
避免为索引器设置除System.Int32、System.Int64、System.String、System.Object、枚举或泛型类型参数之外的其他参数类型。
不要同时提供在语义上等效的索引器和方法。
注意：不要在一个类型中提供一组以上的重载索引器。
总结
初级经济法重点总结下载党员个人总结TXt高中句型全总结.doc高中句型全总结.doc理论力学知识点总结pdf
总结类的声明
类的成员
类的构造函数和析构函数
方法
静态成员
字段和属性
索性器以及设计原则
浙公网安备 33021202002483