复合类型 #

struct Point
    x::Float64
    y::Float64
end

p = Point(1.0, 2.0)
p.x
p.y

p = Point(1.0, 2.0)
p.x = 10.0

struct Person
    name
    age
end

p = Person("Alice", 25)
typeof(p.name)
typeof(p.age)

mutable struct MutablePoint
    x::Float64
    y::Float64
end

p = MutablePoint(1.0, 2.0)
p.x = 10.0
p.y = 20.0
p

struct ImmutablePoint
    x::Float64
    y::Float64
end

p1 = ImmutablePoint(1.0, 2.0)
p1.x = 10.0

p2 = MutablePoint(1.0, 2.0)
p2.x = 10.0

struct Point
    x::Float64
    y::Float64
end

p = Point(1.0, 2.0)

struct Point
    x::Float64
    y::Float64
    
    Point(x::Real, y::Real) = new(Float64(x), Float64(y))
    Point(x::Real) = new(Float64(x), Float64(x))
end

Point(1, 2)
Point(5)

struct Point
    x::Float64
    y::Float64
end

Point(x::Real) = Point(Float64(x), Float64(x))
Point() = Point(0.0, 0.0)

Point()
Point(5)

struct PositiveNumber
    value::Float64
    
    function PositiveNumber(x::Real)
        x > 0 || error("Value must be positive")
        new(Float64(x))
    end
end

PositiveNumber(5)
PositiveNumber(-1)

struct Config
    host::String
    port::Int
    debug::Bool
end

Config(host::String) = Config(host, 8080, false)
Config() = Config("localhost", 8080, false)

Config()
Config("example.com")
Config("example.com", 443, true)

using Base: @kwdef

@kwdef struct ServerConfig
    host::String = "localhost"
    port::Int = 8080
    debug::Bool = false
end

ServerConfig()
ServerConfig(host="example.com")
ServerConfig(port=443, debug=true)

struct Point
    x::Float64
    y::Float64
end

Base.:+(p1::Point, p2::Point) = Point(p1.x + p2.x, p1.y + p2.y)
Base.:*(p::Point, s::Real) = Point(p.x * s, p.y * s)

Point(1.0, 2.0) + Point(3.0, 4.0)
Point(1.0, 2.0) * 2

struct Point
    x::Float64
    y::Float64
end

Base.show(io::IO, p::Point) = print(io, "Point($(p.x), $(p.y))")

Point(1.0, 2.0)

struct Point
    x::Float64
    y::Float64
end

Base.convert(::Type{Point}, t::Tuple) = Point(t[1], t[2])

p = convert(Point, (1.0, 2.0))

struct MyComplex
    real::Float64
    imag::Float64
end

Base.:+(a::MyComplex, b::MyComplex) = MyComplex(a.real + b.real, a.imag + b.imag)
Base.:*(a::MyComplex, b::MyComplex) = MyComplex(
    a.real * b.real - a.imag * b.imag,
    a.real * b.imag + a.imag * b.real
)
Base.abs(c::MyComplex) = sqrt(c.real^2 + c.imag^2)
Base.show(io::IO, c::MyComplex) = print(io, "$(c.real) + $(c.imag)im")

c1 = MyComplex(1, 2)
c2 = MyComplex(3, 4)
c1 + c2
c1 * c2
abs(c1)

mutable struct BankAccount
    owner::String
    balance::Float64
    
    function BankAccount(owner::String, initial_balance::Real=0.0)
        initial_balance >= 0 || error("Initial balance cannot be negative")
        new(owner, Float64(initial_balance))
    end
end

function deposit!(account::BankAccount, amount::Real)
    amount > 0 || error("Amount must be positive")
    account.balance += amount
    return account.balance
end

function withdraw!(account::BankAccount, amount::Real)
    amount > 0 || error("Amount must be positive")
    amount <= account.balance || error("Insufficient funds")
    account.balance -= amount
    return account.balance
end

account = BankAccount("Alice", 1000.0)
deposit!(account, 500.0)
withdraw!(account, 200.0)

struct Rectangle
    width::Float64
    height::Float64
    
    function Rectangle(w::Real, h::Real)
        w > 0 && h > 0 || error("Dimensions must be positive")
        new(Float64(w), Float64(h))
    end
end

area(r::Rectangle) = r.width * r.height
perimeter(r::Rectangle) = 2 * (r.width + r.height)
Base.show(io::IO, r::Rectangle) = print(io, "Rectangle($(r.width) × $(r.height))")

r = Rectangle(3.0, 4.0)
area(r)
perimeter(r)