标签: access-modifiers

I wonder if it is valid C++ :

class Test {
    struct PrivateInner {
        PrivateInner(std::string const &str) {
            std::cout << str << "\n";
        }
    };

public:
    using PublicInner = PrivateInner;
};

//Test::PrivateInner priv("Hello world");        // Ok, private so we can't use that
Test::PublicInner publ("Hello World");           // ?, by using public alias we can access private type, is it ok ?

考虑以下简单的类层次结构:

上午

classdef A < handle
    methods (Access = protected)    %# protected vs. private
        function foo(obj)
            disp('class A')
        end
    end
end

BM

classdef B < A
    methods (Access = public)
        function foo(obj)
            disp('class B')
        end
    end
end

B类继承自A类,并且应该将受保护的foo方法覆盖为public.

如果我们尝试实例化派生类,我们会收到以下错误:

>> b=B();
Error using B
Method 'foo' in class 'B' uses different access permissions than its superclass 'A'. 

奇怪的是,如果foo在超类中定义为私有方法,则A在调用重写方法时代码工作正常:

>> clear classes
>> b=B(); b.foo()
class B

那么这是MATLAB OOP实现中的限制/错误,还是有这么好的原因呢？(代码在R2012b上测试)

作为比较,在Java中,规则规定您不能降低子类中方法的可见性,但您可以增加它,其中:

(weakest) private < package < …

考虑一下这段代码:

public class TopLevelClass {
    Cloneable c = new Cloneable() {
        private int privateField;
        private void privateMethod() {};
    };
}

有一个匿名类,它有一个private成员字段和一个private成员方法.它已成功编译.

然后考虑这个:

public class TopLevelClass {
    Cloneable c = new Cloneable() {
        private class PrivateInnerClass {}
    };
}

有一个匿名类,它有一个private成员类.然而...

• javac说: error: modifier private not allowed here
• 日食说:Illegal modifier for the local class PrivateInnerClass; only abstract or final is permitted _{真的是本地课吗？}

什么？为什么匿名类不能有public,protected或private_{(以下简称为those)}成员类而它们可具有those构件的字段和方法？ …

好的,所以这真的很奇怪.我有一个私有成员,我想将它用于Form2.我已经创建了一个公共静态方法,因此我可以将该成员转换为Form2.

这是我的代码:

private static AppController appController;
private BreadRepository breadRep;
private CakeRepository cakeRep;
private SandwichRepository sandwichRep;

public Form1()
{
    InitializeComponent();

    breadRep = new BreadRepository();
    cakeRep = new CakeRepository();
    sandwichRep = new SandwichRepository();
    appController = new AppController(breadRep , sandwichRep, cakeRep);
}
public static AppController getController()
{
    return appController;
}

我试图从Form1公开appController,但我得到更多的错误.现在我明白了:

可访问性不一致:返回类型'exemplu_map.controller.AppController'比方法'exemplu_map.Form1.getController()'更难访问任何想法？

更新:

这是我的AppController类:

class AppController
{
    private BreadRepository breadRep;
    private SandwichRepository sandwichRep;
    private CakeRepository cakeRep;
    public AppController(BreadRepository breadRep, SandwichRepository sandwichRep, CakeRepository cakeRep)
    {
        this.breadRep = breadRep;
        this.sandwichRep = sandwichRep;
        this.cakeRep = cakeRep; …

为什么python没有像c#,java那样的访问修饰符,例如public,private等.在python中封装和信息隐藏的替代方法是什么.

我想知道什么是最好的做法,当我想要一些功能公开,一些内部使用协议时我.

我写的AudioManager在斯威夫特3包装AVPlayer作为一个框架.

我想要一些方法是公共的,所以例如使用AudioManager的ViewController可以访问一些方法,但是一些方法不会暴露在框架之外
- >即使用访问修饰符internal而不是public.

我正在用协议驱动设计编写框架,几乎每个部分都应该有一个协议.
因此协议正在与框架内的协议进行通信.
例如,主类 - AudioManager有一个AudioPlayer,并且应该能够internal在其上调用一些函数,
例如,pause(reason:)但该方法应该internal在框架之外暴露.

这是一个例子.

internal enum PauseReason {
    case byUser
    case routeChange
}

// Compilation error: `Public protocol cannot refine an internal protocol`
public protocol AudioPlayerProtocol: InternalAudioPlayerProtocol { 
   func pause() // I want 
}

internal protocol InternalAudioPlayerProtocol {
    func pause(reason: PauseReason) // Should only be accessible within the framework
}

public class AudioPlayer: …

相当新的Java,但我想知道为什么包访问被认为比子类访问"更具限制性".也就是说,为子类提供对成员访问权限的每个访问修饰符也为整个包提供访问权限,并且存在提供包访问但不提供子类访问的修饰符.

这不是完全倒退吗？假设我在某个包中有一个类ControlledInstantiation.如果我有另一个类AlsoControlledInstantiation扩展ControlledInstantiation,我无法调用ControlledInstantiation的构造函数,除非我将其设置为protected或public.如果我将它设置为protected,那么包中的任何其他类都可以根据需要经常实例化它.因此,对于其超类(和语法,是)必须替代的东西获得与超类相同或更少的访问权限,而不是服务于不同但相关的函数的东西.这就像告诉你的孩子他不能玩你的钱包,因为你不会让你的邻居这样做,然后让你的邻居睡在你的房子,因为你的孩子.

所以我想我在问,这个决定的动机是什么,我怎么能绕过它呢？

我在理解java中的受保护访问修饰符(或其背后的设计)时遇到了一些麻烦.我认为这意味着包访问和访问通过继承包含抽象成员的类的对象.

我写了以下示例代码.我看到如果取消注释,注释掉的行会产生编译错误.为什么我可以通过Second中的Second对象访问pro,但不能通过Second中的First对象访问pro？

package first;

public class First {

    protected void pro(){
        System.out.println("Can see protected method");
    }

}

package first;

public class InFirst {


    public static void main(String[] args){
        First fst = new First();
        fst.pro();
    }

}

package second;

import first.First;

public class Second extends First {

    public static void main(String[] args){

        First fst = new First();

//      fst.pro();

        Second sec = new Second();
        sec.pro();

    }
}

在代码行方面是否有关于"获取"大小的指导方针或一般共识？我在一个成员上有一个Get方法,这里很容易增长到30行代码.我不确定在什么时候这应该被引入一个方法.但是后来我只会调用类似GetMyString的东西并将值赋给另一个成员并在构造函数中调用它.

有没有值得这样做？

这对SO来说太主观了吗？

派生类如何从基类调用方法.
另一方面,其他课程不应该有访问权限.

我的情况:
我有一个基类,我写了一个私有方法来注册一些值.

private void register(string param1, int param2){//...}

我这样做是为了允许子类注册不同的东西.
问题是,派生类无法访问基类的私有方法或字段.
这对我来说很有意义,因为私有意味着私人.

我不想将该方法设为公共,因为其他类不应该能够调用此方法.
有人可以提供解决方案或指导我更好的设计吗？