面向对象特征提取
面向对象特征提取
1、启动eCognition，选择Rule Set Mode。
2、新建工程：File -> New Project或者点击按钮，选择影像or_196560080.tif，确定。
3、界面布局：选择Classification -> Class Hierarchy，打开类层次视图；选择Image Objects -> Image Objects Information，打开目标信息视图；选择Process -> Process Tree，打开进程树视图；选择Tools -> Feature View，打开特征视图。通过拖拽，形成下面的工作界面：
4、设置尺度参数：设置三个分割尺度，分别是100，70，50，三个尺度对应的层次分别命名为L1，L2，L3。
5、第一尺度（100）分割：在Process Tree中右键，选择Append New，在Algorithm中选择Segmentation -> multiresolution segmentation，Image Object Domain中选择Pixel Level，而Algorithm parameters中的Level Name命名为L1，Scale Parameter设为100，Shape设为0.2，
Compactness设为0.5，如下图所示：
点击OK后，Process Tree中会多出一条记录，如下：
在该记录上点击右键，选择Execute，即按照设定的参数进行分割，分割的效果如下：
6、第二尺度（70）分割：在eCognition的尺度分层规则中，大尺度对应的层摆在最上面，小尺度的层摆在下面。在Process Tree中右键，选择Append New，在Algorithm中选择Segmentation -> multiresolution segmentation。由于第二尺度对应为第二层次，因此其应该在第一层（L1）下面，所以Image Object Domain中选择image object level，Level设置为L1，而Algorithm parameters中的Level Name命名为L2，Level Usage 设置为Create below，Scale Parameter设为70，Shape设为0.2，Compactness设为0.5，如下图所示：
按第5步的步骤运行该尺度的分割，可以得到该尺度下的分割结果。
7、第三尺度（50）分割：与第6步一样，只不过Image Object Domain中的Level设置为L2，Algorithm parameters中的Level Name设置为L3，Scale parameter设置为50，如下图：
在Process Tree中右键点击Execute后得到该尺度下的分割结果。双击Process Tree中的每一条记录，或者在记录上右键单击Edit，可以修改该分割参数，重新Execute后可以得到新的分割结果。在修改过程中，层之间的关系不能随意调整。
8、视图切换：有以下几个视图切换比较常用，，第一个是层视图，用于查看原始影像；第二个是分类视图，用于查看分类结果；第三个是样本视图，用于查看样本；第四个是特征视图，用于查看特征。，都是用来显示分割目标的边界。用来显示原始图像或者均值图像。，通过这个上下箭头来显示不同的层。9、特征提取：eCognition中对特征的提取是在某一尺度下进行的。由于不同地物在不同尺度上分割出来的目标具有不同的形态特征，比如颜色、形状、纹理等，通过这些特征可以在不同尺度上提取地物的特征。例如道路等具有明显长条形状，适合在大尺度上提取，而房屋的形态适合在小尺度上提取。在Feature View视图中，选择一个特征，双击，分割影像会显示出相应的特征，单击影像上的一个目标，会显示该目标在该特征上的值。例如双击Object
Features -> Layer Values -> Mean -> Layer 3，影像的该层的特征，如下图：
与原始影像比对可以看出，草地和湖泊在该特征上的值很小，显示得很暗，而道路和房屋的值很大，显示得很亮，因此在此尺度上可以很好区分草地湖泊与道路房屋；而双击Object Features -> Geometry -> Extent -> Length/Width，可以看出道路在这个特征上的值很
大，显示得很亮，因此可以通过这个特征将道路与其他地物区分开。
影像对象，如下图：
征，才能更好地提取不同的地物，也才能为后续的影像分类打好基础。
面向对象三大基本特性,五大基本原则
透切理解面向对象三大基本特性是理解面向对象五大基本原则的基础 三大特性是：封装,继承,多态 所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。 所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力； 所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。 五大基本原则 单一职责原则SRP(Single Responsibility Principle) 是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一
面向对象的三个基本特征讲解
面向对象的三个基本特征是：封装、继承、多态。 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程(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的话：“不要犯傻，如果它不是晚邦定，它就不是多态。” 那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。 概念讲解 泛化（Generalization）
面向对象的三大特性
面向对象的三大特性 收藏 面向对象的三个基本特征是：封装、继承、多态。 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 在Java中类中成员的属性有：public，protected，
面向对象特征提取
面向对象特征提取 1、启动eCognition，选择Rule Set Mode。 2、新建工程：File -> New Project或者点击按钮，选择影像or_196560080.tif，确定。
3、界面布局：选择Classification -> Class Hierarchy，打开类层次视图；选择Image Objects -> Image Objects Information，打开目标信息视图；选择Process -> Process Tree，打开进程树视图；选择Tools -> Feature View，打开特征视图。通过拖拽，形成下面的工作界面：
4、设置尺度参数：设置三个分割尺度，分别是100，70，50，三个尺度对应的层次分别命名为L1，L2，L3。 5、第一尺度（100）分割：在Process Tree中右键，选择Append New，在Algorithm中选择Segmentation -> multiresolution segmentation，Image Object Domain中选择Pixel Level，而Algorithm parameters中的Level Name命名为L1，Scale Parameter设为100，Shape设为0.2， Compactness设为0.5，如下图所示： 点击OK后，Process Tree中会多出一条记录，如下：
在该记录上点击右键，选择Execute，即按照设定的参数进行分割，分割的效果如下： 6、第二尺度（70）分割：在eCognition的尺度分层规则中，大尺度对应的层摆在最上面，小尺度的层摆在下面。在Process Tree中右键，选择Append New，在Algorithm中选择Segmentation -> multiresolution segmentation。由于第二尺度对应为第二层次，因此其应该在第一层（L1）下面，所以Image Object Domain中选择image object level，Level设置为L1，而Algorithm parameters中的Level Name命名为L2，Level Usage 设置为Create below，Scale Parameter设为70，Shape设为0.2，Compactness设为0.5，如下图所示： 按第5步的步骤运行该尺度的分割，可以得到该尺度下的分割结果。 7、第三尺度（50）分割：与第6步一样，只不过Image Object Domain中的Level设置为L2，Algorithm parameters中的Level Name设置为L3，Scale parameter设置为50，如下图：
面向对象的三大特性
面向对象的三大特性 类：属性（变量）和方法 一、封装 1．定义：封装最简单的理解就是包装，指隐藏对象的属性和实现细节，仅仅对外公开接口，即对象的内部状态对外界是透明的。 2．原则：“该隐藏的一定要隐藏，该公开的一定要公开。” *对象的属性尽可能的私有，根据需要配上相应的get/set方法。 *对象的方法根据需要决定是否公开，公开的是声明，隐藏的是实现。意义：使方法实现的改变对架构的影响最小化。 二、继承 1．定义：是一种由已存在的类型创建一个或多个子类型的机制. 2．父类到子类是从一般到特殊的关系。 *泛化：将不同子类中的共性抽象成父类的过程。 *特化：在原有父类的基础上加入一些个性的过程。 *原则：父类放共性，子类放个性。 3．继承的关键字：extends 4．Java 只支持单继承：一个类最多只有一个直接的父类。 *注：父子类之间的关系是树状关系，而多继承是网状关系。 5．父类中的私有属性可以继承但是不能访问，也可以说父类中的私有属性子类不能继承。 6. 访问权限： 宽 | public 全部类可见 | protected本类可见，同包类可见，子类可见 | default 本类可见，同包类可见 | private 本类可见
严 private：本类内部可以访问，不能继承到子类。 *能否继承到子类？不能 default：本类内部可以访问，同包其他类也可以访问。 protected：本类内部可以访问，不同包的子类也可 以访问，同包其他类也可以访问。 *能否继承到子类？能继承到子类 public：任何地方都可以访问 *能否继承到子类？能继承到子类 7.方法覆盖(Override)： *方法名：相同 *参数表：相同 *访问限制符：相同或者更宽 *返回值类型：相同或者子类返回的类型是父类返回 的类型的子类（在JDK5.0 以后） *抛出的异常：以后再说。 8.属性遮盖：属性不能够被覆盖。 9.super 关键字 *super（）表示调用父类的构造方法。 *super（）也和this 一样必须放在方法的第一句。 *super 可以屏蔽子类属性和父类属性重名时带来的属性遮盖，super. 表示调用父类的方法或属性。 *在子类的构造函数中如果没有指定调用父类的哪一个构造方法，那么就会调用父类的无参构造方法，即super（）。 10.带继承关系的子类对象创建的过程 1）类加载，初始化静态属性（零值）和执行静态代码 块，顺序为：先父类后子类； 2）分配空间； 3）初始化属性（零值）和执行普通代码块； 4）调用本类的某一个构造方法（递归地构造父类对 象），顺序为：先父类后子类。 三、多态（美女、汽车） 1．定义：指引用变量拥有许多不同形式的能力 2．多态分为两种：编译时多态和运行时多态。 *编译时类型：主观概念，把它看作什么。 *运行时类型：客观概念，实际它是什么。 例：Animal a=new Dog(); 指着狗问，这个动物是什么动物？ 3．运行时多态的三原则： *对象类型不变。
遥感专题讲座——影像信息提取(四、面向对象特征提取)
面向对象的影像分类技术 “同物异谱，同谱异物”会对影像分类产生的影响，加上高分辨率影像的光谱信息不是很丰富，还有经常伴有光谱相互影响的现象，这对基于像素的分类方法提出了一种挑战，面向对象的影像分类技术可以一定程度减少上述影响。 本小节以ENVI中的面向对象的特征提取FX模块为例，对这种技术和处理流程做一个简单的介绍。 本专题包括以下内容： ??●面向对象分类技术概述 ??●ENVI FX简介 ??●ENVI FX操作说明 1、面向对象分类技术概述 面向对象分类技术集合临近像元为对象用来识别感兴趣的光谱要素，充分利用高分辨率的全色和多光谱数据的空间，纹理，和光谱信息来分割和分类的特点，以高精度的分类结果或者矢量输出。它主要分成两部分过程：影像对象构建和对象的分类。
影像对象构建主要用了影像分割技术，常用分割方法包括基于多尺度的、基于灰度的、纹理的、基于知识的及基于分水岭的等分割算法。比较常用的就是多尺度分割算法，这种方法综合遥感图像的光谱特征和形状特征，计算图像中每个波段的光谱异质性与形状异质性的综合特征值，然后根据各个波段所占的权重，计算图像所有波段的加权值，当分割出对象或基元的光谱和形状综合加权值小于某个指定的阈值时，进行重复迭代运算，直到所有分割对象的综合加权值大于指定阈值即完成图像的多尺度分割操作。 影像对象的分类，目前常用的方法是“监督分类”和“基于知识分类”。这里的监督分类和我们常说的监督分类是有区别的，它分类时和样本的对比参数更多，不仅仅是光谱信息，还包括空间、纹理等信息。基于知识分类也是根据影像对象的熟悉来设定规则进行分类。 目前很多遥感软件都具有这个功能，如ENVI的FX扩展模块、易康（现在叫Definiens）、ERDAS的Objective模块、PCI的FeatureObjeX（新收购）等。 表1为三大类分类方法的一个大概的对比。
面向对象的三个基本特征和概念
面向对象的三个基本特征（讲解） 面向对象的三个基本特征是：封装、继承、多态。 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程 (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的话：“不要犯傻，如果它不是晚邦定，它就不是多态。” 那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
java面向对象的三个特征
使用java面向对象编程的三大特征 大多数新人，在才开始学习java面对对象编程的过程中对于这一块的三大特征一直比较模糊，基本都是刚开始学习接触编程，一个人跌跌撞撞摸索着往前走，初学的时候很多东西理解的也懵懵懂懂，后来实践的多了，有些东西才慢慢清楚；二是经过一定的实践之后，反过头来再去学习一些基础东西才能够理解的更透彻；三是有些东西基础但是确很重要，是值得好好搞一搞的。 1、面向对象 面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。 2、对象 对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。 3、类 类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。 Java中的类实现包括两个部分：类声明和类体。 类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。 当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc()要求垃圾回收时，垃圾回收线程与系统同步运行。 向对象的三个基本特征是：封装、继承、多态。 4、封装 封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。 可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。 private：类中限定为private的成员，只能被这个类本身访问。如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。 default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
面向对象三个基本特征
封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程(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的话：“不要犯傻，如果它不是晚邦定，它就不是多态。” 那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
面向对象的三大基本特征,五大基本原则
面向对象的三大基本特征，五大基本原则 网上的讲解很多，但大都类似，这里进行转载整理。三大基本特征是理解五大基本原则的前提。 一、三大基本特征：封装、继承、多态 1、封装 封装就是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。 面相对象的不就是使用程序处理事情时以对象为中心去分析吗，与面向过程不同，面向过程关心处理的逻辑、流程等问题，而不关心事件主体。而面向对象即面向主体，所以我们在解决问题时应该先进行对象的封装（对象是封装类的实例，比如张三是人，人是一个封装类，张三只是对象中的一个实例、一个对象）。比如我们日常生活中的小兔子、小绵羊都可以封装为一个类。 比如兔子的属性有两只耳朵、四只腿、一双眼睛、三瓣嘴等；行为（功能）有跑、跳、吃素等。 2、继承
继承是面向对象的基本特征之一，继承机制允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。类似下面这个图： 我们在上面已经封装了兔子这个类，其他动物也一样可以进行封装。在封装过程中我们发现兔子、绵羊这两个类具有相似的功能或特性如吃草，所以我们可以抽取共有特征和方法形成高一层的类，如这里的食草动物、食肉动物。继承之间是子父类的关系。继承机制可以很好的描述一个类的生态，也提高了代码复用率，在Java中的Object类是所有类的超类，常称作上帝类。 3、多态 多态同一个行为具有多个不同表现形式或形态的能力。是指一个类实例（对象）的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。 多态的优点： 1.消除类型之间的耦合关系 2.可替换性 3.可扩充性 4.接口性 5.灵活性 6.简化性 多态存在的三个必要条件：
1面向对象变成的特征
1.面向对象变成的特征: 1.抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。比如，我们要设计一个学生成绩管理系统，考察学生这个对象时，我们只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。抽象包括两个方面，一是过程抽象，二是数据抽象。过程抽象是指任何一个明确定义功能的操作都可被使用者看作单个的实体看待，尽管这个操作实际上可能由一系列更低级的操作来完成。数据抽象定义了数据类型和施加于该类型对象上的操作，并限定了对象的值只能通过使用这些操作修改和观察。 2.继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。这也体现了大自然中一般与特殊的关系。继承性很好的解决了软件的可重用性问题。比如说，所有的Windows 应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。 3.封装： 封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。一旦定义了一个对象的特性，则有必要决定这些特性的可见性，即哪些特性对外部世界是可见的，哪些特性用于表示内部状态。在这个阶段定义对象的接口。通常，应禁止直接访问一个对象的实际表示，而应通过操作接口访问对象，这称为信息隐藏。事实上，信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。 4. 多态性： 多态性是指允许不同类的对象对同一消息作出响应。比如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同。又比如，同样的选择编辑-粘贴操作，在字处理程序和绘图程序中有不同的效果。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 够详细了吧。答案补充但是要真正理解什么是面向对象，只看它的特点不一定能搞清楚，还是要在运用中多接触才能更深一步的理解。 2.java的基本类型变量: 基本类型（primitive type） 基本数据类型的变量包含了单个值，这个值的长度和格式符合变量所属数据类型的要求，可以是一个数字、一个字符或一个布尔值，例如一个整型值是32位的二进制补码格式的数据，而一个字符型的值是16位的Unicode字符格式的数据等。 3.string strvalue=”abcdefg”; strvalue.substring(3);
面向对象的特点
面向对象的特点、 答案：.信息隐藏和封装特性： 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。 2.继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。 3.组合特性 组合用于表示类的“整体/部分”关系。例如主机、显示器、键盘、鼠标组合成一台计算机。 4.动态特性 （1）抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 （2）多态性： 多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 九九乘法表的输出 答案：public class KY2_11 { public static void main(String args[]) { int i=0,j=0; int sq=0; for(i=1;i<=9;i++) { for(j=1;j<=i;j++) { sq=i*j; System.out.print(j+"*"+i+"="+sq+" "); if(i==j) { System.out.println(); } } } } } 还有单例模式 System.out.println (Singleton.getInstance()); System.out.println (Singleton.getInstance()); main 函数中有这两句，一摸一样。 第一句执行的时候，第一次调用getInstance()，意思是要获取Singleton的一个对象实例。 而正常情况下，我们要获取对象的话是用 new Singleton()，这个方法的，但是这个方法在Singleton里面被声明为：private ，意思是外界不能调用。 不能调用，我怎么用你的对象？ Singleton里面实现了生成对象的方法，getInstance(),你要用他的对象就必须调用这个方法。
面向对象的三个基本特征详解
面向对象的三个基本特征详解 面向对象的三个基本特征是：封装、继承、多态。 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程(OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”。 被继承的类称为“基类”、“父类”或“超类”。 继承的过程，就是从一般到特殊的过程。 要实现继承，可以通过“继承”(Inheritance)和“组合”(Composition)来实现。 在某些OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。 继承概念的实现方式有三类：实现继承、接口继承和可视继承。 1、实现继承是指使用基类的属性和方法而无需额外编码的能力; 2、接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力; 3、可视继承是指子窗体(类)使用基窗体(类)的外观和实现代码的能力。 在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。
例如，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的话：“不要犯傻，如果它不是晚邦定，它就不是多态。” 那么，多态的作用是什么呢?我们知道，封装可以隐藏实现细节，使得代码模块化; 继承可以扩展已存在的代码模块(类); 它们的目的都是为了——代码重用。而多态则是为了实现
面向对象语言有哪3个特性
1.面向对象语言有哪3个特性？《封装、继承、多态。 2.什么时候使用构造方法？构造方法有类型吗？《《用类创建对象时；没有类型。 3.类中的实例变量在什么时候会被分配内存空间？《《用类创建对象时。 4.什么叫方法的重载？构造方法可以重载吗（一个类中可以有多个方法具有相同的名字， 但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。可以。）5.类中的实例方法可以操作类变量（static变量）吗？类方法（static方法）可以操作实例 变量吗？《可以；不可以。 6.类中的实例方法可以用类名直接调用吗？《《不可以。 7.简述类变量和实例变量的区别《《一个类通过使用new运算符可以创建多个不同的对象， 不同的对象的实例变量将被分配不同的内存空间。所有对象的类变量都分配给相同的一处内存，对象共享类变量。 8.this指针关键字代表什么？this可以出现在类方法中吗？《《代表调用当前方法的对象。 不可以。 1.子类可以有多个父类吗？《《不可以。 https://www.360docs.net/doc/413390767.html,ng包中的Object类是所有其他类的祖先类吗？是 3.如果子类和父类不在同一个包中，子类是否继承父类的友好成员？不继承 4.子类怎样隐藏继承的成员变量？声明与父类同名的成员变量 5.子类重写方法的规则是怎样的？重写方法的目的是什么？《》子类重写的方法类型和父 类的方法的类型一致或者是父类的方法的类型的子类型，重写的方法的名字、参数个数、参数的类型和父类的方法完全相同。重写方法的目的是隐藏继承的方法，子类通过方法的重写可以吧父类的状态和行为改变为自身的状态和行为。 6.父类的final方法可以被子类重写吗？《《《不可以 7.什么类中可以有abstract方法？《《Abstract类 8.对象的上转型对象有怎样的特点？《《上转型对象不能操作子类新增的成员变量，不能 调用子类新增的方法。上转型对象可以访问子类继承或隐藏的成员变量，可以调用子类继承的方法或子类重写的实例方法。 9.一个类的各个子类是怎样体现多态的？《《通过重写 10.面向抽象编程的目的和核心是什么？《《面向抽象编写的目的是为了应对用户需求的变 化，核心是让类中每种可能的变化对应地交给抽象类的一个子类类去负责，从而让该类的设计者不去关心具体实现。 1.接口中能声明变量吗？《《不能 2.接口中能定义非抽象方法吗？《《不能 3.什么叫接口的回调？《《可以把实现某一接口的类创建的对象的引用赋给该接口声明的 接口变量中。那么该接口变量就可以调用被类实现的接口中的方法。 4.接口中的常量可以不指定初值吗？《《不可以 5.可以在接口中只声明常量，不声明抽象方法吗？《《可以 1.内部类的外嵌类的成员变量在内部类中仍然有效吗？》》有效 2.内部类中的方法也可以调用外嵌类中的方法吗？《《可以 3.内部类的类体中可以声明类变量和类方法吗？《《不可以 4.匿名类一定是内部类吗？《《一定是 1.
面向对象编程的三大特征
面向对象有3大特征：封装、继承、多态。 什么是封装呢？封装就是将属性私有化，提供公有的方法访问私有属性。实现了封装后，就给每个属性一对赋值方法给取值方法，可以在方法中加入对属性的存取限制，也可以根据需要将这两个方法单独存在，这样就提高了程序的维护性。 什么是继承？举一个例子：教师类包括Java老师、c#老师。他们的授课内容不同，但是他们都属于同一所学校。我们可以把授课看做是方法，把属于的学校看成是属性。我们可以抽象出一个教师类做父类，抽象出Java老师、c#老师做子类，让Java 老师、c#老师去继承父类的学校属性，而单独实现授课的方法。这就是父类跟子类的关系。 什么是多态？多态是面向对象思想的核心。可是做到同一个接口，使用不同的实例而执行不同的操作。同样拿教师类举例。我们可以在父类教师类里定义授课方法，然后在子类里将授课方法重写。在具体实现的时候，可以根据需要将父类做为类型去创建不同的对象，根据不同的对象去调用各自重写的方法。 面向对象编程可以使代码维护方便、可扩展性好、支持代码重用技术等等。面向对象编程并非通过一两天的学习或听一次课就能掌握的。这就需要我们不断地分析，不断地进行实际的编程
练习，从而能的掌握面向对象程序设计。 我认为如果真的能把面向对象编程彻底的理解了，吃透了。那么我们编的程序结构会更加清晰完整，更加容易维护与管理。面向对象编程(object-oriented programming)是一种编程语言模式，它能够很好的将现实世界里的一切通过计算机完成。会涉及到很多知识，如类、对象、继承、封装、多态、重载等等。 现实生活里的所有物体都可以看成是一个对象。所有的对象又能做一个归纳。如人类、汽车类、植物类。。。。。人类又可以根据不同的工作性质分了警察类、教师类、学生类。。。。教师类还可以根据教授的课程细分，如Java老师、c#老师等等。 每一个对象都有他的特征跟行为。我们可以把特征看做是属性、把行为看做是方法。如老师的姓名、年龄是特征，老师教书是行为，则姓名、年龄就是教师类的属性，教书就是教师类的方法。 在我们面向对象编程的过程中，第一步是定义所要操作的所有对象以及它们之间的相互联系。类是对象的类型，定义了一个类就定义了一个数据类型。一个教师姓名是张三丰，则这个叫张三丰的老师就是一个具体的对象，他的数据类型就是老师。一个