Dart Public Method

​

Syntax

abstract class NetworkClient {
  // Public instance method with explicit return type and body
  void connect(String endpoint) {
    // Implementation
  }

  // Public method with omitted return type (implicitly dynamic)
  processData(data) {
    // Implementation
  }

  // Public abstract method (no body, terminated with a semicolon)
  void disconnect();

  // Public external method (implementation provided outside Dart)
  external void nativeCall();

  // Public static method
  static bool validateConfiguration() => true;

  // Public getter (abstract)
  bool get isConnected;

  // Public setter (abstract)
  set connectionTimeout(int seconds);

  // Private method (for contrast; restricted to the defining library)
  void _initializeSocket() {
    // Implementation
  }
}

enum ConnectionState {
  connected, disconnected;
  
  // Public method on an enum
  bool isConnected() => this == ConnectionState.connected;
}

​

Technical Characteristics

• Implicit Visibility: The absence of the _ prefix is the sole mechanism for declaring a method as public. Dart compilers and analyzers treat any non-underscored method, getter, or setter as part of the public API of the enclosing declaration.
• Library-Level Privacy: Dart enforces encapsulation at the library level, not the class level. A public method is exposed across library boundaries, meaning it can be invoked by any external Dart file that imports the library containing the method’s declaration.
• Getters and Setters (Accessors): Accessor methods are subject to the exact same visibility rules as standard methods. They form a fundamental part of a class’s public API and implicit interface, allowing property access semantics while executing method logic.
• Implicit Interfaces: Every class in Dart implicitly defines an interface containing all of its instance members, including public methods, private methods, getters, and setters. When a class implements another class using the implements keyword, it must provide concrete implementations for the entire interface. Because the implicit interface includes private members, a class containing private methods cannot be fully implemented by a class residing in a different library.
• Inheritance and Overriding: Public instance methods defined on classes and mixins are inherited by subclasses and can be overridden using the @override annotation. Conversely, methods defined on extension and extension type declarations are statically resolved and cannot be overridden. When overriding a method, the signature does not need to strictly match the superclass’s definition:
  • Covariant Return Types: Dart allows an overridden method to return a subtype of the original return type.
  • Contravariant Parameter Types: Dart naturally supports contravariance for parameters, allowing an overridden method to safely accept a supertype of the original parameter type without any special keywords.
  • Covariant Parameters: If an overridden method needs to accept a subtype of the original parameter type, the parameter must be explicitly marked with the covariant keyword.
• Invocation: Public instance methods are invoked on an instantiated object or value using dot notation (instance.methodName()). Public static methods are invoked directly on the type declaration itself (ClassName.methodName()). Public getters and setters are invoked using property access syntax (instance.propertyName and instance.propertyName = value).