什么是一些常见的,现实世界的例子使用Builder模式的？它给你带来了什么？为什么不使用工厂模式？
可能类似于问题,为什么外部Java类可以访问内部类私有成员？或使用子类中的super关键字访问超类私有字段.
但是存在一些差异:子类可以访问其父级(并且只有最近的父级)的私有成员.
鉴于以下示例代码:
public class T {
private int t;
class T1 {
private int t1;
public void test() {
System.out.println(t);
}
}
class T2 extends T1 {
private int t2;
public void test() {
System.out.println(t);
System.out.println(super.t1);
System.out.println(this.t2);
}
}
class T3 extends T2 {
public void test() {
System.out.println(t);
System.out.println(super.t1); // NG: t1 Compile error! Why?
System.out.println(super.t2); // OK: t2 OK
}
}
}
在Java中,内部类可以访问封闭类的私有成员.但是外层类可以访问内部类的私有成员吗？这与内部阶级是否是静态无关.我认为这不是真的,但以下代码似乎编译并正常工作.
public class Outer {
class Inner {
private int i = 0;
private Inner() {}
}
public static void main(String[] args) {
Outer o = new Outer();
Outer.Inner oi = o.new Inner();
oi.i = 10;
}
}
背景:我已经使用嵌套类N封装了(父)类E,在E中有几个N实例.在封闭的(父)类中,我正在进行一些计算,我正在为嵌套类的每个实例设置值.像这样的东西:
n1.field1 = ...;
n1.field2 = ...;
n1.field3 = ...;
n2.field1 = ...;
...
它是一个大的eval方法(在父类中).我的意图是 - 因为所有计算都在父类中(它们不能按照嵌套实例进行,因为它会使代码更复杂) - 使setter仅对父类和getter公共可用.
现在有一个问题:
我被困 - 怎么做(限制访问父类,不多也不少)？
我怀疑我会先回答问题 - "但是为什么你不按每个字段拆分评估" - 所以我通过例子回答这个问题:你如何计算集合的最小值和最大值？快点？答案是 - 一次通过.这就是为什么我有一个eval函数可以进行计算并一次设置所有字段.
谁能告诉我私人会员的访问级别？很长一段时间我一直对这段代码感到困惑:为什么私有成员,Line类的k,可以在outter类的"print"方法中访问？
public class myClass {
public static class Line{
private double k;
private double b;
private boolean isVertical;
public Line(double k, double b, boolean isVertical){
this.k = k;
this.b = b;
this.isVertical = isVertical;
}
}
public static boolean print(Line line){
System.out.println(line.k);
}
}
我知道内部类可以访问外部类中的所有内容(因为它是该类的成员)但是反过来呢？
外部类是否可以访问内部类中的私有变量和方法？
我看过文章提到内部类应该是私有的,这样它们只能被外部类访问.这对内部类的可访问性有什么影响？
在内部类中处理访问级别的最佳实践是什么？我假设更多的封装更好,但这是以牺牲可访问性为代价的吗？
从TypeScript 1.6开始,我们可以使用类表达式轻松创建内部类.在像Java这样的其他以OOP为中心的语言中,内部类可以访问外部类的成员,甚至是私有成员.
此行为类似于闭包的概念,其中函数可以从定义它的作用域中访问变量.
为什么我无法在TypeScript中实现这一点？ECMAScript 2015中的类规范是否起作用？
显示预期行为的代码:
class OuterClass {
private outerField = 1337;
public InnerClass = class {
public accessOuter() {
return this.outerField; // outerField not defined
}
}
}
var outer = new OuterClass();
var inner = new outer.InnerClass();
var win = inner.accessOuter();
public class Test {
public static enum MyEnum {
valueA(1),valueb(2),valuec(3),valued(4);
private int i;
private Object o;
private MyEnum(int number) {
i = number;
}
public void set(Object o) {
this.o = o;
}
public Object get() {
return o;
}
}
public static void main(String[] args) {
System.out.println(MyEnum.valueA.i); // private
}
}
输出：1
如果它是枚举中的私有成员，为什么会显示 1？
直到今天我才意识到这一点，但是在 Java 中私有字段在内部类中并不是真正私有的。您可以实例化一个类并像访问公共字段一样访问这些字段。我的问题是为什么这是在 Java 中完成的？哪些设计决策导致了封装中断？允许这样做有什么好处吗？
public class test {
public static void main(String[] args) {
Inner inner = new Inner();
inner.data = "TEST";
System.out.println(inner.data);
Inner1 inner1 = new Inner1();
inner1.data = "TEST";
System.out.println(inner1.data);
new test();
}
public test() {
Inner2 inner2 = new Inner2();
inner2.data = "TEST";
System.out.println(inner2.data);
Inner3 inner3 = new Inner3();
inner3.data = "TEST";
System.out.println(inner3.data);
}
private final class Inner3 {
private String data;
public String getData() {
System.out.println("Inner3.getData()");
return data;
}
public void setData(String data) {
System.out.println("Inner3.setData(String)"); …我刚刚发现内部类可以像这样访问另一个内部类的私有成员:
public class TestOutter {
class TestInner1 {
private int mInt = 1;
}
class TestInner2 {
public int foo(TestInner1 value) {
return value.mInt;
}
}
}
TestInner2的方法foo可以访问TestInner1的私有成员mInt.
但我以前从未见过这种情况.我不知道让代码进入TestInner2可以访问TestInner1的私有成员的含义.
我在谷歌搜索了内部类,没有一个搜索结果显示内部类有这个功能.我也查阅了Java语言规范,但它仍未提及.
我有代码在用户单击特定按钮的事件上建立服务器连接.我创建了一个内部类来监听动作.在我在内部类中的单个方法中,我还建立了前面提到的服务器连接.
我的问题是,Socket连接只能在"内部"类中使用吗？或者,外部类可以继续与所述服务器通信吗？
但是,我知道内部类具有对外部类的无限制访问权(就好像它是外部类一样.我的问题是另一种方式.
这个问题可能有点令人困惑，最好通过一个例子来说明：
unit Test
interface
type
TestClass = class()
Splitter1: TcxSplitter;
procedure SomeMethod();
end;
implementation
uses
cxSplitter;
// Locally-declared child type
type
TcxSplitterAccess = class(TcxSplitter);
procedure TestClass.SomeMethod()
var
pos: integer;
begin
// Access to protected field FPositionBeforeClose by casting
pos := TcxSplitterAccess(Splitter1).FPositionBeforeClose;
end;
请注意，在实现部分中，有一个类型TcxSplitterAccess被声明为TcxSplitter该类的子类。在该方法中SomeMethod()，属于类TestClass，一个TcxSplitter对象被强制转换为本地声明的TcxSplitterAccess类，然后受保护的字段是对象访问。
作为具有 Java、C++、C# 等语言背景的人，这让我感到惊讶。在这些语言中，只要您是从该对象的类型或继承类型。例如，类中的方法ClazzA可以访问其他ClazzA对象的私有字段，因为访问是在类型级别而不是实例级别强制执行的。用这些语言在本地声明一个类不会让包含类访问本地类的受保护数据（编辑：正如评论中指出的那样，至少对于 Java 来说实际上不是这样）。
但是，在此示例中，该类型通过首先转换为该类型TestClass来直接访问TcxSplitter对象上的受保护字段TcxSplitterAccess。我无法找到有关此“技巧”为何有效的文档。Delphi 处理访问级别是否与类 …