public、protected、private在C++和Java中的应用及区别

转载
2009年08月04日 17:33:00

标签：

                <li><a href="http://so.csdn.net/so/search/s.do?q=java&amp;t=blog" target="_blank">java</a> <span>/</span></li>

                <li><a href="http://so.csdn.net/so/search/s.do?q=c++&amp;t=blog" target="_blank">c++</a> <span>/</span></li>

                <li><a href="http://so.csdn.net/so/search/s.do?q=class&amp;t=blog" target="_blank">class</a> <span>/</span></li>

                <li><a href="http://so.csdn.net/so/search/s.do?q=struct&amp;t=blog" target="_blank">struct</a> <span>/</span></li>

                <li><a href="http://so.csdn.net/so/search/s.do?q=access&amp;t=blog" target="_blank">access</a> <span>/</span></li>

                <li><a href="http://so.csdn.net/so/search/s.do?q=object&amp;t=blog" target="_blank">object</a> <span style="display: none;">/</span></li>

            </ul>
            <ul class="right_bar">
                <li><button class="btn-noborder"><i class="icon iconfont icon-read"></i><span class="txt">4124</span></button></li>
                <!--<li><button class="btn-noborder"><i class="icon iconfont icon-dashang-"></i><span class="txt">0</span></button></li>-->

                <li class="edit" style="display: none;">
                    <a class="btn-noborder" href="http://write.blog.csdn.net/postedit/4408352">
                        <i class="icon iconfont icon-bianji"></i><span class="txt">编辑</span>
                    </a>
                </li>
                <li class="del" style="display: none;">
                    <a class="btn-noborder" onclick="javascript:deleteArticle(fileName);return false;">
                        <i class="icon iconfont icon-shanchu"></i><span class="txt">删除</span>
                    </a>
                </li>
            </ul>
        </div>
        <div id="article_content" class="article_content csdn-tracking-statistics" data-mod="popu_307" data-dsm="post" style="overflow: hidden;">
            <p>Java中这个三个保留字用来修饰类的数据成员和成员函数，以及类本身，而C++中修饰类的数据成员和成员函数，以及类的继承，但不用来修饰类本身。</p>

◆ C++中应用：
1.Public, Private, and Protected 的成员

如果使用 class 关键字来定义类，那么定义在第一个访问标号前的任何成员都隐式指定为 private；如果使用 struct 关键字，那么这些成员都是 public。使用 class 还是 struct 关键字来定义类，仅仅影响默认的初始访问级别。默认情况下（没有使用任何关键字的场合），struct 的成员为 public，而 class 的成员为 private。

· public: 程序的任何地方都能使用；

· protected：只能是类本身及其派生类以及友元访问。并且，派生类只能通过派生类对象访问其基类的 protected 成员，派生类对其基类类型对象的 protected 成员没有特殊访问权限。像private一样，类的对象实例是不能访问的protected类成员的。

例如，假定 Bulk_item 定义了一个成员函数，接受一个 Bulk_item 对象的引用和一个 Item_base 对象的引用，该函数可以访问自己对象的 protected 成员以及 Bulk_item 形参的 protected 成员，但是，它不能访问 Item_base 形参的 protected 成员。

     void Bulk_item::memfcn(const Bulk_item &d, const Item_base &b)
     {
         // attempt to use protected member
         double ret = price;   // ok: uses this->price
         ret = d.price; // ok: uses price from a Bulk_item object
         ret = b.price; // error: no access to price from an Item_base
     }

· private：只能是类本身，以及友元函数和友元类访问；类的对象实例是不能访问 private 类成员的。

2.Public, Private, and Protected 的继承

基类本身指定对自身成员的最小访问控制。如果成员在基类中为 private，则只有基类和基类的友元可以访问该成员。派生类不能访问基类的 private 成员，也不能使自己的用户能够访问那些成员。如果基类成员为 public 或 protected，则派生列表中使用的访问标号决定该成员在派生类中的访问级别：

