C++中的类与封装

1，类的组合：

1，类不是孤立存在的，类之间都会有一些关系，组合就是类的基本关系之一；

2，电脑一般而言是由 CPU、内存、主板、键盘和硬盘等部件组合而成；

3，学习电脑组装需要多少时间？学习电脑组装是否需要学习显示器、键盘、鼠标、主板、内存等部件的设计与制造？

1，我们可以使用一个类，但是可能对类的内部状态一无所知；

2，类的封装：

1，类通常分为以下两个部分：

1，类的实现细节；

1，使用者往往可以忽略；

2，类的使用方式；

2，当使用类时，不需要关心其实现细节；

1，普通用户使用手机：

1，只需要学习如何发短信、打电话、拍照等；

2，对类的使用者而言，简单且能够满足需求才可以，如果太复杂，则不会有人使用这个类；

3，封装对于类的使用者而言是非常重要的概念，必须知道当我们创建类的 时候，一定要将复杂的实现细节全部封装在内部，不让使用者知道，对于使用者而言我们留给他们的就是一些非常简单的使用方式就可以了，这就是类的封装；

3，当创建类时，才需要考虑其内部实现细节；

1，手机开发工程师：

1，需要考虑手机内部的实现细节；

3，封装的由来：

1，根据经验：并不是类的每个属性都是对外公开的；

1，如：女孩儿不希望外人知道自己的体重和年龄；

2，如：男孩儿不希望别人知道自己的身高和收入；

2，而一些类的属性是对外公开的：

1，如：人的姓名、学历、国籍等；

3，必须在类的表示法中定义属性和行为的公开级别：

1，类似文件系统中文件的权限；

2，“公开级别”就是封装的体现；

4，C++ 中类的封装：

1，肯定要对类的行为和属性进行封装，所以定义的访问级别要作用于成员变量和成员函数；

1，C++ 中已经可以对类成员进行访问级别的定义了；

2，成员变量：C++ 中用于表示类属性的变量；

3，成员函数：C++ 中用于表示类行为的函数；

4，C++ 中可以给成员变量和成员函数定义访问级别：

1，public：

1，成员变量和成员函数可以在类的内部和外界访问和调用；

2，private：

1，成员变量和成员函数只能在类的内部被访问和调用；

3，这两个关键字体现了封装的概念；

5，类成员的访问属性编程实验：

 #include <stdio.h>
 #include <stdio.h>

 struct Biology
 {
     bool living;
 };

 struct Animal : Biology
 {
     bool movable;

     void findFood()
     {
     }
 };

 struct Plant : Biology
 {
     bool growable;
 };

 struct Beast : Animal
 {
     void sleep()
     {
     }
 };

 struct Human : Animal
 {
     void sleep()
     {
         printf("I'm sleeping...\n");
     }

     void work()
     {
         printf("I'm working...\n");
     }
 };

 struct Girl : Human
 {
 private:
     int age;
     int weight;
 public:
     void print()
     {
         age = ;
         weight = ;

         printf("I'm a girl, I'm %d years old.\n", age);
         printf("My weight is %d kg.\n", weight);
     }
 };

 struct Boy : Human
 {
 private:
     int height;
     int salary;
 public:
     int age;
     int weight;

     void print()
     {
         height = ;
         salary = ;

         printf("I'm a boy, my height is %d cm.\n", height);
         printf("My salary is %d RMB.\n", salary);
     }
 };

 int main()
 {
     Girl g;
     Boy b;

     g.print();

     b.age = ;
     b.weight = ;
     //b.height = 180;

     b.print();

     return ;
 }

6，类成员的作用域：

1，类成员的作用域都只在类的内部，外部无法直接访问；

1，所以类成员函数可以直接访问成员变量和成员函数；

2，外部函数要通过对象（除了静态成员函数通过类访问）来访问类的成员；

3，类的内部还是外部的判断依据是：是否定义在类的里面；

2，成员函数可以直接访问成员变量和调用成员函数；

3，类的外部都可以通过类变量访问 public 成员；

4，类成员的作用域与访问级别没有关系：

1，类的作用域仅是为了说明在类的内部是可以访问的，不管有没有访问级别；

2，访问级别仅仅是为了外部函数访问类的成员而准备；

　　1，C++ 中用 struct 定义的类中所有成员默认为 public；

7，类成员的作用域编程实验：

 #include <stdio.h>

 int i = ;

 struct Test
 {
 private:
     int i;

 public:
     int j;

     int getI()
     {
         i = ;

         return i;
     }
 };

 int main()
 {
     int i = ;  // 定义的第四个 i

     Test test;

     test.j = ;

     printf("i = %d\n", i);             // i = 2;
     printf("::i = %d\n", ::i);         // ::i = 1; 访问默认的命名空间、也就是全局作用域，其没有名字；
     // printf("test.i = %d\n", test.i);    // Error
     printf("test.j = %d\n", test.j);    // test.j = 4
     printf("test.getI() = %d\n", test.getI());  // test.getI() = 3

     return ;
 }

1，对于类而言是有作用域的，类的作用域仅仅指的是类的成员变量和成员函数     的作用域，在整个类中；

2，类外部访问类内部成员必须同过对象（或类）来访问；

3，总而言之：

1，类的内部：通过类的作用域访问，与访问级别无关；

2，类的外部：通过类的对象（或类）访问，有访问级别的限制；

8，小结：

1，类通常可以分为使用方式和内部细节两部分；

2，类的封装机制使得使用方式和内部细节相分离；

1，通过封装给类成员定义访问级别，以 public 成员作为使用方式，以 protected 和 private 作为内部细节；

2，只有这样，我们的程序设计才可能简单、产生的 bug 才可控；

3，C++ 中通过定义类成员的访问级别实现封装机制；

4，public 成员可以在类的内部和外界访问和调用；

5，private 成员只能在类的内部被访问和调用；