Dart Encapsulation and abstraction:explanations and expmles

---

Mastering Dart Encapsulation and Abstraction: Explained with Examples

Introduction:

In the world of Dart programming, mastering encapsulation and abstraction is crucial for writing clean, maintainable, and efficient code. Encapsulation involves bundling data and methods within a single unit (class) and controlling access to that unit, while abstraction focuses on hiding implementation details and providing a simplified interface. In this comprehensive guide, we delve deep into Dart encapsulation and abstraction, providing clear explanations, insightful examples, and practical insights to help you elevate your Dart programming skills to the next level.

Encapsulation and abstraction are two important concepts in object-oriented programming, including Dart.

Let’s break down each concept and provide examples in Dart:

Dart Encapsulation:

Encapsulation is the bundling of data (attributes or properties) and methods (functions or procedures) that operate on the data into a single unit, typically called a class. It allows for the internal representation of an object to be hidden from the outside and only accessible through well-defined interfaces. This helps in achieving data hiding and restricting direct access to certain parts of the object.

Example in Dart:

class Car {
String _brand;
String _model;
int _year;

Car(this._brand, this._model, this._year);

// Getters
String get brand => _brand;
String get model => _model;
int get year => _year;

// Setter for year with validation
set year(int year) {
if (year > 0) {
_year = year;
} else {
throw ArgumentError("Year must be a positive value.");
}
}

void start() {
print("$_brand $_model started.");
}
}

void main() {
var myCar = Car("Toyota", "Camry", 2020);
print("Brand: ${myCar.brand}, Model: ${myCar.model}, Year: ${myCar.year}");
myCar.start();
}

In this example, the Car class encapsulates the brand, model, and year of the car. These attributes are encapsulated within the class and accessed through getter methods (brand, model, year). The start() method demonstrates encapsulation of behavior, as it’s a method that operates on the data inside the class.

Dart Abstraction:

Abstraction is the process of hiding the complex implementation details and showing only the necessary features of an object. It focuses on what an object does rather than how it does it. Abstract classes and interfaces are used to achieve abstraction in Dart.

Example in Dart:

abstract class Shape {
void draw(); // Abstract method
}

class Circle extends Shape {
double radius;

Circle(this.radius);

@override
void draw() {
print("Drawing a circle with radius $radius");
}
}

class Rectangle extends Shape {
double width;
double height;

Rectangle(this.width, this.height);

@override
void draw() {
print("Drawing a rectangle with width $width and height $height");
}
}

void main() {
var circle = Circle(5.0);
var rectangle = Rectangle(3.0, 4.0);

circle.draw();
rectangle.draw();
}

In this example, Shape is an abstract class that defines an abstract method draw(). Concrete classes Circle and Rectangle inherit from Shape and provide their own implementations of the draw() method. The abstraction here is that both Circle and Rectangle classes present a unified interface for drawing shapes, regardless of their specific implementations.

Encapsulation and abstraction are key principles in object-oriented programming that promote modularity, maintainability, and code reusability.

Step by step:How to create Encapsulation and abstraction

let’s break down the steps to create encapsulation and abstraction in Dart:

1. Encapsulation:

Encapsulation is achieved by bundling data (attributes or properties) and methods (functions or procedures) that operate on the data into a single unit, typically called a class. Here are the steps to create encapsulation:

Step 1: Define a class:

class MyClass {
// Define private variables
String _name;
int _age;

// Constructor
MyClass(this._name, this._age);

// Define getter methods
String get name => _name;
int get age => _age;

// Define setter methods with validation if needed
set age(int age) {
if (age > 0) {
_age = age;
} else {
throw ArgumentError("Age must be a positive value.");
}
}

// Other methods can be defined here
}

Step 2: Access the encapsulated data using getter methods:

void main() {
var obj = MyClass("John", 30);
print("Name: ${obj.name}, Age: ${obj.age}");
}

Step 3:

Encapsulated methods can also be called on the object:

