現実世界を模倣してものを動かすJAVAプログラミングの真髄とは?

現実世界を模倣してものを動かすJAVAプログラミングの真髄とは?

本のまとめ

▼読んだ本は?
■スッキリわかるJava入門 第2版 (スッキリシリーズ)
■中山 清喬さん, 国本 大悟さん
http://amzn.asia/d/gNqveeV
▼プログラミング言語としてのJavaのメリットは?
■学びやすく標準的な基本構文
■大規模開発を支援するオブジェクト指向に対応
■豊富に準備された便利な命令群
■多様なコンピュータやOS環境で同じように動作
▼Java開発における3つのステップは?
【1】ソースコードを作成する
【2】「javac」コマンドを用いてコンパイラと呼ばれるソフトウェアによりソースコードをコンパイルし、CPUが理解できるバイトコードに変換しクラスファイルを生成する
【3】JVM(仮想マシン)を内部に持つインタプリタにより、javaコマンドを用いてクラスファイル内のバイトコードを実行する
▼Javaで記述する3つの「文」タイプとは?
【1】変数宣言の文
└データをメモリ内部に格納し準備するための「箱/入れ物」を宣言する文

public class Main {
    public static void main(String[] args){
        int age;
        age = 30;
    }
}

【2】計算の文
└演算子(+/-/=)とオペランド(a/b/5/10)を組み合わせて計算を行う文

public class Main {
    public static void main(String[] args){
        int a = 20;
        int b = 5;
        int c = 1+2+3+4+5; //足し算
        int d = 1*2*3*4*5; //掛け算
        int e = 1-2-3-4-5; //引き算
    }
}

【3】命令実行の文
└さまざまな命令を実行する文

public class Main {
    public static void main(String[] args){
        int a = 1;
        System.out.println(a); 
    }
}
▼「定数」とは?
■上書きできない変数=定数のこと
■定数を宣言する際には先頭に「final」をつける

public class Main {
    public static void main(String[] args){
        final double TAX = 1.08;
    }
}
▼変数に格納するデータ型にはどんなものがある?
■int:普通の整数を格納
■long:大きな整数を格納(基本はintでOK)
■short:小さな整数を格納(基本はintでOK)
■byte:更に小さな整数を格納(基本はintでOK)
■double:普通の少数を格納
■float:少しあいまいでも良い少数を格納(基本はdoubleでOK)
■boolean:「true/false」(Yes/No)を格納
■char:1文字のみの文字列をを格納
■String:複数の文字列を格納
▼配列とは?
■いくつかの関係あるデータをグループ化して、まとめて一つの変数の箱に入れる仕組みのこと
■配列に格納する各要素のデータ型は、同一のデータ型を利用する必要がある(例えば一つのデータがint型の場合、他のデータもint型とする)
■配列内の各要素には「添え字/index」が付与されており、indexは必ず0からスタートする
■例えば5科目のテストの点数を配列に格納する場合

public class Main {
    public static void main(String[] args){
        int[] score = {10,20,30,40,50};
        for(i=0; i<score.length; i++){
            System.out.println(score[i]);
        }
    }
}
▼Javaに用意されているさまざまな演算子とは?
■基本演算子
└ + 足し算の結果を算出
└ – 引き算の結果を算出
└ * 掛け算の結果を算出
└ / 割り算の結果を算出
└ % 割り算の余りを算出

■代入演算子
└ += 左辺に右辺を足して、その結果を左辺に代入(例えば「int result = 10+=5」の場合、reslutは15)
└ -= 左辺から右辺を引いて、その結果を左辺に代入(例えば「int result = 10-=5」の場合、reslutは5)

■インクレメント/デクリメント演算子
└ ++ 左辺に1を足して、その結果を左辺に代入(例えば「int result = ++10」の場合、reslutは11)
└ — 左辺から1を引いて、その結果を左辺に代入(例えば「int result = – -10」の場合、reslutは9)

■論理演算子
└&& → 左辺と右辺の両方が満たされた場合にtrueを返す

 if(age >= 18 && gender == 1){}

└|| → 左辺か右辺のいづれかが満たされた場合にtrueを返す

 if(name.equals("鈴木") || married == true){}

■否定
└! 左辺が右辺と異なった場合にtrueを返す

 if(!(age == 10)){}
▼プログラミングにおける3つの制御フローは?
【1】順次:単純に上から順番に文を実行する
【2】分岐:条件によって違う文を実行する
【3】繰り返し:条件が満たされるまで同じ文を繰り返し実行する
▼「分岐」文の書き方は?
【1】「if文」で書く
■例えば「晴れていれば、洗濯する」「晴れていなければ、DVDを見る」で分岐する文

