C#的面向对象

对象包含：成员、属性、方法（对象的行为）

C#实例化对象并访问对象成员

C# 方法默认访问级别 : private
C# 类默认访问级别 : internal

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

namespace kids
{
    class Program
    {
        static void Main(string[] args)
        {
            Child xiaoming = new Child();//实例化了child类的对象
            xiaoming.name = "马晓明";//为字段赋值
            xiaoming.sex = "男";
            xiaoming.age = 6;
            Console.WriteLine("我叫" + xiaoming.name + ",今年" + xiaoming.age + "岁；");
            xiaoming.PlayBall();//调用踢球的方法
            Console.ReadKey();//调试防止闪退
        }
    }

    /// <summary>
    /// C# 方法默认访问级别 : private 
    /// C# 类默认访问级别 : internal
    /// </summary>
    public  class Child
    {
        public string name;//public 访问修饰符公共的，private私有的,默认的访问修饰符。（不可被外部类访问）
        public string sex;
        public int age;
        public void PlayBall()
        {
            Console.WriteLine("吼啊");
        }
    }
}

属性的封装

封装就是隐藏对象的信息，留出访问的接口。在C#中，我们常使用属性对字段进行封装。

private string _sex;//隐藏的字段
public string Sex//公开的属性
{
    //get、set访问器
    get//只读
    {
        return _sex;
    }
    set//只写
    {
        _sex=value;}
    }

封装示例代码：

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

namespace kids
{
    class Program
    {
        static void Main(string[] args)
        {
            Child xiaoming = new Child();//实例化了child类的对象
            xiaoming.Name = "马晓明";//为字段赋值
            xiaoming.Sex = "男";
            xiaoming.Age = 6;
            xiaoming.Age = 65;
            Console.WriteLine("我叫" + xiaoming.Name + ",今年" + xiaoming.Age + "岁；");
            xiaoming.PlayBall();//调用踢球的方法
            Console.ReadKey();//调试防止闪退
        }
    }

    /// <summary>
    /// C# 方法默认访问级别 : private 
    /// C# 类默认访问级别 : internal
    /// </summary>
    public  class Child
    {
        private string name;//public 访问修饰符公共的，private私有的,默认的访问修饰符。（不可被外部类访问）
        private string sex;
        private int age;
        //封装的快捷键：ctrl + R +E
        public string Name
        {
            get
            {
                return name;//读访问器
            }

            set
            {
                name = value;//写访问器
            }
        }

        public string Sex
        {
            get
            {
                return sex;
            }

            set
            {
                sex = value;
            }
        }

        public int Age
        {
            get
            {
                return age;
            }

            set
            {
                //set块约束属性赋值，只有满足条件3-7岁的可以被赋值
                if (value >= 3 && value <= 7)
                {
                    age = value;
                }
            }
        }

        public void PlayBall()
        {
            Console.WriteLine("吼啊");
        }
    }
}

方法的重载

方法的重载，同一个类中，多个方法，名字相同，参数不同,可以是参数类型不同也可以数量不同，但至少有一方面不同

public void EatSugar(string sugar){}
public void EatSugar(int count){}

参考链接：http://www.jb51.net/article/36735.htm

return 的使用’

定义方法时，每一个参数必须单独申明。
比如，可是是int n1,int n2 但不能是int n1,n2

尽量让每个方法只完成一个功能，避免限制。

return 可以有返回值，方法的类型根据返回值类型设置。

class ReturnTest 
{
    static double CalculateArea(int r) //方法的类型必须与返回值类型相同
    {
        double area = r * r * Math.PI;
        return area;//返回值类型为double
    }

    static void Main() 
    {
        int radius = 5;
        double result = CalculateArea(radius);
        Console.WriteLine("The area is {0:0.00}", result);
    }
}
// Output: The area is 78.54

C#构造方法

