123456

ref 关键字，将值传递改为引用传递

构造方法的作用：为属性赋值。

如果没有显式定义构造方法，则会由一个默认的无参数的构造方法

如果显示定义了构造方法，则没有默认构造方法

只能用 new 方法（）的形式调用构造方法

构造方法通常生命为 public

构造方法没有返回值类型

构造方法必须与类名相同

限制属性赋值就是在 set 方法中增加业务判断也处理支路

c# 封装的快捷键 ctrl +r+e

c# 中对象与属性的区别。

prvate string _name;

public string Name

{

    set{_name=value;}

   get{return _name;}

}

struct:

s

C#中的数据类型

值类型：int char double bool

值类型变量存储对象的值，赋值会创建值得副本，修改任何一个副本，不会影响其他的副本

引用类型：类 数组 接口 string

引用类型变量存储对象的内存地址，赋值不会创建值得副本，只会创建地址的副本，修改任何一个副本，也同时修改其他的副本。

初始化：一、用有参数构造方法初始化对象

二、用无参数构造方法初始化对象

三、对象初始化器初始化对象（使用的是构造方法的无参数构造）与二相同，只是写法更加简洁而已。

例子：Child child=new Child(){Name=“小米”，Age=55} 

or Child Child3 = new Child{ Name = "周润发", Age = 5 };

封装的概念：隐藏对象的信息，留出访问的接口

关于封装：

类和对象；把字段封装成属性；方法；构造方法；值类型与引用类型

引用：结构 枚举 out ref

方法

构造方法

ref起到传参作用：

out是获取结果且可以返回多个值；return返回一个值。

使用Out 修饰形参必须得给形参赋值

关键字 ref ：让值类型参数按引用类型传参。

注意，这里的值类型不能是对象的属性。诸如 Growth( ref c1.Age)，就是错误的。

正确举例：

先定义方法，注意使用ref ：static void Growth( ref int age){ age ++ ；}

然后定义一个值类型变量：int age1 = 3;

调用方法的时候，也必须使用ref ：Growth( ref age1);

在Main中访问静态方法时不需要实例化对象便可以直接调用方法名

值类型和引用类型作为方法参数时的区别：

1、按值传参，方法修改形参，实参不会被修改；

2、按引用传参，方法修改形参，实参不会被修改；

枚举：限定了范围

枚举：

1、值类型

2、不能定义字段属性和方法

3、枚举值是从0递增的整数

例子：enum Gender

//Child c1 = new Child("梁晓雪", "女", 4);//错误    5    参数 2: 无法从“string”转换为“Gender”    
            //Child c2 = new Child("刘小牛","猴",5);
            //Child c2 = new Child("刘小牛", Gender.男, 5);
            Child c2 = new Child("刘小牛", (Gender)0, 5);

1、创建枚举类型：项目名称，右键，添加，类或新建项（代码文件）

2、枚举属于值类型，枚举中不能定义字段属性和方法，枚举值是从0开始的整数值

3、枚举类型限定了一组有限的值，可以在某种程度上防止错误数据的输入

简单来说，struct是值类型，创建一个struct类型的实例被分配在栈上。class是引用类型，创建一个class类型实例被分配在托管堆上。但struct和class的区别远不止这么简单。
概括来讲，struct和class的不同体现在：
● 类是引用类型，struct是值类型
● 在托管堆上创建类的实例，在栈上创建struct实例
● 类实例的赋值，赋的是引用地址，struct实例的赋值，赋的是值
● 类作为参数类型传递，传递的是引用地址，struct作为参数类型传递，传递的是值
● 类没有默认无参构造函数，struct有默认无参构造函数
● 类支持继承，struct不支持继承
● 类偏向于"面向对象",用于复杂、大型数据，struct偏向于"简单值"，比如小于16字节，结构简单
● 类的成员很容易赋初值，很难给struct类型成员赋初值
● 类的实例只能通过new someclass()来创建，struct类型的实例既可以通过new somestruct()来创建，也可以通过somestruct mystruct;来创建
一、从赋值的角度体验struct和class的不同
引用类型赋值，是把地址赋值给了变量