public class Main {
    public static void main(String[] args){
        boolean tenki = true;
        if(tenki == true){
            System.out.println("洗濯する");
        }else{
            System.out.println("DVDを見る");
        }
    }
}

【2】「switch文」で書く
■例えば「1なら大吉」「2なら中吉」「3なら小吉」「それ以外なら凶」で分岐する文

public class Main {
    public static void main(String[] args){
        int fortune = 1;
        switch(fortune){
            case 1:
            System.out.println("大吉");
            break;
            case 2:
            System.out.println("中吉");
            break;
            case 3:
            System.out.println("小吉");
            break;
            default:
            System.out.println("凶");
        }
    }
}

※swich文を利用する場合「==」のみ、「!=」「>」「<」は使えない
※swich文を利用する場合比較する値が「整数」「文字列」のみ、「少数」「真偽値」は使えない
※break記載が無い場合、一度条件に一致すると、その先の命令を実行する
※continue記載がある場合、一度条件に一致すると、その先の命令をスキップする

▼「繰り返し」文の書き方は?
【1】「while文」で書く
■例えばトイレに誰か入っていることを確認してから、「扉をノックして1分待つ」を繰り返す文

public class Main {
    public static void main(String[] args){
        boolean doorClose = true;
        while(doorClose == true){
            System.out.println("ドアをノックする");
            System.out.println("1分待つ");
        }
    }
}

※while文では、最初に条件式を評価するため、条件式に合致しない場合ブロックは一度も実行されない

【2】「do-while文」で書く
■例えば「扉をノックして1分待つ」を行った後、反応がなければ扉のノックを繰り返す文

public class Main {
    public static void main(String[] args){
        boolean doorClose = true;
        do{
            System.out.println("ドアをノックする");
            System.out.println("1分待つ");
        }while(doorClose == true)
    }
}

※do-while文では、動作を行ってから条件式を評価するため、1度は必ず処理が実行される

【3】「for文」で書く
■例えば「こんにちは」を10回を繰り返す文

public class Main {
    public static void main(String[] args){
            for(int i=0; i<10; i++){
                System.out.println(i);
          }
    }
}

【4】「拡張for文」で書く

public class Main {
    public static void main(String[] args){
        int score[] = {0,1,2,3,4,5};
        for(int value:score){
            System.out.println(score[value]);
        }
    }
}
▼分岐文/繰り返し文の判定に使われる条件式の種類は?
■数値やbooleanを評価する場合
└「==」条件として、左辺と右辺が等しければ、、、
└「!=」条件として、左辺と右辺が異なれば、、、
└「>」条件として、左辺が右辺より大きければ、、、
└「<」条件として、左辺が右辺より小さければ、、、
└「>=」条件として、左辺が右辺より大きいか等しければ、、、
└「<=」条件として、左辺が右辺より小さいか等しければ、、、

■文字列「String」型を評価する場合のみequals()を利用する必要がある

public class Main {
    public static void main(String[] args){
    String tenki = "晴れ";
        if(tenki.equals("晴れ")){
            System.out.println("洗濯をします");
        }else{
            System.out.println("DVDを見ます");
        }
    }
}
▼メソッドとは?
■一連の操作をまとめて名前をつけたもの
■mainメソッドが1番はじめに実行される
■例えば「helloメソッド」を作成し、mainメソッドから呼び出す記述は以下

public class Main {
    public static void hello(){
        System.out.println("こんにちは");
    }
    public static void main(String[] args){
        hello();
    }
}
▼引数(引き渡す値)とは?
■メソッドを実行する際に、メソッドに引き渡す値のこと。メソッド名の後につける()内部に記述する

public class Main {
    public static void main(String[] args){
        hello("Aさん"); 
        hello("Bさん"); 
        hello("Cさん");
    }
    public static void hello(String name){
        System.out.println(name+"、こんにちは");
    }
}
▼戻り値とは?
■呼び出されたメソッドから呼び出し元のメソッドに戻される値を「戻り値」と呼ぶ
■例えばString型の文字列を返す場合の記述

public class buhin {
    public static String stringreturn(){
        String s = "文字列";
        return s ;
    }
}
▼オーバーロードとは?
■同じ名前で異なる複数のメソッドを定義すること
■引数のデータ型が異なるか、引数の個数が異なればオーバーロードの利用が可能
【1】同一のメソッド名だが、引数のデータ型が異なる場合

