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 boolean hasNext(); } public class … Read more
private doesn’t seem to work if you are defining a method on an explicit object (in your case self). You can use private_class_method to define class methods as private (or like you described). class Person def self.get_name persons_name end def self.persons_name “Sam” end private_class_method :persons_name end puts “Hey, ” + Person.get_name puts “Hey, ” + … Read more
In a Java interface each method is by default public: Every method declaration in the body of an interface is implicitly abstract, so its body is always represented by a semicolon, not a block. Every method declaration in the body of an interface is implicitly public. [..] In an implementing class you are not allowed … Read more
The access modifiers work on class level, and not on object level. That is, two objects of the same class can access each others private data. Why: Primarily due to efficiency. It would be a non-negligible runtime overhead to check if this == other each time you access other.x which you would have to if … Read more
Here’s the short and the long of it. What private means in Ruby is a method cannot be called with an explicit receivers, e.g. some_instance.private_method(value). So even though the implicit receiver is self, in your example you explicitly use self so the private methods are not accessible. Think of it this way, would you expect … Read more
protected methods can be called by any instance of the defining class or its subclasses. private methods can be called only from within the calling object. You cannot access another instance’s private methods directly. Here is a quick practical example: def compare_to(x) self.some_method <=> x.some_method end some_method cannot be private here. It must be protected … Read more
fileprivate is now what private used to be in earlier Swift releases: accessible from the same source file. A declaration marked as private can now only be accessed within the lexical scope it is declared in. So private is more restrictive than fileprivate. As of Swift 4, private declarations inside a type are accessible to … Read more
Herb Sutter has very nicely explained it here. Guideline #2: Prefer to make virtual functions private. This lets the derived classes override the function to customize the behavior as needed, without further exposing the virtual functions directly by making them callable by derived classes (as would be possible if the functions were just protected). The … Read more
The default visibility is known as “package-private” (though you can’t use this explicitly), which means the field will be accessible from inside the same package to which the class belongs. As mdma pointed out, it isn’t true for interface members though, for which the default is “public”. See Java’s Access Specifiers
class A { public: int x; protected: int y; private: int z; }; class B : public A { // x is public // y is protected // z is not accessible from B }; class C : protected A { // x is protected // y is protected // z is not accessible from … Read more