我想从提供此受保护方法的类的子类中调用另一个实例的受保护方法.请参阅以下示例:
public class Nano {
protected void computeSize() {
}
}
public class NanoContainer extends Nano {
protected ArrayList<Nano> children;
}
public class SomeOtherNode extends NanoContainer {
// {Nano} Overrides
protected void computeSize() {
for (Nano child: children) {
child.computeSize(); // << computeSize() has protected access in nanolay.Nano
}
}
}
javac告诉我computeSize() has protected access in Nano.我看不出这个的原因(我以为我已经在其他一些代码中这样做了).我想保护这种方法,我该怎么办？
javac version "1.7.0_09"
我想提供一个精简版本,但我没有想到这样的事实,即这些类位于不同的包中.
nanolay.Node
nanolay.NanoContainer
nanogui.SomeOtherNode
好的,让我从一个例子开始.这是我在另一个程序集中的基类
namespace BL
{
public class BasicClass
{
protected internal void func()
{
//Code Logic
}
}
}
现在这是我在另一个程序集中的派生类
namespace DL
{
public class DerivedClass:BasicClass
{
private void hello()
{
func();
}
}
}
我能够调用func()from基类,因此它显示了protected 访问修饰符属性,但访问修饰符属性如何.因为它声明了内部,所以internal允许它访问func()另一个程序集.如果那么为什么调用它protected internal而不是简单protected
假设我有以下特征和扩展该特征的类
trait T { protected def f() }
class C extends T { def f(): println("!") }
object Main extends App {
val c = new C
c.f() // should be a compile error
}
我在 for 的声明中f声明了，以便可以从 的范围内调用它，但不能由其他人调用。换句话说，应该是编译错误。我以为修饰符 from会保留下来，但事实并非如此。protectedTCC.f()protectedT
我可以C.f()像protected在声明中那样重新声明C，但我不想重复自己。在 Scala 中还有其他方法可以做到这一点吗？
我查看了有关此主题的先前主题,但他们没有帮助解决问题.
我正在尝试在excel中打开受密码保护的文件而无需任何用户交互.我在网上搜索,发现这个代码使用win32com.client当我运行这个时,我仍然得到输入密码的提示...
from xlrd import *
import win32com.client
import csv
import sys
xlApp = win32com.client.Dispatch("Excel.Application")
print "Excel library version:", xlApp.Version
filename,password = r"\\HRA\Myfile.xlsx", 'caa team'
xlwb = xlApp.Workbooks.Open(filename, Password=password)
我正在学习 Java 访问修饰符。为此，我创建了一个类Machine：
package udemy.beginner.interfaces;
public class Machine {
public String name;
private int id;
protected String description;
String serialNumber;
public static int count;
public Machine(){
name = "Machine";
count++;
description = "Hello";
}
}
然后，在另一个包中，我创建了一个类Robot作为汽车的子类Machine：
package udemy.beginner.inheritance;
import udemy.beginner.interfaces.Machine;
public class Robot extends Machine {
public Robot(){
Machine mach1 = new Machine();
String name = mach1.name;
//here I am getting error "The field Machine.description is not visible"
String description = mach1.description; …在我阅读了这些概念之后，似乎用户/内核模式和真实/受保护模式都是为了保护目的。基本上，这些模式是有区别的，以防止一个程序被另一个程序崩溃。那么为什么对同一件事使用不同的术语呢？
这是我要测试的课程：
namespace ClassLibrary1
{
public class MyBase
{
public async Task DoSomething (MyContext context) => await DoSomethingInternal (context);
public async Task DoSomething() => await DoSomethingInternal();
protected virtual async Task DoSomethingInternal(MyContext context) { }
protected virtual async Task DoSomethingInternal() { }
}
public class MyContext { }
public class MyClass : MyBase
{
protected override Task DoSomethingInternal(MyContext context) => Task.CompletedTask;
protected override Task DoSomethingInternal() => Task.CompletedTask;
}
}
这是测试代码：
namespace UnitTestProject1
{
[TestClass]
public class UnitTest1
{
[TestMethod]
[ExpectedException(typeof(TaskCanceledException))]
public async …In Java package protectedAccess 非常方便，因为它允许编写模块化代码。这是不可能的，Kotlin除非您将所有这些类粘贴到一个文件中并将Private它们全部放入或Internal在单独的Module. 但我不喜欢这个解决方案。将大量内容放入一个文件中是不可读的，另一个问题是您无法测试任何Method不可读Class的内容Public。还有其他解决方案吗？
我在两个不同的包中有两个类：
package package1;
public class ParentClass {
public void testPublic() {
}
protected void testProtected() {
}
}
package package2;
import package1.ParentClass;
public class ChildClass extends ParentClass {
void test() {
ParentClass par = new ParentClass();
par.testProtected(); // Line 1 : ERROR: testProtected() has protected access in ParentClass
testProtected(); // Line 2 : No error
ChildClass ch = new ChildClass();
ch.testProtected(); // Line 3 : No ERROR
testProtected(); // Line 4 : No error
}
}
我能够理解为什么调用时没有错误testProtected() -- …
正如开发文档所说，Dart doesn't have the keywords public , protected , and private . If an identifier starts with an underscore (_), it's private to its library.但我@protected在 Flutter 框架中发现了很多关键字。这是什么@protected意思？
abstract class InheritedWidget extends ProxyWidget {
const InheritedWidget({ Key key, Widget child })
: super(key: key, child: child);
@override
InheritedElement createElement() => InheritedElement(this);
@protected
bool updateShouldNotify(covariant InheritedWidget oldWidget);
}