public class Main {
    public static int add(int x , int y){
        return x+y;
    }
    public static double add(double x , double y){
        return x+y;
    }
}

【2】同一のメソッド名だが、引数の個数が異なる場合

public class Main {
    public static int add(int x , int y){
        return x+y;
    }
    public static double add(int x , int y , int z){
        return x+y+z;
    }
}
▼パッケージとは?
■各クラスファイルを、異なるパッケージに属する形に指定する
■異なるパッケージに属していれば、同一のクラス名が使える
■パッケージ名がかぶらないよう基本ルールとしてドメイン名を逆にしたものを使うことが多い
└「nanya-kanya.com」→「com.nanya-kanya」のような形

■「com.nanya-kanya」パッケージを指定する場合は以下

package com.nanya-kanya;
public class Main {}

■別のパッケージにあるクラス内のメソッドを呼び出す場合は以下

public class Mainyobu {
    public static void main(String[] args){
          com.nanya-kanya.Main.method();
    }
}

■パッケージ名やクラス名が長いときには「import」文を使うことで毎回パッケージ名を指定しなくてよくなる

import com.nanya-kanya.Main;
▼JVMはどうやってクラスファイルを探しに行く?
【1】実行するクラス名をJVMが受け取る
【2】クラスファイルを読み込むクラスローダーに対して、FQDN(パッケージを含む完全限定クラス名)を教える
【3】クラスローダーはクラスパス(クラスファイルまでのパッケージ構造)を確認する
【4】クラスパスを基準として「パッケージ」→「クラス」と順番に降りていく
【5】発見したクラスファイルを読み込む
【6】クラスファイル内部に書かれたメインメソッドを実行する

■クラスパスをJVMに伝える方法は以下
【1】javaコマンド実行時に毎回クラスパスを指定する

 > java -cp c:\work Calc

【2】OSの環境変数に予めクラスパスを指定しておく
└WindowsOSの場合「コンパネ→詳細設定→環境変数」より指定可能

▼オブジェクト指向とは?
■プログラム行数が増えてくると複雑化し、人自身が把握できなくなってしまうため、人がプログラミングを簡易に把握できることを目的に生まれた
■ソフトウェアを開発する時に現実世界をまねて、特定の役割を持った「部品」に分割してプログラミングを行うこと
■現実世界に必要な部品(オブジェクト)をプログラマーが指示して操るため、「オブジェクト指向」と呼ばれる
■工場で指示を出す「工場長プログラム」と、指示に基づいてそれぞれの役割を果たす「部品プログラム」のような形で分けるイメージ
▼オブジェクト指向でプログラミングするためにまずやることは?
■現実世界の出来事の手順を全て書き出し、それぞれの役割毎の部品に分解する。例えばATMなら次のような流れに分解
【1】お客さん→振込元口座/振込先口座/振込金額を決めて用紙に書く
【2】銀行員→振込用紙をチェックする
【3】銀行員→振込金額分の預金があるかチェックする
【4】銀行員→足りない場合、不足分を振込元口座に追加してもらうよう依頼
【5】お客さん→振込元口座に追加入金する
【6】銀行員→振込金額をチェックし、紙に印刷する
▼インスタンスとは?
■特定のクラスをまるごとクラス型として生成し、変数内に格納すること
■例えばキャラクターインスタンスを生み出す場合、「new」を使い以下のような形で記述

public class Main {
    public static void main(String[] args){
         Character c = new Buhin();
         c.fight();
    }    
}
public class Buhin{
    String name = "character";
    int hp = 100;
    public void fight(){
         System.out.println(name+"の攻撃");
    }  
}
▼コンストラクタとは?
■部品クラス内で使われるメソッド
■工場長クラスからインスタンスとして呼び出されるタイミングで、自動的に実行されるメソッドのこと
■「メソッド名とクラス名が一致」+「戻り値が宣言されていない」メソッドのみがコンストラクタとして自動実行される
■書き方は次のような形

public class Hero{
    String name;
    int hp;
    Hero(){
        this.hp = 100;
    }
}

public class Main {
    public static void main(String[] args){
         Character h = new Hero();
    }    
}
▼静的メンバとは?
■静的フィールドと静的メソッドを総称し静的メンバと呼ぶ

【1】静的(static)フィールド
■部品クラス内部で使われ、全てのインスタンスで共通してフィールドを保持する
■例えば工場長クラスから複数のインスタンスが呼び出されても「money」変数の中身はインスタンス間にて共通で数字が変化する

