Ruby类与对象 #

class Person
end

person = Person.new
person.class

class Person
end

class UserProfile
end

class HTTPClient
end

class XMLParser
end

Person.class
Person.superclass
Person.class.superclass

class Person
end

person = Person.new
person.class
person.object_id

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end
end

person = Person.new("Ruby", 30)

class Person
  def initialize(name = "Unknown", age = 0)
    @name = name
    @age = age
  end
end

person1 = Person.new
person2 = Person.new("Ruby")
person3 = Person.new("Rails", 20)

class Person
  def initialize(name)
    @name = name
  end

  def name
    @name
  end

  def name=(new_name)
    @name = new_name
  end
end

person = Person.new("Ruby")
person.name
person.name = "Rails"
person.name

class Person
  attr_reader :name
  attr_writer :email
  attr_accessor :age

  def initialize(name, age)
    @name = name
    @age = age
  end
end

person = Person.new("Ruby", 30)
person.name
person.age
person.age = 31
person.email = "ruby@example.com"

class Example
  attr_reader :read_only
  attr_writer :write_only
  attr_accessor :read_write

  def initialize
    @read_only = "只读"
    @write_only = "只写"
    @read_write = "读写"
  end
end

obj = Example.new
obj.read_only
obj.read_only = "new"
obj.write_only = "new"
obj.write_only
obj.read_write
obj.read_write = "new"

class Person
  def initialize(name)
    @name = name
  end

  def greet
    "Hello, I'm #{@name}"
  end

  def introduce
    "#{greet}. Nice to meet you!"
  end
end

person = Person.new("Ruby")
person.greet
person.introduce

class Calculator
  def add(a, b)
    a + b
  end

  def multiply(a, b)
    a * b
  end

  def calculate(a, b)
    add(a, b) * multiply(a, b)
  end
end

calc = Calculator.new
calc.add(1, 2)
calc.calculate(2, 3)

class Person
  def initialize(name)
    @name = name
  end

  def name
    @name
  end

  def introduce
    "I'm #{self.name}"
  end

  def self.species
    "Human"
  end
end

person = Person.new("Ruby")
person.introduce
Person.species

class Person
  def self.create(name)
    Person.new(name)
  end

  class << self
    def default
      Person.new("Default")
    end
  end
end

person = Person.create("Ruby")
person = Person.default

class Person
  @@count = 0

  def initialize
    @@count += 1
  end

  def self.count
    @@count
  end
end

Person.new
Person.new
Person.count

class Person
  @default_name = "Unknown"

  def self.default_name
    @default_name
  end

  def self.default_name=(name)
    @default_name = name
  end
end

Person.default_name
Person.default_name = "Default"
Person.default_name

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end

  def self.create_adult(name)
    Person.new(name, 18)
  end

  def self.create_child(name)
    Person.new(name, 10)
  end

  def self.from_hash(hash)
    Person.new(hash[:name], hash[:age])
  end
end

adult = Person.create_adult("Ruby")
child = Person.create_child("Kid")
person = Person.from_hash({ name: "Test", age: 25 })

class Person
  attr_reader :name, :age, :email, :city

  def initialize
    @name = "Unknown"
    @age = 0
    @email = ""
    @city = ""
  end

  def set_name(name)
    @name = name
    self
  end

  def set_age(age)
    @age = age
    self
  end

  def set_email(email)
    @email = email
    self
  end

  def set_city(city)
    @city = city
    self
  end
end

person = Person.new
  .set_name("Ruby")
  .set_age(30)
  .set_email("ruby@example.com")
  .set_city("Beijing")

class BankAccount
  attr_reader :balance, :owner

  def initialize(owner, initial_balance = 0)
    @owner = owner
    @balance = initial_balance
    @transactions = []
  end

  def deposit(amount)
    @balance += amount
    @transactions << { type: :deposit, amount: amount, balance: @balance }
  end

  def withdraw(amount)
    return false if amount > @balance

    @balance -= amount
    @transactions << { type: :withdraw, amount: amount, balance: @balance }
    true
  end

  def transactions
    @transactions.dup
  end
end

account = BankAccount.new("Ruby", 1000)
account.deposit(500)
account.withdraw(200)
account.balance

class ShoppingCart
  def initialize
    @items = []
  end

  def add_item(product, quantity = 1)
    @items << { product: product, quantity: quantity }
  end

  def remove_item(product)
    @items.reject! { |item| item[:product] == product }
  end

  def total
    @items.sum { |item| item[:product].price * item[:quantity] }
  end

  def items
    @items.dup
  end

  def clear
    @items.clear
  end
end

class Logger
  LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }

  def initialize(level = :info)
    @level = LEVELS[level]
  end

  def debug(message)
    log(:debug, message) if @level <= LEVELS[:debug]
  end

  def info(message)
    log(:info, message) if @level <= LEVELS[:info]
  end

  def warn(message)
    log(:warn, message) if @level <= LEVELS[:warn]
  end

  def error(message)
    log(:error, message) if @level <= LEVELS[:error]
  end

  private

  def log(level, message)
    timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
    puts "[#{timestamp}] #{level.to_s.upcase}: #{message}"
  end
end

logger = Logger.new(:debug)
logger.info("Application started")
logger.error("Something went wrong")