我在一些代码中找到了这个构造.

私有静态类实现A有什么好处吗？这让我想起了C++中的Pimpl成语.在Java中使用Pimpl习语是否有任何好处？

public abstract class A {
    public void doStuff();

    public static A getNewInstance() {
       return new AImpl();
    }

    private static class AImpl extends A {
        public void doStuff()  {
           ....
        }    
    } 

}

在一个片段中,我有一个打开PopupWindow的按钮.

private class onMenuClickListener implements View.OnClickListener {
    @BindView(R.id.popup_radiogroup) RadioGroup popupRadioGroup;
    @BindView(R.id.popup_textview) TextView popupTextView;

    PopupWindow popupWindow = getPopupWindow(R.layout.popup_window);

    @Override
    public void onClick(View v) {
        ButterKnife.bind(this, popupWindow.getContentView());
        popupWindow.showAsDropDown(menuButton);
    }
}
private PopupWindow getPopupWindow(int layout_resource_id)  {
    LayoutInflater inflater = (LayoutInflater) getContext()
            .getSystemService(LAYOUT_INFLATER_SERVICE);
    View popupView = inflater.inflate(layout_resource_id,(ViewGroup)getView());

    return new PopupWindow(popupView,
            LinearLayout.LayoutParams.WRAP_CONTENT,
            LinearLayout.LayoutParams.WRAP_CONTENT,true);
}

当我尝试运行此代码时,我收到此错误:"@BindView字段可能不包含在私有类中." 为什么ButterKnife无法访问私有内部类,但它可以自由访问受保护的内部类？

在我的Android项目中，我定义了一些回调来对按钮单击，连接事件或UI事件（例如Dilaog.onShow（））进行操作。出于演示目的，我选择了必须从一些Activity代码启动的Runnable接口。使用Java，我有不同的表达方式。

一种模式是使用匿名类

runOnUiThread(new Runnable() { 
    public void run() { 
        doSomething(); 
    }
});

private void doSomething() {
}

另一个-定义内部私有类，即

private DoSomething implements Runnable {
    public void run() { 
        // do something; 
    }
}
...
runOnUiThread(new DoSomething());

还有一个-使用私有成员，例如：

private final Runnable doSomething = new Runnable() {
    public void run() { 
        // do something; 
    }
}
...
runOnUiThread(doSomething);

这是我最喜欢的另一个，因为一方面，除非有人真正使用它，否则它实际上不会构造对象；因为它避免了多余的类，因为它可以在需要时使用参数。

private Runnable doSomething() { 
    return new Runnable() {
        public void run() { 
            // do something; 
        }
    }
}
...
runOnUiThread(doSomething());

我不是在寻找关于品味或宗教信仰的争论，而是在寻找代码的可维护性和性能。我想收到一些提示和建议，这些建议可以帮助我发展自己的偏爱，可能-根据给定的情况选择不同的偏爱。

扰流板：

Java的进步使这个问题过时了，​​请参见已接受的答案。

当我使用 _ 作为类名的前缀时（另请参见this和this），该类将变为非公开的并且不会由 pydoc 显示：

    class _DoNotShowMeInPydoc:
      """Class Documentation which is not displayed"""

这正是我想要的，因为这个类仅在内部使用，对于使用该模块的人来说并不重要。

但是 - 如果有人想了解我的模块的内部结构（当然）也有文档记录，该怎么办？pydoc 是否有一个标志或选项来显示非公共类？

来自Java,我试图在Ruby中实现LinkedList.我在Java中实现它的常用方法是使用一个名为LinkedList的类和一个名为Node的私有内部类,其中LinkedList的每个对象都是Node对象.

class LinkedList
  private
  class Node
    attr_accessor :val, :next
  end
end

我不想将Node类暴露给外部世界.但是在Ruby中使用此设置,我可以使用以下方法访问LinkedList类之外的私有Node类对象 -

node = LinkedList::Node.new

