标签: access-modifiers

我想要进行以下设置:

class Descriptor
{
    public string Name { get; private set; }
    public IList<Parameter> Parameters { get; private set; } // Set to ReadOnlyCollection

    private Descrtiptor() { }
    public Descriptor GetByName(string Name) { // Magic here, caching, loading, parsing, etc. }
}

class Parameter
{
    public string Name { get; private set; }
    public string Valuie { get; private set; }
}

从XML文件加载后,整个结构将是只读的.我想这样做,只有Descriptor类可以实例化一个参数.

一种方法是创建一个IParameter接口,然后Parameter在Descriptor类中使类成为私有,但在实际使用中,Parameter将有几个属性,我想避免重新定义它们两次.

这有点可能吗？

我今天遇到了以下"奇怪"功能 - 如果您在A类主体中引用了A类中的对象,则可以访问该对象的私有字段 - 即:

public class Foo{
   private int bar;
   private Foo foo;
   public void f()
   {
       if(foo.bar == bar) // foo.bar is visible here?!
       {
            //
       }
   }
}

有人对此有一个很好的解释吗？

我最近一直在努力学习F#的面向对象方面,并且对如何限制对该语言中的类型/模块的访问感到好奇.

更具体地说,我想知道写这个之间的区别:

Example.fsi

module Stack =
    val foo : string

Example.fs

module Stack =
    let foo = "foo"
    let bar = "bar"

或者这个:

module Stack =
    let foo = "foo"
    let private bar = "bar"

他们到底完全没有做同样的事情吗？来自C#背景,我更倾向于使用访问修饰符而不是签名(FSI)文件.它们似乎更通用(例如,可以应用于命名空间中的模块/类型),而我不会在任何情况下签名文件提供访问修饰符所不具备的内容.

我有两个对象,RoomManager并且Room会有几个Room和一个RoomManager.我希望它RoomManager是唯一一个允许创建Room对象的人.所以我想知道是否有一种方法可以使Room构造函数(以及其余的Room方法/属性)只能访问RoomManager.我在考虑将它们移动到自己的命名空间并制作Room私有或内部或其他东西.从可访问性级别(C#参考)我看到内部是针对整个程序集,而不仅仅是命名空间.

我想做这样的事情(例子是简化的,但包含所有关键部分):

class Master
{
  type DataType = Int
  var counter : DataType = 0
}

class Slave(private val master : Master)
{
  val counter = master.counter  // (*)
}

在这里(*)我收到错误:

private value master将其定义范围作为Slave.this.master.DataType类型的一部分进行转义

val counter = master.counter

我理解错误,但我不明白原因 - 类型是类的一部分Master,而不是对象master,所以如果类是私有的,而不是对象,这很重要.好吧,至少在理论上.

很容易快速解决方法:

  val counter : Master#DataType = master.counter  

但我相信这是与以前完全相同的代码的显式版本,它"只"需要更多的输入.这是一个功能吗？

题:

类型(此处为DataType)是否可以依赖于对象,而不是Scala中的类(即每个类实例的类型定义)？

我是D语言新手的C#程序员.我在D编程语言中有点与OOP混淆.

假设我有以下课程:

public class A {
   protected void foo() {
      writefln("A.foo() called.");
   }
};

public class B : A {
   public override void foo() {
      writefln("B.foo() called.");
   }
};

该protected修改意味着我可以访问该.foo()方法只是在继承的类,所以为什么这个d程序正常编译？

这相当于C#.NET:

using System;

public class A {
   protected virtual void foo() {
      Console.WriteLine("a.foo() called.");
   }
};

public class B : A {
   public override void foo() {
      Console.WriteLine("b.foo() called.");
   }
};

public class MainClass  {
   public static void Main(string[] args) {
      A …

需要对私有变量和继承有更多的了解.之前我的理解是,如果一个类中有字段,并且当我继承该类时,不受访问限制的字段(私有变量)将存在于继承的类中.但是如果有一个公共g/setter方法,我可以在基类中使用私有变量.

我怎样才能想象一个基类中的私有变量.

注意:我已经阅读了有关Symbols,WeekMaps和Maps 的以下SO问题和7个答案(截至目前),请在投票前阅读完整的问题:JavaScript ES6类中的私有属性
文章:https://esdiscuss.org/ 话题/ ES7-财产初始化

以下是我的Simple Class包含私有,公共和受保护的属性和方法.

  'use strict';
  class MyClass {
    constructor () {
      this.publicVar = 'This is Public Variable';
      this.privateVar = 'This is Private Variable';
      this.protectedVar = 'This is Protected Variable';
    } // Public Constructor Method.
    
    publicMethod () {
      console.log('   Accessing this.publicVar: ', this.publicVar);
      console.log('   Accessing this.privateVar: ', this.privateVar);
      console.log('   Accessing this.protectedVar: ', this.protectedVar);
      return 'Its Public Method'
    } // Public Method.

    privateMethod () {return 'Its Private Method'} // …

我正在为我的学习开发一个应用程序。现在我刚刚启动了一个应用程序，在那里我得到了一个包含足球联赛和俱乐部等的数据库。现在我有了俱乐部和球员的列表，现在我正在尝试添加更多的联赛，然后只有 1 个。但是当我收到这个错误时做同样的事情然后做之前。这是不工作列表的代码：

public List<Competitie> GetAllCompetities()
        {
            List<Competitie> Competitie = new List<Competitie>();
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                connection.Open();
                string query = "Select * from competitie";
                MySqlCommand selectallcompetitiecommand = new MySqlCommand(query, connection);
                MySqlDataReader reader = selectallcompetitiecommand.ExecuteReader();
                while (reader.Read())
                {
                    Competitie comp = new Competitie();
                    comp.IdCompetitie = reader.GetInt32(0);
                    comp.NaamCompetitie = reader.GetString(1);
                    Competitie.Add(comp);
                }
            }
            return Competitie;
        }

然后这是正在工作的俱乐部的代码：

public List<Clubs> GetAllClubs(string selecteditem)
        { //Zorgt voor alle dingen van de tabel clubs.
            List<Clubs> Clubs = new List<Clubs>();
            using (MySqlConnection connection = …

假设我有一个带有一些成员的类，并且这些成员的限制访问修饰符比类本身少。

一个具体的例子可能是：

package apples;

class A { // package private
    public int foo() { // public (=> less restrictive than *package private*)
        return 42;
    }
}

据我所知，一个类访问修饰符的限制要比成员访问修饰符的限制更大，它将覆盖限制性较小的成员访问修饰符。因此，限制较少的成员访问修饰符应该完全无效。

• 我的理解正确吗？
  • 如果没有，后果是什么？
• 限制成员访问修饰符较少的正当理由是什么？
• 最后，有什么最佳实践可遵循？

我也做了一些试验，因为我认为一旦开始传递函数引用，它可能会产生后果，但是即使那样，访问修饰符似乎也没有关系。

我构造的情况如下：

• apples.B提供bla()返回对的引用的公共方法apples.A.foo。
• 然后pizzas.C调用apples.B.bla获取A.foo对它的引用并对其进行调用。
• 因此对A.foo()不能直接看到C，而只能通过间接访问B.bla()

我已经对其进行了测试，并且无论是否将foo() 包的访问修饰符设为私有，这都没有什么不同。

package apples;

import java.util.function.IntSupplier;

public class B { …