· 如果是Public 继承，基类成员保持自己的访问级别：基类的 public 成员为派生类的 public 成员，基类的 protected 成员为派生类的 protected 成员。

· 如果是 protected 继承，基类的 public 和 protected 成员在派生类中为 protected 成员。

· 如果是 private 继承，基类的的所有成员在派生类中为 private 成员。

假如，size 在 Base 中为 public，但在 Derived 中因为 private 继承 Base 后变为 private。为了使 size 在 Derived 中成为 public，可以在 Derived 的 public 部分增加一个 using 声明。如下这样改变 Derived 的定义，可以使 size 成员能够被用户访问，并使 n 能够被从 Derived 派生的类访问：
     class Derived : private Base {
     public:
        // maintain access levels for members related to the size of the object
        using Base::size;
     protected:
         using Base::n;
         // …
      };

· 默认继承保护级别
上面介绍过用 struct 和 class 保留字定义的类具有不同的默认访问级别，同样，默认继承访问级别根据使用哪个保留字定义派生类也不相同。使用 class 保留字定义的派生默认具有 private 继承，而用 struct 保留字定义的类默认具有 public 继承。

· 友元关系不能继承
先看下面的代码：
     class Base {
         friend class Frnd;
     protected:
         int i;
     };
     // Frnd has no access to members in D1
     class D1 : public Base {
     protected:
         int j;
     };
     class Frnd {
     public:
        int mem(Base b) { return b.i; } // ok: Frnd is friend to Base
        int mem(D1 d) { return d.i; }    // error: friendship doesn’t inherit
     };
     // D2 has no access to members in Base
     class D2 : public Frnd {
     public:
        int mem(Base b) { return b.i; } // error: friendship doesn’t inherit
     };
如上，基类的友元对从该基类派生的类型没有特殊访问权限。同样，如果基类和派生类都需要访问另一个类，那个类必须特地将访问权限授予基类的和每一个派生类。

· 继承与静态成员
如果基类定义 static 成员，则整个继承层次中只有一个这样的成员。无论从基类派生出多少个派生类，每个 static 成员只有一个实例。static 成员遵循常规访问控制：如果成员在基类中为 private，则派生类不能访问它。假定可以访问成员，则既可以通过基类访问 static 成员，也可以通过派生类访问 static 成员。一般而言，既可以使用作用域操作符也可以使用点或箭头成员访问操作符。

     struct Base {
         static void statmem(); // public by default
     };
     struct Derived : Base {
         void f(const Derived&);
     };
     void Derived::f(const Derived &derived_obj)
     {
        Base::statmem();      // ok: Base defines statmem
        Derived::statmem();   // ok: Derived in herits statmem
        // ok: derived objects can be used to access static from base
        derived_obj.statmem();     // accessed through Derived object
        statmem();                 // accessed through this class

· 派生类到基类转换的可访问性
如果是 public 继承，则用户代码和后代类都可以使用派生类到基类的转换。如果类是使用 private 或 protected 继承派生的，则用户代码不能将派生类型对象转换为基类对象。如果是 private 继承，则从 private 继承类派生的类不能转换为基类。如果是 protected 继承，则后续派生类的成员可以转换为基类类型。
无论是什么派生访问标号，派生类本身都可以访问基类的 public 成员，因此，派生类本身的成员和友元总是可以访问派生类到基类的转换。

◆ Java中应用：

1. 在Java中，这三个关键字就没有C++那么复杂，修饰数据成员和成员方法时，访问权限如下表

private
只能被类本身以及内部类的方法访问。

protected
可以被类本身，子类，以及同一包中的其它类访问。

public
可以在所有类中访问。

关于内部类的相关用法说明，打算另写一篇文章单独学习。

2. public 修饰类本身

在一个java源文件中，只能有一个public类，但可以有多个非public类。public类一般是含有main方法，并且名字与文件名相同。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/chopin407/archive/2009/04/24/4107795.aspx

public、protected、private在C++和Java中的应用及区别

public、protected、private在C++和Java中的应用及区别

猜你喜欢