我知道,使用Ruby 1.9,我们可以使用private_constant方法将Node指定为私有常量.但我想知道这是否是实现这一目标的正确方法？另外,为什么我能够在LinkedList类之外创建Node对象,即使它被声明为私有？

我使用私有类的实例作为提供给stream.BeginRead操作的状态对象.(该类对我的主流读/写类是私有的.)

public class MainClass
{
    // ...

    private class ResponseState
    {
        public IResponse response;
        public Stream stream;
        public byte[] buffer = new byte[1024];
    }
}

可以直接通过字段访问课程.在这种情况下,我是否真的应该通过属性提供对类的访问,即使它只用于保持状态？

有兴趣知道其他人做了什么.

我对 Java OO 编程比较陌生，并且已经回顾了与此类似的问题，尽管它们似乎没有直接回答我的问题。

基本上，我知道如果类中的数据成员被声明为private，那么它只能从同一个类中访问。

我的讲师总是建议所有属性都应声明为私有 -这是为什么？

现在我熟悉使用 GET 方法，我的问题是，是否可以通过从另一个类调用 PUBLIC“get”方法（返回上述属性）来在其自己的类之外访问私有属性？

例如：

public class Class()
{

    private int number = 0;

    public Class()
    {
    }

    public int getNumber()
    {
        return number;
    }

}

然后来自另一个班级：

public class Class2()
{

    Class class = new Class();

    public void showNumber()
    {
        System.out.print(class.getNumber());
    }
}

第二个代码块是否允许 Class2 内的showInt()中的方法实际访问 Class 的私有属性？

我想我真的很难决定是否应该将任何属性或方法声明为公共或私有。

是否有任何应该遵循的特定经验法则？

感谢回复者提供的任何帮助。

亲切的问候

我创建了一个有很多部分的小部件。因此，在一个文件中创建此小部件并不是一种好的做法。因此，我重新排列了许多文件。我将这些小部件（部分）设为私有，这样就无法在其他文件中访问它们。我只想在根小部件中访问这些小部件。（或者可以在其目录文件中访问私有类）我该怎么做？

// homepage/homepage.dart

import 'package:flutter/material.dart';

class Homepage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Container(
      child: Column(
        children: [
          _Part1(),
          _Part2(),
        ],
      ),
    );
  }
}

// homepage/part1.dart
import 'package:flutter/material.dart';

class _Part1 extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Container(
      
    );
  }
}

// homepage/part2.dart
import 'package:flutter/material.dart';

class _Part2 extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Container(
      
    );
  }
}

我对 C# 和犀牛模拟很陌生。我搜索并找到了与我的问题类似的主题，但找不到合适的解决方案。

我试图了解在我的单元测试中是否调用了私有方法。我正在使用犀牛模拟，阅读了很多关于它的文件，其中一些只是说将方法的访问说明符从私有更改为公共，但我无法更改源代码。我试图将源文件链接到我的测试项目，但它没有改变。

  public void calculateItems()
    {
        var result = new Result(fileName, ip, localPath, remotePath);

        calculateItems(result, nameOfString);
    }

    private void calculateItems(Result result, string nameOfString )

从上面的代码中可以看出，我有两个方法名称完全相同，calculateItems，但是public 一个没有参数，private 一个有两个参数。我试图了解当我在单元测试中调用 public 方法时，是否调用了私有方法？

    private CalculateClass sut;
    private Result result; 

    [SetUp]
    public void Setup()
    {
      result = MockRepository.GenerateStub<Result>();
      sut = new CalculateClass();
    }

    [TearDown]
    public void TearDown()
    {

    }

    [Test]
    public void test()
    {     
        sut.Stub(stub => stub.calculateItems(Arg<Result>.Is.Anything, Arg<string>.Is.Anything));

        sut.calculateItems();

        sut.AssertWasCalled(stub => stub.calculateItems(Arg<Result>.Is.Anything, Arg<string>.Is.Anything));
    }

在我的单元测试中，我遇到了这样一个错误，上面写着“calculateItems 没有重载方法需要两个参数”。有没有办法在不改变源代码的情况下测试它？