k4h4shi
9/3/2017 - 11:24 AM

Type of Java

Type of Java

/**
 * 変数やメソッドをまとめる入れ物がクラスであり、クラスから作ったオブジェクトがインスタンスである<br>
 * 生成されたインスタンスを使用するためには、インスタンスを特定する情報を知っておく必要がある<br>
 * その情報を参照(ポインタ)と呼び、参照という値を保持する型を参照型と呼ぶ。
 * 
 * ベストプラクティス:<br>
 * - 原則としてオートボクシング、アンボクシングは利用せず、明示的に変換を行う<br>
 * - ファイルやデータベース、HTTPリクエストなどを保持する値はラッパークラスを用いる<br>
 * - 数値計算に用いる変数は、プリミティブ型とする<br>
 * - 記述量の削減が効果的な場合に限り、オートボクシング、アンボクシングを利用する
 * 
 * @author k4h4shi
 *
 */
public class ReferenceType {
	/**
	 * 文字列型:
	 * 値: 文字型の配列
	 * 振る舞い: 文字列に対する操作
	 */
	static String string;
	/**
	 * byte型のラッパークラス
	 * 値: byte
	 * 振る舞い: byteに対する操作
	 */
	static Byte b;
	/**
	 * short型のラッパークラス
	 * 値: short
	 * 振る舞い: shortに対する操作
	 */
	static Short s;
	/**
	 * int型のラッパークラス
	 * 値: int
	 * 振る舞い: intに対する操作
	 */
	static Integer i;
	/**
	 * long型のラッパークラス
	 * 値: long
	 * 振る舞い: longに対する操作
	 */
	static Long l;
	/**
	 * char型のラッパークラス
	 * 値: char
	 * 振る舞い: charに対する操作
	 */
	static Character c;
	/**
	 * float型のラッパークラス
	 * 値: float
	 * 振る舞い: floatに対する操作
	 */
	static Float f;
	/**
	 * double型のラッパークラス
	 * 値: double
	 * 振る舞い: doubleに対する操作
	 */
	static Double d;
	/**
	 * boolean型のラッパークラス
	 * 値: boolean
	 * 振る舞い: booleanに対する操作
	 */	
	static Boolean bool;
	/**
	 * 参照型のリテラルには、文字列リテラルとnullリテラルがある。
	 */
	static void literals() {
		// 文字列リテラル
		string = "string"; // ダブルクオートで囲む
		System.out.println(string); // => string
		
		// 参照型の変数やフィールドの場合、参照を利用してメソッドを呼び出すことが出来る
		System.out.println(string.toUpperCase()); // => STRING
		
		// nullリテラル
		string = null;
		System.out.println(string); // => null
		
		// 参照の値にnullが入っている状態でメソッドの呼び出しを行うと、NullPointerExceptionが投げられる
		// System.out.println(s.toUpperCase()); // => java.lang.NullPointerException
	}
	
	static void wrapperClass() {
		// 定数
		// byte型の情報
		System.out.println(
				"Byte: { SIZE(bit)" + Byte.SIZE
				+ ", BITES: " + Byte.BYTES
				+ ", MIN: " + Byte.MIN_VALUE
				+ ", MAX: " + Byte.MAX_VALUE
				+ " }"
				);
		// int型の情報
		System.out.println(
				"Integer: { SIZE(bit)" + Integer.SIZE
				+ ", BITES: " + Integer.BYTES
				+ ", MIN: " + Integer.MIN_VALUE
				+ ", MAX: " + Integer.MAX_VALUE
				+ " }"
				);
		
		// int -> Integer
		i = new Integer(10);
		System.out.println(i); // => 10
		
		// Integer -> int
		int intValue = i.intValue();
		System.out.println(intValue); // => 10
		
		// String -> Integer
		i = new Integer("100"); // 新たなインスタンスを生成する
		System.out.println(i); // => 100
		i = Integer.valueOf("101"); // キャッシュされたオブジェクトを返す
		System.out.println(i); // => 101
		i = Integer.valueOf("11", 2); // 基数を指定する
		System.out.println(i); // => 3
		
		// String -> int
		intValue = Integer.parseInt("100");
		System.out.println(intValue); // => 100
		intValue = Integer.parseInt("11", 2); // 基数を指定する
		System.out.println(intValue); // => 3
		
		// int -> String
		string = Integer.toString(10);
		System.out.println(string); // => 10
		
		// Integer -> String
		string = i.toString();
		System.out.println(string); // => 3
	}
	static void autoBoxingAndUnBoxing() {
		int num = 10;
		Integer numInt = 10; // コンパイル時にInteger.valueOf(10)に自動変換される(オートボクシング)
		Integer sum = num + numInt; // numIntがnumInt.intValue()でintに自動変換され(アンボクシング)、演算結果を再度オートボクシングする
		System.out.println(sum); // => 20
		
		
		// -128 ~ 127までは事前に生成されたオブジェクトが利用される
		Integer int1 = 127;
		Integer int2 = 127;
		// そのため、==演算子による判定がtrueになる
		System.out.println(int1 == int2); // => true
		
		// 128からは新たにオブジェクトが生成されるため、異なるオブジェクトとして扱われる
		Integer int3 = 128;
		Integer int4 = 128;
		// そのため、==演算子による判定がfalseになる
		System.out.println(int3 == int4); // => false
		
	}
	