void main() {
var obj = MyClass("John", 30);
obj.someMethod();
}

2. Abstraction:

Abstraction is achieved by hiding the complex implementation details and showing only the necessary features of an object. Here are the steps to create abstraction:

Step 1: Define an abstract class or interface:

abstract class MyShape {
void draw(); // Abstract method
}

Step 2:

Implement the abstract class or interface in concrete classes:

class Circle extends MyShape {
@override
void draw() {
print("Drawing a circle");
}
}

class Rectangle extends MyShape {
@override
void draw() {
print("Drawing a rectangle");
}
}

Step 3:

Use the abstract class or interface to interact with objects without knowing their specific implementations:

void main() {
var shape1 = Circle();
var shape2 = Rectangle();

shape1.draw(); // Output: Drawing a circle
shape2.draw(); // Output: Drawing a rectangle
}

These steps demonstrate how to create encapsulation and abstraction in Dart. Encapsulation helps in hiding internal details of a class and providing controlled access to its members. Abstraction helps in providing a clear interface to interact with objects without exposing their underlying complexities.

complete example with explanation

let’s create a complete example with explanations for both encapsulation and abstraction in Dart.

Encapsulation Example:

Encapsulation involves bundling the data and methods that operate on the data within a single unit (class) and controlling access to that unit. Here’s a complete example:

class Person {
// Private variables, accessible only within this class
String _name;
int _age;

// Constructor
Person(this._name, this._age);

// Getter methods to access private variables
String get name => _name;
int get age => _age;

// Setter method with validation
set age(int age) {
if (age > 0) {
_age = age;
} else {
throw ArgumentError("Age must be a positive value.");
}
}

// Method to print person's details
void printDetails() {
print("Name: $_name, Age: $_age");
}
}

void main() {
// Creating an instance of Person class
var person = Person("John", 30);

// Accessing encapsulated data using getter methods
print("Name: ${person.name}, Age: ${person.age}");

// Calling encapsulated method
person.printDetails();

// Updating age using setter method
person.age = 35;
print("Updated Age: ${person.age}");
}

Explanation:

The Person class encapsulates the data (_name and _age) and methods (printDetails() and age setter method) within it.
_name and _age are private variables, so they can only be accessed within the Person class itself.
Getter methods (name and age) provide controlled access to the private variables from outside the class.
The age setter method validates the input before updating the age.
printDetails() method is encapsulated within the Person class to print the person’s details.
In the main() function, we create an instance of the Person class and demonstrate accessing data, calling methods, and updating the age.

Abstraction Example:

Abstraction involves hiding the complex implementation details and showing only the necessary features of an object.

Here’s a complete example:

abstract class Shape {
// Abstract method, to be implemented by concrete subclasses
void draw();
}

class Circle extends Shape {
@override
void draw() {
print("Drawing a circle");
}
}

class Rectangle extends Shape {
@override
void draw() {
print("Drawing a rectangle");
}
}

void main() {
// Creating instances of concrete classes
var shape1 = Circle();
var shape2 = Rectangle();

// Calling the abstract method without knowing the specific implementation
shape1.draw(); // Output: Drawing a circle
shape2.draw(); // Output: Drawing a rectangle
}

Explanation:

The Shape class is an abstract class that defines an abstract method draw(). This method represents a common behavior for all shapes.
Concrete subclasses (Circle and Rectangle) extend the Shape class and provide their specific implementations for the draw() method.
In the main() function, we create instances of concrete classes (Circle and Rectangle) and call the draw() method without knowing the specific implementation details.
This demonstrates abstraction, as we interact with objects through a common interface (Shape), hiding the specific implementation details of each shape.

let’s provide more examples for both encapsulation and abstraction in Dart.

Encapsulation Example:

In this example, we’ll create a BankAccount class to demonstrate encapsulation. It will encapsulate the account balance and provide methods to deposit, withdraw, and get the current balance.

