Dart

// Type inferred
var name = 'Alice';
var age  = 25;

// Explicit type
String city   = 'Hyderabad';
int    score  = 92;
double pi     = 3.14159;
bool   active = true;

// final — set once at runtime
final url = 'https://api.example.com';

// const — compile-time constant
const MAX = 100;

// dynamic — opt out of type checking
dynamic anything = 'hello';
anything = 42;  // OK

// Non-nullable by default
String  a = 'hi';   // never null
String? b = null;  // nullable

// ? — conditional member access
b?.toUpperCase()  // null if b is null
b?.length        // null if b is null

// ! — null assertion (throws if null)
String c = b!;   // trust me, not null

// ?? — if-null operator
String d = b ?? 'default';

// ??= — assign if null
b ??= 'assigned';

// late — initialise later (non-null)
late String username;
username = 'alice';  // before use

// Check type
age is int           // true
age is String        // false
age is! String       // true

// Cast
dynamic v = 42;
int n = v as int;

// Parse strings
int    i = int.parse('42');
double d = double.parse('3.14');
int?   x = int.tryParse('bad');
// x == null (doesn't throw)

// Convert to string
42.toString()         // '42'
3.14.toStringAsFixed(1) // '3.1'

class Animal {
  String name;
  int    age;

  // Constructor shorthand
  Animal(this.name, this.age);

  // Named constructor
  Animal.unknown()
      : name = 'Unknown',
        age  = 0;

  // Getter
  String get info =>
      '$name ($age)';

  // Setter
  set newName(String n) {
    name = n.trim();
  }

  void speak() => print('...');

  @override
  String toString() => info;
}

// extends — inherit one class
class Dog extends Animal {
  String breed;

  Dog(String name, this.breed)
      : super(name, 0);

  @override
  void speak() => print('Woof!');
}

// abstract class
abstract class Shape {
  double area();
  void describe() =>
      print('area=${area()}');
}

// implements — use as interface
class Circle implements Shape {
  final double r;
  Circle(this.r);
  @override
  double area() => 3.14159 * r * r;
}

// mixin — reusable behaviour
mixin Flyable {
  void fly() => print('Flying!');
  int speed = 100;
}

mixin Swimmable {
  void swim() => print('Swimming!');
}

// with — apply mixins
class Duck extends Animal
    with Flyable, Swimmable {
  Duck() : super('Duck', 1);
}

var d = Duck();
d.fly();    // Flying!
d.swim();   // Swimming!

// on — restrict mixin to type
mixin Trainable on Animal {
  void train() =>
      print('$name trained');
}

// Future — value arriving later
Future<String> fetchUser(int id) async {
  await Future.delayed(
      Duration(seconds: 1));
  return 'User $id';
}

void main() async {
  String user = await fetchUser(1);
  print(user);  // 'User 1'
}

Future.value(42)
Future.error('oops')

// Run multiple in parallel
var results = await Future.wait([
  fetchUser(1),
  fetchUser(2),
]);

Future<void> loadData() async {
  try {
    var data = await fetchUser(1);
    print(data);
  } catch (e) {
    print('Error: $e');
  } finally {
    print('Done');
  }
}

// .then() chain
fetchUser(1)
  .then((u) => print(u))
  .catchError((e) => print(e))
  .whenComplete(() => print('done'));

// FutureOr — sync or async
FutureOr<String> maybeAsync()
    => 'immediate';

// async* + yield → Stream
Stream<int> count(int n) async* {
  for (var i=1; i<=n; i++) {
    await Future.delayed(
        Duration(seconds: 1));
    yield i;
  }
}

// await for — consume stream
await for (var n in count(3))
  print(n);  // 1, 2, 3

// Stream from Iterable
Stream.fromIterable([1,2,3])
  .map((x) => x * 2)
  .where((x) => x > 2)
  .listen((x) => print(x));

// StreamController
var ctrl = StreamController<int>();
ctrl.sink.add(1);
ctrl.stream.listen((v) => print(v));
ctrl.close();

import 'package:flutter/material.dart';

// Stateless — no mutable state
class HelloWidget extends StatelessWidget {
  final String name;
  const HelloWidget({super.key,
                     required this.name});
  @override
  Widget build(BuildContext ctx)
      => Text('Hello $name');
}

// Stateful — mutable state
class Counter extends StatefulWidget {
  const Counter({super.key});
  @override
  State<Counter> createState()
      => _CounterState();
}

class _CounterState extends State<Counter> {
  int _count = 0;
  @override
  Widget build(BuildContext ctx) =>
      ElevatedButton(
        onPressed: () =>
            setState(() => _count++),
        child: Text('$_count'),
      );
}

Scaffold(
  appBar: AppBar(title: Text('App')),
  body: Column(
    children: [
      Text('Hello'),
      SizedBox(height: 16),
      ElevatedButton(
        onPressed: (){},
        child: Text('Click'),
      ),
    ],
  ),
)

Row(children:[...])
Stack(children:[...])

ListView.builder(
  itemCount: items.length,
  itemBuilder: (ctx, i) =>
      Text(items[i]),
)

Container(
  width: 100, height: 100,
  color: Colors.blue,
  padding: EdgeInsets.all(8),
)

FutureBuilder<String>(
  future: fetchUser(1),
  builder: (ctx, snap) {
    if (snap.hasError)
      return Text('Error');
    if (!snap.hasData)
      return CircularProgressIndicator();
    return Text(snap.data!);
  },
)

StreamBuilder<int>(
  stream: count(5),
  builder: (ctx, snap) {
    if (!snap.hasData)
      return CircularProgressIndicator();
    return Text('${snap.data}');
  },
)