Dart类与对象 #

class Person {
  String name;
  int age;
  
  Person(this.name, this.age);
  
  void sayHello() {
    print('Hello, I am $name, $age years old.');
  }
  
  String get info => 'Name: $name, Age: $age';
  
  set setName(String value) {
    name = value;
  }
}

var person = Person('Alice', 25);
person.sayHello();
print(person.info);
person.setName = 'Bob';

class User {
  String name;
  int _age;
  static int count = 0;
  static const String type = 'user';
  
  User(this.name, this._age) {
    count++;
  }
  
  int get age => _age;
  set age(int value) => _age = value;
}

class Point {
  double x;
  double y;
  
  Point(this.x, this.y);
}

var point = Point(3.0, 4.0);

class Point {
  double x;
  double y;
  
  Point(this.x, this.y);
  
  Point.origin() : x = 0, y = 0;
  
  Point.fromJSON(Map<String, dynamic> json)
      : x = json['x'],
        y = json['y'];
}

var origin = Point.origin();
var fromJson = Point.fromJSON({'x': 1.0, 'y': 2.0});

class Rectangle {
  final double width;
  final double height;
  final double area;
  
  Rectangle(this.width, this.height) : area = width * height;
  
  Rectangle.square(double size) 
      : width = size, 
        height = size, 
        area = size * size;
}

class User {
  String name;
  int age;
  
  User(this.name, this.age);
  
  User.guest() : this('Guest', 0);
  
  User.fromName(String name) : this(name, 18);
}

class ImmutablePoint {
  final double x;
  final double y;
  
  const ImmutablePoint(this.x, this.y);
  
  static const origin = ImmutablePoint(0, 0);
}

const point = ImmutablePoint(3.0, 4.0);

class Logger {
  final String name;
  static final Map<String, Logger> _cache = {};
  
  Logger._internal(this.name);
  
  factory Logger(String name) {
    return _cache.putIfAbsent(name, () => Logger._internal(name));
  }
}

var logger1 = Logger('app');
var logger2 = Logger('app');
print(identical(logger1, logger2));

class Animal {
  String name;
  
  Animal(this.name);
  
  void speak() {
    print('$name makes a sound');
  }
}

class Dog extends Animal {
  String breed;
  
  Dog(String name, this.breed) : super(name);
  
  @override
  void speak() {
    print('$name barks');
  }
  
  void fetch() {
    print('$name fetches the ball');
  }
}

var dog = Dog('Buddy', 'Golden Retriever');
dog.speak();
dog.fetch();

class Vehicle {
  String brand;
  
  Vehicle(this.brand);
  
  void start() {
    print('$brand vehicle starting...');
  }
}

class Car extends Vehicle {
  String model;
  
  Car(String brand, this.model) : super(brand);
  
  @override
  void start() {
    super.start();
    print('$brand $model is ready to go!');
  }
}

abstract class Shape {
  double area();
  double perimeter();
  
  void describe() {
    print('Area: ${area()}, Perimeter: ${perimeter()}');
  }
}

class Circle extends Shape {
  double radius;
  
  Circle(this.radius);
  
  @override
  double area() => 3.14159 * radius * radius;
  
  @override
  double perimeter() => 2 * 3.14159 * radius;
}

class Rectangle extends Shape {
  double width;
  double height;
  
  Rectangle(this.width, this.height);
  
  @override
  double area() => width * height;
  
  @override
  double perimeter() => 2 * (width + height);
}

class Flyable {
  void fly() {
    print('Flying...');
  }
}

class Swimmable {
  void swim() {
    print('Swimming...');
  }
}

class Duck implements Flyable, Swimmable {
  @override
  void fly() {
    print('Duck is flying');
  }
  
  @override
  void swim() {
    print('Duck is swimming');
  }
}

abstract class Drawable {
  void draw();
  
  void render() {
    draw();
  }
}