public class buhin {
    static int money = 1000;
}

【2】静的(static)メソッド
■部品クラス内で使われ、インスタンス化せずに静的メソッドを直接呼び出せる形となる
■例えば以下のような形で直接「setRandomMoney」メソッドを呼び出せる

public class Main {
  public static void main(String[] args){
         setRandomMoney();  
  }
}

public class buhin {
    static void setRandomMoney(){
        Hero.money =(int)(Math.Random()*1000);
    }
}
▼データ隠蔽とは?
■特定のクラスやメソッド、フィールドに対して「外部からのアクセス制御」をかけること
■基本的には「フィールド=private」「メソッド=public」とする形が通常

■アクセス制御レベルには以下4種類がある
【1】private
└自分自身のクラス内だけで操作可能
【2】package private
└自分と同じパッケージに属するクラスだけで操作可能
【3】protected
└自分と同じパッケージか、継承したクラスからだけで操作可能
【4】public
└どんなクラスからでも操作可能

■privateとしたフィールドからデータを取り出す場合「getter/ゲッター」メソッドを用いる
└フィールドを外側のクラスから書き換えることができなくなるため「Read-only」となる

public class Hero {
    private String name="◯◯" ;
    public String getName(){
        return this.name;
    }
}
public class Main {
  public static void main(String[] args){
          Hero h = new Hero();
          h.name = h.getName;
          System.out.println(h.name);
    }
}

■privateとしたフィールドのデータを書き換える場合「setter/セッター」メソッドを用意する
└フィールドを外側のクラスから読めなくなるため「Write-only」となる

public class Hero {
    private int hp;
    public void setName(String name){
            this.name = name;
    }
}
public class Main {
   public static void main(String[] args){
     Hero h = new Hero();
          h.setName("◯◯");
    }
}
▼オブジェクト指向を実現するJavaの3つの記述方法は?
【1】カプセル化
└クラス内の記述を特定の役割を持った「属性/操作」にグルーピングして記述する

【2】継承
└過去に作った部品の機能を元に、新しい部品を作る継承を利用して記述する

【3】多態性
└似かよった2つの部品を、だいたい同じものとして捉えられる多態性(ポリモーフィズム)を利用して記述する

▼「継承」とは?
■他クラスの中身を引き継ぎ利用すること
■継承を行う場合、以下のような形でclassファイルの先頭に「extends」記載

public class SuperHero extends Hero{
    int hp = 100;
    int mp = 200;
}
public class Hero{
    int hp;
    int mp;
}
▼継承を行う時の各クラスの呼び方は?
■継承される側の大本クラス:スーパークラス/親クラス
■継承する側のクラス:サブクラス/子クラス
※子クラスが複数の親クラスから継承を受けることはできない

■オーバーライド
└スーパークラスで保持しているメソッドの中身を子クラスで書き換えること
■クラス全体の継承を禁止したい場合、以下のような形でclassファイルの先頭に「final」記載

 public final class Main{}

■メソッド単体の継承を禁止したい場合、以下のような形でメソッドの先頭に「final」記載

public final void run(){}

■継承の具体例としては以下など
※クラスは大本になるほど、内容が抽象化されていく
【1】親クラス:Charcter
【2】子クラス:Hero
【3】孫クラス:SuperHero

継承のみに利用されるクラスの書き方は?
【1】抽象クラス
■インスタンスとして実体化(メモリに格納)し利用しないクラス
■実際の計算式を含まない抽象メソッドを一つでも含む限り、抽象クラスとする必要がある
■抽象クラスの書き方は以下

public abstract class Chusho{
    public abstract chushomethod();
}

【2】インタフェース
■フィールドを保持せず、全てのメソッドが抽象メソッドであるクラスのこと
■インタフェースの書き方は以下

public interface CleaningService{
    Shirt washShirt(Shirt s);
    Shirt washTowl(Towl t);
    Shirt washCoat(Coat c);
}

■インターフェースを継承しクラスを記述する場合「implements」を記述する

public class KyotoCleaningShop 
implements CleaningService{}

■親クラスの継承と異なり、インタフェースのみ多重継承が許されており、複数の親インタフェースの継承が可能

public class PrincessHero 
implements Hero, Princess, Character{}
▼多態性とは?
■あるものを、あえてザックリ捉えることでメリットを享受すること
└厳密に言えば「Hero」だがザックリ捉えるとみんな「Character」
└厳密に言えば「SuperHero」だがザックリ捉えるとみんな「Character」

