// Java：接口多实现
interface Flyable { void fly(); }
interface Swimmable { void swim(); }
class Duck implements Flyable, Swimmable {
    public void fly() { System.out.println("飞"); }
    public void swim() { System.out.println("游"); }
}

// Dart：混入实现交叉效果
mixin Flyable { void fly() => print('飞'); }
mixin Swimmable { void swim() => print('游'); }
class Duck with Flyable, Swimmable {}

// TS：交叉类型——不需要类，只需要形状
type Flyable = { fly: () => void };
type Swimmable = { swim: () => void };
type Duck = Flyable & Swimmable;
const duck: Duck = { fly: () => console.log('飞'), swim: () => console.log('游') };

// Dart：sealed class
sealed class Status {}
class Pending extends Status {}
class Approved extends Status { final String reviewer; Approved(this.reviewer); }
class Rejected extends Status { final String reason; Rejected(this.reason); }

// TS：字面量联合类型——一行搞定
type Status = 'pending' | 'approved' | 'rejected';

// Go：用 iota 枚举手动映射
type Status int
const ( Pending Status = iota; Approved; Rejected )
func (s Status) String() string {
    switch s { case Pending: return "pending"; case Approved: return "approved"; case Rejected: return "rejected"; default: return "unknown"; }
}

interface BaseButtonProps { children: React.ReactNode; disabled?: boolean; onClick?: () => void; }
type ButtonVariant = 'primary' | 'secondary' | 'text';
type ButtonProps = BaseButtonProps & { variant: ButtonVariant; size?: 'small' | 'medium' | 'large'; };

const Button = ({ variant, size = 'medium', children, ...rest }: ButtonProps) => (
    <button className={ ` btn btn-${variant} btn-${size}`} {...rest}>{children}</button>
);

// Java：不能设默认类型
public <T extends Comparable<T>> T max(T a, T b) { return a.compareTo(b) > 0 ? a : b; }

// Go 1.18+：同样无默认类型
func Max[T comparable](a, b T) T { return a }

// Dart：无默认类型
T max<T extends Comparable<T>>(T a, T b) => a.compareTo(b) > 0 ? a : b;

// TS：泛型默认类型——Java/Go/Dart 做不到
function createStore<T = Record<string, unknown>>(initial?: T) {
    let state: T = initial ?? {} as T;
    return { getState: () => state, setState: (next: Partial<T>) => { state = { ...state, ...next }; } };
}

function UserProfile() {
    const [user, setUser] = useState<User | null>(null); // 显式泛型
}

interface SelectProps<T> { options: T[]; value: T | null; onChange: (value: T) => void; getLabel: (option: T) => string; }
function Select<T>({ options, value, onChange, getLabel }: SelectProps<T>) {
    return <select onChange={e => onChange(options[Number(e.target.value)])}>
        {options.map((opt, i) => <option key={i} value={i}>{getLabel(opt)}</option>)}
    </select>;
}

// Java：Object 直接强转
Object obj = someApi();
if (obj instanceof String) { String s = (String) obj; System.out.println(s.length()); }

// Go：interface{} type switch
var obj interface{} = someApi()
switch v := obj.(type) { case string: fmt.Println(len(v)); case int: fmt.Println(v); }

// Dart：dynamic 随意调
dynamic obj = someApi();
print(obj.length); // 编译不报错，运行时可能崩

// TS：unknown 必须守卫
const obj: unknown = someApi();
if (typeof obj === 'string') { console.log(obj.length); }
if (obj instanceof Array) { console.log(obj.length); }
function isUser(obj: unknown): obj is { id: number; name: string } {
    return typeof obj === 'object' && obj !== null && 'id' in obj && 'name' in obj;
}

async function fetchData() {
    try {
        return await (await fetch('/api/users')).json();
    } catch (error: unknown) {
        if (error instanceof Error) { console.error(error.message); }
        else if (typeof error === 'string') { console.error(error); }
        else { console.error('未知错误'); }
    }
}

// Java：interface 定义契约
interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }
class Shape implements Drawable, Resizable { /* ... */ }

// Go：struct 定义数据结构
type Drawable interface { Draw() }
type Shape struct { /* ... */ }

// Dart：class 和 typedef
class Drawable { void draw() {} }
typedef JsonMap = Map<String, dynamic>;

// TS：interface 可扩展 + 声明合并
interface Animal { name: string; age: number; }
interface Dog extends Animal { breed: string; }
interface Dog { owner?: string; } // 同名合并

// type 灵活
type Status = 'active' | 'inactive';        // 联合类型
type Pair<T> = [T, T];                       // 元组
type PartialDog = Partial<Dog>;              // 全变可选

