C#面向对象编程：类概述

一，类声明

class：类声明使用的关键字。

语法：[修饰符]  class 类的名称 [类的基类或接口] {  //方法属性  }

[修饰符] [类的基类或接口] 是可选项

例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _24._5._18类
{


    public class shenmng //声明类
    {
        public void fangfa()  //创建一个方法
        {
            Console.WriteLine("声明练习");
        }
    }



    class Program
    {
        static void Main(string[] args)
        {
            shenmng s = new shenmng();//实例化对象
            s.fangfa();
        }
    }
}

二，类修饰符

修饰符	说明
abstract	抽象类,表明该类是一个不完整的类,只有声明没有具体的实现,一般只能用作其他类 的基类,不能单独使用
internal	内部类,表明该类只能从同一个程序集的其他类中访问
new	新建类,表明类中隐藏了由基类中继承而来的,与基类中同名的成员
private	私有类,表明只能在定义它的类中访问这个类
protected	保护类,表明只能在定义它的类以及该类的子类中访问这个类
public	公有类,表明该类可以被任何其他类访问~
sealed	密封类,表明该类不能再做其他类的基类,该类不能被继承

类修饰符可以两个或多个组合起来使用

注意：

1.如果省略类修饰符,则默认为私有修饰符private。

三，类的静态特性和动态行为

1.类的静态特性

类中的属性（或者字段）可以看作是类的静态描述。（既静态特性就是属性）

在定义属性时也可以使用访问修饰符来定义访问级别。

例:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _24._5._18类
{

    public class jintai //静态特性
    {
        //属性
        int a;
        public string b;
        private int c;

    }

    class Program
    {
        static void Main(string[] args)
        {
            jintai b = new jintai();//实例化对象
            b.a = 12;//报错 a默认为private
            b.b = "西欧";
            b.c = 34; //报错 c 是私有类
        }
    }
}

 在上述代码中公有属性b 可以在其他类进行访问设置，私有属性c则不能，如果没有定义则默认为私有属性例如a。

2.类的动态行为

和静态特性相对应，类的动态行为是方法，方法是实体能够执行的操作。

和属性一样，方法也具有访问属性。

例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _24._5._18.动态行为
{

    public class dong //声明类
    {
        //属性
        public int ac;
        private int ae;
        //方法
        public void gai( int a)
        {
            ae = a;

        }
        public void chu()
        {
            Console.WriteLine(ae);
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            dong s = new dong();
            s.gai(30);
            s.chu();

        }
    }
}

在上述代码中使用方法更改了类的私有属性。

四，类继承

继承是一种机制，它使派生类可以对基类进行扩展和专用化。

继承的本质是代码重用。

声明两个类:A 和B类。其中，B类从A类直接继承而来，A类被称为类的直接基类，B类为 A 类的派生类。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _24._5._18.继承
{
    public class A 
    {
        public void a()
        {
            Console.WriteLine("我是A");

        }
        
    }
   public class B:A
    {
        public void b()
        {
            Console.WriteLine("我是B"); 
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            A s1 = new A();
            B s2 = new B();
            s1.a();
            s2.a();
        }
    }
}

五，类，对象，实例化

类：类是现实世界中对象或者关系的模拟，是抽象的概念。同时类是数据结构，为创建类的实例提供定义。例如“程序员”这个概念，没有“程序员”这个具体的东西，只有“张三”“李四”“王五”这些具体的程序员实例。在这里“程序员”是一个类

对象：类的实例被称为对象。例如上述程序员例子中的的“张三”“李四”，他们是具体化的实例。

类和对象的关系总结

1.类是具有相同或相似结构、操作和约束规则的对象组成的集合。
2.对象是某一类的具体化实例,每一个类都具有某些共同特征对象的抽象

实例化：实例化是一种操作，他为类的实例分配内存

C#使用new关键字实现实例化类得到一个具体的对象

格式1：类名 实例名 = new 类名();

格式2：类名 实例名;实例名 = new 类名();

两种方式并无本质区别，就是两种写法，一个是分开写，一个是合起来写。

例：以格式二为例，声明名称为L的类，并且创建L的实例s ,然后实例化。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _24._5._18实例化
{

    public class L//创建类
    { }

    class Program
    {
        static void Main(string[] args)
        {
            L s;//创建L的实例s
            s = new L();//实例化
        }
    }
}

在上述代码中声明名称为L的类，即L是一个类。s是L类的一个实例，也称为对象。此时，s的值为 null，s不可用。“L s=new L()”表达式将a实例化，此时，a的值不为 null，它才可以被引用或访问。