Character c = new SuperHero();
Character c = new Hero();

■以下のようにまとめた「Character」に同じ操作を実行するためなどに使われる

public class Main{
    public static void main(String[] args){
            Character[] c = new Character[5]
            c[0]=new Hero();
            c[1]=new Hero();
            c[2]=new Thief();
            c[3]=new Wizard();
            c[4]=new Wizard();
        for(Character ch : c){
            ch.setHp(ch.getHp()+50);
        }
    }
}
▼JavaにおけるAPIとは?
■予め他の人が作ったパッケージとその中のクラスをJavaではAPIと呼ぶ
■パッケージ名+クラス名を指定することで対象クラス(=API)を呼び出すことができる
■200を超えるパッケージ、3,500を超えるクラスが予め用意されている
■APIとして提供されるパッケージは「java.」「javax.」の名称でパッケージングされている
└java.lang. 重要なクラス群を格納したパッケージ(記載省略可能)
└java.util. 便利にするクラス群を格納したパッケージ
└java.math. 数学に関するクラスを格納したパッケージ
└java.net. ネットワーク通信に関するクラスを格納したパッケージ
└java.io. ファイル読み書きなどに関するクラスを格納したパッケージ
▼具体的なAPIは例えばどんなもの?
■「java.io.FileReader」を利用することでファイルを一気に読み込むのではなく、ストリーム型で1文字ずつファイルを読み込む

import.java.io.*
public class Main {
    public static void main(String[] args) throws Exception{
        String filename = "c:\\test.txt";
        FileReader fr = new FileReader(filename);
        char c1 = (char) fr.read(); // ファイルの最初の1文字目を読む
        char c2 = (char) fr.read(); // ファイルの2文字目を読む
        fr.close();
    }
}

■「java.io.FileWriter」を利用することでファイルに対して、ストリーム型で1文字ずつファイルに文字を書き込む

import.java.io.*
public class Main {
    public static void main(String[] args) throws Exception{
        String filename = "c:\\test.txt";
        FileWriter fw = new FileWriter(filename);
        fw.write1 = ('あ'); // ファイルの最初の1文字目を書き込む
        fw.write2 = ('い'); // ファイルの2文字目を書き込む
        fr.close();
    }
}

■「java.net」パッケージを利用して、WEBページの内容を取得

import java.io.InputStream;
import java.net.URL;
public class Main {
    public static void main(String[] args) throws Exception{
        URL u = new URL("http://www.example.com");
        InputStream is = u.openStream();
        int i = is.read();
        while(i ! = -1){
            char c = (char) i ;
            System.out.println(c); //読み込んだページ内容を表示
            i = is.read();
        }
    }
}

■「java.sql」パッケージを利用して、データベースの情報を取得

import java.sql.*;
public class Main {
    public static void main(String[] args) throws Exception{
        Class.forname("org.h2.Driver");
        String dburl = "db-name"; //接続するDB名を指定
        String sql = "INSERT INTO EMPLOYEES(name) VALUES('name')";
        Connection conn = DriveManager.getConnection(dburl); //接続先ホストを指定
        conn.createStatement().executeUpdate(sql) //SQLを送信
        conn.close(); //DB接続を閉じる
    }
}

■「java.awt.FlowLayout」「java.swing」パッケージを利用して、GUIで動くプログラムが作成可能

import java.awt.FlowLayout
import java.swing.*
public class Main {
    public static void main(String[] args){
        JFrame frame = new JFrame("はじめてのGUI");
        JLabel label = new JLabel("Hello world");
        JButton button = new JButton("押してね");

        frame.getContentPane().setLayout(new FlowLayout());
        frame.getContentPane().add(label);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300,100);
        frame.setVisible(true);
    }
}

■「java.servlet.http」を利用してWEBアプリケーションを作成可能

import java.io.*;
import java.util.Date;
import java.servlet.http.*;
@webServlet("/HelloServlet")
public class HelloServlet extends HttpServlet {
        protected void doGet(HttpServletRequest req, 
        HttpServletResponse res) throws IOException{
            Date d = new Date();
            Writer w = res.getWriter();
            w.write("");
            w.write("Today is"+d.toString());
            w.write("");
        }
    }
}
▼Javaの統合開発環境(IDE)とは?
■「Eclipse」「NetBeans」などがある
■エディタ、コンパイラ、インタプリタのすべてを内蔵した開発用ソフトウェア
■1つの画面でソースコードの編集からコンパイル、実行まで開発作業を行うことができる
■ソースコードを見やすくカラーリング、キー入力を支援、デバッグを助ける機能などがある
■「Eclipse」は英語ベースだが、拡張機能を追加し日本語化された「Pleiades」がある
▼3タイプのJavaプログラムエラーとは?
【1】文法エラー
└「セミコロンエラー」「privateメソッドを外部から呼び出す」など文法の誤りによりコンパイルに失敗するパターン
└コンパイラが指摘したエラー箇所を修正する

