One of the core concepts of programming, inheritance is one of the most important features of object-oriented programming,
and Flutter also follows the principles of object-oriented programming.
In this course, we will explain the concept of inheritance in Flutter, how to use it, and through practical examples,
you will gain a deep understanding of inheritance.
1. Definition of Inheritance
Inheritance refers to the process where a new class (child class or subclass) inherits the properties and
methods of an existing class (parent class or super class). This maximizes code reuse and allows
for easy expression of relationships between classes.
2. Necessity of Inheritance
Inheritance is necessary for the following reasons:
- Code Reuse: By reusing the code that has already been written in a new class,
it reduces code duplication and makes maintenance easier. - Maintenance: Changes or bug fixes in the parent class are automatically applied
to all child classes that inherit from it. - Hierarchical Structure: It creates a hierarchical structure among related classes
contributing to the readability of the program.
3. How to Use Inheritance in Flutter
Since Flutter is based on the Dart language, it follows the inheritance implementation of Dart.
To inherit a class in Dart, the `extends` keyword is used.
The basic syntax is as follows.
class Parent {
void show() {
print("This is a method of the parent class.");
}
}
class Child extends Parent {
void display() {
print("This is a method of the child class.");
}
}
In the above example, the `Child` class inherits from the `Parent` class,
allowing it to use the `show()` method while also defining its own
`display()` method.
4. Method Overriding
The process of redefining a parent class method in a child class through inheritance
is called Method Overriding.
This allows the child class to implement the parent class method
in its own way.
class Parent {
void show() {
print("Parent class's show()");
}
}
class Child extends Parent {
@override
void show() {
print("Child class's show()");
}
}
By using the `@override` keyword, you can explicitly indicate the method you are overriding
that was inherited from the parent class,
thus increasing the clarity of the code.
5. Multiple Inheritance and Mixins
Dart does not support multiple inheritance, but you can
combine multiple classes using mixins. A mixin is
a way to reuse code through classes that are not classes themselves.
To define a mixin, you can use the `mixins` keyword.
mixin MixinA {
void methodA() {
print("Method of Mixin A");
}
}
class Base {}
class Child extends Base with MixinA {
void methodB() {
print("Method of the child class");
}
}
In this example, the `Child` class is able to use
the `methodA()` method through the `MixinA` mixin.
In other words, mixins enable code reuse as an alternative to multiple inheritance.
6. Practical Example: Utilizing Inheritance in Flutter
Now let’s create a simple example that utilizes inheritance
in a Flutter application. Here, we will show how to use
inheritance along with basic UI composition.
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
home: HomeScreen(),
);
}
}
class HomeScreen extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: Text('Inheritance Example')),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
ChildWidget(),
SizedBox(height: 20),
ParentWidget(),
],
),
),
);
}
}
class ParentWidget extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Text(
'This is the parent class.',
style: TextStyle(fontSize: 24),
);
}
}
class ChildWidget extends ParentWidget {
@override
Widget build(BuildContext context) {
return Text(
'This is the child class.',
style: TextStyle(fontSize: 24, color: Colors.blue),
);
}
}
The above code describes two widget classes.
`ParentWidget` outputs basic text, while
`ChildWidget` inherits from `ParentWidget` and changes
the text color.
This shows how inheritance can be used to change or
extend the properties of UI widgets.
7. Summary
In this lesson, we learned about the concept of inheritance in Flutter and
its necessity, explained the inheritance syntax in Dart,
method overriding, and advanced concepts such as mixins.
We also confirmed how inheritance is utilized through a practical example and
learned how to effectively use inheritance in a Flutter application.
Inheritance is one of the central concepts of object-oriented programming,
and it plays an important role when developing Flutter applications.
In future lessons, we will discuss extending inheritance to develop complex
applications.
We hope this course provides insight into understanding the basic concept of inheritance and
how it can be applied in programming.