既然console.writeline()是方法，那为什么writeline的参数可以是字符串类型，也可以是数字类型，还可以是布尔类型char类型呢？

在vs开发环境下，选中WriteLine，你会看到更多，希望能够帮到你。

1. //
   
2.         public static void WriteLine();
   
3.         //
   
4.         // 摘要:
   
5.         //     将指定布尔值的文本表示形式（后跟当前行终止符）写入标准输出流。
   
6.         //
   
7.         // 参数:
   
8.         //   value:
   
9.         //     要写入的值。
   
10.         //
    
11.         // 异常:
    
12.         //   System.IO.IOException:
    
13.         //     发生了 I/O 错误。
    
14.         public static void WriteLine(bool value);
    
15.         //
    
16.         // 摘要:
    
17.         //     将指定的 Unicode 字符值（后跟当前行终止符）写入标准输出流。
    
18.         //
    
19.         // 参数:
    
20.         //   value:
    
21.         //     要写入的值。
    
22.         //
    
23.         // 异常:
    
24.         //   System.IO.IOException:
    
25.         //     发生了 I/O 错误。
    
26.         public static void WriteLine(char value);
    
27.         //
    
28.         // 摘要:
    
29.         //     将指定的 Unicode 字符数组（后跟当前行终止符）写入标准输出流。
    
30.         //
    
31.         // 参数:
    
32.         //   buffer:
    
33.         //     Unicode 字符数组。
    
34.         //
    
35.         // 异常:
    
36.         //   System.IO.IOException:
    
37.         //     发生了 I/O 错误。
    
38.         public static void WriteLine(char[] buffer);
    
39.         //
    
40.         // 摘要:
    
41.         //     将指定的 System.Decimal 值的文本表示形式（后跟当前行终止符）写入标准输出流。
    
42.         //
    
43.         // 参数:
    
44.         //   value:
    
45.         //     要写入的值。
    
46.         //
    
47.         // 异常:
    
48.         //   System.IO.IOException:
    
49.         //     发生了 I/O 错误。
    
50.         public static void WriteLine(decimal value);
    
51.         //
    
52.         // 摘要:
    
53.         //     将指定的双精度浮点值的文本表示形式（后跟当前行终止符）写入标准输出流。
    
54.         //
    
55.         // 参数:
    
56.         //   value:
    
57.         //     要写入的值。
    
58.         //
    
59.         // 异常:
    
60.         //   System.IO.IOException:
    
61.         //     发生了 I/O 错误。
    
62.         public static void WriteLine(double value);
    
63.         //
    
64.         // 摘要:
    
65.         //     将指定的单精度浮点值的文本表示形式（后跟当前行终止符）写入标准输出流。
    
66.         //
    
67.         // 参数:
    
68.         //   value:
    
69.         //     要写入的值。
    
70.         //
    
71.         // 异常:
    
72.         //   System.IO.IOException:
    
73.         //     发生了 I/O 错误。
    
74.         public static void WriteLine(float value);
    
75.         //
    
76.         // 摘要:
    
77.         //     将指定的 32 位有符号的整数值的文本表示（后跟当前行的结束符）写入标准输出流。
    
78.         //
    
79.         // 参数:
    
80.         //   value:
    
81.         //     要写入的值。
    
82.         //
    
83.         // 异常:
    
84.         //   System.IO.IOException:
    
85.         //     发生了 I/O 错误。
    
86.         public static void WriteLine(int value);
    
87.         //
    
88.         // 摘要:
    
89.         //     将指定的 64 位有符号的整数值的文本表示（后跟当前行的结束符）写入标准输出流。
    
90.         //
    
91.         // 参数:
    
92.         //   value:
    
93.         //     要写入的值。
    
94.         //
    
95.         // 异常:
    
96.         //   System.IO.IOException:
    
97.         //     发生了 I/O 错误。
    
98.         public static void WriteLine(long value);
    
99.         //
    
100.         // 摘要:
     
101.         //     将指定对象的文本表示形式（后跟当前行终止符）写入标准输出流。
     
102.         //
     
103.         // 参数:
     
104.         //   value:
     
105.         //     要写入的值。
     
106.         //
     
107.         // 异常:
     
108.         //   System.IO.IOException:
     
109.         //     发生了 I/O 错误。
     
110.         public static void WriteLine(object value);
     
111.         //
     
112.         // 摘要:
     
113.         //     将指定的字符串值（后跟当前行终止符）写入标准输出流。
     
114.         //
     
115.         // 参数:
     
116.         //   value:
     
117.         //     要写入的值。
     
118.         //
     
119.         // 异常:
     
120.         //   System.IO.IOException:
     
121.         //     发生了 I/O 错误。
     
122.         public static void WriteLine(string value);
     
123.         //
     
124.         // 摘要:
     
125.         //     将指定的 32 位无符号的整数值的文本表示（后跟当前行的结束符）写入标准输出流。
     
126.         //
     
127.         // 参数:
     
128.         //   value:
     
129.         //     要写入的值。
     
130.         //
     
131.         // 异常:
     
132.         //   System.IO.IOException:
     
133.         //     发生了 I/O 错误。
     
134.         [CLSCompliant(false)]
     
135.         public static void WriteLine(uint value);
     
136.         //
     
137.         // 摘要:
     
138.         //     将指定的 64 位无符号的整数值的文本表示（后跟当前行的结束符）写入标准输出流。
     