【2】実行時エラー
└「配列の範囲外要素へのアクセス」「0での割り算」「ファイルが存在しない」「メモリ不足」「nullが入った変数の利用」などコンパイルは完了するが、実行中にエラーが発生し動作が継続できなくなるパターン
└エラーが発生した時の対処法を「例外処理」として明示しておき、事態を回避する

【3】論理エラー
└「電卓ソフトを作ったが計算結果がおかしい」などコンパイルは完了、実行時のエラーも存在しないが結果がおかしい形のエラー
└原因箇所を自力で探して、コードの対象箇所を修正する

▼Javaで例外処理を行うには?
■「try-catch」文を利用する

try{
    FileWriterfw = new FileWriter("c:data.txt");
    fw.write("hello!");
    fw.close();
}catch(IOException e){
    System.out.println("エラーです。終了します。");
    System.exit(1);
}

■例外クラスの種類としては以下
【1】Error系の例外
└「java.lang.Error」クラスの子孫で回復の見込みがない致命的な状況のため、このエラーをキャッチしても打つ手はないためキャッチする必要はない
└「OutOfMemoryError(メモリ不足)」「ClassFormatError(クラスファイルの破損)」など

【2】Exception系の例外
└「java.lang.Exception」クラスの子孫で、当然エラーの発生を想定し対処方法を考えておく必要があるエラー
└「IOException(ファイルの読み書きができない)」「ConnectException(ネットワークに接続できない)」などがある

【3】RuntimeException系の例外
└「java.lang.RuntimeException」クラスの子孫で、想定するときりがない例外的状況
└「NullPointerException(変数がnull)」「ArrayIndexOutOfBoundsException(配列の添字が不正)」などがある

■「【2】Exception系の例外」の場合には、try-catch文を用意していないとコンパイルエラーとなる

import java.io.
public class Main{
    public static void main(String[] args){
        try{
            FileWriter fw = new FileWriter("data.txt");
        }catch(IOException e){
            System.out.println("エラーが発生しました。");
        }
    }
}

■例外発生の如何を問わず必ず処理を実行する場合「try-catch-finally」構文を利用

try{
    本来の処理
}catch(例外クラス 変数名){
    例外が発生した場合の処理
}finally{
    例外があってもなくても必ず実行する処理
}

■例外を無視する場合「throws」宣言を行う

public static void subsub() throws IOException{
    FileWriter fw = new FileWriter("data.txt");
}

思ったこと

WEBサイトからGUIベースのシステムまで、OSを選ばず様々な領域で幅広く使われているJavaに関して、「順次・分岐・繰り返し」処理というプログラミングの基礎に立ち返ってから、1つ1つの役割を持つ部品に分解してプログラミングを行っていくオブジェクト指向の真髄までを、初心者向けに優しく教えてくれる本でした。

非エンジニアである自分にとって、引数・戻り値とかが何回か出てきた時点で、もはや今まで自分が何をしていたのかすらわからなくなってしまうことも多かったりします。そのようなプログラミングの根本的な基礎として「まっすぐ処理する順次」「途中で枝分かれする分岐」「同じことをもう1回行う繰り返し」の3つに処理を分解し、それぞれに対応する構文を順序立てて学べます。

またオブジェクト指向というのは、基本的には現実世界をまねて、役割を持った部品に1つずつプログラミングを分解していくという説明を聞くと、中々プログラムを学びづらい文系の人にとっても、少し距離を近づけやすくなる気がしました。

しかし、こういうプログラミング言語を駆使して、ものをごりごりと動かしていくエンジニアと呼ばれる人たちって、改めてすげーなって思わされますね。何個かの処理を書くだけでも頭がいっぱいになるところで、膨大な処理をつなげあわせて最終的に一連のつながった動きをするってちょっと神がかってるし、それが難しくてバグが出るんだなっていう、テストの重要性を改めて痛感させてもらった本でした。

ありがとうございました!

関連する記事