标签: access-modifiers

我正在尝试将XML序列化添加到C#中相当简单的类结构中.本质上,有一个根类的实例(称为AClass),它包含一些其他类的几个实例的List(称之为AnotherClass):

[XmlRoot("RootNode")]
public class AClass {
    [XmlElement("ListNode")]
    internal List otherObjects { get; set; }
}

public class AnotherClass {
    [XmlAttribute("Name")]
    internal string name { get; set; }
}

在序列化时,我希望将这两个类序列化在一起 - 也就是说,如果我序列化了AClass,它的AnotherClass列表也会被序列化(请参阅此问题).

我有这个主要工作,但问题是在序列化过程中,XmlSerializer似乎只想处理public类的属性 - 如果声明列表,它根本不会序列化AnotherClass internal.

我试着让程序集的内部对序列化程序可见:

[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Xml")]

这似乎没有做任何事情.有没有办法让XmlSerializer递归序列化内部声明的对象列表？

也许是私有静态方法和属性等.

• 在类的情况下：

如果我们使用工厂方法，我们将不得不返回创建的实现作为已实现接口的类型。

public class Factory {

  public Product getProduct() {
    return new ProductA();
  }
}

public interface Product {
}

class ProductA implements Product {
}

为了避免客户将返回的 Product 强制转换为 Product{A, B, C... etc.} 的具体实现，我们必须：

1. 分别打包客户和工厂的代码（比方说com.example.client和com.example.factory）
2. 声明具有默认（“包”）访问权限的具体实现（对工厂可见，对客户端不可见）

    package com.example.client;
    ...
    public class Client {
      public static void main(String[] args) {
        Product i = new Factory().getProduct();
        ProductA a = (ProductA) i; // the type of ProductA isn't visible.
      }
    }

• 在方法的情况下：

例如我们需要使用隐藏方法的同一个工厂

public class Factory {

  public Product …

如果我有一个抽象类

public abstract class Player
{
    //fields
    private Sport _sport;

    //properties
    protected Sport Sport
    {
        get { return _sport; }
        set { _sport = value; }
    }      
}

这个受保护的访问修饰符是多余的,因为抽象无法实例化？

我有如下场景，其中有一个World类只有一个私有构造函数和另一个类App。

正如代码所示，一个新的实例World可以创建内部App类，尽管只有私有构造的World。

在Java中是禁止的，我认为在groovy中也是禁止的，但是App运行没有任何错误。

// World.groovy
class World {
    private World() {
    }
}

// App.groovy
class App {
    static void main(String[] args) {
    def world = new World()
    println world
}

我无法理解在 groovy 中怎么可能。另一个类如何在 groovy 中实例化一个只有私有构造函数的类？

我对编程总体上比较陌生,我想知道是否有人能帮我理解访问修饰符的目的？我理解他们为类和变量等设置了不同级别的访问权限,但为什么要限制对这些访问权限的访问权限呢？不允许访问不同的东西有什么意义？为什么不只是允许访问一切？

对不起,如果这是一个愚蠢的问题!

我在StackOverflow中看到了关于这个主题的一些讨论,但我没有看到一些帮助我理解以下内容的东西:

我来自C++背景,最近我开始学习Java.在C++中,当使用protected时,只有子类可以访问该成员(类似于Java中的Field).

在C++中,还有"朋友"类可以访问提供"友谊"的类的私有/受保护的成员.这有点类似于Java中的"package"字段修饰符(默认字段修饰符),除了在C++中友谊提供对所有私有成员的访问,但在Java中,来自同一包中的类的访问特定于类字段.

我无法理解的是,假设我只想访问子类,我可以在C++中通过声明受保护的成员不会"给予"友谊来实现这一点.

但是在Java中,我不知道怎么做,因为通过使用"protected"字段修饰符 - 我还可以访问包中的所有类.我发现这样做的唯一方法是声明受保护的字段并将类隔离在其包中.

从这里,我得出的结论是,一个包中的类的分组必须基于类之间的"友谊"来完成. 这确实是包装分组中的主要考虑因素吗？

另一件我不明白的事情,在Java中,假设我在A类中有两个字段:b,c.我想给b访问b而不是c,我想给c访问c而不是b.而对于"世界"我想要b,c被隐藏.怎么做到呢？我猜B,C应该和A在同一个包中.但是通过使用包修饰符声明b,c 我让B,C访问b和c. Java中有没有办法做到这一点？

希望对这个问题有一些解释

我在Java中实现模板模式.让我们假设以下代码:

public abstract class A {

  public final void work() {
    doPrepare();
    doWork();
  }

  protected abstract void doPrepare();

  protected abstract void doWork();
}

public final class B extends A {

  @Override 
  protected abstract void doPrepare() { /* do stuff here */ }

  @Override 
  protected abstract void doWork() { /* do stuff here */ }
}

public final class Main {

  public static void main(String[] args) {
    B b = new B();
    b.work();
  }
}

我认为这是一个问题,一个人很容易意外打电话b.doWork()而不是总是打电话b.work().如果可能的话,最优雅的解决方案是什么,以"隐藏"钩子？

修改 RESX 文件时，我注意到顶部工具栏中的“访问修饰符”选项。

共有三种不同的选项：public、internal和no code generation。我猜这些决定了哪些应用程序可以访问这些资源文件，但我不确定这三个选项之间的区别是什么。

1. 我假设可以从解决方案中的任何项目访问公共资源。

2. 我认为内部资源只能由定义资源的项目访问。

3. 我不知道没有代码生成做什么。

这三个选项实际上是什么意思？

我编写了一个 Groovy 脚本，我需要访问一个具有私有访问修饰符的字段。这工作正常，但会产生警告：

Access to <field_name> exceeds its access rights

我想抑制这个警告。@SuppressWarnings为了实现它，我必须使用什么值的注释？

我试过了@SuppressWarnings("all")，效果很好，但我想对抑制进行更精细的控制。我也试过了，@SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")但是没有效果。

下面这个警告在 IntelliJ 中的外观：

不幸的是，自动提示没有提出任何合理的解决方案：