139.         //
     
140.         // 参数:
     
141.         //   value:
     
142.         //     要写入的值。
     
143.         //
     
144.         // 异常:
     
145.         //   System.IO.IOException:
     
146.         //     发生了 I/O 错误。
     
147.         [CLSCompliant(false)]
     
148.         public static void WriteLine(ulong value);
     
149.         //
     
150.         // 摘要:
     
151.         //     使用指定的格式信息，将指定对象（后跟当前行终止符）的文本表示形式写入标准输出流。
     
152.         //
     
153.         // 参数:
     
154.         //   format:
     
155.         //     复合格式字符串。
     
156.         //
     
157.         //   arg0:
     
158.         //     要使用 format 写入的对象。
     
159.         //
     
160.         // 异常:
     
161.         //   System.IO.IOException:
     
162.         //     发生了 I/O 错误。
     
163.         //
     
164.         //   System.ArgumentNullException:
     
165.         //     format 为 null。
     
166.         //
     
167.         //   System.FormatException:
     
168.         //     format 中的格式规范无效。
     
169.         public static void WriteLine(string format, object arg0);
     
170.         //
     
171.         // 摘要:
     
172.         //     使用指定的格式信息，将指定的对象数组（后跟当前行终止符）的文本表示形式写入标准输出流。
     
173.         //
     
174.         // 参数:
     
175.         //   format:
     
176.         //     复合格式字符串。
     
177.         //
     
178.         //   arg:
     
179.         //     要使用 format 写入的对象的数组。
     
180.         //
     
181.         // 异常:
     
182.         //   System.IO.IOException:
     
183.         //     发生了 I/O 错误。
     
184.         //
     
185.         //   System.ArgumentNullException:
     
186.         //     format 或 arg 为 null。
     
187.         //
     
188.         //   System.FormatException:
     
189.         //     format 中的格式规范无效。
     
190.         public static void WriteLine(string format, params object[] arg);
     
191.         //
     
192.         // 摘要:
     
193.         //     将指定的 Unicode 字符子数组（后跟当前行终止符）写入标准输出流。
     
194.         //
     
195.         // 参数:
     
196.         //   buffer:
     
197.         //     Unicode 字符的数组。
     
198.         //
     
199.         //   index:
     
200.         //     buffer 中的起始位置。
     
201.         //
     
202.         //   count:
     
203.         //     要写入的字符数。
     
204.         //
     
205.         // 异常:
     
206.         //   System.ArgumentNullException:
     
207.         //     buffer 为 null。
     
208.         //
     
209.         //   System.ArgumentOutOfRangeException:
     
210.         //     index 或 count 小于零。
     
211.         //
     
212.         //   System.ArgumentException:
     
213.         //     index 和 count 共同指定一个不在 buffer 中的位置。
     
214.         //
     
215.         //   System.IO.IOException:
     
216.         //     发生了 I/O 错误。
     
217.         public static void WriteLine(char[] buffer, int index, int count);
     
218.         //
     
219.         // 摘要:
     
220.         //     使用指定的格式信息，将指定对象的文本表示形式（后跟当前行终止符）写入标准输出流。
     
221.         //
     
222.         // 参数:
     
223.         //   format:
     
224.         //     复合格式字符串。
     
225.         //
     
226.         //   arg0:
     
227.         //     要使用 format 写入的第一个对象。
     
228.         //
     
229.         //   arg1:
     
230.         //     要使用 format 写入的第二个对象。
     
231.         //
     
232.         // 异常:
     
233.         //   System.IO.IOException:
     
234.         //     发生了 I/O 错误。
     
235.         //
     
236.         //   System.ArgumentNullException:
     
237.         //     format 为 null。
     
238.         //
     
239.         //   System.FormatException:
     
240.         //     format 中的格式规范无效。
     
241.         public static void WriteLine(string format, object arg0, object arg1);
     
242.         //
     
243.         // 摘要:
     
244.         //     使用指定的格式信息，将指定对象的文本表示形式（后跟当前行终止符）写入标准输出流。
     
245.         //
     
246.         // 参数:
     
247.         //   format:
     
248.         //     复合格式字符串。
     
249.         //
     
250.         //   arg0:
     
251.         //     要使用 format 写入的第一个对象。
     
252.         //
     
253.         //   arg1:
     
254.         //     要使用 format 写入的第二个对象。
     
255.         //
     
256.         //   arg2:
     
257.         //     要使用 format 写入的第三个对象。
     
258.         //
     
259.         // 异常:
     
260.         //   System.IO.IOException:
     
261.         //     发生了 I/O 错误。
     
262.         //
     
263.         //   System.ArgumentNullException:
     
264.         //     format 为 null。
     
265.         //
     
266.         //   System.FormatException:
     
267.         //     format 中的格式规范无效。
     
268.         public static void WriteLine(string format, object arg0, object arg1, object arg2);
     
269.         //
     
270.         // 摘要:
     
271.         //     使用指定的格式信息，将指定的对象和可变长度参数列表（后跟当前行终止符）的文本表示形式写入标准输出流。
     
272.         //
     
273.         // 参数:
     
274.         //   format:
     
275.         //     复合格式字符串。
     
276.         //
     
277. 
     
278.     }

复制代码

方法重载。写了多个方法，方法名一致，但参数类型、参数数量不一样，构成方法重载。