上课认真学来的c#类与对象，会持续更新，推荐新手入门观看

本文链接：https://blog.csdn.net/mx_20030322/article/details/123832649

5.1面向对象程序设计的基本概念

5.2类与对象

5.3类的静态成员

5.4构造函数和析构函数

5.5属性

5.6方法

5.1.1面向对象程序设计

面向对象的程序设计简称OOP，是一种基于结构分析的，以数据为中心的程序设计方法。

创建类来封装数据及处理这些数据的操作到类的数据结构中。

在使用类时，在主函数中创建的变量称作为对象，利用这个对象来进行对所封装类里包含的内容进行赋值，操作，等等。

5.1.2面向对象程序设计的基本概念

1类：类是对具有相同特征的一类事物所做的抽象（归纳）。

2对象：对象是类的实例，是现实存在的并且可唯一区分的。

对象我认为是：这个就是在主函数中，所创建的，对所做题目和行为来进行实例化的一个对象

比如：学生可以看作1个类，学生里的小明和李华就是类中的对象，大学也可以看作是一个类，大学中的某个大学，比如清华大学，北京大学等等对象，都属于大学这个类中的对象。

3属性：类的特点，大学是一个类，大学的特点，占地面积，地理位置，环境如何

4方法：类的方法代表了类所具的动作，比如汽车是一个类，那么启动，开车，加速，减速等等汽车的行为就可以说是这个类的方法。

5封装：隐藏属性，方法或实现细节的过程，仅对外公开接口将；

个人对封装的理解：抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

6继承：面向对象中一个类自动拥有另一个类的全部属性和方法，继承后的类仍具有被继承类的特点，同时又出现新的特点，后面这句是这么理解的，父类是爹，子类是儿子，子类继承了父类的全部特点，并且子类又含有新的特点（头一次写，体会为主）

7多态：相同的对象收到相同的消息时，或不同的对象收到相同的消息时，产生不同的行为方式。

这么理解多态可能有些绕口，多态，多种状态，你收到了这条消息，可能会进行这种行为，但是你接收到这条消息的同时，也可能会进行另一种行为，或者说，接收不同消息，执行不同的行为，感谢仔细阅读

5.2类与对象

5.2.1类的声明

类的声明语法格式如下：
             [类的修饰符] class 类名 [:基类名]
             {
                  　//类的成员;
             }
举例如下
public class Person
{
     public string name;
     public int age;
     public void show()
     {
          Console.WriteLine("姓名：{0}\n年龄：{1}",name,age);
     }
}

类修饰符有四个如下所示

类的修饰符	说明
public	公有类。表示对该类的访问不受限制。
internal	内部类。访问仅限于当前程序集。(非嵌套类中的默认访问修饰符)
abstract	抽象类。表示该类是一个不完整的类，不允许建立类的实例。
sealed	密封类。不允许从该类派生新的类。

public 在类前面加上，即表示所有类都有可以访问此类

internal class A 这个对类的访问修饰符来说，在程序中只要和A类在同一个namespace集里，就可以进行访问，但是如若不和A在同一个namespace集里，就无法对其A进行访问了

abstract 暂时没学呢，跳过跳过~

sealed 密封类，无法从此类中派生出新的类，也没学呢，暂时没有理解~跳过跳过

5.2.2对象的声明和对象的实例化

在c#语言中，对象的声明定义格式为：类名变量名；这时对象声明后不包含任何有效内容，要想使用的话，则需要对其对象进行实例化，用new来对其类名修饰，格式如下：

这是先声明后实例化
    Person liming;   //对象的声明
    liming=new Person(); //创建一个实例，并用liming去引用
这是声明的同时进行对对象的实例化    
    Person liming=new Person();

5.2.3类成员

在c#中，按照类的成员是否为函数将其分成两大类，一种不以函数体现，称“域“

另一种是以函数形式体现，称为成员方法

类的具体成员有以下类型常量变量事件类型

方法成员有以下类型方法属性索引指示器运算符构造函数析构函数

定义类成员时需要注意以下几个原则：

类中的常量、变量、属性、事件或类型不能与其他类成员同名。

类中的方法名，不能和类中其他成员同名，既包括其他非方法成员，又包括其他方法成员。如果没有显式指定类成员访问修饰符，默认类型为私有类型修饰符（internal）。

在类中成员变量的语法定义：格式如下

{访问修饰符} （数据类型）成员变量；例如

