=begin
Pregunta 1
Desarrolle sus clases en Ruby que permita realizar el siguiente
programa:
auto = Auto.new(“Volvo”, 19,000)
neto = auto.calcular_neto(2)
puts “Neto: #{neto}” donde el método calcular_neto(2)
debe calcular el costo de dos autos Volvo con precio 19,000
y además le suma IGV que es una constante 0.18.
=end
class Auto
attr_accessor :auto01, :auto02
def initialize(auto01,auto02)
auto01 = auto01
@auto02 = auto02
end
def calcular_neto
(auto01 + auto02)*0.18 + auto01 + auto02
end
In future if there is an error please post the error message. Also it
was not necessary to post a multi line comment at the start that was
not of any significance to the question.
In the initialiser you can either use @auto.. or self.auto.. The
latter will use the accessor. This is necessary even if you change
the parameter name in the initialiser so that it is not the same as
the accessor.
It seems that in fact you do not need either in calculator_neto but I
am not sure why it is necessary in the initialiser but is not
necessary there. Probably someone more knowledgeable will explain.
You definitely missed a couple of important topics about OOP and
encapsulation in particular.
Take a look on attribute accessors in Java (as example), so you could
understand how it work in ruby and what attr_accessor key word does.
This guy has a nice explanation (cannot say it about his english, so you
can look for similar guide in Spanish)
You need more practice and at least one good book about the way ruby
works, because without any background you will be thinking that the
whole mess you can find in Ruby is the right way to do things.
Think about an example below:
class Auto
attr_accessor :auto01, :auto02
def initialize(auto01,auto02)
@auto01 = auto01
@auto02 = auto02
end
def calcular_neto
auto01 = 1
# what will happend here? what are local variables?
puts auto01
# why have I used "@" symbol. Why is it needed
puts @auto01
puts auto02
# Would be result the same if I changed auto01 to
@auto01
(auto01 + auto02)*0.18 + auto01 + auto02
end
# think about this one. Why it has get prefix?
# why do we need return? What does ruby return and when?
# Is there a difference between "@" and "self"?
# what will be the result?
def get_neto
return (@auto01 + @auto02)*0.18 + self.auto01 + self.auto02
end
end
Check it out please, and post here further questions
I would like the program receives as parameters the catidad volvo car
and demarcates the program calculate the cost plus impuesos (IGV) of the
desired amount of cars.
I tried to modify the program to try to introduce a "for" to iterate the
program depending on how many cars you wish to calculate
First I suggest that you could use puts within your code to try and
work out exactly which bit of code is not working. Usually you will
then see your mistake, otherwise you can come back and explain exactly
the problem. In this case you did not even tell us what was
happening. In this case you could output the value of i and check
that the result of the calculation is what you expect.
Secondly, though we have determined that it is ok to use accessor
methods when reading a variable within a member method I suggest that
you would be much better to use @auto here, what is the point in
wasting processor time calling the accessor method? Also it is clearer
for the reader to see exactly what you are doing.
Thirdly what is for i in 0..i supposed to do? Iterate i through the
values 0 to i?
Fourthly it is normal to do something with the result of a calculation
rather than just calculating it and ignoring the answer.
Fifthly I suggest you work right through a ruby tutorial. I am sure
there are many on the web.
Sixthly this is a Ruby on Rails list, questions are generally supposed
to have some relevance to Rails applications. I think there are
specific Ruby lists/forums if you are not using Rails.
Okay, I have been following this for a while. I am writing here respectfully of other contributors. It is just that I see the matter differently, and I am wondering why none of you have suggested inheritance.
You have a car. And that car has a model and has a price. Anyway in your application, you will store, one by one, a car model and its price.
Your class should look like this:
class Auto
attr_accessor :model, :price
def initialize(model_value, price_value)
@model = model_value
@price = price_value
end
end
That’s it for class Auto. You are basically using class Auto for storage
Introduce a new class, using inheritance
class Auto_Calculations < Auto
def calculate_percent(...)
end
def calculate_percent_plus_itself(...)
end
end
Just seems to me that the failure in this fellow’s code is that he is combining two data instances in one class.
Point taken, however I beg to differ… However novice in ROR folks maybe, I think that they
bring significance in background. As an educator I have found that appealing to more advanced notions, may be effective. We just have different styles.
From the get go all you needed to suggest was:
class Auto
attr_accessor :auto01, :auto02
def initialize(auto01_value,auto02_value)
@auto01 = auto01_value
@auto02 = auto02_value
end
def calcular_neto
(self.auto01 + self.auto02)*0.18 + self.auto01 + self.auto02
end
