This has nothing to do with constructors specifically. This is just how protected access works. The way protected access specifier works, it allows the derived class B to access the contents of an object of base class A only when that object of class A is a subobject of class B. That means that the … Read more
It works, but only you the children tries to access it own variable, not variable of other instance ( even if it belongs to the same inheritance tree ). See this sample code to understand it better: //in Parent.java package parentpackage; public class Parent { protected String parentVariable = “whatever”;// define protected variable } // … Read more
Yes, protected members can be accessed from the class itself, subclasses of the class and also all classes in the same package of the class (doesn’t matter if those are subclasses or not). If you didn’t know that last part before, then you’ve just learned something new. It simply means that you can use those … Read more
You cannot initialize m_data in the derived class constructor but instead pass it as an argument to the base class constructor. That is: DerivedClass::DerivedClass(std::string data) : BaseClass(data) { }
They are the same for all practical purposes. But since you asked for differences, one difference I can think of is if you are searching for the class’s constructor using reflection, then the BindingFlags that match will be different. BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; var constructor = typeof(MyClass).GetConstructor(flags, null, new Type[0], null); This will … Read more
Sure, that works fine. Apple uses the same approach for example in the UIGestureRecognizer class. Subclasses have to import the additional UIGestureRecognizerSubclass.h file and override the methods that are declared in that file.
When foo receives a FooBase reference, the compiler doesn’t know whether the argument is a descendant of Foo, so it has to assume it’s not. Foo has access to inherited protected members of other Foo objects, not all other sibling classes. Consider this code: class FooSibling: public FooBase { }; FooSibling sib; Foo f; f.foo(sib); … Read more
Usually protected means only accessible to subclasses or classes in the same package. However here are the rules for constructors from the JLS: 6.6.2.2. Qualified Access to a protected Constructor Let C be the class in which a protected constructor is declared and let S be the innermost class in whose declaration the use of … Read more
There is some consensus that one should prefer composition over inheritance in OOP. There are several reasons for this (google if you’re interested), but the main part is that: inheritance is seldom the best tool and is not as flexible as other solutions the protected members/fields form an interface towards your subclasses interfaces (and assumptions … Read more
The first answer is basically correct – protected members can be accessed by classes from the same package subclasses of the declaring class from other packages However, there is a little trick: 6.6.2 Details on protected Access A protected member or constructor of an object may be accessed from outside the package in which it … Read more