iOS 类属性 类属性对象

类、对象、方法和属性详解

一、相关概念：

1、对象:现实世界中的实体（世间万物皆对象）

2、类:具有相似属性和方法的对象的集合

3、面向对象程序设计的特点:封装 继承 多态

4、对象的三要素：属性（对象是什么）、方法（对象能做什么）、事件（对象如何响应）

类 (class) 是最基础的 C# 类型。

• 类是一个数据结构，将状态（字段）和操作（方法和其他函数成员）组合在一个单元中。
• 类为动态创建的类实例 (instance) 提供了定义，实例也称为对象 (object)。
• 类支持继承 (inheritance) 和多态性 (polymorphism)，这是派生类 (derived class) 可用来扩展和专用化基类 (base class) 的机制。

相互关系：类是对象的抽象，对象是类的实例，类是一种抽象的分类，对象则是具体事物。

比如如果车是一个类，某个人的一辆奔驰车就是一个对象，车的颜色质量就是它的属性，启动、停止这些动作则可以定义为车的方法。

二、类的定义与语法

1、定义类：

[修饰符] class 类名  
{
类成员
}

2、类的访问修饰符:

public internal
a) public:可访问域是所在的程序和任何引用的程序 访问不受限制
语法:
public class 类名
{
类成员
}

b) internal:可访问域定义范围内 (默认访问修饰符)

语法：

(internal) class 类名
{
类成员
}

3、类成员：数据成员和字段

成员	说明
常量	与类关联的常数值
字段	类的变量
方法	类可执行的计算和操作
属性	与读写类的命名属性相关联的操作
索引器	与以数组方式索引类的实例相关联的操作
事件	可由类生成的通知
运算符	类所支持的转换和表达式运算符
构造函数	初始化类的实例或类本身所需的操作
析构函数	在永久丢弃类的实例之前执行的操作
类型	类所声明的嵌套类型

a) 数据成员:字段和常量

字段:变量

声明:类型 字段名

例：

public class Persion
{
public string name;
}

b) 方法成员 （方法是类的行为，告诉我们类能够做什么，）

实例方法：

修饰符 返回值类型 方法名(参数列表)
{
方法体
}

修饰符：如：public、private、protected、internal

返回值类型：若方法无返回值，则使用 void

例：

public class Example01  //实例方法
{
public void SayHello()  //定义一个无参无返回的方法
{ 
Console.WriteLine("Hello There")
}
static void Main()
{
Example01 objA=new Example01()
objA.SayHello()    //创建对象并调用方法
}
}

静态方法：

修饰符 static返回值类型 方法名(参数列表) //增加了static关键字

{

方法体

}

例：

public class Example01  //实例方法
{
public static void SayHello()  //定义一个静态方法
{ 
Console.WriteLine("Hello There")
}
static void Main()
{
Example01.SayHello()    //不需要创建对象
}
}

静态方法与实例方法的区别：静态方法只与类有关，它不依赖于对象的存在而存在；实例方法则在对象存在后才能使用。

三、实例化对象：关键字：new

语法：

类 对象名称=new 类();

例：

代码如下

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
namespace ConsoleApplication1 
{ 
public class car 
{ 
private string carName; 
private string carType; 
private int price; 
public string CarName 
{ 
get { return carName; } 
set { carName = value; } 
} 
public string CarType 
{ 
get { return carType; } 
set { carType = value; } 
} 
public int Price 
{ 
get { return price; } 
set { price = value; } 
} 
  
public void  action() 
{ 
Console.WriteLine("一辆名叫{0}车，型号是{1}，价钱是：{2}",carName,carType,price); 
} 
} 
  
    //创建实例并访问字段和方法 
class Program 
{ 
static void Main(string[] args) 
{ 
//创建car类的实例 
car vehicle = new car(); 
//给实例赋值 
vehicle.CarName = "奔驰"; 
vehicle.CarType = "XZ001"; 
vehicle.Price = 1000000; 
  		//调用方法 
vehicle.action(); 
} 
} 
}

四、属性

1、

概念：用于访问类的字段的成员

属性用途：保证数据安全，作数据的验证

声明：

访问修饰符 数据类型 属性名

