精华内容
下载资源
问答
  • Java 类成员访问控制符

    千次阅读 2013-10-20 19:02:11
    今天被问了一个 Java 基础知识:Java 类成员访问控制符(Access Modifier)有几种?这些访问控制符之间有何区别?   首先回答第一个问题。通常我们可以显示声明的访问控制符有三个:public, private 和 ...

    今天被问了一个 Java 基础知识:Java 类成员的访问控制符(Access Modifier)有几种?这些访问控制符之间有何区别?

     

    首先回答第一个问题。通常我们可以显示声明的访问控制符有三个:public, private 和 protected。但是,我们也会碰到另一种情况:在成员变量或者方法声明前面不加任何的访问控制符。通过这种方式声明的成员具有缺省访问控制(default access)属性。具有缺省访问属性的类成员的可访问性被限制在包(package)内,因而有人也称之为包可见访问控制。

     

    然后,关于四种访问控制属性的对比,可以直接引用 SO 上的一张非常清晰的对比图表:

    Modifier    | Class | Package | Subclass | World
    ————————————+———————+—————————+——————————+———————
    public      |  ✔    |    ✔    |    ✔     |   ✔
    ————————————+———————+—————————+——————————+———————
    protected   |  ✔    |    ✔    |    ✔     |   ✘
    ————————————+———————+—————————+——————————+———————
    no modifier |  ✔    |    ✔    |    ✘     |   ✘
    ————————————+———————+—————————+——————————+———————
    private     |  ✔    |    ✘    |    ✘     |   ✘

     

    这张图表可以这样解读(以 protected 为例):

    proctected 访问控制符所修饰的类成员在声明该成员的类类所在的包中的所有其他类以及该类的所有子类中是可见的,而对除此之外的其他类是不可见的。

     

    需要注意的一点是,缺省访问控制的类成员只是包内可见,如果其子类也同一个包内,那么也是子类可见的。但是,由于对包外声明的子类是不可见的,所以有上图标中的第4行第4列的✘。

     

    另外,值得领会的另一个问题是:在实际编程中应该如何选择使用哪一种访问控制符?SO上得票数第二的回答也是值得读一下的。总的来说,访问控制符设计的初衷是针对 OO 中的封装性 - 应该尽量将信息隐藏。类成员的访问权限放的越开,日后对于该类成员的任何改变就越要谨慎,因为这个类成员可能被很多人使用。如何选择,应该充分考虑类成员的最终用途。

     

    展开全文
  • C#类成员访问修饰

    千次阅读 2015-09-10 15:07:55
    今天想起C#中的默认访问修饰是internal了还以为是public呢,单元测试时候一直是黄色敬告。所以把csdn的东西翻出了(在百度上搜到的)。当用internal修饰(c#默认加修饰就是internal)可能会出现问题:...
    今天想不起C#中类的默认访问修饰符是internal了还以为是public呢,单元测试时候一直是黄色敬告。所以把csdn的东西翻出了(在百度上搜不到的)。当用internal修饰类(c#默认不加修饰符就是internal)可能会出现问题:当你在继承或者是实例化一个internal类的时候你的访问权限不能打破原来internal类的访问限制。
    例:internal class A{}
            public class B:A{}是不允许的;
            public class C{ public A a=new A();}是不允许的.

    msdn参考:
    访问修饰符(C# 编程指南)

    所有类型和类型成员都具有可访问性级别,用来控制是否可以在您程序集的其他代码中或其他程序集中使用它们。您在声明类型或成员时使用以下访问修饰符之一来指定其可访问性:

    public (可以修饰类)

    同一程序集中的任何其他代码或引用该程序集的其他程序集都可以访问该类型或成员。

    private (成员的默认访问修饰符) (成员方法和成员字段的默认访问符)

    只有同一类或结构中的代码可以访问该类型或成员。

    protected

    只有同一类或结构或者派生类中的代码可以访问该类型或成员。

    internal (可以修饰类,类的默认修饰符)

    同一程序集中的任何代码都可以访问该类型或成员,但其他程序集中的代码不可以。(internal指的是同一个程序集,内部成员和类型才是可以访问的.内部访问通常用于基于组件的开发,因为它使一组组件能够以私有方式进行合作,而不必向应用程序代码的其余部分公开)

    protected internal

    同一程序集中的任何代码或其他程序集中的任何派生类都可以访问该类型或成员。

    下面的示例演示如何为类型和成员指定访问修饰符:

    不是所有访问修饰符都可以在所有上下文中由所有类型或成员使用,在某些情况下类型成员的可访问性受到其包含类型的可访问性的限制。以下各节提供了有关可访问性的更多详细信息。


    c中类的默认访问修饰符,是private还是internal - 一束光 - 山的那边很漂亮 类和结构的可访问性 

    直接在命名空间中声明的类和结构(即,没有嵌套在其他类或结构中的类和结构)可以是公共类和结构,也可以是内部类和结构。如果不指定访问修饰符,则默认为 internal。嵌套的类和结构还可以声明为私有类和结构。不可以从包含类型访问私有嵌套类型。

    派生类的可访问性不能高于其基类型。换句话说,不能有从内部类 A 派生的公共类 B。如果允许这种情况,将会使 A 成为公共类,因为 A 的所有受保护的成员或内部成员都可以从派生类访问。

    可以使用 InternalsVisibleToAttribute 使其他某些程序集能够访问您的内部类型。有关更多信息,请参见友元程序集(C# 编程指南)


    c中类的默认访问修饰符,是private还是internal - 一束光 - 山的那边很漂亮 类成员和结构成员的可访问性 

    可以使用五种访问类型中的任何一种来声明类成员(包括嵌套的类和结构)。结构成员无法声明为受保护成员,因为结构不支持继承。

    成员的可访问性决不能高于其包含类型的可访问性。例如,在内部类型中声明的公共方法只具有内部可访问性。

    如果类或结构的成员为属性、字段、方法、事件或委托,并且该成员是某个类型或具有参数或返回值类型,则该成员的可访问性不能超过该类型。例如,如果 C 不是公共类,则不能返回类 C 的公共方法 M。同样,如果 A 声明为私有,则类型 A 不能有受保护的属性。

    用户定义的运算符必须始终声明为公共运算符。有关更多信息,请参见 operator(C# 参考)

    析构函数不能具有可访问性修饰符。

    若要设置类成员或结构成员的访问级别,请向该成员声明添加适当的关键字。下面是一些示例:


    c中类的默认访问修饰符,是private还是internal - 一束光 - 山的那边很漂亮说明:

    protected internal 可访问性的意思是受保护“或”内部,而不是受保护“和”内部。换句话说,可以从同一程序集内的任何类(包括派生类)中访问 protectedinternal 成员。若要限制为只有同一程序集内的派生类可以访问,请将类本身声明为内部,并将其成员声明为受保护。


    c中类的默认访问修饰符,是private还是internal - 一束光 - 山的那边很漂亮 其他类型 

    直接用命名空间声明时,可以将接口声明为公共接口或内部接口,并且与类和结构一样,接口默认具有内部可访问性。接口成员始终是公共成员,因为接口的用途是让其他类型能够访问某个类或结构。访问修饰符不能应用于接口成员。

    枚举成员始终是公共的,不能应用任何访问修饰符。

    默认情况下,委托默认具有内部访问级别。

    展开全文
  • 在C++的成员函数中,允许直接访问的对象的私有成员变量。 b. 在成员函数中可以访问同类型实例的私有变量。 c. 拷贝构造函数里,可以直接访问另外一个同类对象(引用)的私有成员。 d. 成员...
    问题(知识点)描述:
    a. 在C++的类的成员函数中,允许直接访问该类的对象的私有成员变量。
    b. 在类的成员函数中可以访问同类型实例的私有变量。
    c. 拷贝构造函数里,可以直接访问另外一个同类对象(引用)的私有成员。
    d. 类的成员函数可以直接访问作为其参数的同类型对象的私有成员。
    举例描述上述知识:
    1).在拷贝构造函数中可以访问引用对象的私有变量:例如: 
    class   Point 

    public: 
           Point(int xx=0,int yy=0){X=xx;Y=yy;} 
           Point(Point &p); 
    private: 
           int   X,Y; 
    }; 
    Point::Point (Point   &p) 

           X=p.X; 
           Y=p.Y; 
    }
    2). 在类的成员函数中可以访问同类型实例的私有变量
    class  A
    {
    public:
    int getA() const { return a; }
      void setA(int val) { a = val; }
      void assign(A& _AA)
     {
      this->a = _AA.a;
      _ AA.a = 10;//可以直接访问
     }
       void display()
          {
            cout<<"a:"<<a<<endl;
          }
    private:
       int a;
    };




    3). 
    #include <iostream>
    using namespace std;
    class TestClass
    {
    public:
        TestClass(int amount)
        {
            this->_amount = amount;
        }
        void UsePrivateMember()
        {
            cout<<"amount:"<<this->_amount<<endl;
            /*----------------------*/
            TestClass objTc(10);
            objTc._amount = 15;   //访问同类型实例的私有变量
            cout<<objTc._amount<<endl; 
            /*----------------------*/
        }
    private:
        int _amount;
    };






    int main()
    {
        TestClass tc(5);
        tc.UsePrivateMember();
        return(0);
    }




    关于该问题(知识点)的讨论和或解释:
    1. 私有是为了实现“对外”的信息隐藏,或者说保护,在类自己内部,有必要禁止私有变量的直接访问吗?难道还要让我们声明一个类
    为自身的友元?
    Point::Point(Point   &p) 

            X=p.X;   //这在Point类中的Point函数内,所以没错。 
            Y=p.Y; 
    }
    请记住你是在定义你的类,不是在用。
    2. C++的访问修饰符的作用是以类为单位,而不是以对象为单位。
    通俗的讲,同类的对象间可以“互相访问”对方的数据成员,只不过访问途径不是直接访问.
    步骤是:通过一个对象调用其public成员函数,此成员函数可以访问到自己的或者同类其他对象的public/private/protected数
    据成员和成员函数(类的所有对象共用),而且还需要指明是哪个对象的数据成员(调用函数的对象自己的成员不用指明,因为有this指
    针;其他对象的数据成员可以通过引用或指针间接指明)
    可以提供访问行为的主语为“函数”。
    类体内的访问没有访问限制一说,即private函数可以访问public/protected/private成员函数或数据成员,同理,protected
    函数,public函数也可以任意访问该类体中定义的成员public继承下,基类中的public和protected成员继承为该子类的public和
    protected成员(成员函数或数据成员),然后访问仍然按类内的无限制访问。
    3. 注意公有和私有的概念:每个类的对象都有自己的存贮空间,用于存储内部变量和类成员;但同一个类的所有对象共享一组类方法,
    即每种方法只有一个源本。很明显,类方法是所有该类对象共同使用的,因此不存在每个对象有一组类方法的副本。源本的类方法自然
    可以访问所有该类对象的私有成员。
    4. 访问权限是相对于类而言,而非对象!
    一个问题,为什么成员函数可以访问私有成员呢?结果很显然,如果不能访问,那么私有成员的存在就没有了意义。而对于成员函数中
    允许访问对象的数据成员,一方面保证了安全性与封装性,另一方面提供方便的操作。第一句话的解释,就是承认只有成员函数可以访
    问私有成员,这里不涉及友元及派生。这样一来,安全性仍然得到了保证,也完成了封装工作。对于第二句话,试想,如果都得靠接口
    来实现数据传送,那么操作是否极为不便?既然处于成员函数中,已经保证了足够的安全和封装性,那么这里如果还得借助接口,就有
    些不合情合理了。作为对数据成员的灵活处理,设计者允许在成员函数中访问对象的私有成员,为使用者提供了很大的方便。这同时也
    反映了语言的灵活性和原则性.




    C++中类访问权限控制:
    第一:private, public, protected 访问标号的访问范围,在没有继承的情况下:
    private:
    只能由1.该类中的函数、2.其友元函数访问。
    不能被任何其他访问,该类的对象也不能访问。
    protected:
    可以被1.该类中的函数、2.子类的函数、以及3.其友元函数访问。
    但不能被该类的对象访问。
    public:
    可以被1.该类中的函数、2.子类的函数、3.其友元函数访问,也可以由4.该类的对象访问。
     注:友元函数包括3种:设为友元的普通的非成员函数;设为友元的其他类的成员函数;设为友元类中的所有成员函数。
    第二:类的继承后方法属性变化,具体情况如下:
    private 属性是不能够被继承的,protected继承和private继承能降低访问权限。
    使用private继承,父类的protected和public属性在子类中变为private;
    使用protected继承,父类的protected和public属性在子类中变为protected;
    使用public继承,父类中的protected和public属性不发生改变; 
     如下所示: 
                       public:        protected:       private:
    public继承          public        protected        不可用 
    protected继承       protected     protected        不可用 
    private继承         private       private          不可用 




    class A
    {
     public:
         A(int i) : a(i){}
     protected:
         int a;
     };
    class B : public A
    {
     public:
         B(int i) : A(i) {}
         void fb(A  &a) {cout<<a.a<<endl;}
     };
    编译出错;若将倒数第二行改为
    void fb(B  &a) {cout<<a.a<<endl;}
    则编译运行都没问题:
    保护类型只能被本类中的方法或者派生类访问,不能被本类的具体对象访问。a是类A的保护类型成员,能被A中的方法(函数)访
    问,能被B类访问,不能被类A的具体对象A a访问。
    一个类的保护成员或私有成员只能被该类的成员函数或该类的友元函数来访问,外部代码不能访问,B类中的函数fb对于A类中的
    保护成员变量a来说是外部代码不能通过该类的对象直接访问,由于B类公有继承了A类,a在A类中是保护成员,则在B类中也是保
    护成员,因此B类中的函数可以访问自己的保护成员。
    展开全文
  • 今天想起C#中的默认访问修饰是internal了还以为是public呢,单元测试时候一直是黄色敬告。 所以把csdn的东西翻出了(在百度上搜到的)。当用internal修饰(c#默认加修饰就是internal)可能会出现问题...
    今天想不起C#中类的默认访问修饰符是internal了还以为是public呢,单元测试时候一直是黄色敬告。 所以把csdn的东西翻出了(在百度上搜不到的)。当用internal修饰类(c#默认不加修饰符就是internal)可能会出现问题:当你在继承或 者是实例化一个internal类的时候你的访问权限不能打破原来internal类的访问限制。
    例:internal class A{}
            public class B:A{}是不允许的;
            public class C{ public A a=new A();}是不允许的.
     
    msdn参考:
    访问修饰符(C# 编程指南)

    所有类型和类型成员都具有可访问性级别,用来控制是否可以在您程序集的其他代码中或其他程序集中使用它们。您在声明类型或成员时使用以下访问修饰符之一来指定其可访问性:

    public (可以修饰类)

    同一程序集中的任何其他代码或引用该程序集的其他程序集都可以访问该类型或成员。

    private (成员的默认访问修饰符)

    只有同一类或结构中的代码可以访问该类型或成员。

    protected

    只有同一类或结构或者派生类中的代码可以访问该类型或成员。

    internal (可以修饰类,类的默认修饰符)

    同一程序集中的任何代码都可以访问该类型或成员,但其他程序集中的代码不可以。

    protected internal

    同一程序集中的任何代码或其他程序集中的任何派生类都可以访问该类型或成员。

    下面的示例演示如何为类型和成员指定访问修饰符:

    不是所有访问修饰符都可以在所有上下文中由所有类型或成员使用,在某些情况下类型成员的可访问性受到其包含类型的可访问性的限制。以下各节提供了有关可访问性的更多详细信息。

    直接在命名空间中声明的类和结构(即,没有嵌套在其他类或结构中的类和结构)可以是公共类和结构,也可以是内部类和结构。如果不指定访问修饰符,则默认为 internal 。嵌套的类和结构还可以声明为私有类和结构。不可以从包含类型访问私有嵌套类型。

    派生类的可访问性不能高于其基类型 。换句话说,不能有从内部类 A 派生的公共类 B 。如果允许这种情况,将会使 A 成为公共类,因为 A 的所有受保护的成员或内部成员都可以从派生类访问。

    可以使用 InternalsVisibleToAttribute 使其他某些程序集能够访问您的内部类型。有关更多信息,请参见友元程序集(C# 编程指南)

    可以使用五种访问类型中的任何一种来声明类成员(包括嵌套的类和结构)。结构成员无法声明为受保护成员,因为结构不支持继承。

    成员的可访问性决不能高于其包含类型的可访问性。例如,在内部类型中声明的公共方法只具有内部可访问性。

    如果类或结构的成员为属性、字段、方法、事件或委托,并且该成员是某个类型或具有参数或返回值类型,则该成员的可访问性不能超过该类型。例如,如果 C 不是公共类,则不能返回类 C 的公共方法 M 。同样,如果 A 声明为私有,则类型 A 不能有受保护的属性。

    用户定义的运算符必须始终声明为公共运算符。有关更多信息,请参见 operator(C# 参考)

    析构函数不能具有可访问性修饰符。

    若要设置类成员或结构成员的访问级别,请向该成员声明添加适当的关键字。下面是一些示例:

    说明:

    protected internal 可访问性的意思是受保护“或”内部,而不是受保护“和”内部。换句话说,可以从同一程序集内的任何类(包括派生类)中访问 protected internal 成员。若要限制为只有同一程序集内的派生类可以访问,请将类本身声明为内部,并将其成员声明为受保护。

    直接用命名空间声明时,可以将接口声明为公共接口或内部接口,并且与类和结构一样,接口默认具有内部可访问性。接口成员始终是公共成员,因为接口的用途是让其他类型能够访问某个类或结构。访问修饰符不能应用于接口成员。

    枚举成员始终是公共的,不能应用任何访问修饰符。

    默认情况下,委托默认具有内部访问级别。

    展开全文
  • public(访问控制符),将一个声明为公共,他可以被任何对象访问,一个程序的主类必须是公共。 abstract,将一个声明为抽象,没有实现的方法,需要子类提供方法实现。 final,将一个生命为最终(即非...
  • 这样的结果就是,在方法之外,并能访问到该内部,也即需要private等访问控制符修饰,因为他本身就是在内部使用的,外部能访问2、一个中,一个static变量只会有一个内存空间,虽然有多个实例,但这些...
  • public (访问控制符) ,将一个声明为公共,他可以被任何对象访问,一个程序的主类必须是公共。 protected (保护访问控制符) 同一个包中的其他任何以及任何子类 (无论子类是在哪个包中声明的) 中引用这些。...
  • Java中的访问控制符

    千次阅读 2016-09-08 23:11:50
    的控制访问JAVA语言中有公共的(public),私有的(private),保护的(protacted)和默认的(default)四...默认访问级别一个的资源仅允许在包内访问成员的访问控制下面给出四种访问控制符的作用级别 访问控制符
  • 修饰符的含义 public 将一个声明为公共,他可以被任何对象访问 abstract 将一个声明为抽象,没有实现方法,需要子类提供方法的实现,所以能创建该的实例 ...public 公共访问控制符 指定该变量为公共的
  • public:这是公有的成员允许类外直接访问,当然,这要加上作用域::, protected:这是保护成员,只允许及其派生类访问 private:这是私有成员,只允许在该中进行访问,当然,在外只可以通过设定的公有函数...
  • public(访问控制符),将一个声明为公共,他可以被任何对象访问,一个程序的主类必须是公共。 abstract,将一个声明为抽象,没有实现的方法,需要子类提供方法实现。 final,将一个生命为最终(即非...
  • 1. 的修饰 修饰 包外 子类 包内 内 public Yes Yes
  • 访问控制符的作用是说明被声明的内容(、属性、方法和构造方法)的访问权限,就像发布的文件一样,在文件中标注...具体的实现就是通过访问控制符中会被其它调用的内容开放出来,而把希望别人调用的内容隐藏起来
  • java中的修饰成员变量修饰、方法修饰

    千次阅读 多人点赞 2016-09-09 15:07:15
    java中的修饰成员变量修饰、方法修饰
  • 目录 一、的修饰符 ...类成员访问控制符 修饰符 成员访求 构造方法 成员变量 局部变量 abstract(抽象的) √...
  • java中的访问控制符

    千次阅读 2019-05-06 12:33:00
    java提供了3个访问控制符,private,protected和public,分别代表了3个访问控制级别,另外还有一个加任何访问控制符的访问控制级别,提供了4个访问控制级别。Java的访问控制级别由小到大如图5.14所示。 標題 ...
  • 访问控制(可见性)PHP 中,对中的成员(属性和方法)的访问控制,是通过以下三个访问修饰来实现的。public(公有的)protected(受保护的)private(私有的)public、protected 和 private 可以控制类成员的...
  • 封装的一个重要属性:访问控制。 通过封装可以控制程序的某个部分所能访问成员,防止对象滥用。从而保护对象中数据的完整性。 在Java中的每个成员(数据成员成员方法)都有一个成为可访问性的属性,用来...
  • C++类成员访问权限

    千次阅读 2019-03-15 15:27:28
    C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限,它们分别表示公有的、受保护的、私有的,被称为成员访问限定。所谓访问权限,就是你能能使用该中的成员。 Java、C# ...
  • Java访问权限的修饰public,private,protected,缺省(default)一个中的成员变量和成员方法(非静态)被访问分为两种场景,一是在该中,或其子类中访问,二是创建该的对象进行访问。假设:有三个 class ...
  • C++访问控制

    千次阅读 2016-09-14 16:00:14
    前言C++中关于访问说明的关键字是public,protected和private,由于C++的继承的访问说明不同,这里会牵扯出非常多不同的情况,本文尝试对此进行整理无继承public,protected和private这三个访问说明其实是...
  • java 访问控制符

    千次阅读 2007-04-18 15:27:00
    对于:默认的:可以在同一个包中的其它中被访问,在同一个包中被其它的所继承。public:可以在任何一个包中的任何一个中被访问和继承。//----------------------------------------------------------------...
  • Scala访问控制修饰

    千次阅读 2016-01-20 17:57:24
    参考自《Programming in Scala》一、访问控制修饰包的成员,或对象可以使用访问控制修饰,比如 private 和 protected 来修饰,通过这些修饰可以控制其他部分对这些,对象的访问。Scala 和访问控制大体上和 ...
  • Java声明变量的时候没有写上修饰为default

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,841
精华内容 39,936
关键字:

不允许类及类成员访问控制符