class BankAccount {
double _balance;

BankAccount(this._balance);

double get balance => _balance;

void deposit(double amount) {
if (amount > 0) {
_balance += amount;
} else {
throw ArgumentError("Amount must be greater than 0.");
}
}

void withdraw(double amount) {
if (amount > 0 && amount <= _balance) {
_balance -= amount;
} else {
throw ArgumentError("Invalid withdrawal amount.");
}
}
}

void main() {
var account = BankAccount(1000.0);
print("Initial Balance: ${account.balance}");

account.deposit(500.0);
print("After Deposit: ${account.balance}");

account.withdraw(200.0);
print("After Withdrawal: ${account.balance}");
}

Explanation:

The BankAccount class encapsulates the balance of the account within it.
_balance is a private variable, accessible only within the BankAccount class.
Getter method balance provides controlled access to the private variable from outside the class.
Methods deposit() and withdraw() encapsulate the behavior of depositing and withdrawing money from the account, respectively.
In the main() function, we create an instance of the BankAccount class, perform deposit and withdrawal operations, and print the updated balance.

Abstraction Example:

In this example, we’ll create an abstract Shape class with abstract methods to calculate area and perimeter. Concrete subclasses Circle and Rectangle will extend the Shape class and implement these methods.

abstract class Shape {
double calculateArea();
double calculatePerimeter();
}

class Circle extends Shape {
double radius;

Circle(this.radius);

@override
double calculateArea() {
return 3.14 * radius * radius;
}

@override
double calculatePerimeter() {
return 2 * 3.14 * radius;
}
}

class Rectangle extends Shape {
double length;
double width;

Rectangle(this.length, this.width);

@override
double calculateArea() {
return length * width;
}

@override
double calculatePerimeter() {
return 2 * (length + width);
}
}

void main() {
var circle = Circle(5.0);
var rectangle = Rectangle(3.0, 4.0);

print("Circle - Area: ${circle.calculateArea()}, Perimeter: ${circle.calculatePerimeter()}");
print("Rectangle - Area: ${rectangle.calculateArea()}, Perimeter: ${rectangle.calculatePerimeter()}");
}

Explanation:

The Shape class is an abstract class with abstract methods calculateArea() and calculatePerimeter().
Concrete subclasses Circle and Rectangle extend the Shape class and provide their specific implementations for these methods.
In the main() function, we create instances of Circle and Rectangle, and call the calculateArea() and calculatePerimeter() methods on them.
This demonstrates abstraction, as we interact with shapes through a common interface (Shape), without needing to know the specific implementation details of each shape.

An application about this lesson with explanation

Let’s create a simple application that demonstrates encapsulation and abstraction in Dart. We’ll create a banking application where s can create accounts, deposit money, withdraw money, and check their balance. We’ll use encapsulation to hide the account details and abstraction to provide a unified interface for interacting with different types of accounts.

// Define an abstract class Account
abstract class Account {
String accountNumber;
double balance;

Account(this.accountNumber, this.balance);

void deposit(double amount) {
if (amount > 0) {
balance += amount;
print("Deposit of \$$amount successful. New balance: \$$balance");
} else {
print("Invalid deposit amount.");
}
}

void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
print("Withdrawal of \$$amount successful. New balance: \$$balance");
} else {
print("Insufficient funds or invalid withdrawal amount.");
}
}

void displayBalance() {
print("Account Number: $accountNumber, Balance: \$$balance");
}
}

// Define a concrete subclass CheckingAccount
class CheckingAccount extends Account {
CheckingAccount(String accountNumber, double balance)
: super(accountNumber, balance);

@override
String toString() {
return "Checking Account - Account Number: $accountNumber, Balance: \$$balance";
}
}

// Define a concrete subclass SavingsAccount
class SavingsAccount extends Account {
double interestRate;

SavingsAccount(String accountNumber, double balance, this.interestRate)
: super(accountNumber, balance);

void calculateInterest() {
double interest = balance * (interestRate / 100);
balance += interest;
print("Interest calculated: \$$interest. New balance: \$$balance");
}

@override
String toString() {
return "Savings Account - Account Number: $accountNumber, Balance: \$$balance";
}
}