{
get{return 字段;}  //读访问器，通过它外部用户可以读取属性的值
set{字段=value;}  //写访问器，通过它外部用户可以为属性赋值，用户输入的值就存放在value关键字中，并可以进行输入值验证。
}
例：
public class Student
{
private int age;   //私有字段，防止用户直接访问
public int Age
{
get{return age;}  //用于读取age的值
set
{
if((value>=18)&&(value<=45))
age=value;  //为age赋值并验证
else
age=18;
}
}
}

3、特殊属性：

a) 只读属性：

public 数据类型 属性名称
{
get{return 字段;}
}

b) 自动属性：

public 数据类型 属性名称{get;set;}

五、方法的参数

1、值参数：按值传递

值参数是通过将实参的值复制到形参，来实现按值传递到方法，也就是我们通常说的按值传递。

方法被调用时，CLR做如下操作：

1、在托管堆栈中为形参分配空间；

2、将实参的值复制到形参。

这个太常用了，按值传递参数，是复制一份，因此不影响原来参数的值。

public class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            int j = 2;
            int k = Plus(i,j);
            Console.WriteLine(i);   //输出 1
            Console.WriteLine(j);   //输出 2
            Console.WriteLine(k);   //输出 5
            Console.ReadKey();
        }
        public static int Plus(int i, int j)
        {
            i = i + 1;
            j = j + 1;
            return i + j;
        }
    }

2、引用参数：向方法传递实参在内存中的地址，按地址传递 关键字ref

和前面的“按值传递”相对应的是按引用传递。顾名思义，这里传递的不在是值，而是引用。注意这里不是传递一个复制品了，而是将真实的自己传到方法中供方法玩弄。

　　注意点：

　　1、按引用传递的参数，系统不再为形参在托管栈中分配新的内存。

　　2、此时，形参名其实已经成为实参名的一个别名，它们成对地指向相同的内存位置。

public class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            int j = 2;
            int k = Plus(ref i,ref j);      //实参前也要加ref关键字
            Console.WriteLine(i);   //输出 2
            Console.WriteLine(j);   //输出 3
            Console.WriteLine(k);   //输出 5
            Console.ReadKey();
        }
        public static int Plus(ref int i, ref int j)    //形参钱要加ref关键字
        {
            i = i + 1;
            j = j + 1;
            return i + j;
        }
    }

3、输出参数：从方法传递回一个结果 关键字：out

输出参数和引用参数有一定程度的类似，输出参数可用于将值从方法内传递到方法外，实际上就相当于有多个返回值。要使用输出参数只需要将引用参数的ref关键字替换为out关键字即可。但又一点必须注意，只有变量才有资格作为输出参数，文本值和表达式都不可以，这点要谨记。

　　注意两个问题：

　　1、编译器允许在方法中的任意位置、任意时刻读取引用参数的值。

　　2、编译器禁止在为输出参数赋值前读取它。

　　这意味着输出参数的初始值基本上是没意义的，因为它在使用前要被赋予新的值。因此想通过输出参数将值传入方法的路是行不通的。

public class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            int j = 2;
            int k = Plus(i,out j);      //实参前也要加out关键字
            Console.WriteLine(i);   //输出 1
            Console.WriteLine(j);   //输出 100
            Console.WriteLine(k);   //输出 102
            Console.ReadKey();
        }
        public static int Plus(int i, out int j)
        {
            i = i + 1;
            j = 100;
            return i + j;
        }
    }

4、数组型参数：参数只允许是一组数组，当方法的参数前带有params关键字时，就是带数组型参数的方法（使用引用传递）参数数组 关键字params

public class Program
    {
        static void Main(string[] args)
        {
            int count1 = Plus(1);       //输出 1
            Console.WriteLine(count1);
            int count2 = Plus(1, 2, 3);//输出 6
            Console.WriteLine(count2);
            int count3 = Plus();    //输出 0  参数数组本身可选，没传入值也不会出错
            {
                Console.WriteLine(count3);
            }
            Console.ReadKey();
        }
        public static int Plus(params int[] values)
        {
            int count = 0;
            foreach (int i in values)
            {
                count = count + i;
            }
            return count;
        }
    }