class program
  {
    static void main(string[] args)
    {
      sizeclass sizeclass = new sizeclass(){width = 10, length = 10};
      console.writeline("赋值前：width={0},length={1}", sizeclass.width, sizeclass.length);
 
      var copyofsizeclass = sizeclass;
      copyofsizeclass.length = 5;
      copyofsizeclass.width = 5;
      console.writeline("赋值后：width={0},length={1}",sizeclass.width, sizeclass.length);
      console.readkey();
    }
  }
 
  public class sizeclass
  {
    public int width { get; set; }
    public int length { get; set; }
  }
 
  public struct sizestruct
  {
    public int width { get; set; }
    public int length { get; set; }
  }
运行结果如下图所示：以上，当把sizeclass赋值给copyofsize变量的时候，是把sizeclass所指向的地址赋值给了copyofsize变量，2个变量同时指向同一个地址。所以，当改变copyofsizeclass变量的值，也相当于改变了sizeclass的值。
struct类型赋值，是完全拷贝，在栈上多了一个完全一样的变量


class program
  {
    static void main(string[] args)
    {
      sizestruct sizestruct = new sizestruct(){length = 10, width = 10};
      console.writeline("赋值前：width={0},length={1}", sizestruct.width, sizestruct.length);
 
      var copyofsizestruct = sizestruct;
      copyofsizestruct.length = 5;
      copyofsizestruct.width = 5;
      console.writeline("赋值后：width={0},length={1}", sizestruct.width, sizestruct.length);
      console.readkey();
    }
  }
程序运行结果如下图所示：以上，当把sizestruct赋值给copyofsizestruct变量的时候，是完全拷贝，改变copyofsizestruct的值不会影响到sizestruct。
二、从参数传值角度体验struct和class的不同
引用类型参数传递的是地址


class program
  {
    static void main(string[] args)
    {
      listtemp = new list(){"my","god"};
      temp.foreach(t => console.write(t + " "));
      console.readkey();
    }
 
    public static void changereferencetype(listlist)
    {
      list = new list(){"hello", "world"};
    }
  }
   


运行结果：my god
为什么不是hello world？
→栈上的temp指向托管堆上的一个集合实例
→当temp放到changereferencetype(temp)方法中，本质是把temp指向的地址赋值给了变量list
→在changereferencetype(listlist)方法内部，又把变量list的指向了另外一个集合实例地址
→但temp的指向地址一直没有改变
我们再来改变changereferencetype(listlist)内部实现方式，其它不变。


class program
  {
    static void main(string[] args)
    {
      listtemp = new list(){"my","god"};     
      changereferencetype(temp);
      temp.foreach(t => console.write(t + " "));
      console.readkey();
    }
 
    public static void changereferencetype(listlist)
    {
      list.clear();
      list.add("hello");
      list.add("world");
    }
  }
   


运行结果：hello world
为什么不是my god？  
→栈上的temp指向托管堆上的一个集合实例
→当temp放到changereferencetype(temp)方法中，本质是把temp指向的地址赋值给了变量list
→在changereferencetype(listlist)方法内部，把temp和list共同指向的实例清空，又添加"hello"和"world"2个元素
→由于list和temp指向的实例是一样的，所以改变list指向的实例就等同于改变temp指向的实例
以上，很好地说明了：引用类型参数传递的是地址。
值类型struct参数传递的是值
   
class program
  {
    static void main(string[] args)
    {
      size s = new size(){length = 10, width = 10};
      changestructtype(s);
      console.write("length={0},width={1}", s.length,s.width);
      console.readkey();
    }
 
    public static void changestructtype(size size)
    {
      size.length = 0;
      size.width = 0;
    }
  }
 
  public struct size
  {
    public int length { get; set; }
    public int width { get; set; }
  }