void main() {
// Creating a CheckingAccount
var checking = CheckingAccount("123456", 1000.0);
print(checking);

// Depositing and withdrawing from CheckingAccount
checking.deposit(500.0);
checking.withdraw(200.0);
checking.displayBalance();

// Creating a SavingsAccount
var savings = SavingsAccount("789012", 2000.0, 5.0);
print(savings);

// Depositing, withdrawing, and calculating interest for SavingsAccount
savings.deposit(1000.0);
savings.withdraw(300.0);
savings.calculateInterest();
savings.displayBalance();
}

Explanation:

We define an abstract class Account that represents a generic bank account with properties like accountNumber and balance, and methods like deposit, withdraw, and displayBalance.
We create concrete subclasses CheckingAccount and SavingsAccount that extend the Account class and provide their specific implementations.
CheckingAccount and SavingsAccount encapsulate the account details and provide methods to deposit, withdraw, and display the balance.
We demonstrate abstraction by interacting with both CheckingAccount and SavingsAccount objects through a common interface provided by the Account class.
This application simulates a banking system where s can create different types of accounts, perform transactions, and check their balances. It showcases encapsulation by hiding the internal details of accounts and abstraction by providing a unified interface for interacting with accounts.

Quiz about:Dart Encapsulation and abstraction

Dart Encapsulation and Abstraction Quiz

1-What is encapsulation in Dart?

a) Hiding implementation details and showing only necessary features
b) Creating multiple instances of a class
c) Managing memory allocation
d) None of the above

Answer: a) Hiding implementation details and showing only necessary features

Explanation: Encapsulation in Dart involves bundling data and methods that operate on the data within a single unit (class) and controlling access to that unit. It helps in hiding internal details of a class and providing controlled access to its members.

2-Which keyword is used to define private variables in Dart?

a) private
b) secret
c) protected
d) hidden

Answer: a) private

Explanation: In Dart, private variables are defined using the underscore (_) prefix before the variable name. These variables are accessible only within the class where they are defined.

3-What is abstraction in Dart?

a) Creating multiple instances of a class
b) Hiding implementation details and showing only necessary features
c) Managing memory allocation
d) None of the above

Answer: b) Hiding implementation details and showing only necessary features

Explanation: Abstraction in Dart involves hiding the complex implementation details of an object and showing only the necessary features. It focuses on what an object does rather than how it does it.

4-Which of the following is an example of encapsulation in Dart?

a) Defining private variables and providing public getter and setter methods
b) Using inheritance to create subclasses
c) Implementing interfaces
d) None of the above

Answer: a) Defining private variables and providing public getter and setter methods

Explanation: Encapsulation involves bundling data and methods within a single unit (class) and controlling access to that unit. Defining private variables and providing public getter and setter methods is an example of encapsulation in Dart.

5-What is the purpose of abstraction in object-oriented programming?

a) To create multiple instances of a class
b) To hide implementation details and provide a simplified interface
c) To manage memory allocation
d) None of the above

Answer: b) To hide implementation details and provide a simplified interface

Explanation: Abstraction helps in hiding the complex implementation details of an object and providing a simplified interface for interacting with it. It focuses on what an object does rather than how it does it.

6-Which keyword in Dart is used to define abstract classes?

a) abstract
b) interface
c) class
d) implements

Answer: a) abstract

Explanation: In Dart, the abstract keyword is used to define abstract classes. Abstract classes cannot be instantiated directly and may contain abstract methods that must be implemented by subclasses.

7-What is the purpose of using getters and setters in Dart?

a) To encapsulate data and control access to it
b) To define abstract methods in a class
c) To create instances of a class
d) None of the above

Answer: a) To encapsulate data and control access to it