interface UserCardProps { user: { id: number; name: string; avatar?: string; }; onFollow?: () => void; }
type UserState = { loading: boolean; error: string | null; data: User | null; };

function UserCard({ user, onFollow }: UserCardProps) {
    const [state, setState] = useState<UserState>({ loading: false, error: null, data: null });
}

// Java：函数式接口
@FunctionalInterface interface Transformer<T, R> { R transform(T input); }
Transformer<String, Integer> len = s -> s.length();

// Go：函数签名类型
type Transformer func(string) int
var lenFn Transformer = func(s string) int { return len(s) }

// Dart：Function 类型
typedef Transformer = int Function(String input);
int lenFn(String s) => s.length;

// TS：箭头函数类型（是类型，不是实现）
type Transformer = (input: string) => number;
const lenFn: Transformer = (s) => s.length;

interface Column<T> {
    title: string;
    dataIndex: keyof T;
    render?: (value: unknown, record: T, index: number) => React.ReactNode; // 从右往左读
}

interface ButtonProps {
    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void; // 读法："接收 MouseEvent，什么都不返回"
}

function useToggle(initial = false): [boolean, () => void] {
    const [value, setValue] = useState(initial);
    const toggle = useCallback(() => setValue(v => !v), []);
    return [value, toggle];
}

// Java：Map 接口
Map<String, String> statusMap = new HashMap<>();
statusMap.put("pending", "待审"); statusMap.put("approved", "已通过");

// Go：map
statusMap := map[string]string{ "pending": "待审", "approved": "已通过" }

// Dart：Map
final statusMap = <String, String>{ 'pending': '待审', 'approved': '已通过' };

// TS：Record 类型
const statusMap: Record<string, string> = { pending: '待审', approved: '已通过' };

// 精确限定 key
type StatusKey = 'pending' | 'approved' | 'rejected';
const statusMap2: Record<StatusKey, string> = { pending: '待审', approved: '已通过', rejected: '已驳回' };

interface SelectOption { value: string; label: string; }
const statusOptions: SelectOption[] = [
    { value: 'pending', label: '待审' }, { value: 'approved', label: '已通过' }, { value: 'rejected', label: '已驳回' },
];

interface Column<T> { title: string; dataIndex: keyof T; width?: number; render?: (value: unknown, record: T) => React.ReactNode; }
const columns: Column<User>[] = [
    { title: 'ID', dataIndex: 'id', width: 80 },
    { title: '姓名', dataIndex: 'name' },
    { title: '操作', dataIndex: 'id', render: (_, record) => <button onClick={() => handleEdit(record)}>编辑</button> },
];

// Java：成员变量，改了不重绘
public class Counter { private int count = 0; public void increment() { count++; } }

// Go：struct field，改了不重绘
type Counter struct { count int }
func (c *Counter) Increment() { c.count++ }

// Flutter：setState 触发重绘
class _CounterState extends State<CounterWidget> {
    int _count = 0;
    void _increment() { setState(() { _count++; }); print(_count); } // 旧值——异步调度
    @override Widget build(BuildContext context) => Text('Count: $_count');
}

// React：useState 自动重渲染
function Counter() {
    const [count, setCount] = useState(0);
    const increment = () => {
        setCount(prev => prev + 1); // 函数形式，避免闭包陷阱
        console.log(count); // 仍然是旧值
    };
    return <div><p>Count: {count}</p><button onClick={increment}>+1</button></div>;
}

// Java：@PostConstruct / @PreDestroy
@Component
public class DataLoader {
    @PostConstruct public void init() { System.out.println("加载数据"); }
    @PreDestroy public void cleanup() { System.out.println("清理资源"); }
}

// Go：init() 函数
var dataCache map[string]string
func init() { dataCache = make(map[string]string); println("包初始化"); }

// Flutter：initState / dispose
class _DataWidgetState extends State<DataWidget> {
    @override void initState() { super.initState(); fetchData(); }
    @override void dispose() { subscription.cancel(); super.dispose(); }
}

// React：useEffect 统一生命周期
function DataWidget({ userId }: { userId: number }) {
    useEffect(() => {
        fetchData(userId);
        return () => { console.log('清理：取消订阅'); };
    }, [userId]);
    return <div>...</div>;
}

// Java：静态变量共享
public class AppContext { public static User currentUser; public static String theme = "light"; }

// Go：context.Context 传递
func Handler(w http.ResponseWriter, r *http.Request) {
    ctx := context.WithValue(r.Context(), "user", currentUser)
    nextHandler(ctx)
}
func nextHandler(ctx context.Context) { user := ctx.Value("user").(User); }

// Flutter：Provider 共享
void main() { runApp(ChangeNotifierProvider.value( value: UserProvider(), child: MyApp() )); }
// 子组件：final userProvider = Provider.of<UserProvider>(context);

