构造方法和析构方法

构造方法

类的构造方法

Woman类后面的“()”;其实指的就是构造方法。

只要你想要创建类或结构的实例，必须调用它的构

造方法。

构造方法负责对类里面的字段进行初始化。

1.构造方法必须类重名;

2.构造方法没有返回值，但可以有参数;

3.构造方法可以有多个重载;

4.不带参数的构造方法称为默认构造;

1.构造方法的本质是一个构造器，是为了类的实例化而产生;

2.构造方法是一种特殊的方法，它没有返回值，它必须与类重名，它只能在初始化的时候被系统自动执行，外部不能调用;

3.构造方法可以不显示的写，系统会默认的为你的类添加一个无参构造方法;

4.如果讲构造函数设为private，则不能被外部实例化;

5.如果类里面有带有参数的构造方法,想调默认构造时,必须把默认构造显示的写出来;

结构体的构造方法

public struct position{

    public int x;

    public int y;

//结构体的自定义构造

public position (int x , int y){

    this.x=x;

    this.y=y;

    }

}

默认构造方法不用写默认构造显示，也有默认构造。

析构方法

析构方法用于析构类的实例。

构造方法用户实例化，分配内存空间，而析构方法正好与它相反，用于释放内存空间。

一般在某个功能结束的时候，做某些事情。

class  Car

{

                        ~Car( )        // destructor 写在类名的前面

        {

                            // cleanup statements...

        }

}

1.不能在结构中定义析构方法，只能对类使用析构方法。

2.一个类只能有一个析构方法。

3.无法继承或重载析构方法。

4.无法调用析构方法。

5.它们是被自动调用的。

6.析构方法既没有修饰符，也没有参数。

面向对象

面向对象是把构成问题事务分解成各个对象，创建对象后用

对象调用各自方法以达到解决问题的目的;

面向对象特性:封装、继承、多态

OOP(面向对象编程)达到软件工程的三个主要目标:

重用性、灵活性、扩展性

封装

封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中(我们称之为类)。

封装的意义在于保护或者防止代码(数据)被我们无意中破坏。

封装就是对类成员的再次包装，这样写更规范。

继承

继承用于创建可重用、扩展和修改在其他类中定义的行为的新类。 其成员被继承的类称为“基类”，继承这些成员的类称“派生类”。派生类只能有一个直接基类。 但是，继承是可传递的。 如果 ClassB 派生出 ClassC，ClassA 派生出ClassB，则 ClassC 会继承 ClassB 和 ClassA 中声明的成员。

由继承的关系我们知道，基类有的，派生类都有;

派生类有的，基类可能没有。

即:派生类可以赋值给基类，而基类不能赋值给派生类。

指定基类的方法

通过在派生的类名后面追加冒号和基类名称，可以指定基类。

1.派生类获得基类的所有方法、字段、属性和事件。

2.继承具有传递性。

3.派生类可以赋值给基类，但是基类不能赋值给派生类。

多数情况 对象总是写在子类里面，不会再基类里创建太多东西。

派生类写构造需要把基类的内容也补充进去

例子：public classname(int a,int x,int y,long z): base ( x,y,z)//x,y,z是基类的内容。

this a=a;

里氏转换

转换原则一：子类对象可以直接赋值给父类对象。

作用：消除子类间的差异。把其类型转换为统一的数据类型,这样就可以写出一套通用的代码,这样即可以最大限度的重用代码,同时也提高了程序开发的效率;

转换原则二：父类转换成子类，这样就可以调用子类里面的公有成员了。

is as关键字

 多态

当派生类从基类继承时，它会获得基类的所有方法、字段、 属性和事件。 派生类可以选择:

 • 继承最接近的基类方法而不重写它

 • 重写基类中的虚拟成员。 

• 定义隐藏基类实现的成员的新非虚实现 

方法替换

当派生类继承基类后，可以定义隐藏基类实现的成员的新非虚实现。通常，我们称这为“方法替换”。

关键字：new

虚函数 重写

相对比于方法替换

关键字 virtual修饰方法

override重写子类里的方法

当采用虚方法重写后，子类方法不会再含有父类方法的特征，如果需要调用原本父类的特征，就需要一个新的关键字

base 

用法：重写时

pubic class A{

            public virtual void Aff{

            }

}

public class A:B

{

        public override void Add(){

                base.Aff();

                //声明附加的方法

        }

}

重写就是多态的表现形式