精华内容
下载资源
问答
  • SP和OOP对比面向对象的三大原则封装 继承 多态对象对象是面向对象编程的核心部分,是实际存在的具体实体,具有明确定义的状态和行为;对象其实就是“数据”和“函数”的封装体,其中:数据表示自身的状态,也称作...

    什么是面向对象?Object 对象,Oriendted 以…为导向的, Programming 程序设计

    面向对象就是使用对象进行程序设计,简写成OOP。

    e3d8b8c69488cf6c80e52b2c95fff955.gif

    SP和OOP对比

    3d4a5c20b3a18930cbd9c835a4fd544c.png

    面向对象的三大原则

    封装  继承   多态

    对象

    对象是面向对象编程的核心部分,是实际存在的具体实体,具有明确定义的状态和行为;

    对象其实就是“数据”和“函数”的封装体,其中:

    数据表示自身的状态,也称作“属性”或“成员数据”;

    函数表示自身的功能,也称作“方法”或“成员函数”。

    类人们为了更好地认识世界,将现实生活中的事物(对象)划分成类;

    同一类中的事物总是具有一些共性;

    类以共同的特性和行为定义实体;

    类是具有相同属性和和行为的一组对象的集合。

    属性事物的特性在类中用变量表示;

    每个对象的每个属性都拥有其特定的值;

    属性名称由类的所有对象共享;

    对象或实体拥有的特征在类中表示时称为属性

    8cd23d212311d2c29a7c3f04362fd87f.gif

    方法事物的行为和动作在类中用函数表示;

    每个对象都有相同的动作和行为;

    对象执行的操作在类中表示为方法。

    b457bd0b6da8e09d529ae0c227265756.gif

    类和对象的区别类是用来描述实体的“模板”或“原型”;

    对象是实际的实体,每一个对象都是类的一个具体实例;

    类用来定义对象所有的属性和方法,同一类的所有对象都拥有相同的特征和操作;

    可以将类理解成生产产品的模具,而对象则是根据此模具生产的一个个产品。

    类与结构

    94e1f1dc6a473294a646ae3b1120a616.gif

    封装将某些东西包装在一起,然后以新的完整形式呈现出来;

    隐藏属性、方法或实现细节的处理方式称为封装;

    封装其实就是有选择性地公开或隐藏某些信息,它解决了数据的安全性问题。

    23fdfdec74bb473923dbd77452f8a0ee.gif

    继承继承就是重用现有的类来生成新类的一种特征;

    通俗地讲就是从现有的类(即父类或基类)创建新类(子类或派生类)的过程;

    现实生活中,继承可以达到财产重用的目的,而在Java中,继承可以使代码重用。

    多态多态是指同一函数在不同的类中有不同的实现;

    多态的好处就是使类更灵活,更便于扩充。

    这里还有一个不得不说的的 “抽象”

    抽象把相同的或相似的对象归为一类的这个过程就是抽象,所以,抽象就是分析问题的方法;

    抽象的基本原则:

    只关心主要问题,而不关心次要问题;

    只关心主要矛盾,而不关心次要矛盾;

    只关心相同的东西,而不关心不同的东西;

    只关心问题是什么,能够完成什么,而不关心怎样去完成。

    抽象的过程其实就是面向对象编程的核心思想。

    在Java中定义类

    b809c9b84477964771a880df9c2f73e2.gif

    在Java中创建对象

    8c2669b765b5112f285bfaf5f178ecd4.gif

    创建对象的语法和数组相似,对象也是引用数据类型,只能使用new运算符从堆中分配内存;

    创建对象的一般语法:

    类名 引用名 = new 类名();

    使用已经定义好的类,创建该类对象的过程称为“实例化”。

    成员运算符  “ . ”只有先实例化类的对象,才可以访问到类中的成员(属性和方法);

    使用成员运算符(.)来访问成员属性或成员方法;

    一般语法是:

    对象名.成员名

    如:

    std.age = 18; //为成员属性赋值

    std.dining(); //调用成员方法

    访问权限:public和privateC语言中结构体的成员可以从任何地方进行访问,这将给数据的安全留下极大的隐患;

    为了避免从类外部直接访问类成员而造成的数据损坏,Java对类成员的访问制定了约束;

    关键字public和private是访问修饰符,用来说明某个成员是否可以从类外部进行访问;

    public修饰的成员可以在任何地方进行访问,不受任何约束;

    private修饰的成员只能够被本类中的其它成员访问,而不能从类的外部进行访问。

    无法从类的外部访问私有成员;

    其它类的私有成员对于当前类也是隐藏的。

    bb1f295f7aff083131f1d9bbe0204bd0.gif

    访问权限示例

    class Student {

    private String name; //姓名,私有的,不可以从类外部直接访问

    private int age; //年龄,私有的,不可以从类外部直接访问

    private float weight; //体重,私有的,不可以从类外部直接访问

    //吃饭的方法,公有的,可以从任何地方访问

    public void dining() {

    System.out.println("吃饱了...");

    weight++; //dining方法是类内部成员,可以直接访问本类私有成员

    }

    //走路的方法,公有的,可以从任何地方访问

    public void walk() {

    System.out.println("走累了...");

    weight--; //walk方法是类内部成员,可以直接访问本类私有成员

    }

    }

    public class Test {

    public static void main(String[] args) {

    Student std = new Student(); //实例化一个Student对象

    std.age = 18; //试图从类外部访问私有成员,将会报出一个错误

    std.dining(); //允许访问公有成员

    }

    }

    访问权限(续)

    加上访问修饰符有时候可能会给操作数据带来不便,但可以在很大程度上保证数据的安全;

    一般地,我们会将成员属性声明为private,而将成员方法声明为public,但这样做并不是绝对的;

    有时候,类外部可能要操作到某些私有数据成员,那么就可以增加一个公有的方法,再由这个方法来操作私有数据,避免因类外部的误操作而造成的数据损坏;

    因为main方法要由类外部的虚拟机来调用,所以main方法必须声明成public。

    如:修改Student类

    class Student { //定义学生类

    private String name; //姓名,私有

    private int age; //年龄,私有

    private float weight; //体重,私有

    public void setName(String name) { //为姓名赋值的方法,公有

    this.name = name;

    }

    public void setAge(int a) { //为年龄赋值的方法,公有

    age = a;

    }

    public void setWeight(float w) { //为体重赋值的方法,公有

    weight = w;

    }

    public void display() { //将所有信息打印出来的方法,公有

    System.out.println("姓名:" + name + ",年龄:" + age + ",体重:" + weight);

    }

    public void dining() {……} //吃饭的方法,公有,代码略

    public void walk() {……} //走路的方法,公有,代码略

    }

    public class Test {

    public static void main(String[] args) {

    Student std = new Student(); //实例化学生类对象

    std.setName("张三"); //为姓名赋值

    std.setAge(18); //为年龄赋值

    std.setWeight(55); //为体重赋值

    std.dining(); //调用吃饭的方法

    std.display(); //将信息打印出来

    }

    }

    对象初始化在上例中,只能逐个地为数据成员赋值,如果想在对象实例化的同时就初始化成员属性,就使用到了构造方法;

    构造方法是特殊的成员方法,它与类同名,在对象实例化时由虚拟机自动调用;

    请注意:构造方法没有返回值类型,也不能有返回值。

    构造方法示例:

    /*定义ConstructorDemo类,对构造方法进行测试*/

    class ConstructorDemo

    {

    /*构造方法,方法名与类名完全一致

    无需指定返回值类型,也不能有返回值*/

    public ConstructorDemo()

    {

    System.out.println("这是构造方法");

    }

    }

    /*Test类,用来容纳main方法

    一般将包含有main方法的类声明为public*/

    public class Test

    {

    /*main方法,程序入口*/

    public static void main(String[] args)

    {

    /*实例化ConstructorDemo类的对象*/

    ConstructorDemo cd = new ConstructorDemo();

    }

    } //会输出“这是构造方法”

    构造方法正是由于在实例化对象的同时会自动调用构造方法,所以构造方法一般用来给数据成员分配资源或初始化数据成员;

    构造方法的一般形式:

    访问权限 类名(形参列表) {

    方法体

    }

    因为是由虚拟机来调用构造方法,所以构造方法一般应定义成public。

    如:为Student类添加构造方法

    class Student { //定义学生类

    private String name; //姓名,私有

    private int age; //年龄,私有

    private float weight; //体重,私有

    //构造方法,根据传递进来的参数,为数据成员赋值

    public Student(String n, int a, float w) {

    //分别为每个数据成员赋初始值

    name = n;

    age = a;

    weight = w;

    }

    public void setName(String n) {……} //为姓名赋值的方法,公有,代码略

    public void setAge(int a) {……} //为年龄赋值的方法,公有,代码略

    public void setWeight(float w) {……} //为体重赋值的方法,公有,代码略

    public void display() {……} //将所有信息打印出来的方法,公有,代码略

    public void dining() {……} //吃饭的方法,公有,代码略

    public void walk() {……} //走路的方法,公有,代码略

    }

    public class Test {

    public static void main(String[] args) {

    //利用构造方法,为数据成员指定初始值

    Student std = new Student("张三", 18, 55);

    std.display(); //将信息打印出来

    }

    }

    构造方法(续)

    每个对象在生成时都必须执行构造方法,而且只能执行一次;

    如果构造方法调用失败,那么对象也无法创建;

    不可以显式地直接调用构造方法;

    在没有定义构造方法的情况下,类会自动产生一个无参数的默认构造方法,这个默认的构造方法什么都不做;

    一旦显式地定义了构造方法,默认构造方法自动消失。故一般定义无参和有参两个构造方法。

    总结

    对象由状态(属性)和行为(方法)组成;

    类是具有相同属性和方法的对象的集合;

    封装可以隐藏对象实现的具体细节;

    必须先实例化类的对象,才可以访问到其中的成员;

    成员运算符用于访问对象的成员;

    成员可以定义为公有,也可以定义为私有;

    构造方法一般用来初始化对象中的数据成员;

    如果不定义构造方法,将有默认的构造方法,一旦定义,默认的构造方法自动消失。

    展开全文
  • 面向对象 什么是面向对象 这里使用面向过程与面向对象对比方式解释什么是面向对象。 一,把想要实现的功能,让一个类实现,而不是具体的实现步骤 二,对象可以是任何事物,比如学生管理系统,的学生可以做成一个类...

    面向对象

    • 什么是面向对象编程
    1. (一:了解)
      面向对象编程(OOP)是一种编程思想,这里借助面向过程和面向对象对比进行理解。比如你打算吃蛋炒饭,可以自己做或者去饭店吃。
      在这里插入图片描述
      可以看出 面向对象面向过程 的区别,面向过程关注的是每一个功能实现的具体步骤,面向对象关注的是对象,然后由对象去调用功能。这里的饭店就是一个对象,把一类事情交给一个对象去处理

      来段故事

      一个老板,接了一个300万的软件开发的项目,但是呢?这位老板本身并不具备软件开发的能力,他要怎么做呢?他可不可以自己做?现学?可以,因为项目就是人做出来的嘛!于是乎,这个老板现学软件开发,终于,5年时间,他把那个项目做出来了,可事实是那个给钱的公司早就黄了!这是不是不靠谱啊?那这个老板该怎么做?他聘请了一批程序员,说这有个项目,你们给我做出来,程序员是不是专业啊?那这没那个老板什么事了,他就去喝茶,玩去了!对这个老板来说,开发软件这个事情是不是从复杂变得简单了?他是不是从一个执行者转换成了指挥者?这些专业程序员对老板来说就是对象,老板面向这些对象,调用这些对象本身具有的功能来实现了自己的目的!这就是面向对象!

    2. (二:举例)
      例一:洗衣机里面放有脏衣服,怎么洗干净?

      面向过程的解决方法:
      1、执行加洗衣粉方法;
      2、执行加水方法;
      3、执行洗衣服方法;
      4、执行清洗方法;
      5、 执行烘干方法;

      将解决这个问题的过程拆成一个个方法(是没有对象去调用的),通过一个个方法的执行来解决问题。

      面向对象的解决方法:
      1、我先弄出两个对象:“洗衣机” 对象和 “人” 对象
      2、针对对象 “洗衣机” 加入一些属性和方法:“洗衣服方法”、“清洗方法”、“烘干方法”
      3、针对对象 “人” 加入属性和方法:“加洗衣粉方法”、“加水方法”
      4、然后执行
      人.加洗衣粉
      人.加水
      洗衣机.洗衣服
      洗衣机.清洗
      洗衣机.烘干

      面向对象编程就是先抽象出对象,然后用对象执行方法的方式解决问题。

      例二:五子棋游戏

      面向过程的设计思路就是首先分析问题的步骤:
      1、开始游戏,2、黑子先走,3、绘制画面,4、判断输赢,5、轮到白子,6、绘制画面,7、判断输赢,8、返回步骤2,9、输出最后结果。把上面每个步骤用不同的方法来实现。

      面向对象的设计则是从共性和功能的思路来解决问题:
      整个五子棋可以分为1、黑白双方,这两方的行为是一模一样的,2、棋盘系统,负责绘制画面,3、规则系统,负责判定诸如犯规、输赢等。第一类对象(玩家对象)负责接受用户输入,并告知第二类对象(棋盘对象)棋子布局的变化,棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化,同时利用第三类对象(规则系统)来对棋局进行判定。

      可以明显地看出,面向对象是以功能来划分问题,而不是步骤。

    3. (三:总结)
      ①、面向对象是一种思考问题的方式,是一种思想。
      ②、面向对象将复杂的事情变简单了。面向过程需要关注每一步的实现,而面向对象只需要关注一个对象就可以了。
      ③、面向对象让我们的角色发生了转变,从原来的执行者过渡到了指挥者。
      ④、面向对象基于面向过程。


    面向对象的五大基本原则

    1. 单一职责原则 (Single Responsibility Principle SRP)
      是指一个类的功能要单一,不能包罗万象。如同一个人一样,分配的工作不能太多,否则一天到晚虽然忙忙碌碌的,但效率却高不起来。

    2. 开放封闭原则 (Open-Close Principle OCP)
      一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如:一个网络模块,原来只服务端功能,而现在要加入客户端功能,那么应当在不用修改服务端功能代码的前提下,就能够增加客户端功能的实现代码,这要求在设计之初,就应当将服务端和客户端分开,公共部分抽象出来。

    3. 里式替换原则 (the Liskov Substitution Principle LSP)
      子类应当可以替换父类并出现在父类能够出现的任何地方。比如:公司搞年度晚会,所有员工可以参加抽奖,那么不管是老员工还是新员工,也不管是总部员工还是外派员工,都应当可以参加抽奖,否则这公司就不和谐了。

    4. 依赖倒置原则(the Dependency Inversion Principle DIP)
      具体依赖抽象,上层依赖下层。假设B是较A低的模块,但B需要使用到A的功能,这个时候,B不应当直接使用A中的具体类: 而应当由B定义一个抽象接口,并由A来实现这个抽象接口,B只使用这个抽象接口:这样就达到了依赖倒置的目的,B也解除了对A的依赖,反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块,假如B也直接依赖A的实现,那么就可能造成循环依赖。一个常见的问题就是编译A模块时需要直接包含到B模块的cpp文件,而编译B时同样要直接包含到A的cpp文件。

    5. 接口分离原则(the Interface Segregation Principle ISP)
      模块间要通过抽象接口隔离开,而不是通过具体的类强耦合起来


    展开全文
  • 面向对象编程 OOP

    2021-07-12 22:26:46
    OOP:Object Oriented Programming,面向对象编程。了解面向对象编程之前,需要了解下面向过程编程。现在有一个实际问题需要编程解决,把大象装冰箱里分几步?如果用面向过程的语言去实现则思路如下: void main()...

      1.面向对象编程 OOP

            OOP:Object Oriented Programming,即面向对象编程。了解面向对象编程之前,需要了解下面向过程编程。现在有一个实际问题需要编程解决,把大象装冰箱里分几步?如果用面向过程的语言去实现则思路如下:

    void main(){
        //1.打开冰箱门    
        openSomething(Refrigerator refrigerator){
        }
        //2.把大象装入冰箱
        putSomethingToRefrigerator(Elephant elephant){
        }
        //3.关上冰箱门
        closeSomething(Refrigerator refrigerator){
        }
    }

            "打开冰箱门"这一个动作,冰箱门被作为操作对象的参数传入方法内,方法内定义打开冰箱门具体的实现。而如果用面向对象的思想去解决这件事的话则思路如下:

    public class Refrigerator{
        openDoor(){      
        }
        putSomething(Elephant elephant){  
        }
        closeDoor(){ 
        }
    }
    public static void main(String[] args){
        Refrigerator refrigerator = new Refrigerator();
        //1.打开冰箱门
        refrigerator.openDoor();
        //2.将大象装入冰箱
        refrigerator.putSomething(new Elephant());
        //3.关上冰箱门
        refrigerator.closeDoor();
    }

            可以看到在面向对象的世界里,一切以对象为核心,同样把大象装进冰箱里这个问题,我们的编程思路是先抽象出冰箱这样一个对象,然后抽象冰箱的静态属性和动态行为, 属性可以包括冰箱颜色、尺寸、耗电量等;动态行为包括开冰箱门,往冰箱门里放东西,关冰箱门等。

            面向过程的编程思路更加偏向于机器的思想,强调如何流程化的解决问题。而面向对象的思维强调以高内聚、低耦合的方式解决问题,先抽象事物模型,再解决实际问题。

    2.面向对象的四大特性

            2.1 抽象

            何为抽象?如果清晰、直观、易于理解被称作"具体",那么反过来则是"抽象"。举个例子:汇编语言就是对机器语言的一种初步抽象。C、C++等语言又是对汇编语言的抽象。面向对象语言则是高度抽象的高级语言。再比如:从化合物到食物,从食物到水果,都属于抽象的层面。Java中的Object类是所有类的默认父类,是对万事万物的抽象,是在哲学方向上进行的延伸思考,高度概括了事物的自然行为和社会行为。哲学中的经典三大问题在Object类中都可以得到隐约的解答:

          (1)我是谁?getClass()说明本质上是谁,而toString()则是当前类的名片

          (2)我从哪里来?Object()构造方法是生产对象最基本的方式,而clone()则是生产对象的另外一种方式

          (3)我要到哪里去?finalize()则是对象在被销毁的时候触发的方法

            另外Object还映射了社会科学领域的一些问题:

          (1)世界是否因你而不同?hashCode()和equals()就是判断与其他元素是否相同的一组方法

          (2)如何与他人协作?wait()和notify()是对象间通信与协作的一组方法

            抽象是面向对象思想中最基础的能力之一,正确而严谨的业务抽象能力是后续封装、继承、多态的基石。

            2.2 封装

            封装是在抽象的基础上决定某些信息是否公开,以及公开的访问等级,概括的说就是以什么样的方式暴露哪些信息。举个例子:在上述把大象装进冰箱的例子里,当我们要执行把大象放进冰箱的步骤时,我们只需要new一个冰箱的对象,然后执行其putSomething()的方法,而无需了解具体冰箱是如何把大象装进去的,也就是说封装了外部不需要感知的复杂处理逻辑。封装使对象之间的关系变得简单,耦合度变弱,利于维护。

            2.3 继承

            继承是面向对象编程技术的基石,允许创建具有逻辑等级结构的类体系。继承是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。继承把枯燥的代码世界变得更有扩展性,为多态打下语法基础。但需要慎用继承,滥用继承会产生方法污染和方法爆炸。方法污染指的是父类具有的行为通过继承传给子类,但子类并不具有执行此行为的能力,比如鸟会飞,鸵鸟继承鸟,发现飞不了。方法爆炸指的是继承树不断扩大,底层类拥有的方法虽然都能执行,但其中部分方法并非与当前类的功能定位有关,由于基类方法众多且名称相似,造成编程时选错方法,导致线上异常。综上所属,提倡以组合优先的原则来扩展继承类的人类,即优先采用组合或聚合的类关系来复用其他类的能力,而不是继承。

            2.4 多态

            多态是以上述三个面向对象特性为基础,根据运行时的实际对象类型,同一个方法产生不同的运行结果,使得同一个行为具有不同的表现形式。多态是指在编译层面无法确定最终调用的方法体,以覆写为基础来实现面向对象的特性,具体为在运行期由JVM进行动态绑定,调用合适的覆写方法体来执行。举个例子:足球烯和石墨烯互为同素异形体,但他们都为碳元素的不同表现形式。

    文中部分内容摘自《码出高效 Java开发手册》

    展开全文
  • 面向对象的程序设计面向对象编程(Object Oriented Programming,OOP,面向对象程序设计) 的主要思想是把构成问题的各个事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙一个事物在整个解决...

    面向对象的程序设计面向对象编程(Object Oriented Programming,OOP,面向对象程序设计) 的主要思想是把构成问题的各个事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙一个事物在整个解决问题的步骤中的行为。

    面向过程就是分析出解决问题所需要的步骤,然后用函数逐步实现,再依次调用就可以了。

    面向对象和面向过程是两种不同的编程思想,没有哪一种绝对完美,要根据具体需求拟定开发方案。例如,开发一个小型软件或应用程序,工程量小,短时间内即可完成,完全可以采用面向过程的开发方式,使用面向对象,反而会增加代码量,降低开发效率。

    面向过程的编程语言(如C语言)不能创建类和对象,不能用面向对象的思想来开发程序;面向对象的编程语言(如C++、PHP等)保留了面向过程的关键字和语句,仍然可以采用面向过程的思想来开发程序。

    面向对象是面向过程的补充和完善。

    注意,不要“死磕”概念上的理解,很多有经验的程序员甚至都不能完全解释清楚面向对象和面向过程的区别,要重在实践,不断揣摩编程语言的思想。

    类和对象的基本概念

    为了方便说明,我们将从现实生活中的实例入手。

    我们知道,工业上使用的铸件(电饭锅内胆、汽车地盘、发动机机身等)都是由模子铸造出来的,一个模子可以铸造出很多相同的铸件,不用的模子可以铸造出不同的铸件。这里的模子就是我们所说的“类”,铸件就是我们所说的“对象”。

    类,是创建对象的模板,一个类可以创建多个相同的对象;对象,是类的实例,是按照类的规则创建的。

    属性和方法

    由模子铸造出来的铸件(对象),有很多参数(长度、宽度、高度等),能完成不同的操作(煮饭、承重、保护内部零件等)。这里的参数就是对象的“属性”,完成的操作就是对象的“方法”。

    属性是一个变量,用来表示一个对象的特征,如颜色、大小、重量等;方法是一个函数,用来表示对象的操作,如奔跑、呼吸、跳跃等。

    对象的属性和方法统称为对象的成员。

    类的继承

    一个类(子类)可以继承另一个类(父类)的特征,如同儿子继承父亲的DNA、性格和财产。

    子类可以继承父类的全部特征,也可以继承一部分,由程序灵活控制。

    C++面向对象程序设计举例

    这里我们将通过几个简单的例子来演示如何站在面向对象的角度设计程序,以及使用类的好处。

    【例】最简单的例子。

    #include

    using namespace std;

    class Time //定义Time类

    {

    public : //数据成员为公用的

    int hour;

    int minute;

    int sec;

    };

    int main( )

    {

    Time t1;//定义t1为Time类对象

    cin>>t1.hour;//输入设定的时间

    cin>>t1.minute;

    cin>>t1.sec;

    //输出时间:

    cout<

    return 0;

    }

    运行情况如下:

    1232 43↙

    12:32:43

    几点注意:

    1) 在引用数据成员hour,minute,sec时不要忘记在前面指定对象名。

    2) 不要错写为类名,如写成

    Time.hour,Time.minute,Time.sec

    是不对的。因为类是一种抽象的数据类型,并不是一个实体,也不占存储空间,而对象是实际存在的实体,是占存储空间的,其数据成员是有值的,可以被引用的。

    3) 如果删去主函数的3个输入语句,即不向这些数据成员赋值,则它们的值是不可预知的。

    【例】引用多个对象的成员。

    1) 程序(a)

    #include

    using namespace std;

    class Time

    {

    public :

    int hour;

    int minute;

    int sec;

    };

    int main( )

    {

    Time t1;//定义对象t1

    cin>>t1.hour;//向t1的数据成员输入数据

    cin>>t1.minute;

    cin>>t1.sec;

    cout<

    Time t2;//定义对象t2

    cin>>t2.hour;//向t2的数据成员输入数据

    cin>>t2.minute;

    cin>>t2.sec;

    cout<

    return 0;

    }

    运行情况如下:

    1032 43↙

    10:32:43

    22 32 43↙

    22:32:43

    程序是清晰易懂的,但是在主函数中对不同的对象一一写出有关操作,会使程序冗长。为了解决这个问题,可以使用函数来进行输入和输出。见程序(b)。

    2) 程序(b)

    #include

    using namespace std;

    class Time

    {

    public :

    int hour;

    int minute;

    int sec;

    };

    int main( )

    {

    void set_time(Time&);//函数声明

    void show_time(Time&);//函数声明

    Time t1;//定义t1为Time类对象

    set_time(t1);//调用set_time函数,向t1对象中的数据成员输入数据

    show_time(t1);//调用show_time函数,输出t1对象中的数据

    Time t2;//定义t2为Time类对象

    set_time(t2);//调用set_time函数,向t2对象中的数据成员输入数据

    show_time(t2);//调用show_time函数,输出t2对象中的数据

    return 0;

    }

    void set_time(Time& t) //定义函数set_time,形参t是引用变量

    {

    cin>>t.hour;//输入设定的时间

    cin>>t.minute;

    cin>>t.sec;

    }

    void show_time(Time& t) //定义函数show_time,形参t是引用变量

    {

    cout<

    }

    运行情况与程序(a)相同。

    3) 程序(c)

    可以对上面的程序作一些修改,数据成员的值不再由键盘输入,而在调用函数时由实参给出,并在函数中使用默认参数。将程序(b)第8行以下部分改为:

    int main( )

    {

    void set_time(Time&,int hour=0,int minute=0,int sec=0);//函数声明

    void show_time(Time&);//函数声明

    Time t1;

    set_time(t1,12,23,34);//通过实参传递时、分、秒的值

    show_time(t1);

    Time t2;

    set_time(t2);//使用默认的时、分、秒的值

    show_time(t2);

    return 0;

    }

    void set_time(Time& t,int hour,int minute,int sec)

    {

    t.hour=hour;

    t.minute=minute;

    t.sec=sec;

    }

    void show_time(Time& t)

    {

    cout<

    }

    程序运行时的输出为:

    12:23:34 (t1中的时、分、秒)

    0:0:0 (t2中的时、分、秒)

    以上两个程序中定义的类都只有数据成员,没有成员函数,这显然没有体现出使用类的优越性。在下面的例子中,类体中就包含了成员函数。

    【例】改用含成员函数的类来处理。

    #include

    using namespace std;

    class Time

    {

    public :

    void set_time( );//公用成员函数

    void show_time( );//公用成员函数

    private : //数据成员为私有

    int hour;

    int minute;

    int sec;

    };

    int main( )

    {

    Time t1;//定义对象t1

    t1.set_time( );//调用对象t1的成员函数set_time,向t1的数据成员输入数据

    t1.show_time( );//调用对象t1的成员函数show_time,输出t1的数据成员的值

    Time t2;//定义对象t2

    t2.set_time( );//调用对象t2的成员函数set_time,向t2的数据成员输入数据

    t2.show_time( );//调用对象t2的成员函数show_time,输出t2的数据成员的值

    return 0;

    }

    void Time::set_time( ) //在类外定义set_time函数

    {

    cin>>hour;

    cin>>minute;

    cin>>sec;

    }

    void Time::show_time( ) //在类外定义show_time函数

    {

    cout<< hour<

    }

    运行情况与例8.2中的程序(a)相同。

    几点注意:

    在主函数中调用两个成员函数时,应指明对象名(t1,t2)。表示调用的是哪一个对象的成员函数。

    在类外定义函数时,应指明函数的作用域(如void Time∷set_time( ))。在成员函数引用本对象的数据成员时,只需直接写数据成员名,这时C++系统会把它默认为本对象的数据成员。也可以显式地写出类名并使用域运算符。

    应注意区分什么场合用域运算符“∷”,什么场合用成员运算符“.”,不要搞混。

    【例】找出一个整型数组中的元素的最大值。这个问题可以不用类的方法来解决,现在用类来处理,读者可以比较不同方法的特点。

    #include

    using namespace std;

    class Array_max //声明类

    {

    public : //以下3行为成员函数原型声明

    void set_value( ); //对数组元素设置值

    void max_value( ); //找出数组中的最大元素

    void show_value( ); //输出最大值

    private :

    int array[10]; //整型数组

    int max; //max用来存放最大值

    };

    void Array_max::set_value( ) //成员函数定义,向数组元素输入数值

    {

    int i;

    for (i=0;i<10;i++)

    cin>> array[i];

    }

    void Array_max::max_value( ) //成员函数定义,找数组元素中的最大值

    {

    int i;

    max=array[0];

    for (i=1;i<10;i++)

    if(array[i]> max) max=array[i];

    }

    void Array_max::show_value( ) //成员函数定义,输出最大值

    {

    cout<< "max="<< max;

    }

    int main( )

    {

    Array_max arrmax; //定义对象arrmax

    arrmax.set_value( ); //调用arrmax的set_value函数,向数组元素输入数值

    arrmax.max_value( ); //调用arrmax的max_value函数,找出数组元素中的最大值

    arrmax.show_value( ); //调用arrmax的show_value函数,输出数组元素中的最大值

    return 0;

    }

    运行结果如下:

    12 12 39 -34 17 134 045 -91 76↙ (输入10个元素的值)

    max=134 (输入10个元素中的最大值)

    请注意成员函数定义与调用成员函数的关系,定义成员函数只是设计了一组操作代码,并未实际执行,只有在被调用时才真正地执行这一组操作。

    可以看出: 主函数很简单,语句很少,只是调用有关对象的成员函数,去完成相应的操作。在大多数情况下,主函数中甚至不出现控制结构(判断结构和循环结构),而在成员函数中使用控制结构。在面向对象的程序设计中,最关键的工作是类的设计。所有的数据和对数据的操作都体现在类中。只要把类定义好,编写程序的工作就显得很简单了。

    展开全文
  • OOP面向对象编程

    2021-05-07 18:35:31
    OOP(Object Oriented Programming)即面向对象编程,本质上是一种编程思想,通过把我们编程中遇到的事物来抽象成对象来编程;与OOP相关的还有OOD(面向对象设计),OOA(面向对象分析)等 OOP应当遵循OOD的原则,...
  • 什么是面向对象编程(OOP)?用对象的思想去写代码,就是面向对象编程面向对象编程的特点抽象:抓住核心问题封装:只能通过对象来访问方法继承:从已有对象上继承出新的对象多态:多对象的不同形态对象的组成属性:...
  • Inheritance (继承) with virtual functions (虚函数) Inheritance(继承)+ Composition(复合) Delegation (委托) + Inheritance (继承) 前言 我们知道想要学习面向对象编程or设计,首先,我们要先掌握一门语言...
  • 面向对象编程OOP)

    2021-10-11 19:42:04
    面向对象OOP Object Orient Programming)是java编程的核心思想。 三大特性:封装,继承,多态 主要组成:类;对象;属性;动作(方法) 类:对某一类有相同特征的事物的抽象,或者说具有同种属性和行为的对象...
  • 本文概述面向对象编程是围绕对象而不是动作和数据而不是逻辑组织的编程模型。类类是一个实体, 它确定对象的行为方式以及对象将包含的内容。换句话说, 构建特定类型的对象是一个蓝图或一组指令。在PHP中, 使用class...
  • 1 面向对象编程简介2 类和实例3 ...面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。 面向过程的程序设计把计算机程.
  • 链接:https://www.cnblogs.com/whale90830/p/10488595.html由C到C++OOP第一课C语言的局限C++的特点C++的程序特征C++程序的结构...
  • 面向对象编程oop)初识面向对象面向对象&面向过程什么是面向对象方法回顾和加深对象的创建分析类与对象的关系创建与初始化对象面向对象三大特征(重点)封装继承多态Static 关键字抽象类和接口抽象类接口 ...
  • Oracle面向对象编程OOP

    2021-05-02 01:17:54
    自Oracle9i以来,Oracle就不再是单纯的关系数据库管理系统,它在关系数据库模型的基础上,添加了一系列面向对象的特性。Oracle9i就号称面向对象数据库。...下面详细介绍下Oracle面向对象编程。1 面向...
  • 面向对象编程OOP)是我们编程的一项基本技能,PHP5对OOP提供了良好的支持. 如何使用OOP思想来进行PHP的高级编程,对于提高 PHP编程能力和规划好Web开发构架都是非常有意义的 面向对象的三大特性:封装性 ,继承...
  • 面向对象编程OOP(Object Oriented Programming) 面向对象是把事物分解成为一个个对象,然后对象之间分工与合作。 面向对象是以对象功能来划分问题,而不是步骤 大象塞进冰箱:1、大象有一个功能:进去 。2、
  • 函数式编程能实现的,OOP均可以知足。...python接下来我就用多个简单的实例,来个你们展示两种不一样的"编程思想" 来实现相同的功能编程两段程序都将实现同一个目的,也就是打印下面这句话:ide 1、咱们先看...
  • 什么是面向对象编程OOP)? 用对象的思想去写代码,就是面向对象编程。 上面这张图就是一个对象,紫色部分就是车的属性,黄色部分就是修改车的方法; 把他们集合到一个构造函数内,就是这样的 function Car...
  • Object Oriented Programming 面向对象程序设计,简称OOP,是一种程序设计思想。 1.面向对象的理解 面向对象区别于面向过程,面向过程是指从解决一个问题的过程出发,一步一步的调用函数去解决问题,而面向对象专注...
  • Java面向对象编程OOP

    2021-07-24 20:27:16
    Java面向对象OOP OOP Objects Oriented Programming https://www.jianshu.com/p/7a5b0043b035 面向过程思想 步骤清晰简单,第一步做什么,第二部做什么… 面向过程适合处理一些较为简单的问题 面向对象思想 ...
  • 面向对象编程OOP)和函数式编程(FP) 编程的本质万变不离其宗就是,操纵一坨数据。 当然操纵的方式有许多,存储的方式也五花八门,但是本质不变,就是访问数据(读取以及改变)。 词条:操作数据 ​ 面向对象:...
  • 面向对象编程思想

    2021-10-31 11:02:17
    ,在这种情况下就要使用面向对象编程了,换句话说,面向对象编程就是应用于经常需要修改的代码,在代码复用的时候,面向对象编程无可替代 直接把对象名写在类定义后面,直接就能生成对象 #include using namespace ...
  • 有一个人走进商店,他对老板说:我想要一个东西,这个东西呢,它是圆形的,是甜甜的,上面有奶油,并且有一些水果在上面,可以插蜡烛...他繁复得叙述的这个什么东西,究竟是...Object OrientedProgramming,面向对象...
  • #C_OOP说明本项目是用 C 实现面向对象编程范式。支持面向对象的三大特性:继承、多态、封装。目前只能支持单继承,不支持接口。背景由于码主转行从事智能家居的开发,许多嵌入式平台是不支持C++的。码主从事过5年...
  • java面向对象编程oop面向对象编程:是一种以对象为原子性的编程思想,每个对象之间相互联系构建了整个系统、 面向对象的本质就是以类组织代码,以对象封装数据。 面向过程编程:是一种注重编程过程的思想,他...
  • OOP-面向对象编程思想 2.1 面向对象的概念 面向对象的编程是使用人类社会的思维方式来记性编程;面向对象是体现了人类社会的思维方式,而不是cpu的思维方式(汇编、二进制命令) 面向对象核心: 抽象、封装、...
  • 知识框架:Java面向对象编程和面向过程编程的区别“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想,简称OP。“面向过程”也可称之为“面向记录”编程思想,就是分析出解决问题所需要的步骤,然后用...
  • 面向对象编程(OOP)

    2021-08-04 10:03:30
    面向对象编程(OOP) 初识面向对象 面向过程思想: 步骤简单,第一步做啥,第二步做啥 面向对象思想: 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对分类进行单独思考.最后才对某个分类下的细节...
  • Python语言的面向对象面向对象编程,即OOP,对于面向对象的语言来说,常常会提到封装、继承、类等概念。面向对象的由来:基于哲学中的万物皆对象,核心思想是将我们的程序对象化,模块化,在Python语言中常用class...
  • 面向对象思想 物以类聚,分类的思维模式,思考问题首先会问题需要哪些分类,然后对这些进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题,适合处理需要多人协作的问题。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,325
精华内容 12,930
关键字:

oop面向对象的编程思想