Ruby学習の走り書き

# Ruby

**特徴**

- オブジェクト指向
- シンプル文法
- 強力なライブラリ

**irbとは**

interactive Rubyの略　対話型評価環境

**変数とは（ローカル変数）**

- 扱うデータに名前を付けて一時的に利用できるようにしたもの
- 変数へ代入

　　　変数名＝式

例）

x=10

name=’Nakamura’

変数名はアルファベットの小文字またはアンダーバーから始まる。基本はアルファベットから始まる。

複数の単語をつなげた変数はアンダーバーをつける　price_costなど

予約語はリファレンスマニュアルを参照。

2つの変数に同じ変数を入れるのはよくない。また、2つの変数を同時に入れるのもわかりにくい。

**定数**

- 変化しない（または頻繁に変化しない）値を扱うときに使う。

　　例）手数料率、消費税率、バージョン、デフォルトの価格、円周率。

- 定数は大文字で始まる必要がある。
- 定数への代入は1度きり。再代入はだめ

**リテラル**

- 数値の123や文字列の’HelloWorld’など、Rubyのプログラムの中に直接記述できる値のこと

リテラルの例）

- 数値　123
- 文字列　’Hello World’
- 配列　[1,2,3]
- ハッシュ　（連想配列）　colors = {’red’ ⇒ ‘#ff0000’,’green’ ⇒’00ff00’,’bule’⇒’0000ff’}

**オブジェクト指向プログラミング言語　概要**

- コンピュータープログラミングの概念の1つ
- オブジェクト指向の概念や手法を取り入れたもの
- プログラムを、データとその振る舞いが結びつけられたオブジェクトの集まりとして構成するなどといった特徴がある。
- オブジェクトとはデータと処理の集まりのこと。
- オブジェクト指向とはオブジェクト同士が相互に関係しあうことで、システムの振る舞いをとらえる考え方。
- クラスとはオブジェクトの設計図
- インスタンスはクラス（設計図）から作成した実態
- メソッドとはクラスの中に定義されているもので、複数の処理を1つにまとめて扱いやすくしたもの。言い換えると、クラスに所属する関数のようなもの

**数値について**

- 3/2などは整数のみ表示されるので、1となってしまう。その場合は3.0/2のようにどちらかを実数にして計算する。
- x=3をx.to_fとすることで実数に変換することができる。
- 数値のクラスについて。irb で1.classと入力するとIntegerという整数を扱えるクラスが表示がされる。また、1.1.classと入力するとFloatという浮動小数点を扱えるクラスが表示される。これらの大元はNumeric（数値）クラスとなっていて、IntegerやFloatはサブクラスである。また、integer をスーパークラスとしてfixnum（31ビット以下）やBignum（31ビット以上）がある。1や1.1などの数値オブジェクトがどんなメソッド（クラスに所属する関数のようなもの）を持っているかは1.methodsで確認できる。

**文字列について（String）**

- 文字列は””か’’で囲う。どちらで囲っても文字列としての違いはないが、””と’’で挙動が異なる場合がある。例えば特殊記号がある場合、’’だと改行記号の\nがただの文字列として表示されて得しまう。改行したい場合は””で囲み\nを入力することで改行コードが認識される。
- 式展開とは文字列の中で式や変数を展開することで、文字列操作を簡単に行うことができる。

　例）　puts "My name is #{first_name} #{last_name}.

- 破壊的メソッドとはレシーバーに当たるオブジェクトの値そのものを変更してしまうメソッドのことです。upcase methodという小文字を大文字にするメソッドがある。

irb(main):027:0> s='hello'
=> "hello"

irb(main):028:0> puts s.upcase
HELLO
=> nil

puts sで出力してもsの変数は変わっていない。しかし下記の！記号を付けると破壊的メソッドとなる。

irb(main):029:0> puts s.upcase!
HELLO
=> nil

irb(main):030:0> puts s
HELLO
=> nil

このように変数自体を書き換えられていることがわかる。

文字列のクラスは

irb(main):031:0> 'abc'.class
=> String

Stringオブジェクトのクラスということが確認できる。

**空白文字について**

- タブや半角スペースなどの空白文字は識別子や予約語を区切るために使うが、いくつ連続しても動作に違いはない。
- スペースを１つ開けて書くのがよい

**演算子による値の比較**

- 2つの値の大小、同じ値かを調べる方法について,関係が成り立つ場合は真(true)関係が成り立たない場合は偽（false）が返る。

irb(main):032:0> 1 < 2
=> true
irb(main):033:0> 2 <1
=> false

**演算子の優先順位**

- 2*3が先に計算されて、その値を4で割った値に１を足している

irb(main):034:0> 1.0 + 2.0 *3.0 /4.0
=> 2.5

- 演算子の優先順位については、リファレンスマニュアルの演算子式に記載されている。
- （）をつかって明示的に計算順を指定することができる。

**数値と文字列は暗黙的に変換されない**

- このように文字列と数値を同時に入れてもタイプエラーとなってしまう。

irb(main):035:0> 1 +'1'
(irb):35:in `+': String can't be coerced into Integer (TypeError)         from (irb):35:in` <main>'
from C:/Ruby32-x64/lib/ruby/gems/3.2.0/gems/irb-1.6.2/exe/irb:11:in `<top (required)>'         from C:/Ruby32-x64/bin/irb:33:in` load'
from C:/Ruby32-x64/bin/irb:33:in `<main>'

- このように.to_iというメソッドを使うと数値に変換してくれる。

irb(main):036:0> 1 + '1'.to_i
=> 2

**インクリメントとデクリメント**

- +=記号を付けることでインクリメントできる

irb(main):042:0> n = 1
=> 1
irb(main):043:0> n += 1
=> 2

- -=記号を付けることでデクリメント

irb(main):044:0> n = 1
=> 1
irb(main):045:0> n -= 1
=> 0

Ruby**真偽値について**

- 真偽値は命題の真偽を表す値。
- falseまたはnilであれば偽(false)
- それ以外はすべて真（true）

真（true）となる例

　trueそのもの

　すべての数値　1、0，-1

　すべての文字列　”abc”,true,”false”,””空文字も含まれる。

論理演算子

　

- 論理積（and） a&&b 　aとbがともに真の場合に真

irb(main):051:0> t1=true
=> true
irb(main):052:0> t2=true
=> true
irb(main):053:0> f1=false
=> false
irb(main):054:0> t1&&t2　t1とt2は両方とも真なのでtrue
=> true
irb(main):055:0> t1 && f1　t1とf1はf1が偽なのでfalse
=> false

- 論理和   (or) 　a || b 　aかbの少なくとも１つが真の場合に真

irb(main):056:0> t1=true
=> true
irb(main):057:0> f1=false
=> false
irb(main):058:0> f2=false
=> false
irb(main):059:0> t1 || f
irb(main):059:0> t1 || f1
=> true
irb(main):060:0> t1 || f
irb(main):060:0> t2 || f2  　どちらかが真ならtrue
=> true
irb(main):061:0> f
irb(main):061:0> f1 || f2　  どちらも偽なのでfalse
=> false

- 真偽値の反転について

　！マークで真偽値を反転できる。

irb(main):062:0> t1 = true
=> true
irb(main):063:0> f
irb(main):063:0> f1 = false
=> false
irb(main):064:0> !t1　反転して偽
=> false
irb(main):065:0> !f1　反転して真
=> true

- 変数が空ではないか確かめる。

irb(main):068:0> name = 'Inoue'
=> "Inoue"
irb(main):069:0> name.empty?　変数にInoueが入っているのでfalse
=> false

- 特定の文字が含まれているか確かめるinclude?(’確かめたい文字’)

irb(main):072:0> name ='Inoue'
=> "Inoue"
irb(main):073:0> name.include?('n')　nが含まれているのでtrue
=> true

**条件分岐　if の構文**

- if 条件１

　　＃条件１が真の場合に実行したい処理

elsif　条件２

　　＃条件２が真の場合に実行したい処理

elsif　条件３

　　＃条件３が真の場合に実行したい処理

els　

　　＃それ以外の処理

end

テストの点数によって、通知表の成績をターミナルに出力するプログラム

- 90点以上A
- 80点以上B
- 60点以上C
- 60点以下D

```ruby
score = 90
if score >= 90
  puts 'A'
elsif score >= 80
  puts 'B'
elsif score >= 60
  puts 'C'
else
  puts 'D'
end
```

結果は

C:\Users\syono\ruby_basic>ruby  ruby-basic.rb
A

となった。

scoreの値を変えると結果もそれに合わせて変わる。

**構文unless**

unless 条件式

　　#条件式が偽（false）の時に実行したい処理。

else 

       #条件式が（false）でない場合、つまり真（true）の時実行したい処理。

end

```ruby
#変数の値が0でなければ
#0ではありませんと出力する

n = 1
if !n.zero?
  puts '0ではありません'
end
```

- elsifに相当するものはない
- 無理にunlessを使う必要はない
- 読みやすいと思う場合はifでOK

**構文　条件分岐　case**

case 対象オブジェクトや式

when 値１

　＃　値１に一致する場合の処理

when 値２

　＃　値２に一致する場合の処理

when 値３

　＃　値3に一致する場合の処理

else

    ＃　どの値とも一致しない場合の処理

end

```ruby
#誕生石から、誕生月を出力するプログラム

#stone = 'peridot'
#if stone == 'ruby'
#  puts '7月'
#elsif stone == 'peridot'
 # puts '8月'
#elsif stone =='sapphire'
#  puts '9月'
#else 
#  puts 'データが登録されていません'
#end

#case

stone = 'ruby'
case stone
when 'ruby'
  puts'7月'
when 'peridot'
  puts '8月'
when 'sapphire'
  puts '9月'
else 
  puts 'データが登録されてません'
end
```

演習　年齢によってテーマパークの入場料を出し分けてターミナルに出力するプログラム

```ruby
#年齢によって、テーマパークの入場料を出し分けてターミナルに出力

puts '年齢を入力してください'
age = gets.chomp.to_i
if age >=12
  puts '5000円'
elsif age >=6
  puts '2500円'
else 
  puts '1000円'
end
```

**メソッド**

- 複数の処理を一つにまとめて、扱いやすくしたもの
- クラス内に定義される　（クラス内で定義する関数みたいなもの）

構文

def メソッド名　(引数１,引数２・・・)

　＃実行したい処理

end

```ruby
#hello world
def hello_world
  puts 'Hello World'
end

hello_world
```

- メソッドの命名ルールは単語の間にアンダーバーを入れる。
- これはメソッドに引数がないパターン
- メソッドの前に数字を入れるとエラーになる。
- 引数があるパターン

```ruby
def add(a, b)
  a + b
end

puts add(10,1)
```

動物の鳴き声によって、鳴き声を返すメソッドのcryを作成

```ruby
#動物の種類によって、鳴き声を返すメソッドcryを作成
#引数にcatが渡されたら戻り値ニャー
#それ以外なら戻り値？？？とする

def cry(animal)
  if animal == 'cat'
    'ニャー'
  else
    '???'
  end
end

  puts cry('cat')
```

演習FizzBuzzメソッドの作成

```ruby
#3で割り切れる数値を引数に渡すと、Fizzを返す
#5で割り切れる数値を引数に渡すと、Buzzを返す
#15で割り切れる数値を引数に渡すと、FizzBuzzを返す
#5で割り切れる数値を引数に渡すと、その数値を文字列にして返す

def fizz_buzz (n)

  if n % 15 == 0
    'FizzBuzz'
  elsif n % 3 == 0
    'Fizz'
  elsif n % 5 == 0
    'Buzz'
  else
    n.to_s
  end
end

puts fizz_buzz(1)
puts fizz_buzz(2)
puts fizz_buzz(3)
puts fizz_buzz(4)
puts fizz_buzz(5)
puts fizz_buzz(6)
puts fizz_buzz(7)
puts fizz_buzz(8)
puts fizz_buzz(9)
puts fizz_buzz(10)
puts fizz_buzz(11)
puts fizz_buzz(12)
puts fizz_buzz(13)
puts fizz_buzz(14)
puts fizz_buzz(15)
```

出力結果は

C:\Users\syono\ruby_basic\ruby.practice>ruby fizz_buzz.rb
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

となる。注意点は先に15で割り切れるFizzBuzzの処理を書いておかないと、15は3でも5でも割り切れるので、先にFizzの処理から始まってFizzBuzzの処理がされない。

**puts,print,pメソッド**

- puts メソッドは改行を加えて変数の内容や変数の戻り値をターミナルに返す。

irb(main):003:0> puts 'inoue'
inoue
=> nil

- printメソッドは改行されない

irb(main):004:0> print 'Inoue'
Inoue=> nil

- pメソッドはデバッグ用のメソッド。デバッグはプログラムの不具合を見つけて修正すること

irb(main):005:0> p 'inoue'
"inoue"
=> "inoue"

**配列**

- 複数のデータをまとめて格納できるオブジェクトのこと。
- 配列内のデータ（要素）は順番に並んでいて、添え字（インデックス）を指定することで、データを取り出せる。

配列の作成

- 空の配列を作る

[]

- 3つの要素が格納された配列を作る。

[要素１,要素２,要素３]

irb(main):001:0> a = [1,2,3,'aa',[1,2,3]]
=> [1, 2, 3, "aa", [1, 2, 3]]

- 1つの配列に数字や文字さらには配列といった混在もできる
- .empty .include .reverseなどのメソッドも使える
- .reverse!という破壊的メソッドを使うとaの配列自体が逆になってしまう。
- （0..25）のような範囲オブジェクトを使うと便利

irb(main):005:0> (0..25).to_a
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]

- 配列の最後に要素を追加したりできる

irb(main):006:0> z = (0..10).to_a
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):007:0> z << 20
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20]

- 配列の要素の結合も.joinメソッドでできる。

irb(main):008:0> s =["my","name","is","inoue"]
=> ["my", "name", "is", "inoue"]
irb(main):009:0> s.join
=> "mynameisinoue"

- セパレータとしてjoin.(’ ‘)スペースを加えると要素間をスペースでセパレートできる。

irb(main):011:0> s.join(' ')
=> "my name is inoue"

**ハッシュとは（連想配列、ディクショナリ、マップ）**

- キーと値の組み合わせでデータを管理するオブジェクト
- ハッシュ

#空のハッシュを作成

{}

#キーと値の組み合わせを3つ格納するハッシュを作成

{キー1  ⇒値１,キー2　⇒値２, キー3 ⇒ 値３}

- キーというのは添え字のことで、連想配列は添え字に好きな名前を付けられる配列のこと

irb(main):014:0> inoue = {'name' => 'Inoue', 'birthplace' => 'Kyoto'}
=> {"name"=>"Inoue", "birthplace"=>"Kyoto"}

irb(main):015:0> puts inoue['name']　#名前を出力
Inoue
=> nil

また要素を加えたいときは、

irb(main):016:0> inoue['age']=27
=> 27

irb(main):017:0> puts inoue
{"name"=>"Inoue", "birthplace"=>"Kyoto", "age"=>27}
=> nil

要素を消したいときは

irb(main):018:0> inoue.delete('age')
=> 20

irb(main):019:0> puts inoue
{"name"=>"Inoue", "birthplace"=>"Kyoto"}
=> nil

とする。

- キーにシンボルを使ったハッシュの扱い。
- シンボルはソースコード上では文字列のように見えるが、内部では整数として扱われる両者を仲立ちするような存在。文字列よりもシンボルの方が早い。

irb(main):020:0> sato = {name: 'Sato', birthplace: 'Tokyo'}
=> {:name=>"Sato", :birthplace=>"Tokyo"}

irb(main):021:0> puts sato
{:name=>"Sato", :birthplace=>"Tokyo"}
=> nil

irb(main):022:0> puts sato[:birthplace]
Tokyo
=> nil

- 値の追加と削除は：をつけるだけ。
- 繰り返し処理のeachを使ってハッシュから一個ずつ値を取り出して何かしらの処理を実行することができる。

irb(main):023:0> scores = {luke: 100, jack: 90,rebert: 70}
=> {:luke=>100, :jack=>90, :rebert=>70}

irb(main):024:0> puts scores
{:luke=>100, :jack=>90, :rebert=>70}
=> nil
irb(main):026:0> scores.each{|k,v| puts v} 

# 値を一個ずつ取り出して処理をする。変数kにはキー、vには値が入って、puts vで値を出力　　　　　　　　　　 　　　　　　　　　　　　　　　　　　　
100
90
70
=> {:luke=>100, :jack=>90, :rebert=>70}

- キーを出力したいとき

irb(main):027:0> scores.keys
=> [:luke, :jack, :rebert]

で出力できる

- ハッシュの持っている値を知りたいときは、scores.valuesで出力できる。

irb(main):028:0> scores.values
=> [100, 90, 70]

**繰り返し処理**

- 同じ処理を何回も実行する

次の３つがある

- for
- while
- do while

**構文　each**

配列やハッシュ.each do |変数|

　#繰り返しを実行したい処理

end

(配列の要素を最初から最後まで順番に取り出しながら、処理を実行する)

```ruby
#each
numbers = [1,2,3,4,5]
numbers.each do |number|
  puts number
end
```

また別の書き方もできる。

```ruby
numbers.each {|number|
 puts number
}
```

**構文 for**

for 変数 in 配列やハッシュ　do

 #繰り返し実行したい処理

end

```ruby
colors = ['red','green','blue']
for color in colors do
  puts color
end
```

- forは原則使わない

慣習としてeachでもforでも書けるときはeachを用いる

**構文　times**

繰り返し回数.times do

 #繰り返し実行したい処理

end

```ruby
5.times do
  puts 'Hello'
end
```

また、何回目の繰り返しか変数として利用することができる。添え字は0から始まる。

```ruby
5.times do |i|
  puts "#{i}: Hello"
end
```

補足：配列を使わず、単純にn回処理を繰り返したいときに使う。

**構文　while**

while 条件式

　＃繰り返し実行したい処理

end

```ruby
i=0

while i < 10
  puts "#{i}:hello"
  i += 1 # i = i + 1
end
```

補足：指定した条件が真である間、処理を繰り返す。

補足：無限ループを発生させないように。もしなったらCtrl+Cで止める

**構文　upto,downto**

- upto

nからｍまで数値を1つずつ増やしながら何かしらの処理を実行したい場合に使う。

- downto

nからmまで数値を1つずつ減らしながら何かしらの処理を実行したい場合に使う。

```ruby
10.upto(14){ |n| puts n}
14.downto(10){|n| puts n}
```

**構文　step**

開始式.step(上限値、一度に増減する大きさ)

```ruby
1.step(10,2){|n| puts n }
10.step(1,-2){|n| puts n }
```

補足：nからmまで数値をxずつ増やしながら何かしらの処理を実行したいときに利用

例）1，3，5，7，9

**構文loop**

loop do

#繰り返し実行したい処理

end

```ruby
i = 0
loop do 
 puts i
 i += i
end
```

補足：あえて無限ループを作りたいときに利用する

また、break文で繰り返す回数を制限できる

```ruby
j = 0
loop do
  puts j
  j += 1
  break if j == 10
end
```

さらにnext ifで

```ruby
numbers = [1,2,3,4,5]
numbers.each do |n|
  next if n % 2 ==0
  puts n 
end
```

eachで繰り返し処理を行って、値が偶数であれば処理を中断して次の繰り返し処理に進むこともできる。

**クラス**

クラスを作ってメソッドを定義して、それを利用する。

例）hello!を出力するメソッド

```ruby
class User
  def hello
    puts 'hello!'
 end
end

user = User.new　#ユーザークラスを利用してターミナルにhelloを表示する処理
user.hello
```

- クラスは用意されたものを使うだけでなく自分で作ることもできる。
- クラス名の最初は大文字
- メソッドとしてhelloを定義する
- クラスが設計図だとするとインスタンスは実態になる
- 自動車で言い換えると設計図である自動車のクラスから、実態であるフェラーリというインスタンスを製造するみたいな感じ

例）上記のクラスに機能を追加して、helloにつづいて自分の名前を出力する

- クラスのインスタンスは変数を使って値を保持することができる。

```ruby
class User

  def initialize(name)
    puts 'initialize!!'　#initialize!!のメソッドはnewが使われたときに呼ばれる特殊なメソッド
    @name = name #渡した引数は変数nameに入る。そして@nameというインスタンス変数に代入
  end　# インスタンス変数はインスタンスの中ならどこでも使える。＠がない方はインスタンス内のみ
  
  def hello
    puts "hello! I am #{@name}."
  end
end

user = User.new('Jon')#newに引数を渡すとnewが実行されたときにinitializeメソッドが呼ばれる
user.hello
```

出力結果
initialize!!
hello! I am Jon.

まず、User.new（Userクラス）のインスタンスが作成される。変数Userに代入。newが呼ばれたときに、initializeというメソッドが必ず呼ばれる。そのため、puts ‘initialize’が表示されている。

引数Jonは変数nameにわたる。そしてnameをインスタンス変数の@nameに代入。この@nameの変数は、インスタンス内ならどこでも利用することができるので、helloメソッドでputsの出力内容の1つとして使うことができる。一つのクラスからインスタンスは複数作ることができる。

**アクセサ**

```ruby
class User
  def initialize(name)
    @name = name
  end

  def name
    @name
  end

  def name=(value)#インスタンス変数を変更したい場合は変更用のメソッドを定義。
    @name = value
  end

end

  emma = User.new('Emma')
  # Emma.@name #NG
  puts emma.name　#ここでEmmaを出力した後に
  emma.name = 'Emily' #変更後のインスタンスnameの値を出力しているので
  puts emma.name　#Emmaの後にEmilyが出力される。
```

結果

C:\Users\syono\ruby_basic\ruby.practice>ruby accesor.rb
Emma
Emily

このようにインスタンス変数の値を読み書きするメソッドのことをアクセサメソッドという

- アクセサメソッドはよく使うので、rubyでは単純にインスタンス変数の内容を外部から読み書きするのであれば、attr_accesorというあらかじめ用意されたメソッドを使うことで、開発者が自分でアクセサメソッドを書く必要がなくなる

```ruby
class User

  attr_accessor :name　# アクセサメソッドを書かなくてもインスタンス変数を参照できる
　　　　　　　　　　　　# attr_reader :name で読み取りのみにできる。書き込みはできない
　　　　　　　　　　　  # attr_writer :nameで書き込みはできるが、読み取りはできない。

  def initialize(name)
    @name = name
  end

end

  emma = User.new('Emma')
  # Emma.@name #NG
  puts emma.name　#参照をして
  emma.name = 'Emily'　#インスタンス変数の書き込みもできる。
  puts emma.name　#また参照する
```

会員情報では、電話番号や住所の情報は書き換わることがある。しかし、誕生日や会員番号など不変の情報もある。こうした際に、住所と電話番号など、可変の情報のみを操作するためにアクセサメソッドが使われる。

**クラスメソッド、クラス変数**

- クラスメソッド

　クラスから直接呼ぶことができるメソッド

- クラス変数

　クラス自体に値を保持することができる変数

```ruby
class User

  @@count = 0 #クラス変数は＠＠で始まる クラス自体に値を保持できる

  def initialize(name)
    @name = name
    @@count += 1 #initializeメソッドが呼ばれた回数をカウント
  end

  def hello
    puts "I am #{@name}. #{@@count} instance(s)."
  end

  def self.info #クラスメソッドにはselfを付ける
    puts "#{@@count} instance(s)"
  end
end

  emma = User.new('Emma')#１つ目のインスタンス
  #emma.hello
  User.info
  olivia =User.new('olivia')#２つ目のインスタンス
  #olivia.hello
  User.info
  mary = User.new('Mary')#３つ目のインスタンス
  #mary.hello
  User.info

  #１つのクラス変数をそれぞれのインスタンスが共通して参照している。
```

結果

1 instance(s)
2 instance(s)
3 instance(s)

インスタンスが呼び出されるたびに@@countが+1される。

```ruby
class User
  REATION = 'USA' #クラス定数
  @@count = 0 #クラス変数は＠＠で始まる クラス自体に値を保持できる

  def initialize(name)
    @name = name
    @@count += 1 #initializeメソッドが呼ばれた回数をカウント
  end

  def hello
    puts "I am #{@name}. #{@@count} instance(s)."
  end

  def self.info #クラスメソッドにはselfを付ける
    puts "#{@@count} instance(s).Reasion: #{REATION}"#クラス定数の呼び出し
  end
end

  emma = User.new('Emma')#１つ目のインスタンス
  #emma.hello
  User.info
  olivia =User.new('olivia')#２つ目のインスタンス
  #olivia.hello
  User.info
  mary = User.new('Mary')#３つ目のインスタンス
  #mary.hello
  User.info

  puts User::REATION # クラス定数はクラスの外からアクセスできる。
  #１つのクラス変数をそれぞれのインスタンスが共通して参照している。
```

出力結果

1 instance(s).Reasion: USA
2 instance(s).Reasion: USA
3 instance(s).Reasion: USA
USA

**クラスの継承**

- 親クラス（スーパークラス）の性能を引き継いで、子クラス（サブクラス）を作成することができる。
- コードの再利用性や拡張性を高める仕組み。

例）

[親]自動車クラス（タイヤ、エンジン、ブレーキ）

- (子)　戦車クラス　（＋大砲）

-(子)　乗用車クラス　（＋後部座席）

-(子)　トラック（+荷台）

```ruby
class User
  def initialize(name)
    @name = name
  end

  def hello #helloを出力するメソッド
    puts "Hello! I am #{@name}."
  end
end

inoue = User.new('Inoue')
inoue.hello

class AdminUser < User #Userクラスが持っているインスタンス変数@nameや#インスタンスメソッドhelloを利用できる。
  def hello_admin #AdminUser専用のメソッド。Userクラスに影響を与えずにAdminUser用の処理を追加できる
    puts "Hello! I am #{@name} form AdminUser."
  end

  def hello
    puts 'Admin!' #親クラスのhelloメソッドではなくて、子クラスでオーバーライドしたhelloメソッドを呼ぶ。
  end
end

sato = AdminUser.new('Sato')#AdminUserクラスから親クラスのHelloメソッドを呼べる
sato.hello
sato.hello_admin
```

出力結果

Hello! I am Inoue.
Admin!
Hello! I am Sato form AdminUser.

**メソッドのアクセス権**

- public

クラスの外部からでも自由に呼び出せる（デフォルト）

```ruby
class User
  def initialize(name)
    @name = name
  end

  def hello
    puts "Hello! I am #{@name}."
  end
end

  user = User.new('Inoue')
  user.hello

  #アクセス権を何も指定しない場合はpublicの指定になる。
```

出力結果

Hello! I am Inoue.

- protected

他ファイル、他クラスからのアクセスをプロテクトする。（あまり使わないので省略）

- private

クラスの外からは呼び出せず、クラス内部でのみ使えるメソッド。

```ruby
class User
  def initialize(name)
    @name = name
  end

  private #これより下のメソッドはアクセス権がprivateになる。クラス内部でのみ使えるメソッド
  def hello
    puts "Hello! I am #{@name}."
  end
end

  user = User.new('Inoue')
  user.hello
```

出力結果

access.rb:13:in `<main>': private method` hello' called for #<User:0x0000013e40096058 @name="Inoue"> (NoMethodError)

**モジュール**

- クラスのようにメソッドや定数をまとめられるもの

クラスとの違い

- インスタンスを作ることができない
- 継承ができない

モジュールの定義方法

module モジュール名

　#モジュールの定義（メソッドや、定数など）

end

#関連するメソッドや定数などをまとめてグループ化したいだけの時に

手軽に使える。

```ruby
#車の運転に関するmodule

module Driver
  def self.run
    puts 'Run'
  end

  def self.stop
    puts 'stop'
  end
end

Driver.run
Driver.stop
```

実行結果

Run
stop

例外　（Exception）

- プログラムの実行中に発生した「例外」的な問題。

例外処理

- 例外が発生したときに、それをキャッチして、ユーザーにメッセージを表示するなど、何らかの処理を行うこと。

```ruby
puts '---数値を入力してください'
i = gets.to_i #getsでターミナルに入力された文字列を取得できる
#それをto_iメソッドで数値に変換する。それを変数iに入れる。

begin
  #例外が起きうる処理
  puts 10 / i
rescue => ex
  #例外が発生した場合の処理
  puts 'error!'
  puts ex.message
  puts ex.class
ensure
  #例外が発生してもしなくても最後に実行したい処理
  puts 'end'
end
```

0を入力したときの結果

- --数値を入力してください
0
error!
divided by 0
ZeroDivisionError
end

10を入力したとき

- --数値を入力してください
10
1
end

Rubyのコーディングルール

- The Ruby Style Guideが有名
- Rubo copでThe Ruby Style Guideのコーディング規約に違反してないか調べられる。