C#面向对象笔记
面向对象(Object Oriented Programming)
面向过程的语言：C语言
------------------------------------
--方法，类，命名空间的关系--
方法和函数是属于某个类的.
一个类可以声音几个属性.也能声明几个方法或函数
基本上类库这种概念.有的话就是所有类的集合就算是类库了.
一个类文件声明时会指定属于哪个命名空间的.
把类比作一个人.那么吃饭就是人的一种方法或函数.
你住的房间就是命名空间.这样别人你的时候就知道上哪个房间找你了.但这房间里不一定会只有你一个人.
-->>对象
对象是具有数据、行为和标识的三部分编程结构。
对象的数据包含在对象的字段、属性、事件中。
对象的行为则由对象的方法和接口定义。
对象通过classe和struts定义。
对象通过标识来区分是否相同。
对象都是从类和结构中定义的模板实例化得到。
均继承于Object类。
以对象为单位，考虑它的属性和方法，而不考虑具体实现过程
OOP 的主要思想：将处理数据的操作封装到类（class）中
使用类时，定义的变量叫对象（Object）
面向对象的三大特性：
– 封装，隐藏内部实现(类，修饰符)
– 继承，复用现有代码
– 多态，改写对象行为(方法重载)
类：一组具有相同数据结构和相同操作对象的集合
由方法成员、数据成员组成
对象：类的实例化
类的访问：
-->>实例方法
没有加static的方法或属性，
先实例化 类名 实例名=new 类名;
实例名.方法名 实例名.属性 来访问
-->>静态方法
加static的方法或属性：
访问：类名.属性 类名.方法名
[访问修饰符] class 类名 [:基类]
{
类成员（变量、常量 、属性、事件、操作符、索引器等）定义
}
5个常用的访问修饰符：
1.public : 公有成员，任何类都可访问
2.private: 私有成员，当前类下可访问
3.internal: 当前项目下可访问
4.protected: 受保护的成员，本类和子类可以访问.
5.protected internal:同一个.NET集合或继承此类的子类可以访问.
命名空间下默认的修饰符：
结构体(struct)intrnal（本项目可访问）
枚举(enum)intrnal
类(class) intrnal
类中的成员private(私有)
类 = 数据 + 方法
变量：
静态变量 如：public static int iage;
实例变量无static
方法：
静态方法 如：public static void Do(){}
实例方法 无static
类的实例化：
类名 实例名(对象名)=new 类名(参数);
class Person
{
public string name;//数据成员、变量成员、全局变量
public string sex;
public int age;
public void Speak()//公有实例无返回值方法
{
Console.WriteLine("姓名：{0}\n性别：{1}\n年龄：{2}", name, sex, age);
}
public static void say()//公有静态无返回值方法
{
Console.WriteLine("大家好！");
}
}
调用：
Person zs = new Person();//类的实例化
zs.name = "张三";
zs.sex = "男";
zs.age = 25;
zs.Speak();//实例方法访问
Person.say();//静态方法访问
注：
同一个类下，实例方法可以直接访问静态和实例成员
同一个类下，静态方法只能直接访问静态成员（加static的成员）
静态成员的访问不用实例化，访问时：类名.实例名
实例化时数据类型的初始化：
数值型 0或0.0
sring型 null
char型 \0
字段与属性：
在类中定义的变量为字段
字段有三个属性：只读，只写，可读写
属性： 定义一个公共的具有get/set方法的变量，这个变量用于保护一个私有变量
读写属性：具有get/set方法的属性
只读：只有get方法的属性
只写：只有set方法的属性
注：
字段命名：首字母小写（骆驼命名法）
属性命名：首字母大写（帕斯卡命名法）
属性是为了保证对字段的读取和赋值符合要求
允许外部访问的变量一定要声明为属性
命名空间：namespace 名字
用于建立类并解决类的重名（类的文件夹）
System 是根命名空间
类的调用：
不同命名空间下类的访问：
1.using 命名空间名（引用命名空间）
2.命名空间名.类名
方法：（Member Function）用来操作类的数据
方法头 + 方法体
方法的重载的特点是（两必须一可以）：
· 方法名必须相同
· 参数列表必须不相同
· 返回值类型可以不相同
方法的参数类型：
值类型：int x
引用类型： ref int x
输出类型： out int x
数组类型：params int[] arrlist 或 arrMylnt(数组)-----引用型
ref与out的区别：
ref 在使用前必需初始化，而out不需要。
ref 引入变量，有进有出
out 引出变量，只出不进
out 参数在进入方法（函数）时后清空自己
两者都是按地址传递,使用后都将改变原来的数值。
out适合用在需要retrun多个返回值的地方，
ref则用在需要被调用的方法修改调用者的引用的时候。
值类型与引用类型比较：
值类型引用类型
存储位置：存实际值存指向实际值的引用地址
内存分配：堆栈托管堆
内存需求：较少较大
执行效率：较快较慢
内存释放时间点：超过变量的作用域空窗时期回收
是否可以为null:不能可以
构造方法(函数)、[析构函数]：
构造方法
创建对象：用于给类的成员赋初始值
方法名与类名相同
class 类名{
访问权限 类名称（类型1 参数1,类型2 参数2,......）
｛
程序语句；
｝
}
注：
构造方法没有返回值，不用void
名字与类名相同
类有一个默认的无参构造方法
一旦定义了一个构造方法，默认的构造方法将不复存在
构造方法的重载：
方法的不同版本，同一种方法，不同的参数
实现重载的条件：个数/类型/顺序
析构函数：
用于回收对象，释放内存空间
不能在结构中定义，只能用于类
一个类只有一个析构函数
无法继承或重载，没有修饰符，也无参数
无法调用，系统自动调用
如：~Student(){} 一般在程序结束时使用，最后使用
抛异常(报错)：
throw new Exception ("错误信息");
或者：
Exception ex = new Exception("错误信息");
throw ex;
==>>>String 字符串类：
相当于char的只读数组集合
具有不可变性,一旦声明就不能再改变，只能通过索引来读取指定位置的char
不能对指定位置的char进行修改
字符串重复赋值时，原值不会消失，新值以新内存空间存储（引用型）
bool StartsWith(d)判断字符串是否以d开头
bool EndsWith(d)判断字符串是否以d结尾
int IndexOf(b)查找b在字符串中的位置
int IndexOf(b, 5)从索引号5的位置开始查找b的位置
字符串与char数组的转换：
ToCharArraynew string(arr);
string word = "Hello word!";
char[] chars = word.ToCharArray();//将字符串转换为char数组
chars[4] = '哦';
word = new string(chars);//将char数组生成一个字符串
Console.WriteLine(word);
输出结果：Hell哦 word!
字符串的切割：
string data = "2000.2.5";
string[] D = data.Split('.');//将字符串按.分割，存入string数组中
string大写与小写转换：
string ToLower():得到字符串的小写形式
string ToUpper():得到字符串的大写形式
Trim():去掉字符串两端的空白
s1.Equals(s2.StringComparison.OrdinallgnoreCase)
两个字符串忽略大小写比较
例如：比较 s1 == s2
string s1 = "hello";
string s2 = "HEllO";
s1 = s1.ToUpper();//或s1 = s1.ToLower();
s2 = s2.ToUpper();//或s2 = s2.ToLower();
字符串的替换：
string Replace(参数1,参数2)参数只能是char或string
把参数1替换成参数2
字符串的截取：
string Substring (int1,[int2]) 截取字符串
int1：索引位置
int2：长度
字符串的连接：
string C = string.Concat(A, B);//将字符串A和B拼接
字符串的查找：
int i = A.IndexOf('e');//从左向右找e，返回其索引号
int i2 = A.IndexOf('e',3,5);//从索引号3开始的5个数里查找e，返回其索引号
bool b=str.Contains('a');//判断字符串中是否含有字符a,返回布尔值
** IndexOf和Contains的区别：
* IndexOf返还的是索引号，Contains返回的是true和false
* 使用Contains方法的效率比IndexOf的效率高很多
判断字符串否以指定的字符开头或结尾：
bool a = A.StartsWith("W");//判断字符串是否以W开始，返回True或False
bool b = B.EndsWith("t");//判断字符串是否以t结尾，返回True或False
判断字符串是否相同 ：
bool x = A == B;
bool x1 = string.Equals(A,B);
bool x2 = A.Equals(B);
字符串的复制：Copy();
string A1 = string.Copy(A);(不常用)
字符串的截取：
string Substring (int1,[int2]) 截取字符串
int1：索引位置
int2：长度
string m1 = C.Substring(5);//从索引号5开始截取，截取到最后
string m2 = C.Substring(5,3);//从索引号5开始截取3个字符
去除字符串两端的空格：
string r = " 1 22 2 ";
string R1 = r.TrimStart();//去除字符串前面的空格
string R2 = r.TrimEnd();//去除字符串后面的空格
string R3 = r.Trim();//去除字符串两端的空格
向字符串中插入元素：
string R4 = r.Insert(4,"eee");//将字符串eee插入到索引号为4的后面
Format格式化字符串 Copy复制 Insert插入........
===========
**类的继承**
===========
基类（父类）：被继承的类
派生类（子类）：继承自其它类的类
继承性的语法：
[访问修饰符] class 派生类名称：基类
public class ChildClass:BaseClass{}
C#只允许单继承
派生类只能继承一个基类（也就是一个子类只能有一个父类）
一个类可以是基类也可以是派生类
在静态方法中不能使用this关键字
========
**封装**
========
1.模块信息通过类来封装
2.对象是封装的基本单位
3.类的成员通过字段、属性、方法、事件封装
4.类的成员通过修饰符来封装（private/public/protected）
========
**多态**
========
相同方法的不同能力的实现
实现多态的方式 ：
重载、继承、抽象类、接口
虚方法：virtual
写于基类中
覆盖（重写）：override
写于派生类中，用于覆盖父类的虚方法
重写的方法名、参数个数、类型及返回值都必须和虚方法一致
抽象类：（Abstract Class）
类有两种：一种是具体类，另一种是抽象类
具体类可以实例化，抽象类不可以实例化。在类声明中使用 abstract 修饰符以指示类只能是其他类的基类。
public abstract class Animal{ }
抽象类的特点：
（1）抽象方法是隐式的 virtual 方法。
（2）只允许在抽象类中使用抽象方法声明。
（3）因为抽象方法声明不提供实现，所以没有方法体；
（4）在抽象方法声明中使用 static 或 virtual 修饰符是错误的。
（5）在派生类中，通过包括使用 override 修饰符的属性声明可以重写抽象的继承属性。
密封类：
密封类不能用作基类。它也不能是抽象类。
密封类主要用于防止派生。
使用sealed关键字创建密封类：
public sealed class Animal{ }
<<<<<<<==========================>>>>>>>>>
目录和文件操作
<<<<<<<==========================>>>>>>>>>
先导入命名空间using System.IO;
=>>目录操作：Directory静态/DirectoryInfo实例
创建目录：CreateDirectory()
Directory.CreateDirectory(@"E:\work\00000\1111");
删除目录：Delete()
Directory.Delete(@"E:\work", true);
获取文件夹目录：GetDirectories()
string[] dirs = Directory.GetDirectories(@"e:\");
获取计算机的逻辑驱动器：GetLogicalDrives()
string[] logic = Directory.GetLogicalDrives();
获取文件目录: GetFiles()
string[] files = Directory.GetFiles(@"d:\");
获取文件创建日期和时间
DateTime dt = Directory.GetCreationTime(@"d:\2003");
获取当前应用程序的工作目录: GetCurrentDirectory()
Console.WriteLine(Directory.GetCurrentDirectory());
判断文件是否存在: Exists()
bool ex = Directory.Exists(@"d:\2003")
获取文件上次的访问时间：
Console.WriteLine(Directory.GetLastAccessTime(@"d:\2003"));
同盘符下移动文件夹：
Directory.Move(@"d:\00\11",@"d:\22\11");
获取文件最后一次修改时间：
Console.WriteLine(Directory.GetLastWriteTime(@"d:\2003"));
DirectoryInfo类：
Name : 当前实例名
Parent : 当前实例的上一级父目录名
Root : 当前实例所在根目录名
CreationTime : 当前实例创建时间
LastAccessTime : 当前实例上次被访问时间
LastWriteTime :当前实例上次修改时间
DirectoryInfo dir1 = new DirectoryInfo(@"e:\22\11");
string na = dir1.Name;
=>>文件操作：File/FileInfo
File类：静态
Create(string path ) :创建文件
Delete( string path) :删除文件
Copy( string spath,string dpath) : 复制文件
Move(string spath,string dpath) : 移动文件
Exists(string path) : 判断文件是否存在
FileInfo类：实例
Name : 获取当前文件的名称
Extension : 获取当前文件扩展名
FullName : 获取文件所在的完整路径。
Exists : 检查当前文件是否存在
Length : 获取当前文件的大小。
Directory : 获取父目录的
DirectoryInfo.
DirectoryName : 获取文件的完整目录路径
向文件中写入数据：
StreamWriter x = new StreamWriter(@"e:\001.txt");
x.Write("欢迎你来到这个地方！");
x.Close();
==>>异常捕获
C#中异常都是以类的形式出现的，
所有的异常类的基类是：Exception类
常见的几个异常类：
ArrayTypeMismatchException:当向数组中保存一个与元素类型不兼容的值时，将会抛出该异常。
DivideByZeroException:当除数为0时，将会抛出该异常。
IndexOutofRangeException:使用超出数组边界的索引时，将会抛出该异常。
try catch 方法：捕捉异常，提示错误！
语法格式：
try
{ 语句块 }
catch(异常对象声明1)
{ 语句块1 }
catch(异常对象声明2)
{ 语句块2 }
……
finally
{ 存在于异常处理的标准事件流之外。
用来清理资源或还原相关设置信息等其他操作
是否发生异常，均要执行的代码块； }
注：
Try 块的代码是程序中可能出现错误的操作部分。
Catch 块的代码是用来处理各种错误的部分（可以有多个）。
finally语句,无论是否产生异常，Finally块都会执行。
例：
try
{
Console.WriteLine("请输入一个整数：");
int a = int.Parse(Console.ReadLine());
}
catch (Exception m)
{
Console.WriteLine("输入错误，错误为："+m.Message);
//如果输入字符不能转换为int，输出：输入错误，错误为：输入字符串格式不正确
}
throw：
用于引发异常，可引发预定义异常和自定义异常。
throw new Exception("出错时的提示");
浙公网安备 33010602011771号