类图上公共，保护，私有的目的是什么？ 有什么例子吗？

Question

我一直对访问修饰符感到好奇。

公开表示该项目可供有权访问该对象的任何人使用，

protected意味着它可用于对象本身及其任何子类，并且

private表示只能在类本身内访问它。

但是，我不知道公共，受保护和私有用例的示例。
我的意思是，有人可以在类图上向我解释有关公共，私有和受保护的访问修饰符的情况吗？
只是为了确保我正确理解它们。

谢谢！

Answer 1

确实，不仅有3种访问类型，而且在不同的语言中还有更多种访问类型。
例如：

1. 公共 -类或与此访问修饰符定义其成员将在任何地方公开访问，即使是从类的范围之内。
2. 私人 –使用此关键字的班级成员将在班级内部进行访问。 它通过类实例的引用保护成员免受外部类访问。
3. protected –与private相同，除了允许子类访问受保护的超类成员。
4. abstract –此关键字只能用于PHP类及其功能。 为了包含抽象函数，PHP类应该是抽象类。
5. final –防止子类覆盖由final关键字定义的超类成员。
6. internal-可以在包含其声明的程序中进行访问，也可以在同一程序集级别进行访问，但不能从另一个程序集进行访问。
7. 受保护的内部 -受保护和内部的访问级别相同。 它可以访问同一程序集中和同一类中的任何位置，也可以访问从同一类继承的类

其中一些适用于类，某些适用于函数，其他适用于变量。
因此，在大多数语言中，所有类成员都是使用公共访问类型声明的（例如，Java除外）。

回到主要问题。
所有这些访问修饰符的应用都是为了方便组件的封装。

在C ++中使用此类访问修饰符的简单示例（ 取自此处 ）：

#include <iostream>
#include<conio.h>
using std::cout;
using std::endl;

struct B { // default access modifier inside struct is public
    void set_n(int v) { n = v; }
    void f()          { cout << "B::f" << endl; }
  protected:
    int m, n; // B::m, B::n are protected
  private:
    int x;
};

struct D : B {
    using B::m;               // D::m is public
    int get_n() { return n; } // B::n is accessible here, but not outside
//  int get_x() { return x; } // ERROR, B::x is inaccessible here
 private:
    using B::f;               // D::f is private
};

int main() {
    D d;

//  d.x = 2; // ERROR, private
//  d.n = 2; // ERROR, protected
    d.m = 2; // protected B::m is accessible as D::m

    d.set_n(2); // calls B::set_n(int)
    cout << d.get_n() << endl; // output: 2

//  d.f();   // ERROR, B::f is inaccessible as D::f


    B& b = d; // b references d and "views" it as being type B

//  b.x = 3; // ERROR, private
//  b.n = 3; // ERROR, protected
//  b.m = 3; // ERROR, B::m is protected

    b.set_n(3); // calls B::set_n(int)
//  cout << b.get_n(); // ERROR, 'struct B' has no member named 'get_n'

    b.f();   // calls B::f()
    return 0;
}

因此，要了解此修饰符的目的，首先必须了解面向对象编程的核心原理，尤其是封装范例。
靠示例代码的和平就不能轻易解释这一点。
修饰符在庞大的OOP世界中很少。

Answer 2

基本上，您使用Public，private，protected和其他访问修饰符关键字来控制对类成员的访问。 例如，您希望变量或方法仅在类内部用于内部目的，但永远不要在类外部看到该成员，然后应使用“私有”访问修饰符关键字对其进行声明。

另一方面，“ Public”用于声明应从类外部访问的成员，构造函数是为什么应使用“ Public”关键字进行声明的明确示例。 执行诸如（.ToString，.Substring）之类的有用任务的方法等其他成员也是应该声明为public的成员的绝佳示例，简而言之，可以在类外部使用它们，并对使用您的类的任何人执行有用的任务。

考虑一下：

class employee
{
private int instanceCount = 0;
private string empName;

public employee(string fname, string lname)
{
//Provide some code for the constructor.
empname = fname + " " + lname;
instanceCount ++;}
}

显然，构造函数应该是公共的，用于计算实例数量的“ instanceCount”变量是私有的。

对于protected，适用于private的所有内容也适用于protected，只有一点点不同，protected可以被继承的类使用，而private不能。