	public static void main(String[] args) {
		literals();
		wrapperClass();
		autoBoxingAndUnBoxing();
	}
}
/**
 * 
 * プリミティブ型は、真偽値型と数値型、文字型からなる基本的なデータ型である<br>
 * 数値型は用途によって必要となるサイズ、値の範囲、及び精度が異なるため、複数の種類が用意されている<br>
 * Javaのプリミティブ型には以下がある<br>
 * <br>
 * 数値 = {byte, short, int, long, double, float}<br>
 * 文字 = {char}<br>
 * 真偽値 = {boolean}<br>
 * @author k4h4shi
 *
 */
public class PrimitiveType {
	/**
	 * 符号付整数値
	 * サイズ: 8bit
	 * 値の範囲: -128 ~ 127
	 */
	static byte bt;
	/**
	 * 符号付き整数値
	 * サイズ: 16bit
	 * 値の範囲: -32768 ~ 32767
	 */
	static short s;
	/**
	 * 符号付き整数値
	 * サイズ: 32bit
	 * 値の範囲: -2147483648 ~ 2147483647
	 */
	static int i;
	/**
	 * 符号付き整数値
	 * サイズ: 64bit
	 * 値の範囲: 9223372036854775808 ~ 9223372036854775807 
	 */
	static long l;
	/**
	 * Unicode文字
	 * サイズ: 16bit
	 * 値の範囲: '¥u0000' ~ '¥uffff' / 0 ~ 65535
	 */
	static char c;
	/**
	 * IEE 754 浮動小数点数
	 * サイズ: 32bit(単精度)
	 * 値の範囲: 2**-149 ~ (2-2**-23)*2**127
	 */
	static float f;
	/**
	 * IEE 754 浮動小数点数
	 * サイズ: 32bit(倍精度)
	 * 値の範囲: 2**-1072 ~ (2-2**-52)*2**1023
	 */
	static double d;
	/**
	 * 真偽値
	 * サイズ: 1bit
	 * 値の範囲: true/false
	 */
	static boolean bool;
	
	/**
	 * リテラルの一覧
	 */
	static void literals() {
		System.out.println("literals: ");
		
		/**
		 * int型の整数リテラル(10進数)
		 */
		i = 123;
		System.out.println(i); // => 123
		/**
		 * int型の整数リテラル(8進数)
		 */
		i = 010; // 先頭に0をつける
		System.out.println(i); // => 8
		/**
		 * int型の整数リテラル(16進数)
		 */
		i = 0xa; // 先頭に0xまたは0Xをつける
		System.out.println(i); // => 10
		/**
		 * int型の整数リテラル(2進数)
		 */
		i = 0b11; // 先頭に0bまたは0Bをつける
		System.out.println(i); // => 3
		
		/**
		 * long型の整数リテラル
		 */
		l = 1L; // 末尾にlまたはLをつける
		System.out.println(l); // => 1
		
		/**
		 * float型の浮動小数点リテラル
		 */
		f = 3.14f; // 末尾にfまたはFをつける
		System.out.println(f); // => 3.14
		
		f = 3F;
		System.out.println(f); // => 3.0
		
		/**
		 * double型の浮動小数点リテラル
		 */
		d = 3.14; // 小数点値はデフォルトでdouble型となる
		System.out.println(d); // 3.14
		d = 3d; // 末尾にdまたはDをつける
		System.out.println(d); // 3.0
		
		bool = true; // trueまたhfalse
		System.out.println(bool); // => true
		
		// 文字リテラル
		c = 'A'; // シングルクオートで囲む
		System.out.println(c); // => A
		
		// 桁数の多い数値の表現
		l = 123_456_789L; // 数値リテラルは_を用いて区切ることが出来る
		System.out.println(l); // => 123456789
		
		i = 0b1111_1111_1111_1111;
		System.out.println(i); // => 65535
		
		System.out.println();
	}
	
	/**
	 * Javaは、型が不整合の場合でも互換性がある場合は自動的に変換を行う<br>
	 * 狭い範囲の整数値から広い範囲の整数値への変換はワイドニングと呼ばれる<br>
	 * 広い範囲の整数力狭い範囲の数値への変換はナローイングと呼ばれる<br>
	 * ナローイングの場合は、キャストを明示しない場合、コンパイルエラーとなる
	 */
	static void wideningAndNarrowing() {
		System.out.println("wideningAndNarrowing:");
		
		// ワイドニング
		s = 100;
		// short型よりもint型の方が表現する値の範囲が広いため自動的に変換される
		i = s;
		System.out.println(i); // => 100
		
		// ナローイング
		i = 32767 + 1;
		s = (short) i; // 範囲を超えた型変換を行うため、値は保証されない
		System.out.println(s); // => -32768
		
		System.out.println();
	}
	
	public static void main(String[] args) {
		literals();
		wideningAndNarrowing();
	}
}