C#学习--面向对象

析构函数和构造函数

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

namespace 面向对象编程
{
    class Person
    {
       /***********构造函数************/
        // 构造函数，函数名和类同名，当用new关键字实例化Person对象时，就会调用这个函数
        // public 公共的，表示这个构造方法是公共的，任何类都可以调用
        //public Person(string a)
        //{
        //    Console.WriteLine(a);
        //}


        // 静态构造函数，只会被执行一次，他是属于类的，不属于那个实例

        /* 静态构造函数特点：
         1.静态构造函数既没有访问修饰符，也没有参数
         2.在创建第一个实例或者引用任何一个静态成员之前，将自动调用静态构造函数来出事化类，也就是无法直接调用静态构造函数，也无法控制什么时候执行
         3.一个类只能有一个静态构造函数，最多只能运行一次
         4.静态构造函数不可以被继承
         5.如果静态构造函数，而类中静态成员有初始值，那么编译器会自动生成默认的静态构造函数。

             */
        static int i = 0;
        static Person()
        {
            i++;

            Console.WriteLine("我被访问了{0}次", i);
        }


        // 私有构造函数
        // private 私有的，访问修饰符，当实例化对象时使用默认构造方法时，编译器就会报错，无法编译通过
        //private Person()
        //{
        //    Console.WriteLine("无参构造函数");

        //}

        /************析构函数***************/
        /*
         1.析构函数没有参数没有返回值，为了与构造函数区别，在前面加上一个符号“~”
         2.一个类智能有一个析构函数，不能重载
         3.如果用户没有编写析构函数，编译系统自动生成一个缺省的析构函数
             */
        ~Person()
        {
            Console.WriteLine("死了");
        }
    }

    class Program
    {
        static void test()
        {
            Person person = new Person();
            //Console.WriteLine(person.GetName());
            Person person2 = new Person();
            person = null;
            person2 = null;

        }


        static void Main(string[] args)
        {

            test();
            Console.ReadKey();
        }
    }
}

 

封装

访问修饰符：

如果没有指定访问修饰符，则默认是private

• • Public
  • Private
  • Protected
  • Internal
  • Protected internal

Public 修饰符

Public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他函数和对象。任何公共成员可以被外部访问

Private 修饰符

Private 访问修饰符允许一个类将其成员变量和成员函数对其他函数和对象进行隐藏。只有同一个类中的函数可以访问他的私有从成员

Protected 修饰符

Protected 修饰符允许子类访问他的基类的成员变量和成员函数。这种方法有助于继承

Internal 修饰符

Internal 修饰符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象，换句话说，带有访问Internal 修饰符的任何成员可以被定义在改成员所定义的应用程序内的任何类或方法访问

Protected internal 修饰符

Protected internal 修饰符允许一个类将其成员变量和成员航沪深对同一应用程序诶的子类以外的其他类对象和函数进行隐藏

方法

• 定义
• 调用

定义

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

调用

使用.语法调用一个类的方法

 

继承

C#不支持多继承，但可以使用接口来实现多继承。用C#创建一个派生类的语法如下：

<acess-specifier> class <base_class>
{
   ...
}
class <derived_class> : <base_class>
{
   ...
}

C#继承实例：

class Rectnangle
    {
        protected double length;
        protected double width;
        public Rectnangle(double l, double w)
        {
            length = l;
            width = w;

            Console.WriteLine("Rectnangle 构造方法{0}{1}",length, width);
        }
    }

    class SubRectangle:Rectnangle
    {
        // base(); 向父类构造函数传递相同的参数
        public SubRectangle(double l, double w) :base(l, w)
        {
            Console.WriteLine("SubRectnangle 构造方法{0}{1}", l, w);
        }
    }

 

多态

1.静态多态性：一个函数在编译时才确定

2.动态多态性：一个函数在运行时才确定

接口

定义：把公共实例方法和属性组合起来，以封装特定功能的一个集合

接口声明：使用关键字interface，接口声明缺省为 public 类型

实例：

 public interface car
    {
        void showName(double a);
        void showAge();
    }

    // 接口实现
    class aodi : car
    {
        public void showName(double a)
        {

        }

        public void showAge()
        {

        }
    }

 

运算符重载

class Rectnangle
    {
        public double length;
        public double width;

       
        public Rectnangle(double l, double w)
        {
            length = l;
            width = w;

            Console.WriteLine("Rectnangle 构造方法{0}{1}",length, width);
        }

       // 重载+号运算符，当两个rectnangle对象相加时，就会执行这里
        public static Rectnangle operator+ (Rectnangle a, Rectnangle b)
        {
            Rectnangle rectnagle = new Rectnangle(10, 20);
            rectnagle.length = a.length + b.length;
            rectnagle.width = a.width + b.width;            
            return rectnagle;

        }
    }

static void main（string[] args）{
    Rectnangle rectna1 = new Rectnangle(10, 20);
            Rectnangle rectna2 = new Rectnangle(10, 20);
            // 执行运算符重载
            Rectnangle rectna3 = rectna1 + rectna2;
}

转载于:https://www.cnblogs.com/programTravel/p/5815831.html