精华内容
下载资源
问答
  • 面向对象三大特征

    千次阅读 热门讨论 2014-04-22 20:34:24
    最近刚开始学习设计模式,在学习初期,把面向对象这个概念弄明白是很有必要的。


           最近刚开始学习设计模式,在学习初期,把面向对象这个概念弄明白是很有必要的。

           之前接触过C语言的基础,后来又学了一点VB,不过这都不是面向对象的语言,当然在编程中也就无法体会到面向对象的思想。

           最近接触了软件工程、UML之后才渐渐了解了面向对象的概念,继而又简单学习了一下C++、C#,下面以C#为工具来总结一下目前所认识的面向对象     


             何为对象?

        进入正题之前,我们先来探讨一下什么是“对象”,不要误会,此“对象”非彼“对象”→_→。

        举个例子,一只小狗,它有眼睛、嘴巴、鼻子、颜色等静态特征(属性),也有吃东西、睡觉等动态特征(方法);又比如一个手机,它既有型号、大小等静态特征(属性),也有打电话、发短息等动态特征(方法)。所以,对对象简单的定义就是“对象是一个包含属性和方法的整体”


        面向对象编程(OOP)

           早期的计算机编程是基于面向过程的方法,例如实现一个求圆的面积的功能:S=3.14*r*r,通过设计一个算法就可以解决问题。随着需求的不断提高,需要被解决的问题也变得越来越复杂,例如前段时间比较火的“捕鱼”游戏,在游戏中,有成千上万条鱼、无数子弹,还有渔网、海底装饰物等等,但在制作游戏的过程中,我们的编程人员不能根据每条鱼的外形,游动方式而写一段相应的代码吧,那还不累死……所以用面向过程的方法来解决就有些困难了,这时就要用到面向对象。

        一切事物皆对象,我们可以将现实世界中的任何事物看成是对象,比如在“捕鱼”游戏的实现中,每条鱼就是一个对象,每张网是一个对象……但是为了避免枯燥乏味,不能只要一条鱼,一张网吧,所以,就要把所有的鱼的共同点找出来,抽象出一个“鱼类”,把所有网的共同点找出来,抽象出一个“网类”……然后用的时候就可以让个鱼类实例化出无数条鱼。所以说,面向对象解决了传统的面向过程的编程方法所无法解决的代码复用的问题。


          


       面向对象的特征

                面向对象有三大特征:封装、继承和多态。

           封装

           封装就是把客观的事物抽象成类,并且类把自己不想对外开放的成员“藏起来”,仅仅提供一些相应的接口供外界访问,实现了信息隐藏,提高了安全性。如一个钟表类,有时、分、秒等属性,有调整时间等方法,实现封装的代码为:       

     class Clock
        {
            private int hour, minute, second;
            public int Hour
            {
                get { return Hour; }
                set { Hour = value; }
            }
            public int Minute
            {
                get { return Minute; }
                set { Minute = value; }
            }
            public int Second
            {
                get { return Second; }
                set { Second = value; }
            }
        }

           在代码中,hour、minute、second就是Clock类“藏起来”的属性,Hour、Minute和Second就相当于是外界访问Clock这些私有属性的接口。


            继承

            假如在整个捕鱼游戏中,有成千上万条鱼,虽然有许多种类的鱼,但这些鱼会有许多共同点,比如每条鱼在屏幕上都会有一个位置(x坐标和y坐标),都会向前游动等等,这时候就可以根据所有鱼的共同特征,抽象出来一个“鱼”类,这个“鱼”类中包含了所有鱼的共同点,因此在实例化每种鱼的时候都使得公用代码得到了共享,避免了重复。  

    class Fish
        {
            protected double x;
            protected double y;
            public Fish()
            {
                x = 0;
                y = 0;
            }
            public double X
            {
                get { return x; }
                set { x = value; }
            }
            public double Y
            {
                get { return y; }
                set { y = value; }
            }
            public void Swim(double distance_x, double distance_y)
            {
                x += distance_x;
                y += distance_y;
            }
        }
        class Turtle : Fish
        {
            public Turtle() : base() { }
            public void Turn()
            {
                //为了区别于其他的鱼,就给乌龟加一个转头并按原路返回的方法
                //……相关代码……
                //……………………
                //……………………
                //……相关代码……
            }
        }
        class Mermaid : Fish
        {
            public Mermaid() : base() { }
            public void SwingArms()
            {
                //为了区别于其他的鱼,就给美人鱼加一个摇摆双臂的方法
                //……相关代码……
                //……………………
                //……………………
                //……相关代码……
            }
        }
           这时,Fish类就是父类(基类),Turtle类和Mermaid类就是子类(派生类)。


           多态

           多态就是用不同的对象调用调用相同的方法,执行不同的操作。还是用捕鱼游戏来举例子,假定美人鱼只能一直向前游,而乌龟可以向任意方向(游动的时候x坐标和y坐标都可以发生改变),则每种鱼就不能只是单单继承Fish的Swim方法了,应该让特定的鱼种继承了Swim方法之后能够有不同游法(虽然同样是游泳,但各有各游的方式,就如同小猫叫的时候是“喵”,小狗叫的时候是“汪”)。    

           实现方法便是在父类中

    class Fish
        {
            protected double x;
            protected double y;
            public Fish()
            {
                x = 0;
                y = 0;
            }
            public double X
            {
                get { return x; }
                set { x = value; }
            }
            public double Y
            {
                get { return y; }
                set { y = value; }
            }
            public virtual void Swim(double distance_x, double distance_y)
            {
            }
        }
        class Turtle : Fish
        {
            public Turtle() : base() { }
            public void Turn()
            {
                //为了区别于其他的鱼,就给乌龟加一个转头并按原路返回的方法
                //……相关代码……
                //……………………
                //……………………
                //……相关代码……
            }
            public override void Swim(double distance_x, double distance_y)
            {
                x += distance_x;
                y += distance_y;
            }
        }
        class Mermaid : Fish
        {
            public Mermaid() : base() { }
            public void SwingArms()
            {
                //为了区别于其他的鱼,就给美人鱼加一个摇摆双臂的方法
                //……相关代码……
                //……………………
                //……………………
                //……相关代码……
            }
            public override void Swim(double distance_x, double distance_y)
            {   
                //美人鱼游的时候只是x坐标发生改变
                x += distance_x;
            }
        }

                 代码中,在Fish类中的Swim方法要变为虚方法(其函数体内可以为空),子类继承这个虚方法后进行重写(即根据自己的特点进行扩充或改变)。如果父类中的虚方法有形参,则子类中重写的时候,函数的形参列表要与父类中虚方法的形参列表一致。

      

            如有不足与纰漏,恳请您留下宝贵意见与建议,感激不尽!

    展开全文
  • js面向对象三大特征

    千次阅读 2019-11-29 13:33:30
    面向对象三大特征: 一、 封装:隐藏内部的细节,不暴露在外面(不让其它访问仅能自己访问) //在js中利用函数的作用域来模拟 // 封装 let Pet=function (name,types) { this.name=name; //封装,将变量用一...

    面向对象三大特征:

    一、 封装:隐藏内部的细节,不暴露在外面(不让其它访问仅能自己访问)

    //在js中利用函数的作用域来模拟
    // 封装
    let Pet=function (name,types) {
        this.name=name;
        //封装,将变量用一个关键字声明,这样外面就不能访问了
        let _types=types;
    };
    //将相同的方法或属性放在原型链上,方便代码的复用
    Pet.say=function(){
        return `hello!我叫:${this.name},我是一只可爱的${this._types}`;
    };
    console.log(Pet.say());//hello!我叫:Pet,我是一只可爱的undefined
    

    二、继承:子类继承父类,就可拥有父类的属性和方法//在js中利用对象冒充(父类构造函数去充当子类的属性)的方式实现继承

    //方法1:在js中利用对象冒充(父类构造函数去充当子类的属性)的方式实现继承
    //继承
    let Pet=function (name,types) {
        this.name=name;
        this.types=types;
    };
    let Dog=function(name,types,colors,age){
        this.colors=colors;
        this.age=age;
    
        this.temp=Pet;//将Pet构造函数赋值给temp,充当Dog的子类
        this.temp(name,types);//调用其构造函数并赋值
        delete this.temp;//此时temp已经无用了,将其删除
    }
    let taidi=new Dog("泰迪","小狗","土其色",2);
    
    console.log(taidi.name+"    "+taidi.types+"    "+taidi.colors+"   "+taidi.age);//泰迪    小狗    土其色   2
    
    //方法2:使用方法借用的方式实现继承
    let Pet=function (name,types) {
        this.name=name;
        this.types=types;
    };
    let Dog=function(name,types,colors,age){
        //借用Pet的方法
        //Pet.apply(this,[name,types]);
        Pet.call(this,name,types);
        this.colors=colors;
        this.age=age;
    }
    let taidi=new Dog("泰迪","小狗","土其色",2);
    
    console.log(taidi.name+"    "+taidi.types+"    "+taidi.colors+"   "+taidi.age);//泰迪    小狗    土其色   2
    
    
    //方法3:最终,js采用了原型链继承的方式
    //采用了原型链继承的方式
    let Pet=function (name,types) {
        this.name=name;
        this.types=types;
    };
    //给Pet原型链上添加一个方法
    Pet.prototype.say=function(){
        return `hello!大家好我是smallzz`;
    }
    
    let Dog=function(name,types,colors,age){
        //借用Pet的方法
        //Pet.apply(this,[name,types]);
        Pet.call(this,name,types);
        this.colors=colors;
        this.age=age;
    };
    //将Pet的构造函数放在Dog的原型链上
    Dog.prototype=new Pet();
    let taidi=new Dog("泰迪","小狗","土其色",2);
    
    console.log(taidi.name+"    "+taidi.types+"    "+taidi.colors+"   "+taidi.age);//泰迪    小狗    土其色   2
    console.log(taidi.say());//hello!大家好我是smallzz
    

    方法4:ES6提供了extends关键字

    //使用extends实现继承
    class Pet{
        constructor(name,types){
            this.name=name;
            this.types=types;
        }
        say(){
            return `hello!大家好我是smallzz`;
        }
    }
    
    class Dog extends Pet{ //继承Pet
        constructor(name,types,colors,age){
            super(name,types);//调用父类的构造器
            this.colors=colors;
            this.age=age;
        }
    }
    
    let taidi=new Dog("泰迪","小狗","土其色",3);
    console.log(taidi.name+"    "+taidi.types+"    "+taidi.colors+"   "+taidi.age);//泰迪    小狗    土其色   3
    console.log(taidi.say());//hello!大家好我是smallzz
    

    三、多态:定义:同一操作用于不同的对象上,会产生不同的结果。js中的对象天生就是多态的

    PS:方法借用

    展开全文
  • JAVA面向对象三大特征

    千次阅读 2018-09-13 09:52:16
    JAVA面向对象三大特征: 1.封装 (英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。 封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。 ...

    JAVA面向对象三大特征:

    1.封装

    (英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
    封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
    要访问该类的代码和数据,必须通过严格的接口控制。
    封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
    适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
    封装的优点
    1. 良好的封装能够减少耦合。
    2. 类内部的结构可以自由修改。
    3. 可以对成员变量进行更精确的控制。
    4. 隐藏信息,实现细节。

    2.继承

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。
    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
    继承的特性
    子类拥有父类非private的属性,方法。
    子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
    子类可以用自己的方式实现父类的方法。
    Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。
    提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。
    继承关键字
    继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。
    implements关键字
    使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。
    super 与 this 关键字
    super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
    this关键字:指向自己的引用。
    final关键字
    final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:

    3.多态

    多态是同一个行为具有多个不同表现形式或形态的能力。
    多态就是同一个接口,使用不同的实例而执行不同操作
    多态的优点
    1. 消除类型之间的耦合关系
    2. 可替换性
    3. 可扩充性
    4. 接口性
    5. 灵活性
    6. 简化性
    多态存在的三个必要条件
    继承
    重写
    父类引用指向子类对象
    虚方法
    我们将介绍在Java中,当设计类时,被重写的方法的行为怎样影响多态性。
    我们已经讨论了方法的重写,也就是子类能够重写父类的方法。
    当子类对象调用重写的方法时,调用的是子类的方法,而不是父类中被重写的方法。
    要想调用父类中被重写的方法,则必须使用关键字super。
    多态的实现方式:
    重写,接口,抽象类和抽象方法

    展开全文
  • Java 面向对象三大特征

    千次阅读 2018-07-24 21:24:59
    面向对象三大特征: 封装性 继承性 多态性 1. 封装性  所谓封装,也就是把客观事物封装成抽象的类,并且类可以把自己的属性和方法只给特定的对象或其他类进行访问,即使用不同的访问统治权限使类被不同的...

     面向对象三大特征:

    • 封装性
    • 继承性
    • 多态性

    1. 封装性

     所谓封装,也就是把客观事物封装成抽象的类,并且类可以把自己的属性和方法只给特定的对象或其他类进行访问,即使用不同的访问统治权限使类被不同的对象访问,类中的方法属性也可单独使用访问控制权限进行修饰。

     简而言之就是,使类对外部保持整洁,只留有主要的接口进行类业务逻辑的使用。

     没有进行封装的类,如下所示:

    class Person {
        public String name;
        public int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }

     进行了封装的类:

    class Person {
        // 将属性私有
        private String name;
        private int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        // 私有属性只能通过get,set方法进行访问
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

    2. 继承性

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

     继承的主要作用在于:在已有功能基础上进行功能的扩充,对类进行扩充,代码的复用。

    3. 多态性

     所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。(利用多态可以得到良好的设计)

     多态表现为以下两点:

    • 方法的多态

     方法的重载:

     同一个方法名可以根据参数数量和类型的不同重载为不同的方法。

     方法的覆写:

     同一个父类的方法,不同的子类实例化,其方法的实现也可能不同。

    • 对象的多态

     对象的多态主要体现在抽象类和接口,可分为向上转型和向下转型。

     向上转型:

    SuperObj superName = new ChildObj();

     发生向上转型一般是为了参数的统一。

     向下转型:

    ChildObj childName = new SuperObj();

     发生向下转型一般是为了得到子类扩充的方法。

     而向上转型和向下转型的本质其实就是方法的覆写。如果子类没有对父类进行方法的覆写,也就不存在对象的多态。

    展开全文
  • Java面向对象三大特征

    千次阅读 2020-09-26 21:21:24
    Java面向对象三大特征 1.重写 ​ **概念:**子类继承父类的以后,可以对父类中同名参数的方法进行覆盖的操作。 ​ 应用: 重写以后,创建子类对象后,子类调用父类中同名同参数的方法时,实际上调用的是子类重写后的...
  • python中面向对象三大特征

    千次阅读 2018-09-13 20:21:05
    面向对象三大特征  1.封装:根据职责将属性和方法封装到一个抽象的类中  2.继承:实现代码的重用,相同的代码不需要重复的写  3.多态:以封装和继承为前提,不同的子类对象调用相同的方法,产生不同的执行结果 一...
  • Python 面向对象三大特征

    千次阅读 2018-05-18 20:51:51
    一、 面向对象三大特征--封装面向对象的程序设计中,某个类把所需要的数据(也可以说是类的属性)和对数据的操作(也可以说是类的行为)全部都封装在类中,分别称为类的成员变量和方法(或成员函数)。这种把成员...
  • 面向对象三大特征介绍

    千次阅读 2019-06-18 16:05:20
    面向过程和面向对象区别 我们都常听到软件设计思想有面向对象和面向过程。那么什么是面向对象、什么是面向过程呢? 接下来我举个例子说明一下他们两者的区别。 有一天你想吃鱼香肉丝,怎么办,有两个选择。 第一...
  • Java基础:面向对象三大特征、五原则

    万次阅读 多人点赞 2015-06-22 13:57:20
    面向对象三大特征: (1)封装(Encapsulation) 所谓封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。封装是面向对象的特征之一,是对象和类...
  • java面向对象三大特征及五原则

    千次阅读 2019-12-28 17:36:56
    一、java面向对象三大特征 1、封装(Encapsulation) 封转是指属性私有化 根据需要提供setter和getter方法来访问属性 隐藏具体属性和实现细节,仅对外开放接口 控制程序中属性的访问级别 目的:增强数据安全性,不...
  • c#总结--面向对象三大特征

    千次阅读 热门讨论 2017-03-05 22:01:05
    前言 想要学好面向对象编程,除了掌握语法结构外,还需要熟悉面向对象三大特征:封装、继承、多态,这三大特征不是相互独立的,而是相互关联的,你中有我、我中有你。封装定义:隐藏对象的属性和方法,设置不同的...
  • Java面向对象三大特征之封装

    千次阅读 2020-03-24 21:06:53
    Java面向对象之封装
  • Java中面向对象三大特征总结

    万次阅读 多人点赞 2017-07-09 14:13:36
    JAVA中面向对象三大特征:  面向对象具有继承性(Inheritance)  面向对象具有多态性(Polymorphism)  面向对象具有封装性(Encapsulation) 一、继承  多个类具有共同的属性(成员变量)与行为(成员...
  • Java面向对象三大特征之多态

    千次阅读 2020-03-27 21:54:31
    Java面向对象之多态知识点
  • Java面向对象三大特征之继承

    千次阅读 2020-03-26 19:29:35
    Java面向对象之继承相关知识点总结
  • Python 面向对象三大特征之多态

    千次阅读 2020-02-14 09:23:15
    【摘要】 面向对象三大特性多态相关知识。 多态 1、多态 多态指的是一类事物有多种形态 动物有多种形态:人,狗,猪 import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstract...
  • 面向对象三大特征:封装,继承,多态; 一、封装:该公开的就公开话,该私有的就隐藏掉,主要是由public,private实现;作用是便于分工和分模块,防止不必要的扩展; 二、继承:就是一种传承,可以把父类型中的数据...
  • 面向对象三大特征之一封装性

    千次阅读 2017-01-18 16:34:44
    一、面向对象三大特征 封装 (Encapsulation) 继承 (Inheritance) 多态 (Polymorphism)二、封装1、什么是封装 封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。2、封装的分类与好处 狭义的封装...
  • 摘要:多态从字面意思上看就是多种形态,在我们python的面向对象里就是不同的对象在接收相同方法或者函数时会产生不同的行为,也就是说,每个对象可以用自己的方式去响应共同的函数,不同的方式实现不同的结果。...
  • java面向对象三大特征 — 封装

    万次阅读 2017-04-26 21:59:41
    权限修饰符 :控制变量等其他东西的可见范围。 public :公共的。public修饰的成员变量...类一般分为2类:实体类 、 工具类。 封装的好处: 1. 提高数据的安全性; 2. 操作简单; 3. 隐藏了实现。
  • 面向对象三大特征和解决的问题

    千次阅读 2014-02-04 14:32:07
    一:什么是“对象” 在计算机的世界里,对象(Object)就是进行研究的任何事物。小到螺丝钉,大道飞机大炮,都可以...他主要有三大特征:封装、继承、多态 :什么是封装? 在软件设计中,封装是指将接口与实现显式
  • Java的三大特性:封装、继承和多态。 封装: 首先,属性可用来描述同一类事物的特征, 行为可描述一类事物可做的操作,封装就是要把属于同一类事物的共性(包括属性与行为)归到一个类中,以方便使用.比如人这个东东,可用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,856
精华内容 55,542
关键字:

面向对象三大特征