两个Demo

发表于 | 分类于

Demo1

一些,类与对象的应用…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#include <iostream>
using namespace std;
#include"math.h"  ///程序中使用到是 sqrt()函数
/**
    1.定义一个Point的类
    2.定义一个Line类. 和Point组成组合的关系(也就是说,Line类里面有一个数据成员是类 类型的Point)
    要求是,通过组合的关系,求一线的长度
         想解这个题前提是会,在两类有组合关系时,使用 参数初始化列表 进行使用到的所有数据成员进行初始化;
***/
class Point{
private:
     int x;
     int y;
public :
    ///空参的构造函数
      Point(){}

    ///有参的构造函数(使用参数初始化列表)
    ///Point(int a,int b):x(a),y(b){}

    ///在函数体内初始化
    Point(int a, int b){
        x=a;
        y=b;
    }

    ///展示横坐标和纵坐标
     void display(){
          cout<<"x=="<<x<<"y=="<<y<<endl;
     }
    ///为了计算Line的长度的时候,获取x y 的值
     int getX(){return x;}
     int getY(){return y;}

     ///为什么用friend 关键字? 因为这个函数体中 直接使用 p.x 和p.y 而x,y是私有的,不能再外面直接访问
     friend ostream& operator<< (ostream& out,Point& p );
};
/***
这是在类体外定义函数,和类体内的区别就是,前面加上了    类名+域作用符::
Point::Point(int a, int b){
        x=a;
        y=b;
    }
*/
class Line{

    private:
        /// p1 和 p2 是Point类 类型的对象,现在当作Line的数据成员,(线的起点和终点)--->  组合关系(has  a )
        Point p1;
        Point p2;

    public:
        ///空参构造
        Line(){}
        ///有参
        Line (int a,int b,int c,int d):p1(a,b),p2(c,d){}
        ///求 长度
        float Length(){
            int c=p1.getX();
            int a=p2.getX();
            int d=p1.getY();
            int b=p2.getY();
           float result =  sqrt(((c-a)*(c-a) +(d-b)*(d-b)));
            return result;
        }
        /// 普通的成员函数展示
        void show(){
            p1.display();
        }




    int x1;///起点的横坐标
    int y1;///起点的纵坐标
    int x2;///终点的横坐标
    int y2;///终点的纵坐标

};

 ///友元函数,重载 <<  ,目的是,拓展<<的功能,让他可以打印对象. 等效于上面的   show()
 /// 函数的返回值类型  函数名(自定义) () {}
  ostream& operator<< (ostream& out,Point& p ){
        out<<"通过友员 x=="<<p.x<<"y=="<<p.y<<endl;
        return out;
    }


int main (){

        /** 
        测试友元函数
        Point pp(5,6);
        cout<<pp;
        **/

        Line l(1,2,3,4);
        l.show();

        int lenth = l.Length();
        cout<<"长度=="<<lenth<<endl;
return  0;
}

Demo2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include <iostream>
using namespace std;
  /**
    条件:
        1.创建一个aminal类(抽象类)
            成员函数: move() 用来计算,动物移动了多远
            数据成员: meter; 米(静态变量)
        2.给aminal类,添加三个子类 dog fish bird;
    要求:
        求出三个动物一个走多远;
    知识储备:
        一:什么是抽象类?
            只要当前类存在任意一个纯虚函数,该就叫做抽象类!
             注意点:
                1.纯虚函数被 virtual修饰
                2.纯虚函数没有函数体;
                3.纯虚函数的()后面=0;
                  例:virtual void fun()=0; -->fun是纯虚函数
                     virtual void fun() const =0; -->fun同样是是纯虚函数,
                                const关键字的作用的限制,当前函数,只能使用类的数据成员,但是不能改变数据成员的值;
        二:抽象类存在的价值?
            一:它不能直接创建对象,所以它存在的唯一目的就是当父亲,让它的子类实现他的方法,-->多态

        三:什么是静态变量?和普通变量的区别?
            1.普通变量属于类的对象,
            2.静态变量属于当前类
                注意点,静态的变量,一定要在类外初始化.而且,必须初始化;
  */

  class animal{

    private :

    public:

           static float meter;

            virtual void move()=0;

             void display(){
                cout<<"动物们一共移动了多远=="<<animal::meter<<endl;
            }
           virtual void show(){
                cout<<"animal--"<<endl;
            }

  };
    float animal:: meter=0;///对静态的变量,一定要在类外初始化.而且,必须初始化;

   /**
        让dog继承animal,重写animal的方法
        问?
            可以不重写animal的方法吗?
        答:
            可以,但是,不重写dog类依然是抽象类,如果他还是抽象类,那么它就不能创建对象,也就是说,我不能直接使用

   */

    ///dog继承animal , 也就是说,dog里面已经有了 animal的所有成员,包括 meter 和 move()
    /// 我们关心的就只有,如何重写animal的函数,以及dog的构造函数了
     class dog:public animal{
    private:
        int dogMeter;
    public :
         dog(int a){dogMeter=a;}///空参

        virtual void move(){ ///重写move函数  前面的virtual关键字和返回值类型,不能省!
            animal::meter+=dogMeter;
         }

       virtual void show(){
        cout<<"dog--"<<endl;
        }

   } ;

   ///鸟
   class bird:public animal{
    private:
        int birdMeter;
    public :
         bird(int a):birdMeter(a){}///使用参数初始化表初始化


        virtual void move(){ ///重写move函数  前面的virtual关键字和返回值类型,不能省!
            animal::meter+=birdMeter;
         }

   } ;

   ///fish
      class fish:public animal{
    private:
        int fishMeter;
    public :
         fish(int a){fishMeter=a;}///在函数体内


        virtual void move(){ ///重写move函数  前面的virtual关键字和返回值类型,不能省!
            animal::meter+=fishMeter;
         }

   } ;


int main (){

    ///1. 创建三个动物的对象
    dog d(10);
    d.move();

    fish f(10);
    f.move();

    bird b(30);
    b.move();

    b.display();

///下面是測試多态和本题无关...
    ///2.通过父类引用指向子类对象(多态)打印出 一共跑了多远
    animal& a=d;
     a.show();
    ///3.通过父类指針指向子类对象(多态)打印出 一共跑了多远
    animal* an = &d;
     an->show();
    (*an).show();

      return  0;
}