class Circle implements Drawable {
  @override
  void draw() {
    print('Drawing circle');
  }
}

class Square extends Drawable {
  @override
  void draw() {
    print('Drawing square');
  }
}

mixin Logging {
  void log(String message) {
    print('[LOG] $message');
  }
}

mixin Timing {
  void timeIt(void Function() action) {
    var start = DateTime.now();
    action();
    var end = DateTime.now();
    print('Elapsed: ${end.difference(start)}');
  }
}

class Service with Logging, Timing {
  void doWork() {
    log('Starting work');
    timeIt(() {
      for (var i = 0; i < 1000000; i++) {}
    });
  }
}

abstract class Animal {
  String get name;
}

mixin Walker on Animal {
  void walk() {
    print('$name is walking');
  }
}

mixin Runner on Animal {
  void run() {
    print('$name is running');
  }
}

class Human extends Animal with Walker, Runner {
  @override
  String get name => 'Human';
}

mixin JsonSerializable {
  Map<String, dynamic> toJson();
  
  String toJsonString() {
    return toJson().toString();
  }
}

mixin Validatable {
  bool validate();
  
  void validateOrThrow() {
    if (!validate()) {
      throw Exception('Validation failed');
    }
  }
}

class User with JsonSerializable, Validatable {
  String name;
  String email;
  
  User(this.name, this.email);
  
  @override
  Map<String, dynamic> toJson() => {
    'name': name,
    'email': email,
  };
  
  @override
  bool validate() => name.isNotEmpty && email.contains('@');
}

class MathUtils {
  static const double pi = 3.14159;
  static int calculationCount = 0;
  
  static double circleArea(double radius) {
    calculationCount++;
    return pi * radius * radius;
  }
  
  static double circleCircumference(double radius) {
    calculationCount++;
    return 2 * pi * radius;
  }
}

print(MathUtils.pi);
print(MathUtils.circleArea(5));
print(MathUtils.calculationCount);

class AppConstants {
  static const String appName = 'MyApp';
  static const String version = '1.0.0';
  static const int maxRetryCount = 3;
  static const Duration timeout = Duration(seconds: 30);
}

class Vector {
  final double x;
  final double y;
  
  const Vector(this.x, this.y);
  
  Vector operator +(Vector other) => Vector(x + other.x, y + other.y);
  Vector operator -(Vector other) => Vector(x - other.x, y - other.y);
  Vector operator *(double scalar) => Vector(x * scalar, y * scalar);
  
  bool operator ==(Object other) =>
      other is Vector && x == other.x && y == other.y;
  
  @override
  int get hashCode => Object.hash(x, y);
}

var v1 = Vector(2, 3);
var v2 = Vector(4, 5);
var v3 = v1 + v2;
var v4 = v1 * 2;

extension StringExtension on String {
  String get capitalized {
    if (isEmpty) return this;
    return '${this[0].toUpperCase()}${substring(1)}';
  }
  
  bool get isEmail {
    return contains('@') && contains('.');
  }
}

print('hello'.capitalized);
print('test@example.com'.isEmail);

extension ListExtension<T> on List<T> {
  T? firstWhereOrNull(bool Function(T) test) {
    for (var element in this) {
      if (test(element)) return element;
    }
    return null;
  }
  
  List<T> sorted(int Function(T, T) compare) {
    var list = [...this];
    list.sort(compare);
    return list;
  }
}

var numbers = [3, 1, 4, 1, 5];
var first = numbers.firstWhereOrNull((n) => n > 3);
var sorted = numbers.sorted((a, b) => a.compareTo(b));

extension DateTimeExtension on DateTime {
  bool get isToday {
    final now = DateTime.now();
    return year == now.year && month == now.month && day == now.day;
  }
  
  bool get isWeekend {
    return weekday == DateTime.saturday || weekday == DateTime.sunday;
  }
}

var today = DateTime.now();
print(today.isToday);
print(today.isWeekend);