Es scheint, dass es die Fähigkeit zur Vererbung hat, die in der Objektorientierung existiert. Sie können es verwenden, ohne die in der Klasse definierten Inhalte zu schreiben, oder Sie können die in der Klasse definierten Inhalte ändern, um die Verwendung in der Klasse zu vereinfachen.
verdienen
** Fehler **
keishou.rb
class Ball
attr_accessor :x, :y, :x_way, :y_way, :step
def initialize(x: 1, y: 1, x_way: 1, y_way: 1, step: 1)
@x = x
@y = y
@x_way = x_way
@y_way = y_way
@step = step
end
def move
@x += @x_way
@y += @y_way
@step += 1
end
def reflect_x
if @x_way == 1
@x_way = -1
elsif @x_way == -1
@x_way = 1
end
end
def reflect_y
if @y_way == 1
@y_way = -1
elsif @y_way == -1
@y_way = 1
end
end
def goal?(x_max, y_max)
@x == x_max && y == 1 \
|| @x == 1 && @y == y_max \
|| @x == 1 && @y == 1 \
|| @x == x_max && @y == y_max
end
def boundary_x?(x_max)
@x == x_max || @x == 1
end
def boundary_y?(y_max)
@y == y_max || @y == 1
end
end
class BilliardTable
attr_accessor :length_x, :length_y, :ball
def initialize(length_x: nil, length_y: nil, ball: nil)
@length_x = length_x
@length_y = length_y
@ball = ball
end
def cue
print_status
loop do
@ball.move
print_status
if @ball.goal?(@length_x, @length_y)
puts "GOAL!!"
break
elsif @ball.boundary_x?(@length_x)
@ball.reflect_x
elsif @ball.boundary_y?(@length_y)
@ball.reflect_y
end
end
end
def print_status
puts "#{@ball.step}, (#{@ball.x}, #{@ball.y})"
end
end
class MyBilliardTable < BilliardTable
def print_status
puts "step = #{@ball.step}, x = #{@ball.x}, y = #{@ball.y}"
end
end
x_max = ARGV[0]
y_max = ARGV[1]
if !x_max || !y_max
puts "Bitte geben Sie das Argument an"
exit 1
end
x_max = x_max.to_i
y_max = y_max.to_i
(6..16).each do |times|
puts "3 x #{times}Laufen Sie auf dem Billardständer"
bt = MyBilliardTable.new(length_x: 3, length_y: times, ball: Ball.new)
bt.cue
end
Ich werde weiterhin den Code verwenden, den ich zuvor geschrieben habe, um zu erben. Tatsächlich ist der Teil dieses Codes, der geerbt wird, der
keishoububun.rb
class MyBilliardTable < BilliardTable
def print_status
puts "step = #{@ball.step}, x = #{@ball.x}, y = #{@ball.y}"
end
end
Dies ist der Teil hier. Die Klassenvererbung ist möglich, indem die übergeordnete Klasse mithilfe des Ungleichungscodes angegeben wird. Dieses Mal wird die Methode des Ausgabeteils geändert. Versuchen Sie dann, mit dieser definierten Klasse ein Objekt zu erstellen.
shori.rb
(6..16).each do |times|
puts "3 x #{times}Laufen Sie auf dem Billardständer"
bt = MyBilliardTable.new(length_x: 3, length_y: times, ball: Ball.new)
bt.cue
end
Der Verarbeitungsteil ist der obige Teil. Die Ausgabe sollte in einer geänderten Form vorliegen, und Sie können sehen, dass die in der BilliardTabel-Klasse definierten Methoden funktionieren, obwohl sie in der MyBilliardTable-Klasse nicht definiert sind.
Abgesehen davon ist es durch objektorientiertes Entwerfen der Klasse möglich, die Billardtabelle zu einem Objekt zu machen, sodass die Tafel ein Muster haben kann. Dieses Mal drücke ich das Board von 3 mal x aus.
banmen.rb
puts "3 x #{times}Laufen Sie auf dem Billardständer"
Wenn Sie soliden Code erstellen möchten, der in Vorheriger Artikel geschrieben wurde, können Sie dies tun, es wird jedoch eine doppelte Schleife und Schleife erstellt. Je mehr Sie tun, desto größer ist der Code, dh desto tiefer ist die Hierarchie des Codes. Infolgedessen ist es schwer zu lesen und schwer zu beheben. Wenn Sie es sich nur vorstellen, wird der Code schwer zu reparieren und schwer zu lesen sein.
Ich denke, dass die Leichtigkeit des Ausdrucks und die Leichtigkeit des Schreibens, wenn solche Bedingungen zunehmen, auch die Vorteile der Objektorientierung sind.
Wenn es sich um einen kleinen Maßstab handelt, ist es möglich, die Funktion mithilfe der Ausbeute zu erweitern, was in Blockeinheiten erfolgen kann. Als Bedeutung von "Ersetzen" ersetzt Yield den Statusmethodenteil.
yield.rb
class Ball
attr_accessor :x, :y, :x_way, :y_way, :step
def initialize(x: 1, y: 1, x_way: 1, y_way: 1, step: 1)
@x = x
@y = y
@x_way = x_way
@y_way = y_way
@step = step
end
def move
@x += @x_way
@y += @y_way
@step += 1
end
def reflect_x
if @x_way == 1
@x_way = -1
elsif @x_way == -1
@x_way = 1
end
end
def reflect_y
if @y_way == 1
@y_way = -1
elsif @y_way == -1
@y_way = 1
end
end
def goal?(x_max, y_max)
@x == x_max && y == 1 \
|| @x == 1 && @y == y_max \
|| @x == 1 && @y == 1 \
|| @x == x_max && @y == y_max
end
def boundary_x?(x_max)
@x == x_max || @x == 1
end
def boundary_y?(y_max)
@y == y_max || @y == 1
end
end
class BilliardTable
attr_accessor :length_x, :length_y, :ball
def initialize(length_x: nil, length_y: nil, ball: nil)
@length_x = length_x
@length_y = length_y
@ball = ball
end
def cue
print_status
loop do
@ball.move
print_status
if @ball.goal?(@length_x, @length_y)
puts "GOAL!!"
break
elsif @ball.boundary_x?(@length_x)
@ball.reflect_x
elsif @ball.boundary_y?(@length_y)
@ball.reflect_y
end
end
end
def cue_2
if block_given?
puts "Es gibt einen Block"
else
puts "Bitte Block angeben"
return
end
loop do
@ball.move
yield status
if @ball.goal?(@length_x, @length_y)
puts "GOAL!!"
break
elsif @ball.boundary_x?(@length_x)
@ball.reflect_x
elsif @ball.boundary_y?(@length_y)
@ball.reflect_y
end
end
end
def status
{
"step" => @ball.step,
"x" => @ball.x,
"y" => @ball.y
}
end
end
x_max = ARGV[0]
y_max = ARGV[1]
if !x_max || !y_max
puts "Bitte geben Sie das Argument an"
exit 1
end
x_max = x_max.to_i
y_max = y_max.to_i
ball = Ball.new()
bt = BilliardTable.new(length_x: x_max, length_y: y_max, ball: ball)
#bt.cue
bt.cue_2 do |status|
puts "Die Anzahl der Schritte ist#{status["step"]}Und die x-Koordinate ist#{status["x"]}, Y-Koordinate ist#{status["y"]}ist"
end
Abhängig von der Skalierung der Funktion, die Sie erweitern möchten, empfiehlt es sich, mithilfe von Yield zu bestimmen, ob Vererbung oder Blockübergabe verwendet werden soll.
Recommended Posts