Explanation: Getters and setters in Dart help in encapsulating data by providing controlled access to class variables. They allow for the implementation of validation, computation, or other logic when getting or setting the values of variables.

8-In Dart, which access modifier is used to make a class member visible only within its own library?

a) private
b) public
c) protected
d) internal

Answer: d) internal

Explanation: In Dart, the internal access modifier is used to make a class member visible only within its own library. It allows for encapsulation of data and methods within a library.

8-What is the main difference between an abstract class and an interface in Dart?

a) Abstract classes can have method implementations, while interfaces cannot.
b) Interfaces can have constructors, while abstract classes cannot.
c) Abstract classes can be instantiated directly, while interfaces cannot.
d) There is no difference between abstract classes and interfaces in Dart.

Answer: a) Abstract classes can have method implementations, while interfaces cannot.

Explanation: In Dart, abstract classes can contain method implementations, while interfaces cannot. Abstract classes can also have instance variables, constructors, and normal methods, while interfaces can only declare method signatures.

9-Which principle of object-oriented programming is closely related to encapsulation and abstraction?

a) Inheritance
b) Polymorphism
c) Encapsulation
d) Abstraction

Answer: c) Encapsulation

Explanation: Encapsulation is one of the fundamental principles of object-oriented programming and is closely related to data hiding and abstraction. It involves bundling data and methods within a single unit (class) and controlling access to that unit.

10-Which of the following best describes encapsulation in Dart?

a) Separating a program into smaller, manageable parts
b) Hiding implementation details and providing controlled access to data
c) Implementing multiple forms of a method in a class
d) Allowing a class to inherit properties and behaviors from another class

Answer: b) Hiding implementation details and providing controlled access to data

Explanation: Encapsulation involves bundling the data and methods that operate on the data within a single unit (class) and controlling access to that unit. It helps in hiding implementation details and providing controlled access to data to prevent accidental misuse.

11-Which of the following statements about Dart encapsulation is true?

a) Private variables in Dart can be accessed from outside the class they are defined in.
b) Encapsulation in Dart is achieved by using the public keyword before variable declarations.
c) Getters and setters in Dart are used to provide public access to private variables.
d) Encapsulation in Dart is only applicable to abstract classes.

Answer: c) Getters and setters in Dart are used to provide public access to private variables.

Explanation: Getters and setters in Dart provide controlled access to private variables by allowing indirect access through methods. This helps in encapsulating data and enforcing validation or logic when accessing or modifying the values of private variables.

12-In Dart, what is the purpose of using the @override annotation?

a) To specify that a method is implemented from an abstract superclass.
b) To indicate that a method overrides a superclass method, providing a compile-time check.
c) To prevent a method from being overridden by subclasses.
d) It has no specific purpose in Dart.

Answer: b) To indicate that a method overrides a superclass method, providing a compile-time check.

Explanation: The @override annotation in Dart is used to indicate that a method in a subclass overrides a method in its superclass. It provides a compile-time check to ensure that the method being overridden actually exists in the superclass, helping to catch errors early.

13-Which of the following best describes abstraction in Dart?

a) Providing controlled access to class members through getters and setters.
b) Defining a class with unimplemented methods that must be implemented by subclasses.
c) Hiding implementation details and showing only essential features of an object.
d) Creating multiple instances of a class with similar properties and behaviors.

Answer: c) Hiding implementation details and showing only essential features of an object.

Explanation: Abstraction in Dart involves hiding the complex implementation details of an object and showing only the necessary features. It focuses on what an object does rather than how it does it, providing a simplified interface for interacting with the object.

14-Which Dart keyword is used to define an interface?

a) interface
b) implements
c) abstract
d) mixin

Answer: a) interface

Explanation: In Dart, the interface keyword is used to define an interface. However, starting from Dart 2.1, interfaces are implicit, and the interface keyword is optional. Dart’s interfaces are implemented implicitly by classes that provide the required methods and properties.