标签: protected

在java中,有三种访问级别:

• 公众 - 对世界开放
• 私人 - 仅向全班开放
• 受保护 - 仅对类及其子类(继承)打开.

那么为什么java编译器允许这种情况发生呢？

TestBlah.java:

public class TestBlah {

    public static void main(String[] args) {
        Blah a = new Blah("Blah");
        Bloo b = new Bloo("Bloo");
        System.out.println(a.getMessage());
        System.out.println(b.getMessage()); //Works
        System.out.println(a.testing);
        System.out.println(b.testing); //Works
    }
}

Blah.java:

public class Blah {
    protected String message;

    public Blah(String msg) {
        this.message = msg;
    }

    protected String getMessage(){
        return(this.message);
    }   
}

Bloo.java:

public class Bloo extends Blah {
    public Bloo(String testing) {
        super(testing);
    }
}

我正在学习TDD,我对私有/受保护变量有疑问.我的问题是:如果我想测试的函数是在私有变量上运行,我应该如何测试它？

这是我正在使用的示例:

我有一个名为的类Table包含一个名为internalRepresentation2D数组的实例变量.我想创建一个函数multiplyValuesByN,通过参数将2D数组中的所有值相乘n.

所以我为它编写测试(在Python中):

def test_multiplyValuesByN (self):  
    t = Table(3, 3) # 3x3 table, filled with 0's
    t.set(0, 0, 4) # Set value at position (0,0) to 4
    t.multiplyValuesByN(3)

    assertEqual(t.internalRepresentation, [[12, 0, 0], [0, 0, 0], [0, 0, 0]])

现在,如果我internalRepresentation私有或受保护,此测试将无效.我怎么应该写测试所以它不依赖internalRepresentation但仍然测试它在调用后看起来是否正确multiplyValuesByN？

我在下面用Eclipse ide编写的代码:

public interface X
{
  final public static int SOME_CONST = 0;
}
public class Handle implements X
{
  protected void methodHandle () { }
 //...
}

public class User implements X
{
  Handle handle = new Handle();
  private void methodUser ()
  {
    Y y = new Y()  // anonymous inner class
    {
      public void methodY ()
      {
        handle.methodHandle (); // <--- why this is NOT giving error ?
      }
    }
  }
}

即使Handle.methodHandle ()是protected,它仍然可以从匿名内部 …

我很困惑为什么类组成public和protected方法/变量.为什么只有扩展类才能访问protected方法/变量？别人可以能帮我开导之间的差异public,并protected和它的功能.

我有一个内部抽象类InternalClassBase和两个(也内部)类InternalClass1和InternalClass2,它从继承InternalClassBase.

我也有一个公共抽象类PublicClassBase和两个(也公开)班PublicClass1和PublicClass2,从继承PublicClassBase.

该PublicClassBase有一个受保护的成员XXX类型InternalClassBase,这样既PublicClass1和PublicClass2可以使用它.

这是我的代码:

internal abstract class InternalClassBase { }
internal class InternalClass1 : InternalClassBase { }
internal class InternalClass2 : InternalClassBase { }

public abstract class PublicClassBase
{
    protected InternalClassBase XXX;  // this is where the error happens
}
public class PublicClass1 : PublicClassBase { }
public class PublicClass2 : PublicClassBase { } …

我想为java的Reader类创建一个新的类对象,但由于它受到保护,我无法访问构造函数.

读者类描述

Reader myReader = new Reader(); 

不管用.

通常,我会创建一个新的函数来访问该构造函数的类,但由于该函数是java默认库的一部分,我该如何访问它？谢谢你的帮助.

我知道这个说明符是如何工作的.

我对实际编程中这些东西的实际使用感兴趣.我无法想象任何受保护类成员真正需要的例子(我的意思是当我们不能用'private'替换'protected'时).

我正在尝试编写一个抽象类(或接口),它强制扩展类实现受保护的静态函数.但这对于抽象类和接口来说既不可能.

错误:

• 静态函数不应该是抽象的
• 必须省略接口成员的访问类型

任何想法如何实现？

UPDATE

目的基本上是静态调用公共函数.这样,该类不需要实例化.也没有必要从类外部代码中调用_doSpecificStuff().

abstract class Foo
{
    public static function doStuff()
    {
        [generic code] 

        static::_doSpecificStuff();
    }

    // sth like that would be nice to have:
    abstract static protected function _doSpecificStuff();
}

我正在尝试使用Java的受保护范围.

我在package1中有一个Base类:

package package1;

 public class Base {

     protected String messageFromBase = "Hello World";

    protected void display(){
        System.out.println("Base Display");
    }

}

我在同一个包中有一个Neighbor类:

package package1;

public class Neighbour {

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

然后我在另一个包中有一个子类,它从package1继承Base:

package package2;

import package1.Base;

 class Child extends Base {


    public static void main(String[] args) {
        Base base1 = new Base();
        base1.display(); // invisible
        System.out.println(" this is not getting printed" + base1.messageFromBase); // invisible

    }


}

我的问题是该display() …

目前我在C#中创建一个GUID键,将其放在USB闪存盘上.我用这个键进行用户识别.密钥本身位于.txt文件中,易于操作.有没有办法使.txt文件不可删除和不可见但仍然可读？