下载文档原格式
什么是⾯向对象、对象是什么、什么是类、如何使⽤对象、类和对象的关系⾯向对象⼀、⾯向对象 概念：⾯向对象是⼀种编程思想，使⽤编程语⾔解决现实问题的⼀种思路。
分类： ⾯向过程: C 语⾔ ⾯向对象: Java ⾯向对象的思想： ⾯向对象的思想： ⾯向过程的思想：⾃顶向下 逐步执⾏。
---> 当解决⼀件事情的时候，⾸先想到的是我该怎么去做⾯向对象思想：以对象为中⼼，使⽤对象调⽤其功能。
---> 当解决⼀件事情的时候，⾸先想到的是我该让谁帮我做。
想到的谁 ---> 对象 对象：现实⽣活中存在的真实的事物都是对象，Java 中有⼀句名⾔： 万物皆对象，⼤到宇宙、⼩到夸克在Java 的世界中都可以看成对象。
提起对象，就需要提起另⼀个概念——类。
类是对象的模板，对象是类的实例。
⼆、类 概念： 将具有相同特征的⼀类事物的共性进⾏抽取(抽取的过程叫做抽象)，形成的⼀个概念叫做类。
类的抽象： 1. 怎么去描述⼀个事物，从哪些维度进⾏描述？ 这个事物具有什么 ---> 属性 这个事物会做什么 ---> ⾏为 2. 怎么去描述⼀类事物的共性？ 这些事物具有什么 ---> 属性 这些事物会做什么 ---> ⾏为 类和对象的关系： 类是对象的模板 对象是类的实例 类的定义： 概述： 属性 ： 使⽤成员变量来进⾏描述 ⾏为 ： 使⽤成员⽅法进⾏描述 语法：关键词：class语法：public class 类名｛｝ 成员变量 定义位置：类中⽅法外 语法： 数据类型 变量名； / 数据类型 变量名 = 初始值；作⽤域：⾄少在本类 默认值： 和数组元素的默认值是⼀样的 基本数据类型 整数类型 0 ⼩数类型 0.0 字符类型空字符 布尔类型 false 引⽤数据类型 null 定义的注意事项 1. 在同⼀个类中不能定义两个同名的成员变量 2. 在同⼀个类中成员变量可以和局部变量可以重名，但是在访问的时候，局部变量优先。
1.面向对象的概念面向对象(Object-Oriented)=对象(Object)+类(Class)+ 继承(Inheritance)+通信(Communication)如果一个软件系统是使用这样4个概念设计和实现的，则将该软件系统称为面向对象的。
下面给出每个概念的具体定义。
1.1 对象从一般意义上讲，对象是现实世界中一个实际存在事物，它可以是有形的（比如一辆汽车），也可以是无形（比如一项计划）。
对象构成世界的一个独立单位，它具有自己的静态特征和动态特征。
静态特征即可用某种数据来描述的特征，动态特征即对象所表现的行为或对象所具有的功能。
现实世界中的任何事物都可以称作对象，它是大量的、无处不在的。
不过，人们在开发一个系统时，通常只是在一定的范围（问题域）内考虑和认识与系统目标有关的事物，并用系统中的对象抽象地表示它们。
所以面向对象方法在提到“对象”这个术语时，既可能泛指现实世界中的某些事物，也可能专指它们在系统中的抽象表示，即系统中的对象。
我们主要对后一种情况讨论对象的概念，其定义是：对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。
一个对象由一组属性和对这组属性进行操作的一组服务构成。
属性和服务，是构成对象的两个主要因素，其定义是：属性是用来描述对象静态特征的一个数据项。
服务是用来描述对象动态特征（行为）的一个操作序列。
一个对象可以有多项属性和多项服务。
一个对象的属性和服务被结合成一个整体，对象的属性值只能由这个对象的服务存取。
在有些文献中把对象标识（OID）列为对象的另一要素。
对象标识也就是对象的名字，有“外部标识”和“内部标识”之分。
前者供对象的定义者或使用者用，后者为系统内部惟一的识别对象。
(怎么感觉这点跟android开发里面的id是一样的，在某个文件下有编程人员定义的所有属性的id，并且是唯一的，一般不允许更改，属于系统内部分配。
) 另外需要说明以下两点：第一点是，对象只描述客观事物本质的与系统目标有关的特征，而不考虑那些非本质的与系统目标无关的特征。
面向对象的名词解释是什么在计算机科学中，面向对象（Object-Oriented）是一种编程范式，它将系统的组织和设计建立在对象的概念上。
面向对象编程的核心理念是将问题分解成不同的对象，每个对象都有自己的状态和行为，并且能够与其他对象进行交互。
面向对象编程的基本概念是“类”和“对象”。
类是一种抽象的概念，描述了一组具有相同属性和行为的对象。
通过类的定义，我们可以创建一些具体的实例，即对象。
对象是类的具体实例化，它拥有类定义的属性和行为。
在面向对象的编程中，我们通过创建对象来解决问题，每个对象都具有自己的数据和可执行的代码。
面向对象编程具有许多特性，其中最重要的是封装、继承和多态。
封装是面向对象编程的基本原则之一。
它指的是将数据和相关操作封装在单个对象中，同时隐藏对象内部的细节。
通过封装，我们可以将对象的数据和行为组织在一起，使其成为一个独立的实体。
封装有助于减少代码的耦合性，提高代码的可维护性和复用性。
继承是面向对象编程的另一个重要概念。
继承允许我们创建一个新的类，该类继承现有类的属性和行为。
新类称为子类或派生类，而被继承的类称为父类或基类。
通过继承，子类可以重用父类的代码，并且可以在其基础上进行扩展或修改。
继承可以提高代码的可读性和可维护性，同时也促进了代码的重用。
多态是面向对象编程的第三个重要特性。
多态允许不同的对象对相同的消息作出不同的响应。
具体来说，多态使我们可以使用一个通用的接口来处理不同类型的对象，而不需要关心对象的具体类型。
这种特性使得代码更加灵活和可扩展，使得程序具有更好的适应性和可复用性。
除了封装、继承和多态，面向对象编程还有其他一些重要的概念，如抽象、接口和消息传递等。
抽象指的是将问题的共同特征提取出来，形成类或接口的过程。
接口定义了类所提供的方法和属性，它为类提供了一种协议，规定了类和外部世界之间的交互方式。
消息传递是面向对象编程中对象之间通信的方式，对象通过发送消息来请求其他对象执行某个操作。
面向对象个人心得体会篇一：面向对象的编程总结一、什么是面向对象：所谓面向对象的编程就是：通过封装，继承，多态，把程序的耦合度降低，传统的雕版印刷术的问题就在于所有刻字都在同一版面上造成耦合度太高所致，当用面向对象的模式，使得印刷程序更加灵活，容易修改，并且易于复用。
对象（Object）是类（Class）的一个实例（Instance）。
如果将对象比作房子，那么类就是房子的设计图纸。
所以面向对象程序设计的重点是类的设计，而不是对象的设计。
类可以将数据和函数封装在一起，其中函数表示了类的行为（或称服务）。
类提供关键字public、protected 和private 用于声明哪些数据和函数是公有的、受保护的或者是私有的。
二：基类类与结构体的区别和联系； Strcut test{Private:Int number; Public:Float socre; };类的创建方式和结构体几乎一样， Class test {Private:Int number; Public:Float socre;Public:Public:Int rp();{ Return number;}Void setnum(int a) {Number=a; }}; 但是大家注意到没有，标准c中不允许在结构体中声明函数的，但是在c++中的类中是可以的，这就和c有了本质的区别，很好体现了c++面向对象的特点。
两种语言的区别：过去的c语言是一种面向过程的语言特性是：程序=算法+数据结构但c++的特性是：对象=算法+数据结构；程序=对象+对象+对象。
区别：在c语言中个成员他们的默认存储控制是public 而c++类中默认的存储控制是private.; 上面的rp()事成员函数，如果我们有如下定义： Test a；的话，调用rp（）就可以写成： a． rp（）；成员函数的调用和普通成员的调用方式一致都采用“.”的操作符。
例如： class test {private://私有成员类外不能够直接访问 int number;public://共有成员类外可以直接访问 float socre; public: int rp() {return number; } void setnum(int a) {number=a; } };void main() { test a; //a.number=10;//错误的，私有成员不能外部访问 a.socre=99.9f; cout<<a.socre<<endl;a.setnum(100);//通过共有成员函数setnum()间接对私有成员number函数进行访问 cout<<a.rp(); cout<<endl; }/*int pp=0; class test {private: int number; public: float socre; int pp; public: void rp(); };void test::rp() { ::pp=11; pp=100; }void main() { test a; test b; a.rp(); cout<<pp<<endl; cout<<a.pp<<endl; }*/利用域区分符我们可以在类定义的外部设置成员函数，但要注意的是，在类的内部必须预声明：类型类名 :: 函数名（）=值void test::rp()在函数类型的后面加上类的名称再加上域区分符(::)再加函数名称，利用这样的方法我们就在类的外部建立了一个名为rp 的test类大成员函数(方法)，可能很多人要问，这么做有意义吗？在类的内部写函数代码不是更好？答案是这样的：在类的定义中，一般成员函数的规模一般都比较小，而且一些特殊的语句是不能够使用的，而且一般会被自动的设置成为inline(内联)函数,即使你没有明确的声明为inline，那么为什么有会被自动设置成为inline呢？因为大多数情况下，类的定义一般是放在头文件中的，在编译的时候这些函数的定义也随之进入头文件，这样就会导致被多次编译，如果是inline的情况，函数定义在调用处扩展，就避免了重复编译的问题，而且把大量的成员函数都放在类中使用起来也十分不方便，为了避免这种情况的发生，所以c++是允许在外部定义类的成员函数(方法)的，将类定义和其它成员函数定义分开，是面向对象编程的通常做法，我们把类的定义在这里也就是头文件了看作是类的外部接口，类的成员函数的定义看成是类的内部实现。
面向对象是一种软件开发方法，其核心是对象。
对象是具有属性和方法的实体，可以和其他对象进行交互。
面向对象的程序设计方式不仅可以提高程序的复用性和可维护性，还可以更好地抽象和描述现实世界中的问题。
在面向对象的编程语言中，对象是指一些相关的属性和方法的集合。
属性是对象的状态信息，而方法是对象执行的操作。
每个对象都有一个唯一的标识符，用于区分其他对象。
对象可以通过消息传递的方式来执行方法，这种方式使得不同对象之间的交互变得非常灵活。
面向对象的程序设计还经常使用类的概念。
类是用于创建对象的蓝图，类中定义了对象的属性和方法。
通过继承的方式，子类可以从父类继承属性和方法，从而简化程序设计。
同时，通过封装的技术，可以将类的实现细节隐藏，使得类的使用更加简单方便。
多态性是面向对象编程的一个重要特性。
多态性是指同一个方法可以被不同的对象调用，并且会根据对象的不同而产生不同的结果。
例如，在一个图形库中，矩形、圆形、三角形都是图形对象，但是在绘制的时候，每个图形需要调用自己的绘制方法。
面向对象编程中还有一些重要的概念，例如接口、抽象类、泛型等。
接口是一组方法的集合，规定了对象的行为规范。
抽象类是一种不能直接实例化的类，需要子类继承并实现其中的方法。
泛型是一种代码模板，可以在编译时对代码进行类型检查，并在运行时进行类型转换，使得代码的安全性更高。
总之，面向对象编程是一种高效、灵活的软件设计方法，可以帮助程序员更好地组织和处理复杂系统。
深入理解面向对象编程的核心概念和技术，可以大大提高程序设计的效率和质量。
①什么是面向对象？个人理解，面向对象是一种思想。
所谓科学的世界观--马克思主义哲学在开篇就定义：“世界是物质的，物质是运动的”。
前半句话就是面向对象的体现，把世界万物都作为对象来考虑。
面向对象的思想已经涉及到软件开发的各个方面。
如，面向对象的分析（OOA，Object Oriented Analysis），面向对象的设计（OOD，Object Oriented Design）、以及我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）。
②面向对象的基本概念(1)对象。
对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。
(2)对象的状态和行为。
对象具有状态，一个对象用数据值来描述它的状态。
对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。
对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中(3)类。
具有相同或相似性质的对象的抽象就是类。
因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象。
类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。
类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。
(4)类的结构。
在客观世界中有若干类，这些类之间有一定的结构关系。
通常有两种主要的结构关系，即一般--具体结构关系，整体--部分结构关系。
一般——具体结构称为分类结构，也可以说是“或”关系，或者是“is a”关系。
整体——部分结构称为组装结构，它们之间的关系是一种“与”关系，或者是“has a”关系。
(5)消息和方法。
对象之间进行通信的结构叫做消息。
在对象的操作中，当一个消息发送给某个对象时，消息包含接收对象去执行某种操作的信息。
发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）。
一般还要对参数加以说明，参数可以是认识该消息的对象所知道的变量名，或者是所有对象都知道的全局变量名。
面向对象的基本概念面向对象（Object-Oriented，简称OO）是一种软件开发方法论，它将现实世界中的事物抽象为对象，并通过对象之间的交互来实现软件系统的设计与实现。
面向对象具有封装、继承和多态三个核心概念，这些概念在面向对象的编程语言和方法中扮演着重要的角色。
本文将详细解释这三个关键概念的定义、重要性和应用。
1. 封装1.1 定义封装是将数据和对数据的操作封装在一个对象中的过程。
它通过将相关的属性和方法集中到一个对象中，隐藏对象内部的细节，提供给外界一个结构简单、功能明确的接口，使对象与外界的交互只通过有限的方式进行。
封装可以有效地实现数据的安全性和可维护性。
1.2 重要性封装的重要性体现在以下几个方面：•信息隐藏：封装将对象的内部细节隐藏起来，只暴露公共接口给外部使用，从而保护对象内部数据的安全性和完整性，避免不必要的干扰和错误操作。
•模块化设计：通过将相关属性和方法封装到一个对象中，可以对系统进行模块化设计，降低系统的复杂性，提高代码的可读性和可维护性。
•减少耦合：封装可以实现对象与对象之间的松耦合，对象之间通过接口进行交互，而不需要关心对方的内部实现细节，提高了系统的灵活性和可扩展性。
•提高复用性：封装将数据和操作封装在一个对象中，可以将对象作为一个整体进行复用，避免了重复编写相同的代码，提高了代码的复用性和可维护性。
1.3 应用场景封装广泛应用于面向对象的程序设计中。
以下是一些常见的应用场景：•类的设计：在面向对象的编程语言中，封装是实现类的基础。
将类的属性和方法封装到一个类中，通过实例化对象来使用和操作对象的属性和方法。
•数据的封装：在面向对象的编程中，通过将数据和操作封装在一个对象中，实现对数据的封装和管理。
例如，在一个学生信息管理系统中，可以将学生的信息（姓名、年龄等）和操作（添加、删除等）封装到一个学生对象中。
•接口的设计：封装也可以应用于接口的设计中，通过对外暴露有限的接口，封装对象内部的实现细节，实现模块之间的解耦和隔离。
面向对象的名词解释引言：在计算机科学和软件开发领域，面向对象是一种常见的开发方法和编程范式。
它凭借其模块化、可维护性和可扩展性而备受青睐。
本文将对面向对象的概念进行解释和探讨。
一、面向对象的基本概念：面向对象是一种用于描述和实现计算机程序的方法，它将现实世界中的事物抽象为对象（Object），并通过对象之间的交互来完成系统功能。
在面向对象的编程中，对象是程序的基本单元，它具有状态（State）、行为（Behavior）和标识（Identity）。
1.1 对象的状态（State）：对象可以通过属性（Property）来描述其状态。
属性是对象的特征或数据。
例如，一辆汽车的颜色、型号和速度等都可以作为其状态的属性。
1.2 对象的行为（Behavior）：对象可以通过方法（Method）来描述其行为。
方法是对象执行的操作或功能。
例如，一辆汽车的启动、加速和停止都可以作为其行为的方法。
1.3 对象的标识（Identity）：对象在系统中具有唯一的标识。
通过该标识，系统可以区分不同的对象。
例如，每辆汽车都有一个唯一的车牌号，用于标识该车辆的身份。
二、面向对象的特性：面向对象的编程具有以下几个重要的特性，它们使得软件开发更加灵活和可维护。
2.1 封装（Encapsulation）：封装是面向对象的基本特性之一，它将数据和操作封装在一个对象中，外部无法直接访问和修改对象内部的数据。
只能通过对象提供的接口来访问和操作。
这样可以实现数据的隐藏和安全访问。
2.2 继承（Inheritance）：继承是面向对象的另一个重要特性，它允许一个对象继承另一个对象的属性和方法。
子类可以通过继承父类的特性来复用代码，并可进行扩展和修改。
继承提供了代码的可重用性和层次性。
2.3 多态（Polymorphism）：多态是面向对象的核心特性之一，它允许不同的对象对相同的消息做出不同的响应。
多态提供了更大的灵活性和可扩展性，使得程序可以根据运行时的上下文选择正确的处理方式。
面向对象的三种方法一、什么是面向对象编程面向对象编程(Object-oriented Programming, OOP)是一种编程范式，它以对象作为程序的基本单元，通过封装、继承和多态等特性对现实世界的事物进行建模和模拟。
面向对象编程具有代码复用性高、可维护性好、扩展性强等优点，因此在软件开发中得到广泛应用。
面向对象编程的核心理念是将问题划分为各个对象，并通过对象间的相互协作来解决问题。
二、面向对象的三种方法面向对象编程有三种常见的方法，分别是：1.继承（Inheritance）2.封装（Encapsulation）3.多态（Polymorphism）三、继承继承是面向对象编程中一种重要的机制，它可以让一个类继承另一个类的属性和方法。
被继承的类称为父类或基类，继承它的类称为子类或派生类。
继承的优点在于代码的重用性。
通过继承，子类可以获得父类的属性和方法，并且还可以在此基础上进行扩展和修改。
这样可以避免重复编写相同的代码，提高代码的可维护性和可读性。
在继承的过程中，子类可以覆盖父类的方法，实现特定的功能。
这种特性称为多态，后面会详细介绍。
继承一般分为单继承和多继承两种情况。
单继承表示一个子类只能继承一个父类，而多继承表示一个子类可以同时继承多个父类。
继承的实现在面向对象编程中，继承可以通过关键字extends来实现。
以下是一个继承的示例：class Animal {String name;void eat() {System.out.println("Animal is eating.");}}class Dog extends Animal {void bark() {System.out.println("Dog is barking.");}}在上面的例子中，Dog类继承了Animal类的属性和方法，并且还增加了新的bark 方法。
继承的应用场景继承主要应用于以下场景：1.子类和父类之间存在”is-a”的关系，即子类属于父类的一种特殊情况。
面向对象面向对象概念 OOP.面向对象不是取代面向过程的。
.类、对象。
“人”是类，“张三”是“人”这个类的对象。
类是抽象的，对象是具体的。
按钮就是类，某个按钮就是对象。
对象可以叫做类的实例（Instance）。
类就像int，对象就像10。
字段Field（和某个对象相关的变量），字段就是类的状态。
人这个类有姓名、年龄、身高等字段。
类不占内存，对象才占内存。
.方法Method，方法就是类能够执行的动作，比如问好、吃饭等。
.类的继承，类之间可以有继承关系，比如“电脑”类可以从“电器”类继承，这样的好处是“电脑”类只需要定义自己特有的字段、方法就可以，也就是只要定义内存大小、CPU型号这些字段或者弹出光驱等方法就可以。
父类(Parent)、基类(Base，基业，祖宗十八代传下来的)。
电脑类是电器类的子类(ChildClass)。
重用。
.面向对象的三个特性：封装、继承、多态。
.没有面向对象的世界中的难题。
static void Main(string[] args){/*Person p = new Person();//创建一个Person对象，用p指向它。
= "tom";p.Hight = 160;p.Age = 36;p.SayHello();}class Person{public int Hight;public int Age;public string Name;public void SayHello(){Console.WriteLine("大家好，我是{0}，我的身高是{1}，我的年龄{2}",,this.Hight,this.Age);//this.我自己的****}}static void Main(string[] args){Person1 p1 = new Person1();p1.Hight = 165;p1.Age = 20;// = "tom";//错误，Name被定义成private，不能在外部访问。
p1.GiveName("汤姆");//p1.OpenEyes();//错误，OpenEyes方法被定义成private，不能在外部访问。
p1.SayHello();}class Person1{public int Hight;public int Age;private string Name;public void GiveName(string name){if (name == "tom" || name == "汤姆"){ = name;}else{return;}}public void SayHello(){OpenEyes();Console.WriteLine("大家好，我是{0}，我的身高是{1}，我的年龄是{2}", , this.Hight, this.Age);//this.我自己的****}private void OpenEyes(){Console.WriteLine("睁开眼睛！");}}static void Main(string[] args){person2 p2 = new person2();p2.Age = 30;Console.WriteLine("年龄：{0}",p2.Age);p2.Age = -30;Console.WriteLine("年龄：{0}", p2.Age);person3 p3=new person3();p3.Age=30;p3.Age=p3.Age+1;Console.WriteLine(p3.Age);person4 p4 = new person4();p4.Age = 30;Console.WriteLine(p4.Age);person5 p5 = new person5();//p5.Age = 30;错误，属性只读。
p5.IncAge();p5.IncAge();Console.WriteLine("年龄：{0}",p5.Age);person6 p6 = new person6();p6.Age = 30; = "飞鸿";Console.WriteLine("我的号是：{0}，我的年龄：{1}",,p6.Age);}class person2{private int age;public int Age//Age中没有保存数据，数据都保存到age中了{set//赋值{if (value < 0 ||value > 200)//与public字段和属性的区别，可以设置非法值的判断{return;}else{this.age = value;//value代表用户赋值过来的值}}get//取值{return this.age;}}}class person3{public int Age{set{}get{return 3;}}}class person4//最常见的错误的类，死循环{private int age;public int Age{set{this.Age = value;}get{return this.Age;}}}class person5{private int age;public int Age//只读属性{get { return age; }}public void IncAge(){age++;}}class person6{//从.net 3.0以后，如果对输入没有限制，可以用以下方式简写属性。
public int Age{set;//编译器自动帮我生成私有字段和set,get代码块。
get;}public string Name{set;get;}}课上练习. 面向对象版聊天机器人. 机器人有不同的名字、维护自己的FullLevel，可以SayHello（我叫***），可以喂食（Eat(int foodCount)），可以对它说话（Speak），对异常情况（错误的喂饭数字，喂的太多撑死了）进行处理，有两个机器人供选择，一开始通过1、2数字选择聊天机器人。
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace面向对象的聊天机器人1{class Program{static void Main(string[] args){机器人r1 = new机器人(); = "小二";r1.Eat(5);机器人r2 = new机器人(); = "小三";r2.Eat(8);Console.WriteLine("请选择机器人：1->小二，2->小三");string s = Console.ReadLine();机器人r;if (s == "1"){r = r1;//r指向“r1指向的对象”}else{r = r2;}r.SayHello();while (true){string str = Console.ReadLine();r.Speek(str);}}}class机器人{public string Name {get;set; }private int FullLevel { get; set; }public void SayHello(){Console.WriteLine("我叫：{0}",);}public void Eat(int foodCount){if (FullLevel > 100){return;}FullLevel = FullLevel + foodCount;}public void Speek(string str){if (FullLevel <= 0){Console.WriteLine("饿死了，不说了！");return;}if (str.Contains("姓名") || str.Contains("名字")){this.SayHello();//类的方法调用同类的另一个方法}else if (str.Contains("女朋友")){Console.WriteLine("年龄小，不考虑！");}else{Console.WriteLine("听不懂！");}FullLevel--;}}}对象的引用(非常重要). i1=3;i2=i1;i1++;//i2是3. p1=new Person();p1.i=3;p2=p1;p1.i++;//p2.i是4. int、string、decimal、bool、byte等基础类型（值类型）是传递拷贝；对象（引用类型）则是传递引用。
因为基础类型不怎么占内存，而对象则比较占内存。
. 函数间传递对象。
. 为对象变量重新赋值。
p2=p1是让p2指向p1指向的对象。
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace对象的引用{class Program{static void Main(string[] args){int i = 10;int j = i;i++;Console.WriteLine(j);//int dataTime char bool等类型是值类型(ValueType)，值类型赋值的时候是传递拷贝。
person p1 = new person(20);person p2 = p1;p1.Age++;Console.WriteLine(p2.Age);//普通对象是引用类型，赋值的时候是传递引用。
IncAge(p2);Console.WriteLine(p2.Age);//传递给函数也是传递引用Console.ReadKey();}static void IncAge(person p){p.Age++;}}class person{public int Age { get; set; }public person(int age){this.Age = age;}}}构造函数. 构造函数用来创建对象，并且可以在构造函数中对对象进行初始化。
