Consider this case: public interface IBar { void Bar(); } internal class C : IBar { public void Bar() { } } Here C.Bar cannot be marked as internal; doing so is an error because C.Bar can be accessed by a caller of D.GetBar(): public class D { public static IBar GetBar() { return new … Read more
Before C# 7.2 we had protected internal modifier. This really means protected OR internal, that is – member A is accessible to child classes and also to any class in the current assembly, even if that class is not child of class A (so restriction implied by “protected” is relaxed). private protected really means protected … Read more
It’s a fundamental principle in OOP: the child class is a fully-fledged instance of the parent class, and must therefore present at least the same interface as the parent class. Making protected/public things less visible would violate this idea; you could make child classes unusable as instances of the parent class.
I think everyone hammered the point of an interface having only public members, no implementation details. What you are looking for is an abstract class. public interface IOrange { OrangePeel Peel { get; } } public abstract class OrangeBase : IOrange { protected OrangeBase() {} protected abstract OrangePips Seeds { get; } public abstract OrangePeel … Read more
Of course you can: class MyClass { int x_; public: int x() const { return x_; } }; If you don’t want to make a copy (for integers, there is no overhead), do the following: class MyClass { std::vector<double> v_; public: decltype(v)& v() const { return v_; } }; or with C++98: class MyClass { … Read more
A static final int field is a compile-time constant and its value is hardcoded into the destination class without a reference to its origin; therefore your main class does not trigger the loading of the class containing the field; therefore the static initializer in that class is not executed. In specific detail, the compiled bytecode … Read more
It depends on what you mean by “safe”. If you’re running with a security manager that allows this sort of thing, then yes, you can do all kinds of nasty things with reflection. But then in that kind of environment the library can probably just be modified to make the method public anyway. Access control … Read more
Yes, it’s almost the same. The protected modifier specifies that the member can only be accessed within its own package (as with package-private) and, in addition, by a subclass of its class in another package.
They are access modifiers and help us implement Encapsulation (or information hiding). They tell the compiler which other classes should have access to the field or method being defined. private – Only the current class will have access to the field or method. protected – Only the current class and subclasses (and sometimes also same-package … Read more
AFAIK, private is the default everywhere in C# (meaning that if I don’t write public, protected, internal, etc. it will be private by default). (please correct me if wrong). This is not true. Types defined within a namespace (classes, structs, interfaces, etc) will be internal by default. Also, members within different types have different default … Read more