C#面向对象笔记

第一章，初探类与对象

1.1、专业单词

单词	释义
OOP	面向对象编程
class	类
object	对象
public	公开的、公有的
private	私有的
protected	受保护的
internal	内部的

1.2、什么是面向对象编程

面向对象编程（Object Oriented Programming ,OOP,面向对象程序设计）是一种计算机编程结构，与面向过程编程相比，具有高重用性、灵活性和扩展性的优点。
C#语言是一种面向对象的编程语言，它的设计思想是将要解决的问题里面的相关对象分析总结出来，抽象出它特征和行为。

1.3、面向对象和面向过程的区别

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用。
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。

1.4、类与对象简介

类——class

类描述了一组有相同特性和相同行为（方法或函数）的对象。在程序中，类实际上就是数据类型！例如：整数、小数等等，整数也有一组特性和行为。
对象——object

对象是系统中用于描述客观事物的一个实体。所有的实物可以表示为对象。所有的概念也可以表示为对象。
类与对象的关系

类是一个抽象的概念，是一组具有相同特性和行为的对象集合。例如：车类、人类、书类；而对象是类的实例化，即类的实物表达，如一辆车、一个人、一本书。

对象是类的具体表达；而类则是对象的抽象表达。

1.5、类的定义

要使用类，必须先定义类

[访问修饰符] class 类名

{
    类成员（常量、字段、构造函数、方法(函数)、属性、事件、索引器、运算符等）的定义；
}

访问修饰符

类或类的成员都有关联的可访问性，它控制能够访问该成员的程序文本区域。C#有五种可访问修饰符。

可访问性	含义
private	私有的，访问仅限于此类
public	公开的，访问不受限制
protected	受保护的，访问仅限于此类和从此类派生的类
internal	程序集内部的，访问仅限于此程序
protected internal	由此声明的程序集或另一程序集派生的类中可以访问

1.6、类的成员

字段

字段是类的数据成员，是描述一类事物共同属性特征的变量。

字段声明语法：

[访问修饰符] 数据类型字段名称；
```
class Student
{
    public string Name;
    public int age;
    string Color;
    double Price;
}
```

方法

类中的方法，是类的行为成员，是对象可执行的操作。

函数声明语法：

[访问修饰符] 返回类型方法名称（形参列表）

{

方法体（局部变量成员，功能实现代码等）

}

class Student
    {
        public string name;
        public int age;
        public void Students(string name, int age)
        {
            Console.WriteLine("我叫{0}，今年{1}岁",name,age);
        }
    }

1.7、创建对象

创建对象就是将类实例化，其过程本质是在内存中为对象分配存储空间，并对对象进行初始化。
C#使用关键字new创建对象

语法：类名对象名=new 类名()；
```
例：
    Student stu =new Student();
```

1.8、使用对象访问类成员

将类实例化一个对象后，可以通过对象访问类的字段，去读取、设置相应字段的值；还可通过对象访问类的方法，执行方法的功能。
访问类字段的语法：

读取字段的值：对象名.字段名

设置字段的值：对象名.字段名=值；
```
例：
    Student stu =new Student();
    stu.name;
    stu.name="Tom";
```

1.9、使用对象访问类成员

访问类方法的语法：

对象名.方法名(实参列表);

例：
    Student stu=new Student;
    stu.name="Tom";
    stu.age=18;
    stu.Students(name,age);

第二章、类的静态成员

2.1、专业单词

单词	释义
static	静态的
instance	实例
field	字段
method	方法

2.2、类的成员

类有数据成员或方法成员，还可划分为实例成员和静态成员

字段（field）成员：是描述状态的数据成员
方法（method）成员：是描述操作的行为成员
静态（static）成员：用static关键字修饰的字段或函数成员
实例（instance）成员：没有用static关键字修饰的字段或函数成员

2.3、静态字段

静态字段是被static关键字修饰的字段，静态字段属于类所有，被这个类的所有对象共享，通过”类名.静态字段名”来访问。

类中定义静态字段语法：

class 类名
{
    [访问修饰符] static 数据类型 字段名;        
}

class Student
{
    //定义静态字段
    public static string school ="计算机大学";
    
    //访问静态字段
    Console.WriteLine("Hello,大家好！\n我是{0}学生",Student.School)<---其他类中
}

2.4、静态方法

静态方法是被static关键字修饰的方法，同样静态方法也属于类所有，被这个类的所有对象共享，通过”类名.静态方法名(实参列表)”来访问。

类中定义静态方法语法：

class 类名
{
    [访问修饰符] static 返回值类型 方法名(形参列表);        
}

class Student
{    
    public static string school ="计算机大学";
    //定义静态方法
    public static void ShowSchool()
    {
        Console.WriteLine("{0}欢迎您",school);
    }
    Student.ShowSchool();<---其他类中
}

2.5、静态成员特征

