公共,保护,私人在课堂图上的目的是什么?任何例子?

时间:2017-07-22 09:49:51

标签: java php private public protected


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

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

protected 表示它可用于对象本身和任何子类,并且

私有表示只能在班级内访问。

但是,我不知道公共,受保护和私人用例的例子 我的意思是,有人可以在类图上向我解释有关公共,私人和受保护访问修饰符的案例吗? 只是为了确保我理解他们。

谢谢!

2 个答案:

答案 0 :(得分:1)

确实不仅有3种访问类型,在不同的语言中有更多的访问类型 例如:

  1. 公开 - 使用此访问修饰符定义的类或其成员可以从任何地方公开访问,甚至可以从类的范围之外进行访问。
  2. 私有 - 具有此关键字的类成员将在类本身中访问。它通过类实例的引用来保护成员免受外部类访问。
  3. 受保护 - 与私有相同,但允许子类访问受保护的超类成员除外。
  4. abstract - 此关键字只能用于PHP类及其功能。对于包含抽象函数,PHP类应该是一个抽象类。
  5. final - 它会阻止子类覆盖使用final关键字定义的超类成员。
  6. 内部 - 可以在包含其声明的程序中访问,也可以在同一程序集级别内访问,但不能从另一个程序集访问。
  7. 受保护的内部 - 受保护和内部的相同访问级别。它可以访问同一个程序集中的任何位置,也可以访问从同一个类继承的类
  8. 其中一些适用于类,一些适用于函数,另一些适用于变量 因此,在大多数语言中,所有类成员都使用 public 访问类型声明(例如,Java除外)。

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

    在C ++中使用此类访问修饰符的简单示例(taken from here):

    #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世界的一小部分。

答案 1 :(得分:1)

基本上,您使用Public,private,protected和其他访问修饰符关键字来控制对类成员的访问。 例如,您希望变量或方法仅在类内部用于内部目的,但该成员永远不应在类外部看到,那么您应该使用&#34; Private&#34;访问修饰符关键字。

另一方面&#34; Public&#34;用于声明应该从类外部访问的成员,构造函数清楚地说明了为什么要使用&#34; Public&#34;关键词。其他成员(如执行有用任务的方法,如(.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 ++;}
}

很明显,构造函数应该是public的&#34; instanceCount&#34;用于计算实例数的变量是私有的。

对于受保护的,适用于私有的所有内容也适用于受保护的,只有很小的差异,受保护可以通过继承类来使用,私有不受。