Dart Programming Language

  1. Object-Oriented Programming (OOP) in Dart
    1. Classes and Objects
      1. Defining a Class
        1. Fields (Instance Variables)
          1. Public Fields
            1. Private Fields (Underscore Prefix)
            2. Methods (Instance Methods)
              1. Method Definitions
                1. Method Overloading Limitations
                2. Creating Instances (Objects)
                  1. The `this` Keyword
                    1. Class Variables vs Instance Variables
                    2. Constructors
                      1. Default Constructor
                        1. Generative Constructors
                          1. Constructor Parameters
                            1. Constructor Body
                            2. Named Constructors
                              1. Multiple Constructor Patterns
                              2. Constant Constructors (`const`)
                                1. Immutable Objects
                                2. Factory Constructors (`factory`)
                                  1. Singleton Pattern
                                    1. Object Caching
                                    2. Initializer Lists
                                      1. Field Initialization
                                        1. Calling Super Constructors
                                        2. Redirecting Constructors
                                          1. Constructor Delegation
                                        3. Getters and Setters
                                          1. Defining Getters
                                            1. Defining Setters
                                              1. Custom Logic for Properties
                                                1. Computed Properties
                                                  1. Property Access Patterns
                                                  2. Inheritance
                                                    1. Extending a Class (`extends`)
                                                      1. The `super` Keyword
                                                        1. Calling Super Methods
                                                          1. Accessing Super Properties
                                                          2. Overriding Members (`@override`)
                                                            1. Method Overriding
                                                              1. Property Overriding
                                                              2. Inheritance Hierarchies
                                                                1. Single Inheritance Model
                                                                2. Abstract Classes and Methods
                                                                  1. Defining Abstract Classes (`abstract`)
                                                                    1. Abstract Methods
                                                                      1. Method Signatures
                                                                      2. Implementing Abstract Classes
                                                                        1. Abstract vs Concrete Classes
                                                                        2. Interfaces
                                                                          1. Implicit Interfaces
                                                                            1. Every Class as Interface
                                                                            2. Implementing an Interface (`implements`)
                                                                              1. Implementing Multiple Interfaces
                                                                                1. Interface Segregation
                                                                                2. Mixins
                                                                                  1. Purpose of Mixins
                                                                                    1. The `mixin` Keyword
                                                                                      1. Using Mixins (`with`)
                                                                                        1. Mixin Constraints (`on`)
                                                                                          1. Multiple Mixins
                                                                                            1. Mixin Linearization
                                                                                            2. Class Modifiers
                                                                                              1. `abstract`
                                                                                                1. `base`
                                                                                                  1. `final`
                                                                                                    1. `interface`
                                                                                                      1. `sealed`
                                                                                                        1. `mixin`
                                                                                                          1. Modifier Combinations
                                                                                                          2. Static Members
                                                                                                            1. Static Variables
                                                                                                              1. Static Methods
                                                                                                                1. Accessing Static Members
                                                                                                                  1. Static vs Instance Members
                                                                                                                  2. Enumerated Types (`enum`)
                                                                                                                    1. Defining Enums
                                                                                                                      1. Enhanced Enums
                                                                                                                        1. Enum Constructors
                                                                                                                          1. Enum Methods
                                                                                                                          2. Enum Properties and Methods
                                                                                                                            1. Enum Values and Index
                                                                                                                            2. Operator Overloading
                                                                                                                              1. Overloadable Operators
                                                                                                                                1. Implementing Custom Operators
                                                                                                                                  1. Equality Operator (`==`)
                                                                                                                                    1. Comparison Operators

                                                                                                                                  Previous

                                                                                                                                  3. Functions

                                                                                                                                  Go to top

                                                                                                                                  Next

                                                                                                                                  5. Collections