静态成员必须通过static关键字定义，通过类名访问。
在内存中，一个静态字段只标识一个储存位置，无论创建了一个类的多少个实例，它的静态字段在内存中只占同一块区域。
静态方法不能作用于对象，即静态方法中不能直接使用实例成员，必须创建类的对象，通过对象名引用访问，但是可以直接访问本类的静态成员。

2.6、实例成员特征

实例成员不能添加static关键字定义，通过对象名访问。
类的实例成员属于类的对象所有，每创建一个类的对象，都在内存中为实例字段开辟了一块区域。类的每个对象，分别包含一组该类所有实例字段的副本。
类的实例方法直接作用于类的对象，在实例方法中可以直接访问本类的静态成员和实例成员。
调用完后会自动释放，节省内存空间。

2.7、编程时，如何选择使用实例成员还是静态成员

对于字段来说，比如你有一个兄弟，你们公用一台电脑，那么这台电脑就是静态成员；你有一本C#的书，你的兄弟也有一本C#的书，这些书是你们各自拥有的，和别人互不相关，这些书就是实例成员。
对于方法来说，使用静态方法是有好处的，因为静态方法只维护一份拷贝，所以无论你有多少个实例，内存中都只会有一份拷贝。如果一个类是一个辅助类，如字符串类、数据库操作类，有很多方法来实现字符串的各种操作的，并且使用频繁，那么这个时候定义的方法最好是静态的，这样不需要每次使用这些方法的时候都实例化对象，而只需要静态调用就好。针对具体对象应用的，使用的少的方法用实例的。因为静态的速度快，但占内存，就像是缓存一样，经常用的数据我们应该将他们缓存起来。实例方法的调用速度相对慢些，但调用完后，会立即释放类，节省内存。

第三章、类的构造函数与属性

3.1、专业单词

单词	释义
property	属性
get	得到、获取
set	设置

3.2、对象的生命周期

每个对象都有一个明确定义的生命周期，生命周期有三个阶段

构造阶段：由构造函数完成，对新建对象进行初始化。
正常使用阶段。
析构阶段：对象使用完后，进行一些清理工作，如释放内存，C#中由析构函数完成。

3.3、构造函数的概念

构造函数是个特别的方法，用来初始化类的新建对象（对象存储的数据）。当访问一个类的时候，系统将首先执行构造函数中的语句。

构造函数在创建类的对象时自动执行，即无论程序是否调用类的字段、属性或方法，构造函数都将在创建对象时执行。

例： class Human { public Human(){} }

3.4、构造函数的特征

构造函数的名称必须与类的名称相同。
构造函数不能声明返回类型（甚至不能使用void），也不能返回值。
一般的，构造函数总是public,private类型的构造函数表明类不能被实例化，通常用于只含有静态成员的类。
在构造函数中不要做初始化以外的事情。
构造函数可以重载，从而提供初始化对象的不同方法。
实例化对象时由编译器自动调用构造函数，不能显式的调用构造函数。
若在定义类时未定义构造函数，系统会自动生成默认的构造函数，此时构造函数的函数体为空。

3.5、构造函数的应用

构造函数的语法

[访问修饰符] 构造函数名 (形参列表)
{
    初始化代码
}

3.6、默认构造函数

每个类都有构造函数。即使没有为类声明构造函数，编译器也会自动的为类提供一个默认的构造函数。
默认构造函数没有参数，当被执行时，系统会给类的所有字段赋一个默认值，这样能够避免编译错误。

各种类型的字段的默认值

类型默认值

数值型（各种整数、小数） 0

char '0'

boo l false

引用类型 null

类型	默认值
数值型（各种整数、小数）	0
char	'0'
boo l	false
引用类型	null

3.7、构造函数的重载

构造函数也可以带参数，这样能传递不同的数据来对类的对象进行初始化。

一个类可有多个不同参数的构造函数，但由于构造函数只能使用一个名称，即同他所在的类名相同，所以只能用构造函数重载来实现。

例：
    class Human
    {
      public  string name;
        public int age;
        
        public Human() { }//无参构造
        
        public Human(string Name) 
        { 
            this.name = Name; 
        }
        
        public Human(string Name,int Age) //含参构造
        { 
            this.name = Name;
            this.age = Age; 
        }
    }

3.8、属性概念

面向对象的封装性原则要求不能直接访问类的数据成员，如何访问类的私有成员呢？为了解决这个问题C#提供了一个称为：属性的访问器来完成这个功能。
类的属性所描述的是状态的信息，它借助于get和set访问器来对属性进行访问定义。

3.9、属性的使用

定义属性

语法：
    [访问修饰符] [static] 数据类型 属性名
    {
        get{读访问器体}
        set{写访问器体}
    }

