方法
- 方法（Method）是由C/C++中的函数（Function）发展而来的
//C语言
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}//函数
int main(void)
{
int a = 4;
int b = 2;
int c = Add(a, b);
printf("%d + %d = %d\n", a, b, c);
return 0;
}
//C++
#include <iostream>
int Add(int x, int y)
{
return x + y;
}//函数
int main()
{
int a = 4;
int b = 2;
int c = Add(a, b);
std::cout << a << " + " << b << " = " << c;
return 0;
}
方法是面向对象，当一个函数以类的成员出现的时候就叫方法，所以方法又叫成员函数
在编写C++程序时，选择添加类（Class），然后输入类名，后面的 .h 文件就是类的声明，而 .cpp 文件就是类的定义（在C#中类的声明和定义是放在一起的）
//ABC.h - 类的声明
#pragma once
class ABC
{
public:
void ShowHello();
};
//ABC.cpp - 类的定义
#include "ABC.h"
#include <iostream>
void ABC::ShowHello()
{
std::cout << "Hello World";
}
//use.cpp
#include <iostream>
#include "ABC.h"
int main()
{
ABC* pABC = new ABC();
//此处已经有了C#方法的雏形了
pABC->ShowHello();
return 0;
}
- 方法是类（或结构体）的成员
C#中函数不能独立于类（或结构体）之外
只有作为类（或结构体）的成员出现时，函数才能被称为方法
namespace ConsoleApp1
{
int Add(int x, int y)
{
return x + y;
}
internal class Program
{
static void Main(string[] args)
{ }
}
}
上段代码中的函数没有在类中，编译会报错
- 方法是类（或结构体）最基本的成员之一
类（或结构体）有两个最基本的成员 - 字段和方法（成员变量和成员函数）
方法表示类（或结构体）所能干的事情 - 使用方法和函数的目的
- 隐藏复杂的逻辑；
- 把大算法分解为小算法；
- 复用；
//未复用
class Tool
{
public double GetCicleArea(double R)
{
return 3.14 * R * R;
}
public double GetCylinderVolume(double R, double H)
{
return 3.14 * R * R * H;
}
public double GetConeVolume(double R, double H)
{
return 3.14 * R * R * H / 3;
}
}
//复用
class Tool
{
public double GetCicleArea(double R)
{
return 3.14 * R * R;
}
public double GetCylinderVolume(double R, double H)
{
return GetCicleArea(R) * H;
}
public double GetConeVolume(double R, double H)
{
return GetCyliderVolume(R, H) / 3;
}
}
将一个大的算法分解为小的算法，再由算法一个一个解决，就是自顶向下逐步求精的方法
方法的声明与调用
方法的声明
函数头 + 函数体
函数头：特性 + 有效的方法的修饰符 + partial + 返回类型 + 方法名 + 类型参数列表 + （ + 形式参数列表 + ）+ 类型参数约束句子
其中只有 返回类型 & 方法名 & **（）**是必须要的；其中 类型参数约束句子 只有在有 类型参数列表 出现时才能出现
方法名最好使用动词或动词短语，所有单词首字母大写（Pascal命名法）
形式参数（parameter，简称：形参）：是一种变量，会参与构成方法的算法逻辑
静态方法和实例方法
静态方法与类绑定，非静态方法（实例方法）与实例绑定
using System;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Tool t = new Tool();
Console.WriteLine(t.Add(1, 2));
//实例方法与实例绑定
Console.WriteLine(Tool.Sub(1,2));
//静态方法与类绑定
}
}
class Tool
{
public int Add(int x, int y)
{ //实例方法
return x + y;
}
public static int Sub(int x, int y)
{ //静态方法
return x - y;
}
}
}
调用方法
方法调用：方法名 + （ + 实际参数列表 + ）
实际参数（Argument，简称：实参）：实际参数列表需要与定义方法时的形式参数列表相匹配
以上面那段代码为例：
int x = Tool.Sub(1);
//此时实际参数个数与形式参数不匹配
int y = Tool.Sub(1.0, 2.5);
//此时实际参数类型与形式参数不匹配
构造器
构造器（Constructor）是类型的成员之一，构造器就是构造函数
狭义的构造器就是实例构造器（Instance constructor）
using System;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Human human = new Human();
//上行代码中的 () 就是调用构造器
Console.WriteLine(human.ID);
Console.WriteLine(human.Name);
People people = new People();
Console.WriteLine(people.ID);
Console.WriteLine(people.Name);
Student student = new Student(1, "None");
//构造器带参数时调用也需要带参数
Console.WriteLine(student.ID);
Console.WriteLine(student.Name);
}
}
class Human
{ //当声明一个类后，没有准备构造器时，编译器会自动为其准备一个默认构造器
//默认构造器可以把内存中的对象的字段进行初始化，就是将 ID 和 Name 进行初始化
public int ID;
public string Name;
}
class People
{
public People()
{ //创建构造器时，构造函数名要与类一致
this.ID = 0;
this.Name = "NULL";
}
public int ID;
public string Name;
}
class Student
{
public Student(int id, string name)
{
this.ID = id;
this.Name = name;
}
public int ID;
public string Name;
}
}
一个类中可以有多个构造器
class People
{
public People(int id, string name)
{
this.ID = id;
this.Name = name;
}
public People()
{
this.ID = 0;
this.Name = "NULL";
}
public int ID;
public string Name;
}
构造器的内存原理
默认构造器
Human human = new Human();
class Human
{
public int ID;
public string Name;
}
第一个代码创建了一个human变量，human变量存储在栈区中（栈区存储由高字节位到低字节位）
new操作符开始执行时，在堆区找足够的内存空间作为实例的内存，而 int 需要占4字节，string 需要占4字节，所以最后占用了8个字节。构造时就对这8个字节进行切割，前4个为int类型，后4个为string类型，然后默认构造器将这8个字节中的值全赋值为0
最后将实例的地址存储在human变量中
带参数的构造器
Human human = new Human(1, "One");
class Human
{
public Human(int id, string name)
{
this.ID = id;
this.Name = name;
}
public int ID;
public string Name;
}
依旧是在栈区分配human变量的内存空间，然后在堆区分配8字节，然后开始切割这8个字节，再在前4个字节中存入1，在后4个字节中存入“One”
最后把实例的地址放进human变量的内存空间中
方法的重载（Overload）
当一个类中的两个方法的名称一致时，方法签名不能一致
方法签名（Method signature）由方法名称、类型形参的个数和方法的形参（由左到右的顺序）的类型、种类（值、引用、输出）组成，方法签名不包含返回类型
class Tool
{
public int Add(int a, int b)
{ return a + b; }
public double Add(double a, double b)
{ return a + b; }
public int Add(int a, int b, int c)
{ return a + b + c; }
public int Add(ref int a, out int b)
{ b = 10; return a + b; }
//ref就是引用、out就是输出
}
构造器也可以有重载，构造器的签名由每一个形参（从左到右的顺序）的类型和种类（值、引用、输出）组成
重载决策：根据调用方法时实参的类型来决定调用哪一个方法。如：
Console.WriteLine(100);
Console.WriteLine("Hello World");
对方法进行debug
debug可以找到bug发生的地方，也可以了解到程序运行的原理
设置断点（breakpoint）
设置断点后，运行程序时会自动停在断点设置处
红色就是断点标识，设置快捷键是F9，然后按F5进行调试，就会执行时停到断点处
当红点标识变成上图标识时，就是程序执行停在了那里
观察方法调用时的调用堆栈（call stack）
上图中第一行就是断点处的方法（函数）
第二行就是调用它的函数，可以双击跳到所需位置
实际代码中此处可能会层层叠加，最后一行就是最外层调用，而红点标识处就是断点处
逐语句（Step-into）、逐过程（Step-over）、跳出（Step-out）
Step-into（F11）会进入所调用的方法中去
Step-over（F10）不会进入所调用的方法中，没有Step-into细致
Step-out（Shift+F11）可以从一个方法中直接回到调用它的那段代码上
观察局部变量的值与变化
在监视中观察
将鼠标移到变量处，可以标识出变量的值，当语句调试到那一处时，会自动将被标识的变量的值显示出来
方法调用时栈内存的分配
stack frame：一个方法被调用时，它在栈内存当中的布局
当代码执行到一个方法时，在栈区中分配一个内存
当在A方法中调用一个B方法时用到了实际参数，传的参数也会分配到栈区中，在C#中这些实际参数归A方法管
分配参数内存时，在C#中先分配左边的参数，再分配右边的参数
当一个方法调用结束后，会回收给它分配的内存，且传递的实参所占的内存也会被回收
方法的返回值会存在cpu的寄存器（一种高速内存）中，当寄存器空间不够存放返回值时才会存放在栈区
using System;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
Tool tool = new Tool();
Console.WriteLine(tool.Add(1, 2));
}
}
class Tool
{
public int Add(int a, int b)
{
int c = Sub(a, b);
return c;
}
public int Sub(int a, int b)
{
int c = a - b;
return c;
}
}
}
上图就是上段代码执行到方法Sub时的栈区内存分配，继续执行就会从上往下慢慢回收已经调用结束的方法所占的内存
注：上图只标识了参数内存分配，实际上还有其他很多元素会分配到栈区中
