In Dart, what makes a class abstract, how do you declare an abstract member, and what must a concrete subclass do with it?

## Abstract classes An **abstract class** is declared with the `abstract` modifier. It describes a family of types and may provide part of their behaviour, but it is **never instantiated directly** — not from another library, and not from its own library either (`instantiate_abstract_class`). ```dart abstract class Shape { Shape(this.label); final String label; double get area; // abstract getter double get perimeter; // abstract getter Shape scaled(double k); // abstract method String describe() => // concrete method '$label: ${area.toStringAsFixed(2)} m2, perimeter ${perimeter.toStringAsFixed(2)} m'; } ``` An abstract class still has constructors. They cannot be called with `Shape(...)`, but a subclass calls them through `super(...)` to initialise the fields the abstract class owns, such as `label`. ## Declaring abstract members - **Methods, getters and setters** become abstract by ending the declaration with `;` instead of a body: `void recalc();`, `double get area;`, `set area(double v);`. - There is **no `abstract` keyword on methods**; `abstract void recalc();` is an error (`abstract_class_member`). - **Fields** are the exception: `abstract double width;` declares an abstract getter and setter pair. Abstract fields cannot have initializers or be `late`. - Abstract members can only exist in **abstract classes** (or mixins). A concrete class with a body-less method is `concrete_class_with_abstract_member`. ## Obligations of a concrete subclass ```dart class Rect extends Shape { Rect(this.width, this.height) : super('rect'); final double width, height; @override double get area => width * height; @override double get perimeter => 2 * (width + height); @override Rect scaled(double k) => Rect(width * k, height * k); } ``` 1. A **concrete** class must have an implementation for every abstract member it inherits — declared itself or inherited from further up (or supplied by a mixin). Otherwise: `non_abstract_class_inherits_abstract_member`. 2. A subclass that cannot supply them all can be declared **`abstract`** itself. 3. Inside an override, `super.area` is only valid if some superclass provides a **concrete** `area`; calling an always-abstract member via `super` is `abstract_super_member_reference`. 4. The override may **narrow the return type**: `Rect scaled(...)` legally overrides `Shape scaled(...)`. ## Looking instantiable: factory constructors An abstract class may declare a **factory constructor** that returns a concrete subtype, so callers write `Shape.square(3)` and never see the implementation class: ```dart abstract class Shape { // ... factory Shape.square(double side) = Square; } ``` ## Abstract class or plain class as interface? | Need | Choose | |---|---| | Shared code plus required hooks | abstract class, subclasses `extend` it | | Only a contract, no shared code | abstract class with only abstract members, implementers `implement` it | | Prevent direct construction | abstract class | | A usable default implementation | a concrete class | In the floor-plan calculator, `Shape` owns the reusable `describe()` and forces each concrete shape to answer `area` and `perimeter`. Code that sums a floor plan depends only on `Shape`. ## Common mistakes - Writing a method with an empty body `{}` and calling it abstract: it is concrete, and subclasses are no longer forced to override it. - Using `throw UnimplementedError()` as a body to fake abstraction: the error moves from compile time to runtime. - Expecting `Shape()` to work inside the declaring library.