导航:首页 > 编程语言 > net面向对象编程

❸ asp.net 是不是面向对象的网络编程

asp 和 asp.net不一样的 我以前也是学asp的 但是发现入门不是很容易 首先还是要学学面向对象的思想 可以学C# 结合一些入门的书学起来可能好一些
你要学的大概有
VisualStudio 2005或者2008工具使用
C#语法
asp.Net的那些对象和asp的那些很相似 相信你学过asp也不难的
主要还是VS工具的熟练应用和常用的一些控件
以上基本上可以帮你入门

至于你说的区别 基本上在布局方面还是采用HTML控件比如表格.文字.Div
而在编程方面都是服务器控件 我现在基本上都永不到html那些控件了
在VS里面应该说100%我现在都是拖动那些服务器控件
区别就是一个能通过.cs编程 而一个你就需要用js脚本来编程

❹ .net(C#)和VC.net的区别

我带你详细分析一下Vc.net 和 .net(C#)的区别。
首先 这是两种不同的语言C++ 和 C#。 但狭义上的Vc.net 和 .net(C#)在同一个.net平台。
所谓 VC.net就是 c++/cli。拥有一些新的C++语法，但同时兼容ANSI C++的标准，保留了传统开发的可延续性。
而C# 语言 只能在.net平台下开发。

以下是我的建议：
如果你要程序的高效性，同时兼顾.net框架，且要使用传统非托管语言（及pascal,gcc/g++,basic）的某些功能，建议使用c++/cli。
如果你完全在.net框架下开发，保证程序的完全面对对象性能，C#的优越性超过了C++，可以是你的工作更高效。

❺ .NET团队“每周一题”（二）——面向对象编程的特点

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø 实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø 可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

❻ .net平台上怎么理解“面向对象”的概念

1。类与实例（面向对象编程--Object-Oriented Programming）对象是一个自包含的实体，用一组可识别的特性和行为来表示。类就是具有相同的属性和功能的对象的抽象的集合。实例就是真实的对 象，实例化就是创建对象的过程，使用new关键字类创建。

2。构造方法构造方法又叫构造函数，其实就是对类进行初始化。构造方法与类同名，无返回值，也不需要void， 在new时候调用。所有类都有构造方 法，如果你不编码则系统默认生成空的构造方法，若你 有定义的构造方法，那么默认的构造方法就会失效了。

3。方法重载方法重载提供了创建同名的多个方法的能力，但这些方法需要使用不同的参数类型。（并不是只有构造方 法可以重载，普通方法也是可以重载的）方法重载时，两个方法必须要方法名相同，但参数类型或个数必须要有所不同。

4。属性与修饰符属性是一个方法或一对方法，但在调用它的代码看来，它是一个字段，即属性适合于以字段的方式使 用方法调用的场合。字段是存储类要满足其设计所需要的数据，字段是与类相关的变量。

5。封装每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己 的操作。

第一，良好的封装能够减少耦合；

第二，类内部的实现可以自由地修改；

第三，类具有清晰的对外接口。

6。继承对象的继承代表了一种‘is-a’的关系，如果对象A和B，可以描述为‘B’是‘A’，则表明B可以继 承A。实际上，继承者可以理解为是对 被继承者的特殊化，因为它除了具有被继承者的特性外，还具有自己独有的个性。

如果子类继承于父类，第一，子类拥有分类非private的属性和功能；第二，子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能；第 三，子类还可以以自己的方式实现父类的功能（方法重写）子类从它的父类中继承的成员有方法，域，属性，事件，索引指示器，但对于构造方法，有一些 特

殊它不能被继承，只能被调用。对于调用父类的成员，可以用base关键字。继承是有缺点的，那就是父类变，则子类不得不变；继承会破坏包装，父类实 现细节暴露给子类，其实质是增大了两个类间的耦合性。当两个类之间具备‘is-a’的关系时，就可以考虑用继承了，但当是‘has-a’关系时就不适合用 继承了。

7。多态表示不同的对象可以执行相同的动作，但要通过他们自己的实现代码来执行。

第一，子类以父类的身份出现

第二，子类在工作时以自己的方式来实现

第三，子类以父类的身份出现时，子类特有的属性和方法不可以使用。为了使子类的实例完全接替来自父类的成员，父类必须将该成员声明为虚拟的。

（virtual）通常除了字段不能虚拟其他属性，事件，索引器，方法都可以虚拟。子类可以使用override关键字，将父类实现替换为自己的实 现，这就是方法重写Override或叫做方法覆盖。多态时对对象的声明必须是父类，而不是子类，实例化的对象是子类，这样才能实现多态。不同的对象可以 执行相同的动 作，但要通过它们自己的实现代码来执行。多态的原理是当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就 是 说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。

8。抽象类(abstract)c#运行把类和方法声明为abstract，即抽象类和抽象方法 （abstract）

第一，抽象类不能实例化；

第二，抽象方法是必须被子类重写的方法；

第三，如果类中包含抽象方法，那么类就必须定义为抽象类不论是否还包含其他一般方法。

抽象类拥有尽可能多的共同代码，拥有尽可能少的数据。抽象类通常代表一个抽象概念，它提供一个继承的出发点，当设计一个新的抽象类时，一定是用来继 承的，所以，在一个以继承关系形成的等级结构里面，树叶节点应当是具体类，而树枝节点均应当是抽象类。也就是说具体的类不是用来继承的

9。接口(interface)接口是把隐式公共方法和属性组合起来，以封装特定功能的一个集合。一旦类实现了 接口，类就可以支持接口所指定的所有 属性和成员。

声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的执行方式。所以接口不能实例化，不能有构造方法和字段；不能有修饰符 （eg：public，private）不能声明虚拟的或静态的等。实现接口的类就必须要实现接口中所有方法和属性。一个类可以支持多个接口，多个类也可 以支持相同的接口。

接口用interface声明，而不是class，接口名称前要加‘I',接口中的方法或属性前面不能有修饰符，方法没有方法体。抽象类与接口的异 同抽象类可以给出一些成员的实现，接口却不包含成员的实现；抽象类的抽象成员可以被子类部分实现，接口的成员需要实现类完全实现；一个类只能继承一个抽象 类，但可以实现多个接口；

第一，类时对对象的抽象；抽象类时对类的抽象；接口是对行为的抽象。接口是对类的局部（行为）进行的抽象，而抽象类是对类整体（字段，属性，方法) 的抽象。

如果只关注行为抽象，那么可以认为接口就是抽象类。总之，不论是接口，抽象类，类甚至是对象，都是在不同层次，不同角度进行抽象的结果，他们的共性 就是抽象

第二，如果行为跨越不同了类的对象，可使用接口；对于一些相似的类的对象，用继承抽象类。

第三，从设计角度讲，抽象类是从子类中发现了公共的东西，泛化出父类，然后子类继承父类，而接口是根本不知子类的存在，方法如何实现还不确认，预先 定义。

10。集合（ArrayList)可以根据使用大小按需求动态增加，不用受事先设置其大小的控制。还有就是可以 随意地添加，插入或移除某一范围元 素，比数组要方便。

