Il semble qu'il ait la capacité d'héritage qui existe dans l'orientation objet. Vous pouvez l'utiliser sans écrire le contenu défini dans la classe, ou vous pouvez modifier le contenu défini dans la classe pour faciliter son utilisation dans la classe.
mérite
Démérite
--Echec de maintenance dû à un héritage excessif (au moment où l'origine est modifiée, des problèmes surviennent fréquemment à la destination d'héritage, etc.)
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 "Veuillez spécifier l'argument"
exit 1
end
x_max = x_max.to_i
y_max = y_max.to_i
(6..16).each do |times|
puts "3 x #{times}Courir sur le stand de billard"
bt = MyBilliardTable.new(length_x: 3, length_y: times, ball: Ball.new)
bt.cue
end
Je vais continuer à utiliser le code que j'ai écrit avant pour hériter. En fait, la partie de ce code héritée est
keishoububun.rb
class MyBilliardTable < BilliardTable
def print_status
puts "step = #{@ball.step}, x = #{@ball.x}, y = #{@ball.y}"
end
end
C'est la partie ici. L'héritage de classe est possible en spécifiant la classe parente à l'aide du code d'inégalité. Cette fois, la méthode de la partie sortie est modifiée. Essayez ensuite de créer un objet en utilisant cette classe définie.
shori.rb
(6..16).each do |times|
puts "3 x #{times}Courir sur le stand de billard"
bt = MyBilliardTable.new(length_x: 3, length_y: times, ball: Ball.new)
bt.cue
end
La partie traitement est la partie ci-dessus. La sortie doit être sous une forme modifiée et vous pouvez voir que les méthodes définies dans la classe BilliardTabel fonctionnent, bien qu'elles ne soient pas définies dans la classe MyBilliardTable.
En passant, en concevant la classe d'une manière orientée objet, il est possible de faire du BilliardTable un objet, de sorte que le tableau puisse avoir un motif. Cette fois, j'exprime le tableau de 3 fois x.
banmen.rb
puts "3 x #{times}Courir sur le stand de billard"
Si vous voulez faire du code solide écrit dans Article précédent, vous pouvez le faire, mais cela créera une double boucle et une boucle. Plus vous en faites, plus le code est volumineux, c'est-à-dire plus la hiérarchie du code est profonde. En conséquence, il est difficile à lire et à réparer. Rien qu'en l'imaginant, le code sera difficile à corriger et à lire.
Je pense que la facilité d'expression et la facilité d'écriture lorsque ces conditions augmentent sont aussi les avantages de l'orientation objet.
S'il s'agit d'une petite échelle, il est possible d'étendre la fonction en utilisant le rendement, ce qui peut être fait en unités de bloc. En tant que signification de «remplacer», yield remplace la partie de méthode d'état.
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 "Il y a un bloc"
else
puts "Veuillez spécifier le bloc"
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 "Veuillez spécifier l'argument"
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 "Le nombre d'étapes est#{status["step"]}Et la coordonnée x est#{status["x"]}, La coordonnée Y est#{status["y"]}est"
end
En fonction de l'échelle de la fonction que vous souhaitez étendre, il est judicieux de déterminer s'il faut utiliser l'héritage ou utiliser yield pour transmettre des blocs.
Recommended Posts