k4h4shi
9/3/2017 - 11:07 AM
Basics of Java
Basics of Java
import org.apache.commons.lang.builder.ToStringBuilder;
/**
*
* クラスは変数やメソッドをまとめる入れ物。
* プログラムを作成する場合は、構造を把握しやすくするなどの理由からプログラムを分割する。
* その際にはまずクラス単位での分割を行う。
* 指針としては、実際のものや概念単位でクラスを分割し、それらを連携させるようにする。
* 以下は、生徒という概念をクラス化したもの
* @author k4h4shi
*
*/
class Student {
// クラスは、クラスブロック内に保持させる変数を宣言することが出来る
// クラスが保持する変数をフィールドと呼ぶ。
String name;
int score;
// MAX_SCOREのフィールドの型名の前にあるstaticやfinalは修飾子と呼ぶ
static final int MAX_SCORE = 100;
// クラス内には、フィールドの他にメソッドを定義することも出来る。
// フィールドとメソッドをまとめてメンバと呼ぶ。
// methodの宣言の構文 = "修飾子 戻り値の型 メソッドの識別子 (引数1の型 引数1の識別子, 引数2の型 引数2の識別子)"
// メソッド宣言の後に処理ブロックを記述することで、メソッドが行う処理を定義することが出来る。
// 引数が1つのメソッド
void setScore(int newScore) {
score = newScore;
}
// 引数なしのメソッド
void printScore() {
System.out.println("Score : " + score);
}
// メソッドの処理の結果を返り値によって呼び出し元に返すことが出来る
// 戻り値がない場合は、型にvoidを記述する
// void以外の型を指定した場合は、必ずreturn文で一致する型の値を返す必要がある。
// return文の構文 = "return 返す値;"
// 戻り値が整数値(int)のメソッド
int getScore() {
return score;
}
// 戻り値なしのメソッド
void printName() {
System.out.println("Name : " + name);
}
// methodのオーバーロード
// 異なる引数の型または引数の数でメソッドを定義することで、
// 同一の識別子のメソッドを定義することが出来る。
// オーバーロードを行うことで呼び出し元で、渡す引数によって実際に呼び出されるメソッドを切り替えることが出来る
void printMaxScore() {
printMaxScore(MAX_SCORE);
}
void printMaxScore(int maxScore) {
System.out.println(maxScore);
}
// thisによる記述
// 他クラスからクラスのメンバへアクセスする際には、"クラスの識別子.メンバの識別子"という記述で行うことができる
// 自分自身のメンバへアクセスする際には、クラスの識別子の代わりにthisを用いることができる
// しかし、自分自身のメンバへアクセスする際にはメンバの識別子のみでアクセスできるため、通常は省略する。
// ただし、引数にフィールドと同名の識別子を受け取っている場合、引数が優先されるため、省略した場合にはフィールドへアクセスできない。
// その場合は、thisによるアクセスを行い、フィールドにアクセスすることを明示する必要がある。
void setName(String name) {
// thisを用いて自身のフィールドへアクセスしている。
this.name = name;
}
// コンストラクタ
// コンストラクタは、インスタンスの生成時に一度だけ呼ばれる特別なメソッド。
// 宣言の際には以下のルールに従うことで宣言できる
// - 返り値の型を宣言しない(返り値の型は自身のクラスと同一になることが決まっているため)
// - メソッドの識別子をクラスの識別子同一のものにする
Student() {
// コンストラクタでは、主に初期化処理を行う
this("student");
}
// コンストラクタは通常のメソッドと同様にオーバーロードが可能
Student(String name) {
// thisによってコンストラクタを呼び出すことが出来る
// オーバーロードを用いることで、同様の初期化処理の記述を省きつつ、複数の初期化の方法を提供することが出来る
this(name, 0);
}
// 全てのフィールドの初期化を行うコンストラクタ
// 以下のように、コンストラクタで初期化処理を行うことが出来る
// フィールドやメソッドを通じて値を設定出来るため、コンストラクタによる初期化の使い分けは以下のようにする
// - インスタンス生成後、値が変わらないもの: コンストラクタに初期化を行う
// - インスタンスのライフサイクルで、値が変わるもの: フィールドやメソッドによるアクセスで値を設定する
// 上記のように使い分けることで、アクセス修飾子などを用いてコンストラクタによってのみ値を設定できるフィールドを作ることが出来る
Student(String name, int score) {
this.name = name;
this.score = score;
}
// javaDoc
// /** */ の間に コメントを記述することでJavaDocが作成出来る
// JavaDocでは記法に沿って記述することでHTML形式のドキュメントを出力することが出来る
/**
* @see Object#toString()
*/
// アノテーション
// @から始まる記述でアノテーションを付加出来る
// アノテーションを付加することで、メンバに対し注釈を追加出来る
// フレームワークによってはアノテーションを用いて意味や機能などを付加することが出来るものもある
// 代表的なものでいえば、jUnitなどでは@Testアノテーションでテストメソッドであることを指定できる
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
/**
* 関係演算子は2つの項の比較を行う演算子。
* 評価結果は真偽値となる。
* {==, !=, >, >=, <, <=, instance0f}の7つがある
* 両辺が等しいかどうか {==, !=}
* 左辺が大きいかどうか(右辺が小さいかどうか) {>, >=}
* 左辺が小さいかどうか(右辺が大きいかどうか) {<, <=}
* 左辺が右辺のインスタンスかどうか(サブクラスを含む) {instanceof}
* なお、instanceof演算子は、プリミティブ型には利用できない。(なぜなら、プリミティブ型はオブジェクトではないから)
* @author k4h4shi
*
*/
public class RelationalOperator {
public static void main(String[] args) {
int x = 10;
int y = 20;
boolean equals = x == y;
boolean notEquals = x != y;
boolean lessThen = x < y;
boolean lessThenOrEquals = x <= y;
boolean greaterThen = x > y;
boolean greaterThenOrEquals = x >= y;
boolean instanceOf = new Integer(x) instanceof Integer;
System.out.println(equals); // => false
System.out.println(notEquals); // => true
System.out.println(lessThen); // => true
System.out.println(lessThenOrEquals); // => true
System.out.println(greaterThen); // => false
System.out.println(greaterThenOrEquals); // => false
System.out.println(instanceOf); // => true
}
}public class Main {
// meinメソッド
// mainメソッドはJavaプログラムの処理の起点となるメソッド。
// Javaアプリケーションにはなくてはならなく、最初に呼び出されるメソッドとなる
// public 及び statci修飾子を付加し、返り値はvoid、識別子はmain、引数はString型の配列をargsとして受け取る
public static void main(String[] args) {
// インスタンスの生成
// 作成したクラスや、提供されているライブラリのクラスは、基本的にはインスタンス化することで使用する
// newキーワードを用いてクラスのコンストラクタを呼び出すことでインスタンス化を行うことが出来る。
// 作成したインスタンスは、同一クラスの型を持つ変数に代入することが出来る
Student kotaro = new Student();
// インスタンスのメンバにアクセスするには、.を用いてメンバの識別子を指定する
// インスタンスのフィールドへアクセスし、値を代入する。
kotaro.name = "kotaro";
// インスタンスのメソッドへアクセスし、処理を呼び出す
kotaro.printName();
// 定義したクラスのインスタンスは、複数個作成することが出来る
Student miki = new Student();
miki.name = "miki";
miki.printName();
}
}/**
* 論理演算子は真偽の判定をする論理演算を行うための演算子。
* 二項演算子が二つと単項演算子が一つある。
* 二項演算子 = { ||, && }
* 単項演算子 = {!}
*
* || 論理和
* && 論理積
* ! 真偽の反転
* @author k4h4shi
*
*/
public class LogicalOperator {
@SuppressWarnings("unused")
public static void main(String[] args) {
boolean trueOrTrue = true || true;
boolean trueOrFalse = true || false;
boolean falseOrTrue = false || true;
boolean falseOrFalse = false || false;
boolean trueAndTrue = true && true;
boolean trueAndFalse = true && false;
boolean falseAndTrue = false && true;
boolean falseAndFalse = false && false;
boolean notTrue = !true;
boolean notFalse = !false;
System.out.println(trueOrTrue); // => true
System.out.println(trueOrFalse); // => true
System.out.println(falseOrTrue); // => true
System.out.println(falseOrFalse); // => false
System.out.println(trueAndTrue); // => true
System.out.println(trueAndFalse); // => false
System.out.println(falseAndTrue); // => false
System.out.println(falseAndFalse); // => false
System.out.println(notTrue); // => false
System.out.println(notFalse); // => true
}
}/**
* if文は条件が真である場合に処理を行う構文 ifキーワードに続いて真偽値に評価される条件式を()の中に記述する。
* 一般的にはブロックを利用した書き方が使われるが、文を利用した書き方も可能。
* ブロックを利用した場合は条件式に続けてブロックを記述すれば、条件が真である場合にブロックが実行される。
* もし、条件が偽である場合、ブロックは存在しないものとして扱われる。
* ブロックを利用した場合の利点は、階層的に入れ子にできるという点と、自然な記述にできるという点である。
*
* 文を利用した場合は、条件式が真の場合、次のセミコロンまでの文が実行される。 条件式が偽の場合、その文は存在しないものとして扱われる。
* 文を利用した場合の利点は、一行で記述できるということがあるが、通常は慣例的にブロックを用いるため、見慣れないという欠点がある。
*
* どちらの場合も、elseキーワードを記述することで条件式が偽の場合の処理を記述することができる。 また、else
* ifキーワードを用いることで、ifの条件式が偽であった際に評価される他の条件式を記述できる。
* その場合、if文と同様、条件式が真の場合に続くブロックまたは式が実行される。
*
* @author k4h4shi
*
*/
public class ConditionalStatement {
public static void main(String[] args) {
boolean condition = false;
boolean otherCondition = true;
// ifブロック
if (condition) {
System.out.println("condition is true");
}
// ifelseブロック
if (condition) {
System.out.println("condition is true");
} else {
System.out.println("condition is not true");
}
// ifelseifelseブロック
if (condition) {
System.out.println("condition is true");
} else if (otherCondition) {
System.out.println("other condition is true");
} else {
System.out.println("both condition is false");
}
// if文
if (condition)
System.out.println("condition is true");
// ifelse文
if (condition)
System.out.println("condition is true");
else
System.out.println("condition is not true");
// ifelseifelse文
if (condition)
System.out.println("condition is true");
else if (otherCondition)
System.out.println("other condition is true");
else
System.out.println("both condition is false");
// switch文
String type = "first";
switch(type) {
case"first":
System.out.println("first");
break;
case"second":
System.out.println("second");
break;
case"third":
System.out.println("third");
break;
case"forth":
case"fifth":
System.out.println("forthOrFifth");
}
}
}/**
* 条件演算子は2つの式のいずれかを利用するかを判定する演算子
* 三項演算子のみがある
* { 条件 ? 真の場合 : 偽の場合 }
* @author k4h4shi
*
*/
public class ConditionalOperator {
public static void main(String[] args) {
boolean truth = Boolean.TRUE ? true : false;
boolean dare = Boolean.FALSE ? true : false;
System.out.println(truth); // => true
System.out.println(dare); // => false
}
}/**
* ビット演算子は数値のビット演算を行うことができる演算子。
* ビット演算子 = {&, |, ^, <<, >>, >>>, ~}の7つがある。
* 二項演算子が6つと単項演算子がoneつある
* 論理演算子とシフト演算子という分け方も可能
* 論理演算 = {&, |, ^, ~}
* シフト演算 = {<<, >>, >>>}
* @author k4h4shi
*
*/
public class BitOperator {
public static void main(String[] args) {
// 二進数
int zero = 0b0;
int one = 0b1;
// bit演算AND
int zeroAndZero = zero & zero;
int zeroAndOne = zero & one;
int oneAndZero = one & zero;
int oneAndOne = one & one;
// bit演算OR
int zeroOrZero = zero | zero;
int zeroOrOne = zero | one;
int oneOrZero = one | zero;
int oneOrOne = one | one;
// bit演算XOR
int zeroXorZero = zero ^ zero;
int zeroXorOne = zero ^ one;
int oneXorZero = one ^ zero;
int oneXorOne = one ^ one;
// bit演算NOT
int notZero = ~zero;
int notOne = ~one;
// 左シフト
int leftShift = one << one;
// 算術右シフト
int rightArithmeticShift = one >> one;
// 論理右シフト
int rightLogicalShift = one >>> one;
System.out.println("bit演算AND");
System.out.println(zeroAndZero); // => 0
System.out.println(zeroAndOne); // => 0
System.out.println(oneAndZero); // => 0
System.out.println(oneAndOne); // => 1
System.out.println("bit演算OR");
System.out.println(zeroOrZero); // => 0
System.out.println(zeroOrOne); // => 1
System.out.println(oneOrZero); // => 1
System.out.println(oneOrOne); // => 1
System.out.println("bit演算XOR");
System.out.println(zeroXorZero); // => 0
System.out.println(zeroXorOne); // => 1
System.out.println(oneXorZero); // => 1
System.out.println(oneXorOne); // => 0
System.out.println("bit演算NOT");
System.out.println(notZero); // => -1
System.out.println(notOne); // => -2
System.out.println("bit左シフト");
System.out.println(leftShift); // => 2
System.out.println("bit算術右シフト");
System.out.println(rightArithmeticShift); // => 0
System.out.println("bit論理右シフト");
System.out.println(rightLogicalShift); // => 0
}
}
/**
* 代入演算子は、代入や、値の代入と同時に演算を行うための演算子
* 代入演算子 = {=, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=}
* 代入を行う演算子 = {=}は1種類
* 算術演算後に代入を行う演算子 = {+=, -=, *=, /= %=}の5種類
* bit論理演算後に代入を行う演算子 = {&=, |=, ^=}
* bitシフト演算後に代入を行う演算子 = {<<=, >>=, >>>=}
* @author k4h4shi
*
*/
public class AssignmentOperator {
public static void main(String[] args) {
int n = 0;
n += 1;
System.out.println(n); // => 1
n -= 1;
System.out.println(n); // => 0
n *= 1;
System.out.println(n); // => 0
n /= 1;
System.out.println(n); // => 0
n &= 1;
System.out.println(n); // => 0
n |= 1;
System.out.println(n); // => 1
n ^= 1;
System.out.println(n); // => 0
n <<= 1;
System.out.println(n); // => 0
n >>= 1;
System.out.println(n); // => 0
n >>>= 1;
System.out.println(n); // => 0
}
}
/**
* 数値演算を行う演算子。
* 二項演算子 = { +, -, *, /, % }の5つ
* 単項演算子 = { -, ++, --}の3つがある。
* 単項演算子のインクリメントとデクリメントには、前置と後置がある。
* 前置の場合は、先に計算が行われ、値が評価される。
* 後置の場合は、先に現在の値が評価され、後に計算が行われる。
* @author k4h4shi
*/
public class ArithmeticOperator {
public static void main(String[] args) {
int x = 1;
int y = 2;
int sum = x + y;
int diff = x - y;
int product = x * y;
int quotient = x / y;
int remainder = x % y;
int unaryMinus = -x;
int postfixIncrement = x++;
int prefixIncrement = ++x;
int prefixDecrement = --x;
int postfixDecrement = x--;
System.out.println(sum); // => 3
System.out.println(diff); // => -1
System.out.println(product); // => 2
System.out.println(quotient); // => 0
System.out.println(remainder); // => 1
System.out.println(unaryMinus); // => -1
System.out.println(postfixIncrement); // => 1
System.out.println(prefixIncrement); // => 3
System.out.println(postfixIncrement); // => 1
System.out.println(prefixDecrement); // => 2
System.out.println(postfixDecrement); // => 2
}
}