精华内容
下载资源
问答
  • Python类和对象1

    2020-12-22 11:44:40
    面向对象中的对象(Object),通常指客观世界存在对象对象具有唯一性,对象之间各不相同,各有特点,每个对象有自己的运动规律内部状态。 对象对象之间相互联系,相互作用,对象也可以是一个抽象事物,时间万物皆...
  •  把数据影响这个数据的操作聚合成一个对象行为称为“封装”  封装隐藏对象的属性实现细节,公对公开接口,控制程序中属性的读修改的访问级别  从外视图看,在一个对象内封装的数据是隐藏的   封装
  • 面向对象概念基本特征

    千次阅读 2018-07-23 16:24:51
    所谓的面向对象就是基于对象概念,以对象为中心,以类继承为构造机制,来认识、理解刻画客观世界设计、构建相应的软件系统。 OO (Object Oriented, 面向对象)是当前计算机界关心的重点,它是90年代软件开发的...

    1 ,什么是面向对象?

    正如每个人心中都有一个哈姆雷特一样,每个人都有对面向对象的不一样的理解

    所谓的面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。

    OO (Object Oriented, 面向对象)是当前计算机界关心的重点,它是90年代软件开发的主流。面向对象的概念和应用已经超越了程序设计和软件开发,扩展到很宽的范围。如数据库系统、交互式界面、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

    OO方法(Object-Oriented Method,面向对象方法)面向对象的方法是一种把面向对象的实现应用于软件开发过程中,指导开发活动的系统方法,简称OO(Object-Oriented)方法,Object Oriented是建立在“对象”概念基础上的方法学。对象是由数据和容许的操作组成的封装体,与客观实体有直接对应关系,一个对象类定义了具有相识性质的一组对象。而每继承性是具有层次关系的类的属性和操作进行共享的一种方式。所谓的面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。

    (我会在介绍完js中对象的特征后面继续介绍面向对象方法,转的一句话说明什么事面向对象方法,让你对面向对象有一个更深入的了解!)

    2 ,JS中的面向对象的基本特征

    面向对象的三个基本特征是:封装、继承、多态。在js中面向对象只有封装和继承,没有多态。

    封装:通过将一个方法或者属性声明为私用的,可以让对象的实现细节对其他对象保密以降低对象之间的耦合程度,可以保持数据的完整性并对其修改方式加以约束这样可以使代码更可靠,更易于调试。封装是面向对象的设计的基石。

    JavaScript是一门面向对象的语言,可它并不具备将成员声明为公共或私用的任何内部机制,所以我们只能自己想办法实现这种特性。下面还是通过一台完整的代码去分析,介绍什么是私有属性和方法,什么是特权属性和方法,什么是公有属性和方法,什么是公有静态属性和方法。

    私有静态属性和方法: 函数有作用域,在函数内用var 关键字声明的变量在外部无法访问,私有属性和方法本质就是你希望在对象外部无法访问的变量。

    特权属性和方法:创建属性和方法时使用的this关键字,因为这些方法定义在构造器的作用域中,所以它们可以访问到私有属性和方法;只有那些需要直接访问私有成员的方法才应该被设计为特权方法。

    公有属性和方法:直接书写在原型prototype上的属性和方法,不可以访问构造器内的私有成员,可以访问特权成员,子类会继承所有的公有方法。

    公有静态属性和方法:最好理解的方式就是把它想象成一个命名空间,实际上相当于把构造器作为命名空间使用。

     /* -- 封装 -- */
        var _packaging =function(){
           //私有属性和方法
          var name ='Darren';
           var method1 =function(){
              //...
           }
           //特权属性和方法
           this.title ='JavaScript Design Patterns' ;
          this.getName =function(){
             return name;
          }
       }
       //公有静态属性和方法
       _packaging._name ='Darren code';
       _packaging.alertName =function(){
          alert(_packaging._name);
       }
       //公有属性和方法
       _packaging.prototype = {
          init:function(){
             //...
          }
       }

    继承:继承是指这样一种能力:他可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

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

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

    ① 构造函数绑定

    这一种方法最简单,使用call 或者 apply 方法,将父对象的构造函数绑定在子对象上,既在子对象构造元素中加一行代码:

    父类构造函数名.apply(this, arguments);

    Person.prototype.getName = function(){
        returnthis.name;
    }
    function Programmer(name,sex) {
        Person.call(this,name);  //在这里添加
        this.sex = sex;
    }

    ② 原型式继承 让子类的prototype对象指向父类的实例,相当于完全删除了prototype对象的原来的值,但是我们需要在原型继承js语句后面加上段代码 : 子类. prototype.constructor = 子类  ,不然子类的原型对象的构造函数属性就会指向所继承的父类prototype上的constructor(直接继承父类的原型的时候),继承父类的实例的时候回丢失constructor属性,继承完成之后当前这个子类的实例也都可以继承父类的prototype上的方法

       //直接继承父类原型
        function Parent(name) {
     		this.name = name;
     	}
     	Parent.prototype.sayHello = function() {
     		console.log("hello");
     	}
     	function Son(name) {
     		this.name = name;
     	}
     	Son.prototype = Parent.prototype;
     	Son.prototype.constructor = Son;//不加这句话Son.prototype.constructor指向Parent
     	var s = new Son();
     	s.sayHello()//hello
    // 原型式继承改进 
     	function Parent(name) {
     		this.name = name;
     	}
     	Parent.prototype.sayHello = function() {
     		console.log("hello");
     	}
     	function Son(name, age) {
     		this.name = name;
     		this.age = age;
     	}
     	Son.prototype.sayHi = function() {
     		console.log("hi");
     	}
     	Son.prototype = new Parent(); //原型继承改进继承父类的实例
     	Son.prototype.constructor = Son;//不加这句话Son.prototype.constructor会丢失
     	var s = new Son();
     	var p = new Parent();
     	s.sayHello()//hello
     	console.log(Son.prototype)
     	p.sayHi()// Uncaught TypeError: p.sayHi is not a function,父类的实例不可以调用子类的方法了

    js中对象的组成

        方法——函数:过程、动态的
        属性——变量:状态、静态的

    下面列举一些别人描述面向对象的思想

    1 ,把一组数据结构和处理它们的方法组成对象(object),把相同的对象归纳为类(class),通过类的封装(encapsulation)隐藏内部细节,通过继承(inheritance)实现类的特化(specialization) / 泛化 (generalization),通过多态(polymorphism)实现基于对象类型的动态分派(dynamic dispatch)。

    2,一种尽量降低后续扩展代码引入 side-effect 可能的代码组织手段

    3,封装:把属性值、红蓝条、攻击、走位、放技能、清兵、游走等行为都塞在一个英雄里。

    ,继承:攻击+10 的装备可以升级到攻击+20,以后还可能升级到攻击+30 并带有吸血效果。不管升级成什么,都携带着攻击+10 这部分属性。

    多态:一个团队需要一个辅助,我们只需要一个辅助英雄,并不关心来的是哪个辅助英雄,能加血就行。

    具备这三种特性的编程思想,叫做面向对象。
     

    展开全文
  • 对象是类的一个实例,有状态和行为。例如,一条狗是一 个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。  类:类是一个模板,它描述一类对象行为和状态。  二Java中的对象  现在让我们深入...

           一类和对象的概念

           对象:对象,万物皆对象,客观存在的事物皆为对象。对象是类的一个实例,有状态和行为。例如,一条狗是一

    个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。

           类:类是一个模板,它描述一类对象的行为和状态。

           二Java中的对象

           现在让我们深入了解什么是对象。看看周围真实的世界,会发现身边有很多对象,车,狗,人等等。所有这些对

    象都有自己的状态和行为。

           拿一条狗来举例,它的状态有:名字、品种、颜色,行为有:叫、摇尾巴和跑。

           对比现实对象和软件对象,它们之间十分相似。

           软件对象也有状态和行为。软件对象的状态就是属性,行为通过方法体现。

           在软件开发中,方法操作对象内部状态的改变,对象的相互调用也是通过方法来完成。

           三Java中的类

           类可以看成是创建Java对象的模板。

           通过下面一个简单的类来理解下Java中类的定义:

    <span style="font-size:18px;">public class Dog{
       String breed;
       int age;
       String color;
       void barking(){
           //
       }
        
       void hungry(){
           //
       }
        
       void sleeping(){
            //
       }
    }</span>

            一个类可以包含以下类型变量:

            A局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方

    法结束后,变量就会自动销毁。

            B成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被

    类中方法、构造方法和特定类的语句块访问。

            C类(静态)变量:类变量也声明在类中,方法体之外,但必须声明为static类型。

            一个类可以拥有多个方法,在上面的例子中:barking()、hungry()和sleeping()都是Dog类的方法。

            四构造方法

            每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认构造方法。

            在创建一个对象的时候,至少要调用一个构造方法。构造方法的名称必须与类同名,一个类可以有多个构造方

    法。

            下面是一个构造方法示例:

    <span style="font-size:18px;">public class Puppy{
       public Puppy(){
       }
     
       public Puppy(String name){
          // 这个构造器仅有一个参数:name
       }
    }</span>

             五创建对象

             对象是根据类创建的。在Java中,使用关键字new来创建一个新的对象。创建对象需要以下三步:

             A声明:声明一个对象,包括对象名称和对象类型。

             B实例化:使用关键字new来创建一个对象。

             C初始化:使用new创建对象时,会调用构造方法初始化对象。

             语法格式:类名 对象名=new 类名();

             下面是一个创建对象的例子:

    <span style="font-size:18px;">public class Puppy{
       public Puppy(String name){
          //这个构造器仅有一个参数:name
          System.out.println("Passed Name is :" + name ); 
       }
    
       public static void main(String []args){
          // 下面的语句将创建一个Puppy对象
          Puppy myPuppy = new Puppy( "tommy" );
       }
    }</span>

            编译并运行上面的程序,会打印出下面的结果:


            六访问实例变量和方法

            通过已创建的对象来访问成员变量和成员方法,如下所示:

    <span style="font-size:18px;">//实例化对象 
    ObjectReference = new Constructor();
    //访问其中的变量 
    ObjectReference.variableName;
    //访问类中的方法 
    ObjectReference.MethodName();</span>
            实例

            下面的例子展示如何访问实例变量和调用成员方法:

    <span style="font-size:18px;">public class Puppy{
       int puppyAge;
    
       public Puppy(String name){
          // 这个构造器仅有一个参数:name
          System.out.println("Passed Name is :" + name ); 
       }
     
       public void setAge( int age ){
           puppyAge = age;
       }
     
       public int getAge( ){
           System.out.println("Puppy's age is :" + puppyAge ); 
           return puppyAge;
       }
     
       public static void main(String []args){
          //创建对象 
          Puppy puppy = new Puppy( "tommy" );
          //通过方法来设定age
          puppy.setAge(2);
          //调用另一个方法获取age 
          puppy.getAge( );
          //你也可以像下面这样访问成员变量 
          System.out.println("Variable Value :" + puppy.puppyAge ); 
       }
    }</span>

            编译并运行上面的程序,产生如下结果:


            七源文件声明规则

            当在一个源文件中定义多个类,并且还有import语句和package语句时,要特别注意这些规则。

            A一个源文件中只能有一个public类。

            B一个源文件可以有多个非public类。

            C源文件的名称应该和public类的类名保持一致。例如:源文件中public类的类名是Employee,那么源文件应该

    命名为Employee.java。

           D如果一个类定义在某个包中,那么package语句应该在源文件的首行。

           E如果源文件包含import语句,那么应该放在package语句和类定义之间。如果没有package语句,那么import语

    句应该在源文件中最前面。

           Fimport语句和package语句对源文件中定义的所有类都有效。在同一源文件中,不能给不同的类不同的包声明。

           G类有若干种访问级别,并且类也分不同的类型:抽象类和final类等。

           除了上面提到的几种类型,Java还有一些特殊的类,如:内部类、匿名类。

           八Java包

           包主要用来对类和接口进行分类。当开发Java程序时,可能编写成百上千的类,因此很有必要对类和接口进行分

    类。

           九import语句

           在Java中,如果给出一个完整的限定名,包括包名、类名,那么Java编译器就可以很容易地定位到源代码或者

    类。import语句就是用来提供一个合理的路径,使得编译器可以找到某个类。

           例如,下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类

    <span style="font-size:18px;">import java.io.*;</span>

           十一个简单的例子

           在该例子中,我们创建两个类:Employee和EmployeeTest。

           首先打开文本编辑器,把下面的代码粘贴进去。注意将文件保存为Employee.java。

           Employee类有四个成员变量:name、age、designation和salary。该类显式声明了一个构造方法,该方法只有一

    个参数。

    <span style="font-size:18px;">import java.io.*;
    public class Employee{
       String name;
       int age;
       String designation;
       double salary;
    
       // Employee类的构造方法
       public Employee(String name){
          this.name = name;
       }
    
       // 设置age的值
       public void setAge(int newAge){
          age =  newAge;
       }
    
       //设置designation的值
       public void setDesignation(String newDesig){
          designation = newDesig;
       }
    
       //设置salary的值
       public void setSalary(double newSalary){
          salary = newSalary;
       }
    
       //打印信息 
       public void printEmployee(){
          System.out.println("Name:"+ name );
          System.out.println("Age:" + age );
          System.out.println("Designation:" + designation );
          System.out.println("Salary:" + salary);
       }
    }</span>

           程序都是从main方法开始执行。为了能运行这个程序,必须包含main方法并且创建一个实例对象。

           下面给出EmployeeTest类,该类实例化2个Employee类的实例,并调用方法设置变量的值。

            将下面的代码保存在EmployeeTest.java文件中。

    <span style="font-size:18px;">import java.io.*;
    public class EmployeeTest {
       public static void main(String args[]){
          // 使用构造器创建两个对象 
          Employee empOne = new Employee("James Smith");
          Employee empTwo = new Employee("Mary Anne");
     
          // 调用这两个对象的成员方法
          empOne.setAge(26);
          empOne.setDesignation("Senior Software Engineer");
          empOne.setSalary(1000);
          empOne.printEmployee();
     
          empTwo.setAge(21);
          empTwo.setDesignation("Software Engineer");
          empTwo.setSalary(500);
          empTwo.printEmployee();
       }
    }</span>

            编译这两个文件并且运行EmployeeTest类,可以看到如下结果:




    展开全文
  • js学习笔记:对象——行为委托

    千次阅读 2017-02-06 10:32:24
    接下来看一个例子:首先我们要定义一个名为Task的对象,它会包含所有任务都可以使用的具体行为。我们会把特定的任务对象都关联到Task功能对象上,让它们在需要的时候可以进行委托。下面是推荐的代码形式,非常简单:...

    委托理论

    其实原型链这个机制的本质就是形成对象之间的关联关系。

    这样的机制更适合用委托理论而不是类的思想去思考。

    接下来看一个例子:首先我们要定义一个名为Task的对象,它会包含所有任务都可以使用的具体行为。我们会把特定的任务对象都关联到Task功能对象上,让它们在需要的时候可以进行委托。

    下面是推荐的代码形式,非常简单:

    Task = {
        setId:function(ID){this.id = ID},
        outputId:function(){console.log(this.id)}
    };
    
    //让XYZ委托Task
    XYZ = Object.create(Task);
    
    XYZ.prepareTask = function(ID,label){
        this.setId(ID);
        this.label = label;
    }
    
    XYZ.outputTaskDetails = function(){
        this.outputID();
        console.log(this.label);
    }

    在这段代码中,Task和XYZ并不是类(或者函数),它们是对象。XYZ通过Object.create()创建,并委托了Task对象。

    相比于面向对象,这种变成风格被称为“对象关联”(OLOO)

    在js中,原型链机制会把对象关联到其他对象,但确实就是没有类似“类”的抽象机制。

    比较“类”和“委托”

    我们通过一个示例代码来比较一下两种设计模式(面向对象与对象关联)具体的实现方法:

    • 面向对象:
    function Foo(who){
        this.me = who;
    }
    
    Foo.prototype.identify = function(){
        console.log(this.me);
    }
    function Bar(who){
        Foo.call(this,who);
    }
    Bar.prototype = Object.create(Foo.prototype);
    
    Bar.prototype.speak = function(){
        console.log("hello"+this.identify());
    }
    
    var b1 = new Bar("b1");
    var b2 = new Bar("b2");
    
    b1.speak();
    b2.speak();

    这是一个典型的面向对象设计模式,子类Bar继承了父类Foo,然后生成了b1与b2两个实例。
    这种风格很常见。

    • 对象关联
    Foo = {
        init:function(who){
            this.me = who;
        },
        indentify:function(){
            console.log(this.me);
        }
    };
    
    Bar = Object.create(Foo);
    Bar.speak = function(){
        console.log("hello"+this.identify());
    }
    
    var b1 = Object.create(Bar);
    b1.init("b1");
    
    var b2 = Object.create(Bar);
    b2.init("b2");
    
    b1.speak();
    b2.speak();

    这段代码通过把b1委托给Bar,把Bar委托给Foo,实现了三个对象之间的关联。

    而非常重要的是,这段代码只是把对象关联起来,并不需要那些模仿类的行为。(构造函数、原型、new)

    类与对象

    我们已经看到了“类”与“行为委托”在设计模式上的区别,现在看看如何在真实场景中应用这些方法。

    首先是Web开发中非常典型的一种前端场景:创建UI控件。

    控件类

    由于我们可能都习惯了面向对象设计模式,因此很快会相对一个包含所有控件通用行为的父类Widget,和继承父类的特殊控件子类Button:

    //父类
    function Widget(){
        ……
    }
    
    Widget.prototype.render = function(){
     ……
    }
    
    //子类
    function Button(){
        //调用父类构造函数
        Widtget.call(this,……);
        ……
    }
    //让Button继承Widget
    Button.prototype = Object.create(Widget.prototype);
    
    //重写render
    Button.prototype.render = function(){
        //调用父类render
        Widget.prototype.render.call(this,……);
        ……
    }
    
    Button.prototype.onClick = function(){
        ……
    }
    $(document).ready(function(){
        var btn1 = new Button(……);
        btn1.render();
    })

    ES6的class语法糖

    ES6提供了class语法糖:

    class Widget{
        constructor(){
            ……
        }
        render(){
            ……
        }
    }
    
    class Button{
        constructor(){
            super(……);
            ……
        }
        render(){
            super(……);
            ……
        }
        onClick(){
            ……
        }
    }

    可以看到,使用了ES6的class之后,第一段代码中很多丑陋的语法都不见了。

    尽管语法上得到了改进,但实际上这里没有真正的类,class仍然是通过原型链机制实现的。

    委托控件对象

    下面的例子使用对象关联风格委托来更简单地实现WidgetButton:

    var Widget = {
        init:function(){
            ……
        },
        insert:function(){
            ……
        }
    }
    
    var Button = Object.create(Widget);
    
    Button.setup = function(){
        //委托调用
        this.init(……);
        ……
    }
    
    Button.build = function(){
        //委托调用
        this.insert(……);
        ……
    };
    
    Button.onClick = function(){
        ……
    }
    $(document).ready(function(){
        var btn1 = Object.create(Button);
        btn1.setup(……);
        btn1.build(……);
    })

    使用对象关联风格来编写代码时不需要把Widget和Button当做父类和子类,相反,Widget只是一个对象,包含一组通用的函数,任何类型的控件都可以委托,Button同样只是一个对象,通过委托关联到Widget。

    在委托设计模式中除了建议在对象中使用不相同且更具描述性的方法名之外,还要通过对象关联避免丑陋的显式伪多态调用:Widget.callWidget.prototype.render.call,代之以简单的相对委托调用:this.initthis.insert

    而在对象关联中不需要使用构造函数创建新对象,说明可以把创建初始化分离为两个过程,更好地支持关注分离。

    展开全文
  • 函数对象: 重载函数调用操作符的类,其对象称为函数对象(function object),即它们是行为类似函数的对象。一个类对象,表现出一个函数的特征,就是通过“对象名+(参数列表)”的方式使用一个类对象,如果没有上...

    函数对象:
    重载函数调用操作符的类,其对象常称为函数对象(function object),即它们是行为类似函数的对象。一个类对象,表现出一个函数的特征,就是通过“对象名+(参数列表)”的方式使用一个类对象,如果没有上下文,完全可以把它看作一个函数对待。
    这是通过重载类的operator()来实现的。
    “在标准库中,函数对象被广泛地使用以获得弹性”,标准库中的很多算法都可以使用函数对象或者函数来作为自定的回调行为;
    demo

    #include <iostream>
    #include <cstdio>
    
    using namespace std;
    
    // 函数对象,类重载了()
    template <typename T>  
    class ShowElement
    {
    public:
    	// 重载()
    	void operator()(T &t) {
    		cout << t << endl;
    	}
    protected:
    private:
    	int n;
    };
    
    // 函数模版
    template <typename T>
    void FuncShowElement(T &t)
    {
    	cout << t << endl;
    }
    
    // 普通函数
    void FuncShowElement2(int &t)
    {
    	cout << t << endl;
    }
    
    void play01()
    {
    	int a = 10;
    	ShowElement<int> showElement;
    	showElement(a); // 函数对象的调用,很像一个函数,所以叫仿函数
    	// 10
    
    	FuncShowElement<int>(a);
    	FuncShowElement2(a);
    	
    }
    
    int main()
    {
    	play01();
    	
    	return 0;
    }
    上面简单演示了函数对象的使用以及和普通函数定义的异同,看下面的demo。

    #include <iostream>
    #include <cstdio>
    #include <vector>
    #include <algorithm>
    
    using namespace std;
    
    // 函数对象,类重载了()
    template <typename T>
    class ShowElement
    {
    public:
    	ShowElement() 
    	{
    		n = 0;
    	}
    	// 重载()
    	void operator()(T &t) {
    		++n;
    		cout << t << ' ';
    	}
    
    	void printN()
    	{
    		cout << "n: " << n << endl;
    	}
    protected:
    private:
    	int n;
    };
    
    // 函数模版
    template <typename T>
    void FuncShowElement(T &t)
    {
    	cout << t << ' ';
    }
    
    // 普通函数
    void FuncShowElement2(int &t)
    {
    	cout << t << ' ';
    }
    
    void play01()
    {
    	int a = 10;
    	ShowElement<int> showElement;
    	showElement(a); // 函数对象的调用,很像一个函数,所以叫仿函数
    	// 10
    
    	FuncShowElement<int>(a);
    	FuncShowElement2(a);
    
    }
    
    // 函数对象的好处
    // 函数对象属于类对象,能突破函数的概念,能保持调用状态信息
    void play02()
    {
    	vector<int> v;
    	v.push_back(1);
    	v.push_back(3);
    	v.push_back(5);
    
    	for_each(v.begin(), v.end(), ShowElement<int>()); // 匿名函数对象,匿名仿函数
    	cout << endl;
    	// 1 3 5
    
    	for_each(v.begin(), v.end(), FuncShowElement2); // 通过回调函数
    	cout << endl;
    	// 1 3 5
    
    	// 改写一下类ShowElement
    	ShowElement<int> showElement;
    	/* for_each函数原型
    
    	template<class _InIt,
    		class _Fn1> inline
    		_Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
    		{	// perform function for each element
    		_DEBUG_RANGE(_First, _Last);
    		_DEBUG_POINTER(_Func);
    		_For_each(_Unchecked(_First), _Unchecked(_Last), _Func);
    
    		return (_STD move(_Func));
    		}
    	*/
    	// 可以看出for_each算法的函数对象传递是元素值传递,不是引用传递
    	for_each(v.begin(), v.end(), showElement);
    	cout << endl;
    	showElement.printN(); // 所以这里打印结果并不是我们预期的3
    	// n: 0
    	
    	// 解决方案,for_each最后是把传进去的函数对象做了值返回
    	showElement = for_each(v.begin(), v.end(), showElement);
    	cout << endl;
    	showElement.printN(); // bingo
    	// n: 3
    }
    
    int main()
    {
    	//play01();
    	play02();
    
    	return 0;
    }
    结论:分清楚STL算法返回的值是迭代器还是谓词(函数对象)是非常重要的。




    展开全文
  • JAVA面向对象对象和

    千次阅读 多人点赞 2015-12-20 09:30:41
    Java是一种面向对象的编程语言,面向对象在整个Java的学习中...以一个人为例,对于人,我们可以从他所具有的特征和所具有的行为来进行分析。 特征:体重、身高、性别、年龄...... 行为:吃饭、睡觉、说话...... 上面的
  • Java 对象和

    千次阅读 2016-05-10 15:36:57
    Java 对象和类定义对象的类几个概念 ... 每个对象都有自己独特的标识、状态和行为 状态/属性/特征 是指那些具有它们当前值的数据域。 行为/动作 由方法定义。调用对象的一个方法就是要求对象
  • 面向对象特征:继承封装多态

    千次阅读 2019-06-05 18:36:35
    面向对象特征:继承、封装多态 封装是指将某事物的属性和行为包装到对象中,这个对象只对外公布需要公开的属性和行为,而这个公布也是可以有选择性的公布给其它对象。在java中能使用private、protected、...
  • 面向对象特征有以下几个方面:1.抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象。抽象只关注对象有哪些行为和属性,并不关注这些行为的细节是什么。2.继承:继承是从已有类得到继承...
  • JAVA 面向对象和对象

    千次阅读 2016-07-17 15:57:34
    本页面更新日期: 2016年07月17日前言 Java 是面向对象的程序设计语言, Java 语言提供了 定义类, 成员变量, 方法 等基本功能.... 类用于描述客观世界里 某一类对象的共同特征. 而对象则是 类的具体存在. Java
  • 面向对象的程序设计Java-类和对象

    千次阅读 2017-02-21 15:11:20
    对象(Object) 对象具有两方面的含义 在现实世界中: 是客观世界中的一个实体 在计算机是中: 是一个可标识的存储区域 ...PS:类和对象有时都统称“对象”,为了明确起见,后者称为对象实例” 例如
  • 行为型模式--Memento模式(备忘录)对象行为型模式 一. 意图  在不破坏封装性的前提下, 捕获一个对象的内部状态, 并在该对象之外保存这个状态. 这样以后就可将该对象恢复到原先保存的状态.   一个...
  • 类图和对象

    千次阅读 2019-06-30 04:52:26
    类的定义:类是具有相似结构、行为和关系的一组对象的描述符。 2.类之间的关系 2.1 关联 关联(association)是模型元素简的一种语义联系,它是对具有共同的结构特征行为特性、关系语义的链的描述。 ...
  • 什么是面向对象,以及什么是类和对象

    千次阅读 多人点赞 2019-08-11 19:04:04
    什么是面向对象,以及什么是类和对象 ​ 1.1面向过程与面向对象的区别 ​ 面向对象是一种现在最为流行的程序设计方法 。将面向过程与面向对象进行比较。 ​ 首先这两个种都是一种编程思维, 在一些简单的动作...
  • 分类性是指将具有一致的数据结构(属性)和行为(操作)的对象抽象成类。一个类就是这样一种抽象,它反映了与应用有关的重要性质,而忽略其他一些无关内容。任何类的划分都是主观的,但必须与具体的应用有关。 (3)继承...
  • 面向对象主要有四大特性· 抽象o 忽略一个主题中与当前目标无关的东西,专注的注意与当前目标有关的方面.(就是把现实世界中的某一类东西,提取出来,用程序代码表示,...表示世界中一类事物的特征,就是对象的属性.比...
  • Java面向对象编程三大特征 - 封装

    千次阅读 多人点赞 2020-03-25 20:45:49
    本文关键字:Java、面向对象、三大特征、封装。封装是面向对象编程中的三大特征之一,在对封装性进行解释时我们有必要先了解一些面向对象的思想,以及相关的概念。
  • C++_类和对象

    2012-03-30 11:22:23
    类的结构(也即类的组成)是用来确定一类对象行为的,而这些行为是通过类的内部数据结构相关的操作来确定的。这些行为是通过一种操作接口来描述的(也即平时我们所看到的类的成员函数),使用者只关心的是接口的功能...
  • JAVA 入坑教程 | 对象和

    千次阅读 2017-01-12 16:18:19
    支持以下基本概念:继承封装抽象类对象实例方法重载本节我们重点研究对象和类的概念:对象对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为...
  • Java - 面向对象特征有哪些?

    万次阅读 2019-03-06 20:08:29
    抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。 封装:通常认为封装是把数据操作数据的方法绑定起来,...
  • 对象的声明实例化

    2017-03-30 18:01:31
    类是封装对象的属性和行为的载体,反过来说,具有相同属性和行为的一类实体被称为类。 在Java中,类中对象行为是以方法定义的,对象的属性是以成员变量的形式定义的,而类包括对象的属性方法。
  • java 面向对象特征(详解):

    千次阅读 2019-09-21 15:27:18
    首先阐述面向对象思想概述 概述 ...向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征行为特征抽象出来,描述成计算 机事件的设计思想。 它区别于面向过程思想,强调的...
  • 第一章:对象与封装1.1为什么要使用面向对象现实...面向对象设计的过程就是抽象的过程,根据业务需求,关注与业务相关的属性和行为,忽略不必要的属性和行为,由现实世界中的“对象”,抽象出软件开发中的“对象”。...
  • 行为:又称为对象的方法,包括具有的功能及具体的实现。  *注:对象的属性用成员变量表示,对象的行为用成员方法表示。 类:一组具有相同属性和行为的对象的抽象。  类型:对象模型中的类可看做是开发...
  • 对象: object 客观世界中任何一个事物都可以看成一个对象,如自然物体(汽车,房子,班级...) 可以看到一个班级作为一个...调用对象中的函数就是向该对象传送一个消息,要求该对象实现某一行为(功能)。 面
  • 和对象之间的关系?封装继承多态?

    千次阅读 2018-03-04 09:19:00
    在面向对象的编程思想中把对象的属性和行为分别称为对象的属性方法,是构成对象的两个主要因素;在编程中,对象的属性被存储在一些变量里;对象的行为则通过定义方法来实现。三大基本特征:封装,继承,多态。 ...
  • 1 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么; 2 封装:通常认为封装是把数据数据操作的方法绑定...
  • 面向对象深度解析对象的继承

    千次阅读 2018-06-21 00:24:41
    对象的属性类型分为数据属性访问器属性1.2.1 数据属性概念:数据属性包含一个数据值的位置,在这个位置可以读取写入值,数据属性有4个描述其行为的值4个特性:[[configurable]]:表示能否通过del...
  • 一个对象应当具有属性和行为两个要素。 - 属性:描述静态特征 - 行为: 描述动态特征。 2. 类 类: 对所有具有共同特征的事物归为一类。 是一个抽象的概念,而对象是一个类中某个具体实体。对象是类的一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 310,998
精华内容 124,399
关键字:

对象的特征和行为称为对象的