ArrayList 不是类型安全的（值类型装箱到Object对象）装箱就是把值类型打包到Object引用类型的一个实例中。拆箱是指从对象中提取类型。

11.泛型是具有占位符（类型参数）的类，结构，接口和方法，这些占位符是类，结构，接口和方法所存储或使用的 一个或多个类型的占位符。

泛型集合类可以将参数型参数用作它所存储的对象的类型的占位符；类型参数作为其字段的类型和其方法的参数类型出现。通常情况下，都建议使用泛型集 合，因为我这样可以获得类型安全的直接优点而不需要从基集合类型派生并实现类型特定的成员。

此外，如果集合元素为值类型，泛型集合类型的性能通常优于对应的非泛型集合类型（并优于从非泛型基集合类型派生的类型），因为使用泛型时不必对元素 进行装箱。

12。委托和事件（delegate，event）委托时对函数的封装，可以当作给方法的特征指定一个名称。而事件则是委托的一种特殊形式，当发生 有意义的事情时，事件对象处理通知过程。委托是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。在发生其他类或对象关注的 事情时，类或对象可通过事件通知它们。

❼ 什么是 .net

正如三楼所说的.net是微软公司推出的编程框架，也可以说是一种环境。可以运用多种语言进行编程，如：C++、C#、VB、Java等。.net是用于构建Internet集成服务平台的最新框架，这种集成服务平台允许各种系统环境下的应用程序通过因特网进行通信和共享数据。.net框架主要由三个主要组成部分：公共语言运行时(CLR)、服务框架(Services Framework)、两类应用摸板(传统的Windows应用程序摸板和基于ASP.NET的面向WEB的应用程序摸板)。

❽ vb.net是面向对象的编程软件吗

不是，VB.NET 是面向过程的编程。

❾ vb. net是面向对象的编程语言是对吗

VB.net
相对VB出现巨大变化的是语意,从运行于基于COM的deterministic,
reference-counted的引擎之上的编程环境，转变为全面面向对象的基于.NET
Framework的语言。.NET
Framework包括了CLR(使用通用垃圾收集机制和JIT编译引擎的虚拟机)和大量的类库。VB开发者进入VB.NET要面对新增的大量类库的问题。
上述变化表明了许多在运行及维护相关优化事宜下面的假定，一些VB6函数和库不再存在而其它的仍然可用，但是比不上.NET语言中自带的可替换的函数和库来得高效。即使它们可被编译，但大多从VB6转换而来的应用将需要一定程度上的重构(refactoring)，以全面利用新语言的优点。在有关句法、应用调试、部署和术语等方面的变化，有大量的文档可以参考。

❿ 深入.NET面向对象编程题目，求解决

public class Employee
{
string _name;
int _age;
DateTime _begin;

public string Name
{
get { return _name; }
set { _name = value; }
}
public int Age
{
get { return _age; }
set { _age = value; }
}
public DateTime Begin
{
get { return _begin; }
set { _begin = value; }
}

public Employee()
{

}

public Employee(string name, int age, DateTime begin)
{
this._name = name;
this._age = age;
this._begin = begin;
}

public virtual void SayHi()
{
Console.WriteLine("hi,我是一个普通员工");
}
}

public class Programmer : Employee
{
List<string> _language;
public List<string> Language
{
get { return _language; }
set { _language = value; }
}

public Programmer()
{
}

public Programmer(string name, int age, DateTime begin, List<string> language)
: base(name, age, begin)
{
this._language = language;
}

public override void SayHi()
{
Console.WriteLine("hi,我是一个程序员");
}
}

public class Manager : Programmer
{
List<string> _project;
public List<string> Project
{
get { return _project; }
set { _project = value; }
}

public Manager()
{
}

public Manager(string name, int age, DateTime begin, List<string> language, List<string> project)
: base(name, age, begin, language)
{
this._project = project;
}

public override void SayHi()
{
Console.WriteLine("hi,我是一个项目经理");
}
}