Flutter Interview & Learning Guide: OOP, Async/Await, Streams, Futures, Generics, Widgets, State Management, Provider, Riverpod, Bloc

Flutter development mein in concepts ko samajhna bahut zaroori hai. Ye concepts aapko scalable, maintainable aur high-performance applications banane mein help karte hain.

---

1. OOP (Object-Oriented Programming)

Object-Oriented Programming ek programming paradigm hai jo Objects aur Classes par based hota hai. Dart (Flutter ki programming language) poori tarah OOP principles ko support karti hai.

Main OOP Concepts

1. Class

Class ek blueprint hoti hai jo objects create karne ke liye use ki jati hai.

class Student {
  String name = "Rehan";
}

2. Object

Class ka instance Object kehlata hai.

void main() {
  Student student = Student();
  print(student.name);
}

3. Encapsulation

Data aur methods ko ek class ke andar wrap karna.

class Employee {
  String _name = "John";

  String getName() {
    return _name;
  }
}

4. Inheritance

Ek class doosri class ki properties aur methods inherit kar sakti hai.

class Animal {
  void sound() {
    print("Animal Sound");
  }
}

class Dog extends Animal {
  void bark() {
    print("Dog Barking");
  }
}

5. Polymorphism

Same method different behavior show karti hai.

class Animal {
  void sound() {
    print("Animal Sound");
  }
}

class Dog extends Animal {
  @override
  void sound() {
    print("Bark");
  }
}

6. Abstraction

Implementation details hide karke only necessary information show karna.

abstract class Shape {
  void draw();
}

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

---

2. Async/Await

Flutter mein network calls aur database operations asynchronous hote hain. Async/Await asynchronous code ko synchronous style mein likhne ki suvidha deta hai.

Example

Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  return "Data Loaded";
}

void main() async {
  String result = await fetchData();
  print(result);
}

Benefits

• Readable code
• Easy error handling
• Callback Hell se bachata hai
• Better performance

---

3. Futures

Future ek value ko represent karta hai jo future mein available hogi.

Example

Future<String> getData() {
  return Future.delayed(
    Duration(seconds: 2),
    () => "Hello Flutter",
  );
}

Using Then

getData().then((value) {
  print(value);
});

Using Await

String data = await getData();

Future States

1. Uncompleted
2. Completed with Data
3. Completed with Error

---

4. Streams

Stream multiple asynchronous values provide karta hai.

Example

Stream<int> countStream() async* {
  for (int i = 1; i <= 5; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

Listen Stream

countStream().listen((value) {
  print(value);
});

Stream Advantages

• Real-time data updates
• Chat applications
• Live tracking
• Notifications

---

5. Generics

Generics code ko reusable aur type-safe banate hain.

Without Generics

List list = [];

With Generics

List<String> names = [];

Generic Class

class Data<T> {
  T value;

  Data(this.value);
}

Usage:

Data<String> name = Data("Rehan");
Data<int> age = Data(25);

Benefits

• Code Reusability
• Type Safety
• Better Performance

---

6. Flutter Widgets

Flutter mein sab kuch Widget hai.

Widgets UI ka basic building block hote hain.

Types of Widgets

Stateless Widget

State change nahi hoti.

class MyWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Text("Hello Flutter");
  }
}

Stateful Widget

State runtime mein change ho sakti hai.

class Counter extends StatefulWidget {
  @override
  _CounterState createState() => _CounterState();
}

class _CounterState extends State<Counter> {
  int count = 0;

  @override
  Widget build(BuildContext context) {
    return Text("$count");
  }
}

Common Widgets

• Text
• Container
• Row
• Column
• ListView
• GridView
• Stack
• Scaffold
• AppBar
• ElevatedButton
• TextField

---

7. State Management

State Management app ke data aur UI synchronization ko manage karta hai.

Why State Management?

• UI Update Control
• Better Performance
• Clean Architecture
• Easy Maintenance

Types

Local State

Single widget ke andar manage hoti hai.

setState(() {});

Global State

Multiple screens mein share hoti hai.

Examples:

• Provider
• Riverpod
• Bloc
• GetX

---

8. Provider

Provider Flutter ka official recommended state management solution tha jo InheritedWidget ke upar bana hai.

Add Dependency

dependencies:
  provider: ^6.0.5

Create Provider

class CounterProvider extends ChangeNotifier {
  int count = 0;

  void increment() {
    count++;
    notifyListeners();
  }
}

Register Provider

ChangeNotifierProvider(
  create: (_) => CounterProvider(),
  child: MyApp(),
);

Access Provider

Consumer<CounterProvider>(
  builder: (context, provider, child) {
    return Text("${provider.count}");
  },
);

Pros

• Easy to Learn
• Officially Supported
• Lightweight

Cons

• Large Applications mein complexity badh sakti hai

---

9. Riverpod (Recommended)

Riverpod Provider ka improved version hai.

Ye compile-time safety aur dependency management provide karta hai.

Add Dependency

dependencies:
  flutter_riverpod: latest_version

Create Provider

final counterProvider = StateProvider<int>((ref) => 0);

Wrap App

void main() {
  runApp(
    ProviderScope(
      child: MyApp(),
    ),
  );
}

Use Provider

class HomeScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {

    final count = ref.watch(counterProvider);

    return Text('$count');
  }
}

Update Value

ref.read(counterProvider.notifier).state++;

Advantages

• Compile-Time Safety
• Better Testing
• No BuildContext Dependency
• Better Performance
• Scalable Architecture

Why Recommended?

Modern Flutter projects mein Riverpod ko zyada prefer kiya jata hai kyunki ye Provider ki limitations ko solve karta hai aur enterprise-level applications ke liye suitable hai.

---

10. Bloc (Business Logic Component)

Bloc state management ka advanced architecture hai jo Events aur States par kaam karta hai.

Add Dependency

dependencies:
  flutter_bloc: latest_version

Event

abstract class CounterEvent {}

class IncrementCounter extends CounterEvent {}

State

class CounterState {
  final int count;

  CounterState(this.count);
}

Bloc

class CounterBloc
    extends Bloc<CounterEvent, CounterState> {

  CounterBloc() : super(CounterState(0)) {

    on<IncrementCounter>((event, emit) {
      emit(CounterState(state.count + 1));
    });
  }
}

UI

BlocBuilder<CounterBloc, CounterState>(
  builder: (context, state) {
    return Text('${state.count}');
  },
);

Advantages

• Clear Separation of Concerns
• Scalable
• Predictable State Changes
• Easy Testing

Disadvantages

• More Boilerplate Code
• Learning Curve High

---

Provider vs Riverpod vs Bloc

Feature	Provider	Riverpod	Bloc
Easy to Learn	✅	✅	❌
Performance	Good	Excellent	Excellent
Testing	Good	Excellent	Excellent
Boilerplate	Low	Low	High
Scalability	Medium	High	Very High
Recommended for New Projects	Good	✅ Best Choice	Large Projects

---

Conclusion

Flutter development mein OOP, Futures, Async/Await, Streams aur Generics fundamentals hain jo har developer ko aane chahiye. UI banane ke liye Widgets use hote hain aur application state manage karne ke liye State Management techniques ka use kiya jata hai.

• Beginner Projects → Provider
• Modern Flutter Apps → Riverpod ✅
• Enterprise Applications → Bloc