1、构造方法的作用:为属性赋值。
2、如果没有显示定义的构造方法，则会有一个默认的无参数的构造方法。
3、如果显示定义了构造方法，则没有默认的构造方法。
4、只能用new 方法名()的形式调用构造方法。
5、构造方法通常声明为public。
6、构造方法没有返回值。
7、构造方法名必须与类名相同。

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            a a1 = new a("1");

            Console.ReadKey();
        }
    }
    class a
    {
        public a(string str)//定义一个构造方法
        {
            Console.Write(str);
        }
    }
}

参考链接：http://www.cnblogs.com/yangfengwu/p/5864625.html

this的使用

this：当前对象，可调用当前的字段、属性、方法

参考资料链接：http://www.oschina.net/code/snippet_584165_48374

构造函数的重载

class Person  
{  
    public Person(string name, int age)               
    {  
     this.Name = name;  
     this.Age = age;  
    }  
    public Person(string name, int age, char sex)       //构造函数的重载  

    {  
        this.Sex = sex;  
    }  
    public Person()                                 //构造函数的重载  
    {
    }  
}  

对象初始化器初始化对象

//对象初始化器初始化对象

Child child3 = new Child(){Name = "周润发",Age = 5};

此处（）可以省略

C#值类型和引用类型

C#结构

参考链接：http://www.cnblogs.com/jiajiayuan/archive/2011/09/20/2181582.html
结构Struct
1、结构是值类型，类是引用类型（两者的根本区别）
2、结构中可以定义字段、属性和方法
3、不能为结构中的字段赋初始值
4、结构的构造方法中必须为所有字段赋值
5、不能为结构显式定义无参数的构造方法
6、结构类型的对象可以不实例化，就直接使用（可以不new，直接使用）

struct A
    {
        public int x;           //不能直接对其进行赋值
        public int y;
        public static string str = null;   //静态变量可以初始化
        public A(int x,int y) ;  //带参数的构造函数
        {
            this.x = x;
            this.y = y;
            Console.WriteLine("x={0},y={1},str={2}", x, y,str);
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            A a =new A(1,2);
            A a1 = a;
            a.x =10;
            Console.WriteLine("a1.x={0}",a1.x);
            Console.Read();
        }
    }

枚举

1.枚举是值类型
2.枚举中不能定义字段属性和方法
3.枚举值是从0递增的整数
（可以将数字强制转换为枚举类型：(枚举变量)0 …）

public class EnumTest
{
    enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

    static void Main()
    {
        int x = (int)Days.Sun;
        int y = (int)Days.Fri;
        int z = (Days).6;
        Console.WriteLine("Sun = {0}", x);
        Console.WriteLine("Fri = {0}", y);
    }
}
/* Output:
   Sun = 0
   Fri = 5
*/

方法传参中的值类型和引用类型

按引用传参：
1）传递类就是引用传参
方法改变形参，通常实参也会被改变
2）ref关键字可以使值类型参数按引用传参
注意：声明、调用的时候，都要加“ref”关键字，
而且实参中“ref”后面不能直接使用属性，应该赋值给一个变量，用变量来传参。（值类型，引用方式传参）
按值传参：
方法改变形参，通常实参不会被改变

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

namespace kids
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 3;
            Growth(ref age);
            Console.WriteLine("我现在{0}岁了" ,age);
            Console.ReadKey();//调试防止闪退
        }
        static void Growth(ref int age)//值类型参数，按引用传参
        {
            age++;
        }
    }




}

out关键字用法
1、ref用于传参，out用于获取方法的计算结果
2、return只能返回一个值，out可以返回多个值
3、out修饰的形参必须赋值

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

namespace kids
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 3;
            //Growth(ref age);

            Console.WriteLine("我现在{0}岁了" ,age);
            int lastAge, nextAge;
            Growth(age,out lastAge,out nextAge);
            Console.WriteLine("我明年{0}岁，我去年{1}岁",nextAge,lastAge);
            Console.ReadKey();//调试防止闪退
        }
        static void Growth(ref int age)//值类型参数，按引用传参
        {
            age++;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="age"></param>
        /// <param name="lastAge">去年的年龄</param>
        /// <param name="nextAge">明年的年龄</param>
        static void Growth(int age,out int lastAge,out int nextAge)
        {
            lastAge = age - 1;
            nextAge = age + 1;
        }
    }




}