private int _name;

protected char status;

internal bool asd;

public class Person
{
     public string name;
     public int age;
      ……
}

类中成员的语法定义如下

{访问修饰符} {返回类型} <方法名>                （参数列表）

        {

//默认访问修饰符为private

//如果不需要返回值则返回类型为：void

方法主体

        }

举例如下：

public class Person
{
     public string name;
     public int age;
     public void show()
     {
          Console.WriteLine("姓名：{0}\n年龄：{1}",name,age);
     }
}

说到这里要提出成员的访问修饰符如下

访问修饰符	说明
public	所属类的成员以及非所属类的成员都可以访问
private	只有所属类的成员才能访问(默认的访问修饰符)
protected	所属类或派生自所属类的成员可以访问
internal	当前程序集可以访问
internal protected	当前程序集或所属类的派生类可以访问

访问成员变量以及成员方法

步骤1：创建类对象，并且对其进行实例化。

步骤2：使用点号访问成员变量。

Person liming = new Person ();
liming.name = “李明"; 
liming.age = 20;
liming.show();

举例：

namespace ConsoleApplication1
{
    public class Person
    {
        //类的变量是public共有的，可以访问
        public string name;
        public int age;
        public void Show()
        {
            Console.WriteLine("姓名：{0}\n年龄：{1}", name, age);
        }
    }
    class Program
    {
        public static void Main()
        {
            Person objPerson = new Person();
            objPerson.name = "张三";
            objPerson.age = 22;//程序正确
            objPerson.Show();
            Console.ReadLine();
        }
    } 
}
*************************************************
namespace ConsoleApplication1
{
    public class Person
    {
        //类的变量是private私有的，只有所属类的成员可以访问
        private string name;
        private int age;
        public void Show()
        {
            Console.WriteLine("姓名：{0}\n年龄：{1}", name, age);
        }
    }
    class Program
    {
        public static void Main()
        {
            Person objPerson = new Person();
            objPerson.name = "张三";//访问错误
            objPerson.age = 22;
            objPerson.Show();
            Console.ReadLine();
        }
    } 
}

teacher类-----------------------------------------------student类

private 成员----------------<------不可以对其访问student类

protected 成员-----------《----------student类不可对其访问

public 成员-----------《--------------可以对其访问student类

internal 成员------------《------只有两个类属于同一个集时才可以访问teacher类

当父类中含有protected类时，若子类想要调用父类中的protected类成员，需要对其子类进行父类继承的行为

class Student
{
  protected string name;
  protected void Write() {
    Console.WriteLine(name);
  }
}
//当Graduate后加：时，是对其父类进行继承的行为。
//：后的类名就是成为父类，而：前的类就称为父类的子类
//子类含有父类几乎全部的成员，属性，而子类可以含有父类没有的成员，属性等行为。
class Graduate : Student
{
  public void Output() {
    Console.WriteLine(name);
    Write();
  }
}

举例：如下

namespace AccCon
{
    class Cup
    {
        public int height; 	//公有成员
        internal int style; //internal类型成员     
        protected int weight;//	保护类型成员
        private int color;	//私有类型成员
        public void Func1()//类的成员函数，可以访问本类的成员
        {
              color=4;	     
              weight=5;	
	       height=1;	    
	       style =2;          //         四种访问均是合法的
        }        
    }
    class MainClass
    {		
       static void Main()
       {
          Cup c1 = new Cup();
          //在类的外部访问类的成员
          Console.WriteLine(c1.height);// 类的公有成员可以被外部程序直接访问
          Console.WriteLine(c1.color);  //类的私有成员不可以被外部程序凡物，编译错误
          Console.WriteLine(c1.weight);  //同上，如若想要进行对成员weight访问，则需要对MainClass类进行继承父类行为，则class MainClass应该改为class MainClass：Cup
          Console.WriteLine(c1.style);  //internal类型成员可以被同一个集的成员进行访问
      }
   }
}

设计控制台应用程序项目，声明一个教师类Teacher和一个学生类Student，他们都包含公有字段id（编号）、name（姓名）和height（身高），定义教师类和学生类的对象并进行测试。

public class Teacher
{
    public string id;
    public string name;
    public double height;
    public void ShowTeacherInfo()
    {
        Console.WriteLine("教师的信息：");
        Console.WriteLine("编号：{0}，姓名：{1}，身高：{2}",id,name,height);
    }   }
