access-specifier

What is the reason of declaring a member of a private inner class public in Java if it still can't be accessed outside of containing class? Or can it? public class DataStructure { // ... private class InnerEvenIterator { // ... public boolean hasNext() { // Why public? // ... } } } Gursel Koca If the InnerEvenIterator class does not extend any class or implement any interface, I think it is nonsense because no other class can access any instance of it. However, if it extends or implements any other non private class or interface, it makes sense. An example: interface EvenIterator { public

We all know members specified protected from a base class can only be accessed from a derived class own instance. This is a feature from the Standard, and this has been discussed on Stack Overflow multiple times: Cannot access protected member of another instance from derived type's scope ; Why can't my object access protected members of another object defined in common base class? And others. But it seems possible to walk around this restriction with member pointers, as user chtz has shown me : struct Base { protected: int value; }; struct Derived : Base { void f(Base const& other) { //int n

I have a two part question Best-Practice I have an algorithm that performs some operation on a data structure using the public interface It is currently a module with numerous static methods, all private except for the one public interface method. There is one instance variable that needs to be shared among all the methods. These are the options I can see, which is the best?: Module with static ('module' in ruby) methods Class with static methods Mixin module for inclusion into the data structure Refactor out the part of the algorithm that modifies that data structure (very small) and make

I have learned that I can never access a private variable, only with a get-function in the class. But then why can I access it in the copy constructor? Example: Field::Field(const Field& f) { pFirst = new T[f.capacity()]; pLast = pFirst + (f.pLast - f.pFirst); pEnd = pFirst + (f.pEnd - f.pFirst); std::copy(f.pFirst, f.pLast, pFirst); } My declaration: private: T *pFirst,*pLast,*pEnd; IMHO, existing answers do a poor job explaining the "Why" of this - focusing too much on reiterating what behaviour's valid. "access modifiers work on class level, and not on object level." - yes, but why? The

I have two files: public interface PrintService { void print(PrintDetails details); class PrintDetails { private String printTemplate; } public interface Task { String ACTION = "print"; } } and public class A implements PrintService { void print(PrintDetails details) { System.out.println("printing: " + details); } String action = PrintService.Task.ACTION; } I thought the code looks okay, but I am getting an error in the second file for the line void print(PrintDetails details) { that states: Cannot reduce the visibility of the inherited method from PrintService . Can someone explain what this

class Example private def example_test puts 'Hello' end end e = Example.new e.example_test This of course will not work, because we specified explicit receiver - instance of Example ( e ), and that is against a "private rule". But I cannot understand, why one cannot do in Ruby this: class Foo def public_m self.private_m # <= end private def private_m puts 'Hello' end end Foo.new.public_m The current object inside public_m method definition (i.e. self ) is the instance of Foo. So why it is not allowed? To fix that I have to change self.private_m to just private_m . But why this differ, isn't