C#入门经典第8版 第八章面向对象编程简介

在我们学习对象的含义的知识点的时候其实需要知道其中OPP技术 对象就是opp技术中的一个构建,

 在类中有一种表达方式为UML UML由我个人理解,其含义就是能将一个类中的成员进行一个画图的显示，来定义其类中的成员是私有还是公共等。书中P122 UMl是为应用程序建模而设计的 类似于，如图

书中有提到属性字段，由于经常使用这里不写笔记介绍。只需要注意其中属性的只读和只写以及对set 或get可以进行访问修饰符的设定,以及能对属性的设置的时候进行一个区间设置。

对象的声明周期，其中对象的生命周期,处理正在使用外还有其两种状态,

第一种 构造阶段  第一次示例化的时候，初始化该对象的时候被称呼为构造阶段。

第二种 析构阶段 在删除一个对象的时候 如执行清理内存 这由析构函数来完成。

构造函数 是在创建对象之初会使用关键字new ，new关键字就是调用构造函数 构造函数默认的类中都会有一个自带的构造函数。构造函数能是私有和公共。如您构造函数设置为私有的那么代码外部就不能进行一个实例化，也称呼为不可创建类，想实例化必须要使用到公共的构造函数。

其中提一下用少的析构函数 析构函数会在程序结束的时候自动触发运行

静态成员

静态成员 在使用的时候甚至不用初始化 直接使用,稍微值得说的就是静态构造函数一个类只能有一个没修饰符没参数，也不能直接调用只会在以下情况执行

1 创建包含静态构造函数的实例时

2访问包含静态构造函数的类的静态构造成员时

示例

1.   static void Main(string[] args)
2.         {
3.            // MyClass myClass = new MyClass();//创建实例时候 触发静态构造方法
4.             MyClass.Student = "Slt"; //访问静态的成员 静态构造函数触发
5.             //myClass.Students = "SLG";//非静态不会触发
6.         }

类库

1.   public class MyClass
2.     {
3.         public virtual string p { get; set; }
4.         public static string Student { get; set; }
5.         public  string Students { get; set; }
6.         public MyClass()
7.         {
8.             //默认构造函数
9.         }
10.          ~ MyClass()
11.         {
12.             //析构函数 程序结束时候触发
13.         }
15.         static MyClass() // 不能调用静态构造函数//不能有访问修饰符号 2不能有参数 3一个类只有一个静态构造函数
16.         {
18.         }
19.     }

接口

声明

1.  interface IFLy {}//接口的定义

接口就是把公共实例非静态方法和属性组合起来，以封装特定功能的一个集合。接口不能单独存在，不能实例化一样的那样实例化接口接口不包含实现其成员的任何代码接口。只需要定义成员。接口一般。被类继，继承接口的类。需要实现当前接口中的成员

可删除对象 如有释放等方法的方法 可以用Using(){}这样的结构如图

 

继承

被继承，我们能称为派生类

派生类类不能访问基类的私有成员，但可以访问其公共成员。不过派生类和外部的代码都可以访问公共成员。其中还有一种受保护关键字。只有派生类才可以访问受保护的成员。外部代码来说，这个受保护的成员访问性与私有成员是一样的。除了定义保护的级别成员。成员定义其继承行为。基类的成员可以是虚拟的，也就是说成员可以由继承它的类重写。派生类可以提供成员的另一种实现代码。这种实现代码不会删除原来的代码，可以在类中访问原来的代码，但外部代码不能访问它们。没有提供其实现的方法。通过派生类使用成员的内部代码，就会自动调用基类中的成员实现代码。

重写虚拟属性(当然不止属性能被虚拟和重写)

1.  public override string p { get => base.p; set => base.p = value; }//这里的base 就是显示调用父类原来中的p

抽象类(书 P127)

抽象类定义不能被实例化，要使用抽象类，必须继承这个类，抽象类可以有抽象成员，抽象类中的成员没有实现代码，所以派生类（子类）必须实现它们。

定义

1. /// <summary>
2.     /// 定义了一个抽象类
3.     /// </summary>
4.     public abstract class MyAbstractClass
5.     {
6. //code
7.     }

这是定义了，抽象类中的抽象成员（抽象成员只能在抽象类中）定义方法为抽象方法，如果是定义抽象抽象方法那么就不用再写方法体，如图1-2 书中还提到了有密封类，如图1-3 注意密封类不能被继承

抽象关键字 abstract

密封关键字 sealed

图1-1

图1-2

图1-3

多态性

多态的含义解释可以阅读书中的P129-130 下面介绍写法

1.   public class Program:P
2.     {
4.         static void Main(string[] args)
5.         {
6.             #region 正常对象初始化
7.             //多态
8.             Program program = new Program();
9.             P P1 = new P();
10.             #endregion
11.             #region 将Progrm的类型赋值给了P
12.             P P2 = program;//正常是不能赋值的  因program 是继承了P2
13.             #endregion
14.             P2.Write();//现在默认P2的类型就是 P的类型 
15.             //所以这里是正常调用
16.             ((Program)P2).KL();
17.             //1 我们自身知道P2的类型其内部就是Program的类型
18.             //2 强制转换一下为Progrm 才能调用到Program的类中成员
19.         }
20.         public void KL() => new Object();
21.     }
22.     public class P
23.     {
24.         public void Write() { }
25.     }

重写父类ToString()方法

1. public override string ToString()
2. {
3.   return base.ToString();//base 就是父类的对象(个人理解) base还有一个名称为 构造函数初始化器 显示调用父类ToString();
4. }

运算符重载★(书 P131)

我们正常再C#语法当中+号可以就是在值类型是起到相加的作，在引用类型是起到连接作用。我们可以将默认的+号的效果进行一个重新定义成我们想要的效果，+号、-号、++等我们统称为运算符。

我们可以重写的运算符。

重写示例

1. public class Program
2.     {
3.         public int old { get; set; }
4.         static void Main(string[] args)
5.         {
6.             Program program = new Program();
7.             Program program1 = new Program();
8.             program.old = 10;
9.             program1.old = 20;
10.           int s=  program + program1;
11.           int ss=  program - program1;
12.             Console.WriteLine(s);
13.             Console.WriteLine(ss);
14.             ReadKey();
15.         }
16.         public static int operator +(Program program, Program program1)=> program.old + program1.old;//自定义+符号运算符重载
17.         public static int operator -(Program program, Program program1)=>program.old - program1.old;
18.         public static bool operator ==(Program program, Program program1)//自定义==号运算符重载 必须与之想对应的 ！=也要重因为他们是成对出现
19.         {
20.             if (program.old == program1.old) return true; else return false;
21.         }
22.         public static bool operator !=(Program program, Program program1)
23.         {
24.             return true;
25.         }
26.         public static implicit operator int(Program program)//implicit 自定义隐式转换
27.         {
28.             return program.old;
29.         }
30.         public static explicit operator string(Program s)//explicit 自定义强制转换
31.         {
32.             return "";
33.         }
34.     }