public class Student
{
    public string id;
    public string name;
    public double height;
    public void ShowStudentInfo()
    {
        Console.WriteLine("学生的信息：");
        Console.WriteLine("编号：{0}，姓名：{1}，身高：{2}", id, name, height);
    }  }
class Program
{
    static void Main(string[] args)
    {
        Teacher zhang = new Teacher();
        zhang.id = "1001";
        zhang.name = "张峰";
        zhang.height = 1.78;
        zhang.ShowTeacherInfo();
        Console.WriteLine();
        Student Tom = new Student();
        Tom.id = "07020101";
        Tom.name = "Tom";
        Tom.height = 1.75;
        Tom.ShowStudentInfo();
        Console.ReadLine();
    }  }

在C#中，成员可以分为静态成员和非静态成员。声明一个静态成员只需要在声明成员的指令前加上static保留字。如果没有这个保留字就默认为非静态成员。

静态成员属于类所有，非静态成员则属于类的对象所有，访问时静态成员只能由类来访问，而非静态成员只能由对象进行访问。

静态成员变量（static）---》类所有

成员变量

非静态成员变量 -----》对象所有

类成员

静态成员方法 -----》类所有

成员方法

非静态成员方法 ------》对象所有

5.3.1静态成员变量

如果在声明类中的成员变量时添加了static修饰符，该类中的这个成员变量就称为静态成员。

静态成员变量用于存储一些属于某个类的全部对象的信息，它是被类的全体对象共享的数据。

***静态成员变量必须通过”类名.静态成员变量名“的形式来进行访问，而不能用对象来引用

***一个静态成员变量只标识一个存储位置。无论创建一个类的多少个实例，他的静态成员变量在内存中都只占同一块区域。

public class Person
{        
    public string name;
    public int age;
    public static string profession;    //定义静态成员
    public void Show()
    {
       Console.WriteLine("姓名：{0}\n年龄：{1}\n职业：{2}\n",name,age,profession);
     }       
 }
class Program
{
    static void Main(string[] args)
    {
        Person.profession = "学生";

        Person Tom = new Person();            
        Tom.name = "Tom";
        Tom.age = 22; 
        Tom.Show();

        Person Rose = new Person();
        Rose.name = "Rose";
        Rose.age = 24;    
        Rose.Show();
        Console.ReadLine();
     }
}

5.3.2静态方法

使用static关键字声明的方法被称为”静态方法“。

静态方法通过”类名.方法名“的形式来访问。

静态方法是不属于特定对象的方法，静态方法可以访问静态成员变量，静态方法不可以直接访问非静态成员变量。

    public class Person
    {        
        public string name;
        public int age;
        public static string profession;//定义静态成员
        public void Show()
        {
            Console.WriteLine("姓名：{0}\n年龄：{1}",name,age);
        }
        public static void ShowProfession()
        {
            Console.WriteLine("职业：{0}\n",profession);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Person.profession = "学生";

            Person Tom = new Person();            
            Tom.name = "Tom";
            Tom.age = 22; 
            Tom.Show();
            Person.ShowProfession();

            Person Rose = new Person();
            Rose.name = "Rose";
            Rose.age = 24;    
            Rose.Show();
            Person.ShowProfession();
            Console.ReadLine();
        }
    }

5.3.3静态成员与非静态成员比较

静态成员具有以下特点

*静态成员必须通过类名使用”.“运算符来引用，而不能用对象来引用

**一个静态字段只标识一个存储位置，无论创建了一个类的多少个实例，它的静态字段在内存内都只在静态存储区占一个区域。

***静态函数成员（方法，属性，时间，运算符或构造函数）不能作用于具体的实例，在这类函数成员中不能直接使用非静态成员。

非静态成员具有以下特点

*非静态成员必须通过对象名来使用.（点号）运算符来引用，而不能用类名来引用

**类的非静态字段属于类的实例所有，每创建一个类的实例，都在内存中为非静态字段开辟了一个块区域。类的每个实例分别包含了一组该类的所有非静态字段的副本

**这个啥意思呢，就是说，当你存入一个静态成员，之后每使用此类的时候，该静态成员均存在于静态存储区中。

***非静态函数成员（方法，属性，所引起，构造函数或析构函数)作用于类的给定实例，在他们的代码体内可以直接引用静态和非静态成员：非静态类可以对成员都进行引用，