示例：
    public class Student
    {
        private string _name;
        //原始写法
        public string Name
        {
            get { return this._name; }
            set { this._name = value; }
        }
        //屌的写法
        public string Name
        {
            get=>_name;set=>_name=value;    
        }
        //便捷写法
        public string Name{get;set;}

访问属性

语法：
    访问静态属性：类名.属性名
    访问实例属性：对象名.属性名

示例：
    
    class Student
    {
        private string _name;
        //定义一个静态属性
        public string Name{get;set;}
        
        public static string power{get;set}
    }
    static void Main(string[] args)
    {
        //访问静态属性
        Student.power="";
        //访问实例属性
        Student stu=new Student();
        stu._Name="";
    }

只读属性

只读属性（少了set访问器）；当编程时，有些属性只能返回值，不能重新赋值，就可用只读属性。

只读属性的写法：
    //便捷写法
    [访问修饰符] 属性的数据类型 属性名称{get;private set;}//可在类中赋值
    [访问修饰符] 属性的数据类型 属性名称{get;}//只能在字段中赋值
    //原始写法
    [访问修饰符] 属性的数据类型 属性名称 {get{return 属性名称};}
    //屌的写法
    [访问修饰符] 属性的数据类型 属性名称{get=>字段名称;}

示例：
    class Student
    {
        private  int _age;
        //便捷写法
        public int Age{get;private set;}
        public int Age{get;}
        //原始写法
        public int Age{return this._age;}
        //屌的写法
        public int Age{get=>_age;}
    }

只写属性

只写属性（少了get访问器）；当编程时，有些属性只能赋值不能取值，就可用只写属性。

只写属性写法：
    //便捷写法
    [访问修饰符] 属性的数据类型 属性名称{set;private get;}//可在类中取值  
    //原始写法
    [访问修饰符] 属性的数据类型 属性名称 {set{属性名称=value};}
    //屌的写法
    [访问修饰符] 属性的数据类型 属性名称{sset=>字段名称=value;}

示例：
    class Student
    {
        private  int _age;
        //原始写法
        public int Age{set{this._age=value}}
        //便捷写法
        public int Age{set;private get;}
        //屌的写法
        public int Age{set=>_age=value}
    }

第四章、类的继承

4.1、专业单词

单词	释义
base class	基类
derived classes	派生类

4.2、什么是继承？

继承是指一个类建立在另一个类的基础上，即一个类被另一个类继承，被继承的类被称为基类（base class），而继承的类被称为派生类（derived classes）。
派生类可以直接将基类的非私有成员作为自己的成员，并且可以在其内部定义自身的扩展成员。通过类的继承，实现代码的重用：派生类不需要重新定义基类。

4.3、继承的层级结构

类的继承具有层级结构，如学生继承了人类，大学生类可以继承学生类，专科大学生类可以继承大学生类，像这种方式叫继承的传递

C#不支持类的多继承，即一个派生类只能直接从一个基类继承，但支持传递继承。

在C#中有一个特殊的基类——object。object没有基类，它是C#所有类的默认基类。

4.4、定义基类和派生类

派生类在声明或定义时，需要指出对应的基类，所以一般先定义基类，再定义派生类。

定义基类语法：class 基类名称{基类成员}
定义派生类语法：class 派生类名称：基类名称{派生类扩充成员}

语法中通过冒号，实现了类的继承，像这种通过显示的语法指定的基类，叫直接基类。

示例：
//定义基类
class Student
{
    public string Name{get；set；}   
}
//定义派生类
class undergraduate：Student
{
    public string Code{get；set；}
}

4.5、使用派生类对象访问基类成员

语法：派生类对象名.基类成员名

//定义基类
    class Student
    {
        public string Name{get；set；}   
    }
    //定义派生类
    class undergraduate：Student
    {
        public string Code{get；set；}
    }
    //使用派生类对象访问基类成员
    class Program
    {
        static void Main(string[] args)
        {
            undergraduate under=new undergraduate();
            under.Code="20110508"
            under.Name="张三";
        }
    }

4.6、类继承的原则

除了类Object外，每个类有且只有一个直接基类，如果没有显示的指定直接基类，它的直接基类就隐式的设为Object。Object没有任何直接或间接基类，并且是所有其他类的终极基类。
基类中的非私有成员，派生类都可使用。但受保护的（protected）成员，只能在派生类中使用，外部类中不能使用，公有的（public）成员在派生类或外部类中都可使用。
派生类除了拥有基类成员外，还可以扩充自己的新成员。
类继承支持继承的传递。如C从B派生，B从A派生，此时A既是B又是C的基类。那么定义时，需要先定义class B：A{}，然后定义 class C：B{}.
类继承只支持单一继承，不支持多继承，即派生类只能有一个直接基类。如 class C：B，A{}这样写是错误的。

posted @ 2020-06-11 21:48 沐白~ 阅读(428) 评论(0) 收藏举报

刷新页面返回顶部

沐白~