// React：createContext + useContext
const ThemeContext = createContext('light');
const UserContext = createContext<User | null>(null);

function App() {
    const [theme] = useState('light');
    return (
        <ThemeContext.Provider value={theme}>
            <UserContext.Provider value={{ id: 1, name: 'Alice' }}>
                <MainLayout />
            </UserContext.Provider>
        </ThemeContext.Provider>
    );
}

function UserAvatar() {
    const theme = useContext(ThemeContext);
    const user = useContext(UserContext);
    return <div className={ ` avatar-${theme}`}>{user?.name}</div>;
}

// Java：状态模式 switch
enum Action { INCREMENT, DECREMENT, RESET }
class CounterFSM { int dispatch(Action a) { switch (a) { case INCREMENT: return ++count; case DECREMENT: return --count; case RESET: return count=0; default: return count; } } int count=0; }

// Go：状态机
func reducer(state int, action Action) int {
    switch action { case Inc: return state+1; case Dec: return state-1; case Reset: return 0; default: return state; }
}

// Flutter：Cubit
class CounterCubit extends Cubit<int> {
    CounterCubit() : super(0);
    void increment() => emit(state + 1);
    void decrement() => emit(state - 1);
}

// React：useReducer
type Action = { type: 'increment' } | { type: 'decrement' } | { type: 'reset' };
function reducer(state: number, action: Action): number {
    switch (action.type) { case 'increment': return state + 1; case 'decrement': return state - 1; case 'reset': return 0; }
}

function CounterWithReducer() {
    const [count, dispatch] = useReducer(reducer, 0);
    return <div><p>Count: {count}</p><button onClick={() => dispatch({ type: 'increment' })}>+</button>
        <button onClick={() => dispatch({ type: 'decrement' })}>-</button>
        <button onClick={() => dispatch({ type: 'reset' })}>重置</button></div>;
}

// Java：私有字段存 Timer
public class TimerComponent { private Timer timer; public void start() { timer = new Timer(); } public void stop() { if (timer != null) timer.cancel(); } }

// Go：struct field 存 ticker
type TimerComponent struct { ticker *time.Ticker; done chan bool }
func (tc *TimerComponent) Start() { tc.ticker = time.NewTicker(time.Second); }

// Flutter：成员变量存 Timer
class _TimerState extends State<TimerWidget> {
    Timer? _timer;
    void start() { _timer = Timer.periodic(Duration(seconds: 1), (_) { setState(() {}); }); }
    @override void dispose() { _timer?.cancel(); super.dispose(); }
}

// React：useRef 存计时器 ID 和 DOM 引用
function Timer() {
    const [count, setCount] = useState(0);
    const timerRef = useRef<number | null>(null);
    const inputRef = useRef<HTMLInputElement>(null);

    const start = () => { timerRef.current = window.setInterval(() => setCount(p => p + 1), 1000); };
    const stop = () => { if (timerRef.current !== null) { clearInterval(timerRef.current); timerRef.current = null; } };
    const focus = () => inputRef.current?.focus();

    return <div><p>Count: {count}</p><button onClick={start}>开始</button><button onClick={stop}>停止</button>
        <input ref={inputRef} /><button onClick={focus}>聚焦</button></div>;
}

// Java：CompletableFuture.allOf
CompletableFuture<User> uf = CompletableFuture.supplyAsync(() -> fetchUser(1));
CompletableFuture<Settings> sf = CompletableFuture.supplyAsync(() -> fetchSettings(1));
CompletableFuture.allOf(uf, sf).join();

// Go：goroutine + sync.WaitGroup
var wg sync.WaitGroup; var user User; var settings Settings
wg.Add(2)
go func() { defer wg.Done(); user = fetchUser(1); }()
go func() { defer wg.Done(); settings = fetchSettings(1); }()
wg.Wait()

// Dart：Future.wait() 并行
final results = await Future.wait([fetchUser(1), fetchSettings(1)]);

// TS：Promise.all() 并行
const [user, settings] = await Promise.all([fetchUser(1), fetchSettings(1)]);

interface ApiResponse { id: number; name: string; email: string; }
function UserCard(user: ApiResponse) { return <div>{user.name} ({user.email})</div>; }

// Java：类优先
@RestController
public class UserController {
    @GetMapping("/{id}")
    public ResponseEntity<User> get(@PathVariable Long id) { return ResponseEntity.ok(userService.findById(id)); }
}

// React：函数优先
const UserPage: React.FC<{ id: number }> = ({ id }) => {
    const [user, setUser] = useState<User | null>(null);
    useEffect(() => { fetchUser(id).then(setUser); }, [id]);
    return user ? <UserCard user={user} /> : <Spinner />;
};