การเปรียบเทียบ compare 2 methods ใน Eclipse

บทความนี้เรามาดูวิธีการเปรียบเทียบ method ใน Eclipse กันครับ ซึ่งมีหลาย ๆ ที่เราต้องการจะเปรียบเทียบ method ในไฟล์ หรือ Class เดียวกัน อยู่ไฟล์เดียวกันทำให้เวลาจะหาความต่างจะต้องการคอยเลื่อนไปเลื่อนมา ในบทความนี้เรามาแนะนำวิธีดี ๆ อีกวิธีหนึ่งที่สามารถใช้เปรียบเทียบ method ได้อย่างง่าย ๆ มาดูวิธีทำกันเลย

เริ่มด้วยการโชว์ outline ขึ้นมาก่อน โดยไปที่ Windows เลือก Show View แล้วเลือก Outline ตามรูปด้านล่าง

จะปรากฎหน้าต่างส่วน Outline ขึ้นมา จะมีรายชื่อ method แสดงขึ้นมาให้เราเลือก method ที่ต้องการจะเปรียบเทียบ จากนั้นคลิกขวาเลือก Compare With แล้วเลือก Other Element ตามรูปด้านล่าง

จะปรากฎหน้าต่าง Compare Java Elements ขึ้นมา ในหน้าต่างนี้เราก็จะเห็นข้อแตกต่างระหว่าง Method แล้วว่าแตกต่างกันส่วนไหนบ้าง ตามรูปด้านล่าง

เป็นวิธีง่าย ๆ ในการเปรียบเทียบความแตกต่างระหว่าง Method ใน Eclipse โดยการ Compare ลองนำไปใช้กันดูครับ

Initialization Block ในภาษา Java

บทความนี้เรามาดูวิธีการใช้ Initialization Block ในภาษา Java กันครับ ว่า Initialization Block มันคืออะไร ใช้ยังไง และต้องรู้อะไรบ้าง

ก่อนอื่นเรามาดูวิธีการใช้งาน Initialization Block แบบง่าย ๆ กันก่อน ตามด้านล่างเลย

package info.doesystem.howto;

public class DoesystemInfo {
 static int x;

 static {
  x = 50;
 }
}

จากโค้ดจะเห็นว่าเรามีบล็อกอยู่ ซึ่งในที่นี้ก็คือ ในวงเล็บ { และ } จะเห็นว่าเป็นบล็อกอยู่ ถ้าแปรตรง ๆ Initialization ก็คือการเริ่มต้น Block ก็คือบล็อก ถ้านำมารวมกัน ก็น่าจะแปลว่า บล็อกเริ่มต้น แล้วใช้ยังไง มีประโยชน์ยังไง มาดูกันต่อไปครับ

A non-static initialization block

- จะ Executed แต่ละครั้งที่ Object ได้สร้างขึ้น - สามารถกำหนดค่าตัวแปรเริ่มต้นใน class ตัวอย่างโค้ด java

package info.doesystem.howto;

class TestNonStaticBlock {
 int a;
 static int b;
 
 {
  a = 0;
  b = 0;
  System.out.println("Running initialization block. Class TestNonStaticBlock");
 }
}

static initialization block

- จะใช้คำว่า static ในการนำหน้าบล็อก
- จะ Executed ครั้งเดียว เมื่อ Class ถูกโหลดขึ้นมา
- สามารถกำหนดค่าเริ่มต้นเฉพาะตัวแปรที่เป็น static เท่านั้น

ตัวอย่างโค้ด java

package info.doesystem.howto;

class TestStaticBlock {
 int a;
 static int b;
 
 static {
  b = 0;
  System.out.println("Running initialization block. Class TestStaticBlock");
 }
}

A non-static initialization block VS static initialization block

ต่อไปมาลองดูความแตกต่างโดยการรันโค้ดดูครับ โค้ดตามด้านล่าง

package info.doesystem.howto;

class TestNonStaticBlock {
 int a;
 static int b;

 {
  a = 0;
  b = 0;
  System.out.println("Running initialization block. Class TestNonStaticBlock");
 }
}

class TestStaticBlock {
 int a;
 static int b;

 static {
  b = 0;
  System.out.println("Running initialization block. Class TestStaticBlock");
 }
}

public class DoesystemInfo {
 public static void main(String[] args) {
  new TestNonStaticBlock();
  new TestNonStaticBlock();
  new TestStaticBlock();
  new TestStaticBlock();
 }
}

จากโค้ด ผลลัพธ์ที่ด้คือ
Running initialization block. Class TestNonStaticBlock
Running initialization block. Class TestNonStaticBlock
Running initialization block. Class TestStaticBlock

จากนั้นลองรันโค้ด

package info.doesystem.howto;

class TestNonStaticBlock {
 int a;
 static int b;

 {
  a = 0;
  b = 0;
  System.out.println("Running initialization block. Class TestNonStaticBlock");
 }
}

class TestStaticBlock {
 int a;
 static int b;

 static {
  b = 0;
  System.out.println("Running initialization block. Class TestStaticBlock");
 }
}

public class DoesystemInfo {
 public static void main(String[] args) {
  System.out.println(TestNonStaticBlock.b);
  System.out.println(TestNonStaticBlock.b);
  System.out.println(TestStaticBlock.b);
  System.out.println(TestStaticBlock.b);
 }
}

ผลลัพธ์ที่ได้ คือ

0
0
Running initialization block. Class TestStaticBlock
0
0

จะเห็นว่า ที่เรารันโค้ดทดสอบแรก จะเกิดการ Execute บล็อก Running initialization block. Class TestNonStaticBlock สองครั้งเพราะเราสร้าง Object ขึ้นมาสองตัว จากนั้นเราก็ลองสร้าง Object กับ Class TestStaticBlock เหมือนกัน แต่จะแสดง Running initialization block. Class TestStaticBlock ขึ้นมาแค่ครั้งเดียว เพราะจะรันครั้งเดียวแค่ตอน Class ตอนโหลดเท่านั้น

จากนั้นเราก็แสดงตัวอย่างที่สอง โดยการใช้ชื่อ Class แล้วตามด้วยตัวแปร จะเห็นว่าไม่มี Running initialization block. Class TestNonStaticBlock เลยเพราะเราไม่ได้สร้าง Object ดังนั้น block ที่ไม่ใช่ static จึงไม่ได้ Execute

Noragami โนรางามิ เทวดาขาจร เรื่องย่อ

ในโลกใบนี้นอกจากมนุษย์แล้ว ยังมีเทพเจ้าที่คอยช่วยเหลือมนุษย์ มีดวงวิญญาณของคนที่ตายไปแล้วซึ่งคอยรับใช้เทพเจ้าอยู่ และยังรวมถึงวิญญาณอื่น ๆ อีกมากมาย ที่แตกต่างกันไป มนุษย์ทั่วไปจะมองเห็นวิญญาณหรือเทพเจ้าได้ยาก นอกจากเด็กอ่อน กับสัตว์ทั้งหลาย หรือมนุษย์บางคนเท่านั้น

อิคิ ฮิโยริ เด็กสาวคนหนึ่งที่มองเห็นตัวตนของวิญญาณได้ เธอได้เห็นชายคนหนึ่งที่ผ่านมากำลังตามหาแมวอยู่ ซึ่งกำลังจะถูกรถชน เธอจึงได้เข้าไปช่วย และเธอก็เกิดอุบัติเหตุขึ้น และได้รู้ภายหลังว่าผู้ชายคนนั้นคือ ยาโตะ เทพเจ้าผู้ยากจนคนหนึ่ง อุบัติเหตุครั้งนั้นทำให้เธอกลายเป็นมนุษย์กึ่งภูติ เธอสามารถถอดวิญญาณออกจากร่างได้โดยมีหางเป็นตัวเชื่อมระหว่างวิญญาณกับร่างมนุษย์ เธอต้องการจะกลับมาเป็นมนุษย์ที่สมบูรณ์แบบเหมือนเดิมเพราะการถอดวิญญาณนั้นอันตราย ดังนั้นจึงได้ขอพรกับ ยาโตะ เทพเจ้าผู้ยากจนคนนั้น ด้วยเงิน 5 เยน

ยาโตะ เทพเจ้าผู้ยากจนไม่มีผู้คนรู้จัก ไม่มีแม้กระทั่งศาลเจ้าเป็นของตัวเอง มีเพียงชุดเก่า ๆ แถมยังไปนอนในศาลคนอื่นเป็นประจำอีก เขาฝันอยากจะมีศาลเจ้าเป็นของตนเอง เป็นเทพที่มีคนรู้จัก เขาทำงานแลกเงิน 5 เยน เขาทำงานหาเงินโดยการแปะเบอร์โทรศัพท์ไว้ตามที่ต่าง ๆ เพื่อว่าเวลามีคนเดือดร้อนจะได้โทรหาเขา ในคำขอของ อิคิ ฮิโยริ นั้นคือการกลับไปเป็นมนุษย์

พวกเขาจะเป็นยังไง ยาโตะจะกลายเป็นเทพเจ้าผู้ร่ำรวยและมีคนนับถือหรือไม่ ฮิโยริจะกลับไปเป็นมนุษย์ได้หรือไม่ จะมีเรื่องราวอะไรเกิดขึ้นกับพวกเขาบ้าง ติดตามกันใน Noragami โนรางามิ เทวดาขาจร รับของสนุกแน่

Static Import ในภาษา Java

บทความนี้เรามาดู static import ที่ใช้กันใน Java กันครับ ว่ามันคืออะไร ใช้ยังไง และมีประโยชน์ยังไง

static import นั้นเราสามารถใช้ได้ตั้งแต่ Java 5 ใน Java 5 เราสามารถ import static fields โดยใช้ import static ได้ ก่อน Java 5 เราจะใช้ static final field และก็ต้อง import class เข้ามา ดังตัวอย่าง

package info.doesystem.howto;

import java.util.Calendar;

public class DoesystemInfo {
 public static void main(String[] args) {
  System.out.println(Calendar.DECEMBER);
 }
}

จากตัวอย่างเราต้อง import java.util.Calendar; จากนั้นก็ต้องใช้ Calendar.DECEMBER ในการจะใช้ค่า static fields แต่ตั้งแต่ Java 5 เป็นต้นไปเราสามารถใช้ static import ได้ดังตัวอย่าง

package info.doesystem.howto;

import static java.util.Calendar.DECEMBER;

public class DoesystemInfo {
 public static void main(String[] args) {
  System.out.println(DECEMBER);
 }
}

จากตัวอย่างเราใช้ import static แล้วก็ใส่ fields ที่ต้องการ จากนั้นเมื่อต้องการใช้งานก็เขียนชื่อ fields ตรง ๆ ไปเลย

นอกจากเราจะสามารถ import static fields แล้วเราก็ยังสามารถ import static method ได้อีกด้วย ดังตัวอย่าง

package info.doesystem.howto;

import static java.util.Calendar.getInstance;

public class DoesystemInfo {
 public static void main(String[] args) {
  System.out.println(getInstance().getTime());
 }
}

จากตัวอย่างเราก็ใช้ import staic แล้วก็ใส่ชื่อ method ที่เราต้องการ

Method Overloading ในภาษา Java

บทความนี้เรามาทำความรู้จักและดูวิธีการใช้งาน Method Overloading ในภาษา Java กันครับ ว่ามันคืออะไร ใช้งานยังไง

ในภาษา Java นั้นมีการยอมรับให้ทำการตั้งชื่อ method เป็นชื่อเดียวกันได้ แต่ method ที่ชื่อเดียวกันจะมีความแตกต่างกันที่ชนิดและขนาดของ argument เพราะจะได้เรียกถูกว่าจะใช้ method ตัวไหน ตัวอย่างโค้ดที่มี Method Overloading ตามโค้ดด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
 }
 
 public static int sumPoint(int a, int b){
  return a + b;
 }
 
 public static int sumPoint(int a, int b, int c){
  return a + b + c;
 }
 
 public static long sumPoint(int a, int b, long c){
  return a + b + c;
 }
}

จากโค้ดเราจะมี method ที่ชื่อ sumPoint เหมือนกันใน Class เดียวกัน แต่เราสามารถรู้ได้ว่า method ไหนเป็น method ไหนโดยการส่ง argument ที่แตกต่างกันไป

Primitives and overloading

เราได้รู้มาแล้วว่าค่า primitive นั้นสามารถแบ่งกลุ่มออกมาได้ โดยมีตัวเลขเป็นหนึ่งในนั้น สมมติว่าเรามีตัวเลขหนึ่ง ๆ อยู่ เช่น 1 แล้วเรามี Method Overloading อยู่รับค่าเป็น primitive หลาย ๆ ค่า เราจะรู้ได้ยังไงว่าต้องส่งไป method ไหน ตามตัวอย่างโค้ด

package info.doesystem.howto;

public class DoesystemInfo {
 void printPrimitive(char x) {
  System.out.println("printPrimitive(char)");
 }

 void printPrimitive(byte x) {
  System.out.println("printPrimitive(byte)");
 }

 void printPrimitive(short x) {
  System.out.println("printPrimitive(short)");
 }

 void printPrimitive(int x) {
  System.out.println("printPrimitive(int)");
 }

 void printPrimitive(long x) {
  System.out.println("printPrimitive(long)");
 }

 void printPrimitive(float x) {
  System.out.println("printPrimitive(float)");
 }

 void printPrimitive(double x) {
  System.out.println("printPrimitive(double)");
 }

 void testDouble() {
  double x = 0;
  System.out.println("double argument:");
  printPrimitive(x);
  printPrimitive((float) x);
  printPrimitive((long) x);
  printPrimitive((int) x);
  printPrimitive((short) x);
  printPrimitive((byte) x);
  printPrimitive((char) x);
 }

 public static void main(String[] args) {
  DoesystemInfo doesystem = new DoesystemInfo();
  doesystem.testDouble();
 }
}

จากตัวอย่างโค้ด เราจะแก้ปัญหานี้ได้โดยการ cast ให้เป็นชนิดที่ต้องการ เพียงแค่นี้มันก็เข้า method ที่ argument ตรงกันแล้ว

Constructors ในภาษา Java

บทความนี้เรามาทำความรู้จักกับ Constructors ในภาษา Java กันครับ ซึ่งใน Java นั้น
- ทุก ๆ class จะต้องมี constructor อย่างน้อย 1 constructor
- ถ้าเราไม่ได้เขียน constructor ใน Class แล้ว compiler จะสร้าง default constructor มาให้
- constructor นั้นจะใช้ในการสร้าง object
- constructor นั้นจะคล้าย ๆ กับ method ดังนั้นในบางครั้งก็จะเรียกว่า constructor method
- constructor นั้นจะไม่มีค่า return
- constructor จะต้องมีชื่อเดียวกับชื่อ Class
- constructor จะมีหรือไม่มี argument ก็ได้
- constructor สามารถใช้ในการกำหนดค่าเริ่มต้นให้กับ object ได้

Syntax ของ constructor

มาดู Syntax ของ constructor กันก่อนครับ ตามด้านล่างเลย

constructorName (listOfArguments) {
    [constructor body]
}

จาก Syntax เรามาดูโค้ดที่มี constructor กันหน่อย ตามโค้ดด้านล่างเลย

package info.doesystem.howto;

public class DoesystemInfo {
 
 // constructor
 DoesystemInfo(){
  // no return value
 }
 
 public static void main(String[] args) {
  DoesystemInfo doesystem = new DoesystemInfo();
 }
}

ถ้าเราต้องการหลาย ๆ constructor ก็สามารถเขียนได้ ดังนี้

package info.doesystem.howto;

public class DoesystemInfo {
 private int view;
 // constructor
 DoesystemInfo(){
  // no return value
  // set initial field
  this.view = 1;
 }
 
 DoesystemInfo(int view){
  // no return value
  // set initial field
  this.view = view;
 }
 
 public int getView() {
  return view;
 }

 public void setView(int view) {
  this.view = view;
 }

 public static void main(String[] args) {
  DoesystemInfo doesystem = new DoesystemInfo(11);
  System.out.println(doesystem.getView());
 }
}

ลำดับการ Run ของ Constructor

รู้มาแล้วว่าทุก ๆ Class จะมี Constructor อย่างน้อย 1 Constructor แล้วมีคำถามไหมว่า ถ้าเกิดมีการ Extends Class ขึ้นมา Constructor อันไหนจะ Run ก่อนกัน ดังนั้นลองเขียนโค้ดแล้วลองรันดูครับ

package info.doesystem.howto;

class Doesystem {
 public Doesystem() {
  System.out.println("Java Doesystem Constructor");
 }
}

public class DoesystemInfo extends Doesystem {
 public DoesystemInfo() {
  System.out.println("Java DoesystemInfo Constructor");
 }

 public static void main(String[] args) {
  DoesystemInfo doesystem = new DoesystemInfo();
 }
}

ผลลัพธ์จากการรันโค้ดที่ได้ คือ
Java Doesystem Constructor
Java DoesystemInfo Constructor

จากผลลัพธ์จะเห็นว่า Class แม่จะรัน constructor ก่อน จากนั้นจึงมารัน constructor ที่ Class ลูกต่อ

For Each Loop ในภาษา Java

บทความนี้เรามาดูวิธีการใช้ for-each กันครับ ซึ่ง for-each นั้นก็จะมีรูปแบบทั่ว ๆ ไป คือ

for(type itr-var : iterableObj) statement-block

จากรูปแบบโค้ดจะเห็นว่าเราได้วนลูปใน iterableObj ซึ่ง iterableObj นั้นจะต้องเป็น array หรือว่าเป็น Object ที่ implements the new Iterable interface ด้วย

ถ้าเราลองไปดูใน Eclipse ก็จะมีคำอธิบายและรูปแบบโค้ดสำหรับ for-each ไว้ ตามรูปด้านล่าง

ตัวอย่างโค้ดที่ใช้ for-each

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) throws InterruptedException {
  int nums[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

  for (int x : nums) {
   System.out.print(x);
   x = x * 10;
   System.out.print("[" + x + "] ");
  }

  System.out.println();

  for (int x : nums) {
   System.out.print(x + " ");
  }
 }
}

จากโค้ดจะเห็นว่าเราใช้ for-each ในการวนแต่ละตัวใน array มาดูอีกตัวอย่างเราใช้ enum มาวนโดยเรียก values() ซึ่งค่าที่ออกมาก็คือ array

package info.doesystem.howto;

public class DoesystemInfo {
 enum NamingOfTheDays {
  Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
 }

 public static void main(String[] args) throws InterruptedException {
  for (NamingOfTheDays name : NamingOfTheDays.values()) {
   System.out.println(name);
  }
 }
}

for-each ใน Arraylist

ต่อไปลองมาดูวิธีการ for-each ใน List กันดูบ้าง วิธีการก็ตามตัวอย่างด้านล่างเลย

package info.doesystem.howto;

import java.util.ArrayList;
import java.util.List;

public class DoesystemInfo {
 public static void main(String[] args) throws InterruptedException {
  List nameOfDay = new ArrayList<>();
  nameOfDay.add("Sunday");
  nameOfDay.add("Monday");
  nameOfDay.add("Tuesday");
  nameOfDay.add("Wednesday");
  nameOfDay.add("Thursday");
  nameOfDay.add("Friday");
  nameOfDay.add("Saturday");

  for (String name : nameOfDay) {
   System.out.println(name);
  }
 }
}

เมื่อเราลองเข้าไปดูใน ArrayList จะเห็นว่ามีการ implements List อยุ่ด้วย และใน List ก็จะ extends Collection ใน Collection ก็จะมีการ extends Iterable อยู่ด้วย ตามรูปด้านล่าง

ดังนั้น แสดงว่า Collection จะสามารถใช้ foreach ได้ทุก Collection เพราะได้ extends Iterable

java break กับ java continue

break statement

- break statement ใช้สำหรับในการหยุดบล็อกต่าง ๆ เช่น while, for, do-while หรือ switch statement
- เมื่อใช้คำสั่ง break จะเป็นการออกจากบล็อก โดยไม่ต้องทำงานส่วนที่เหลือ

continue statement

- continue statement จะเป็นการหยุดคำสั่งการทำซ้ำในปัจจุบันแล้วไปเริ่มต้นใหม่ หรือ iteration ถัดไป

break statement vs continue statement

เพื่อให้เข้าใจมากขึ้นเราจะยกตัวอย่าง โค้ดที่คล้าย ๆ กันระหว่าง break กับ continue ตามโค้ดด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) throws InterruptedException {
  int[] num = new int[] { 1, 2, 3, 4, 5 };
  
  for (int i : num) {
   if(i == 3){
    break;
   }
   System.out.println(i);
  }
  
  System.out.println("---");
  
  for (int i : num) {
   if(i == 3){
    continue;
   }
   System.out.println(i);
  }
 }
}

จากโค้ดข้างบนจะได้ผลลัพธ์ คือ
1
2
---
1
2
4
5

จากโค้ดและผลลัพธ์จะเห็นว่า การใช้ break นั้นจะเป็นการออกจาก loop เลย ส่วน continue นั้นจะเมื่อเจอคำสั่งจะหยุดการทำงานที่เหลือแล้วไปเริ่มต้นใหม่

Microsoft Word Shortcut Keys A ถึง Z

เรามาดู Shortcut Keys หรือคีย์ลัดในโปรแกรม Microsoft Word กันครับ เพื่อเวลาทำงานจะได้สะดวกและรวดเร็วยิ่งขึ้น คีย์ลัดที่ Microsoft Word มีมาให้มีอะไรบ้าง มาดูกัน

Ctrl + A: Select all
Ctrl + B: Bold
Ctrl + C: Copy
Ctrl + D: Font Formatting
Ctrl + E: Center Alignment
Ctrl + F: Find/Replace
Ctrl + G: Goto
Ctrl + H: Replace
Ctrl + I: Italics
Ctrl + J: Justified Alignment
Ctrl + K: Insert Hyperlink
Ctrl + L: Left Alignment
Ctrl + M: Indent
Ctrl + N: New document
Ctrl + O: Open a document
Ctrl + P: Print
Ctrl + Q: Paragraph Spacing
Ctrl + R: Right Alignment
Ctrl + S: Save current document
Ctrl + T: Hanging Indent
Ctrl + U: Underline
Ctrl + V: Paste
Ctrl + W: Close document
Ctrl + X: Cut
Ctrl + Y: Repeat
Ctrl + Z: Undo

จะเห็นว่าคีย์ลัดนี้เราใช้อยู่บ่อย ๆ กันเลยทีเดียว ช่วยให้การใช้งานและทำงานสะดวก รวดเร็ว และง่ายยิ่งขึ้น ถ้าใช้บ่อย ๆ จะช่วยได้มากทีเดียว

Autobox Unbox ในภาษา Java

Boxing คือการแปลงของค่า primitive ไปเป็นค่าของ wrapper instance เช่น แปลงค่าจาก int ไปเป็น Integer
Unboxing คือการแปลงค่าจาก wrapper instance ไปเป็นค่าของ primitive เช่น แปลงค่าจาก Integer ไปเป็น int

มาดูตัวอย่างโค้ดกันเลยครับ

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  Integer iOb = 100; // autobox an int

  int i = iOb; // auto-unbox

  System.out.println(i + " " + iOb);
 }
}

จากตัวอย่างโค้ดจะเห็นว่า Integer iOb = 100 จะเป็นการ autobox ซึ่งจะเป็นการแปลงค่าจาก int ไปเป็น Integer และจะเห็นว่า int i = iOb จะเป็นการ auto-unbox ซึ่งจะเป็นการแปลงค่าจาก Integer ไปเป็น int

การทำงานของ Autobox กับ Auto-Unbox

เรามาดูการทำงานของ Autobox กับ Auto-Unbox กันครับ ว่ามันทำงานยังไง มันใช้วิธีไหนในการแปลงค่า ซึ่งวิธีการดูนั้น เราจะดูจากไฟล์ .class ที่ได้ compile มาแล้ว เราจะใช้โปรแกรม Java Decompiler ในการดู ซึ่งผลลัพธ์ก็ออกมาดังนี้

จากรูปจะเห็นว่าในการ autobox นั้นจะทำการไปเรียก Integer.valueOf() และในการ auto-unbox นั้นจะไปเรียก iOb.intValue() ให้อัตโนมัติ

ข้อควรระวัง
จะเห็นว่าในการ auto-unbox นั้นจะมีการไปเรียก intValue() ซึ่งตรงนี้ถ้า iOb มีค่าเป็น null ละก็จะเกิด NullPointerException ขึ้นมาได้ ดังตัวอย่างโค้ด

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  Integer iOb = null;
  int i = iOb; // auto-unbox
 }
}

จากโค้ดจะเกิด Exception in thread "main" java.lang.NullPointerException ขึ้นมา เพราะว่ามีการ auto-unbox กับ Object ที่เป็น null ซึ่งจะไปเรียก intValue() ดังนั้นควรระวังไว้ให้ดี

ย่อรูปง่าย ๆ ด้วย Photoshop หรือ Paint

บทความนี้เรามาดูวิธีการย่อขนาดรูปง่าย ๆ โดยใช้โปรแกรม Photoshop กับโปรแกรม Paint กันครับ ซึ่งการย่อขนาดโดย Photoshop นั้นจะมีตัวเลือกที่เยอะกว่า แต่สำหรับคนที่ในเครื่องไม่มีโปรแกรม Photoshop ก็สามารถย่อขนาดได้โดยใช้โปรแกรม Paint ดังนั้นจึงได้แนะนำทั้งสองวิธีกันเลย

ย่อขนาดรูปด้วยโปรแกรม Paint

ในการย่อขนาดรูปด้วยโปรแกรม Paint นั้น เริ่มจากเปิดโปรแกรม Pain และรูปที่ต้องการขึ้นมาก่อน จากนั้นให้กดที่ Resize จะปรากฏ Dialog Resize and Skew ขึ้นมา ในส่วนของ Resize ให้ใส่ค่าที่ต้องการลงไป เราสามารถเลือกได้ว่าจะปรับขนาดเป็น percent หรือจะเป็น pixel ก็ได้ ตามรูปด้านล่าง

เมื่อได้แล้วก็กด OK ไปได้เลย

ย่อขนาดรูปด้วยโปรแกรม Photoshop

วิธีในการปรับขนาดรูปด้วยโปรแกรม Photoshop นั้น ให้เปิดโปรแกรม Photoshop กับรูปที่ต้องการปรับขนาดขึ้นมาก่อน จากนั้นให้ไปที่ Image แล้วเลือก Image Size ตามรูปด้านล่าง

เมื่อได้แล้วจะปรากฏ Dialog ขึ้นมา เราสามารถปรับขนาดรูปได้ โดยกรอกขนาดที่ต้องการลงไป ในการปรับขนาดนั้นเราสามารถเลือกปรับได้หลากหลายรูปแบบ ตามรูปด้านล่าง

เมื่อได้ขนาดที่ต้องการแล้วก็ทำการกด Ok ไปได้เลย

เพียงแค่นี้เราก็สามารถปรับขนาดรูปได้ตามต้องการแล้ว ใครถนัดหรือชอบวิธีไหนก็เลือกได้ตามใจชอบเลย

for Statement ในภาษา Java

บทความนี้เรามาดูวิธีการใช้คำสั่ง for ในภาษา Java กันดูครับ ซึ่งคำสั่ง for ก็เหมือนกับคำสั่ง while เป็นคำสั่งในใช้ในการทำงานแบบซ้ำ ๆ หรือเป็น loop แต่มี syntax ที่แตกต่างออกไปนิดหน่อย มาดู Syntax ของ for กันครับ

for (init ; booleanExpression ; update){
    statement (s)
}

จาก Syntax ของ for จะเห็นว่ามีส่วนที่สำคัญอยู่ 3 ส่วน นั่นคือ
- init เป็นสิ่งที่เริ่มต้นก่อนจะทำการ loop ใน for จะทำครั้งแรกและครั้งเดียว
- booleanExpression เป็น boolean ที่บอกว่าให้ทำงานต่อหรือจะหยุด ถ้าเป็น true จะทำงานในบล็อกต่อ
- update เป็น statement ที่จะทำงานหลังจากการทำงานในบล็อกเสร็จแล้ว จะทำทุกครั้งหลังจากจบบล็อก หรือ loop หนึ่ง ๆ

ในคำสั่ง for statement ของ init, booleanExpression และ update จะเป็นแค่ตัวเลือก นั่นคือ เราสามารถใส่ก็ได้ไม่ใส่ก็ได้ ดังตัวอย่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) throws InterruptedException {
  for (;;) {
   System.out.println("0");
  }
 }
}

จากตัวอย่างเราไม่ได้ใส่ statement ทั้ง init, booleanExpression และ update เลย เมื่อลองรันดูจะพบว่าโปรแกรมจะวนลูปแบบไม่รู้จบ

การหยุด loop ของ for ในภาษา java มีหลายวิธี เช่น
- ใช้คำสั่ง break;
- ทำให้ booleanExpression เป็น false
- Runtime error

for VS while

เราสามารถเขียน for แบบ while ได้ ดังตัวอย่าง

while (expression) {
 ...
}

for ( ; expression; ) {
 ...
}

จากโค้ดจะเห็นว่าเราสามารถเขียน for เลียนแบบ while ได้ โดยละเว้นการ init กับ update ก็จะเหลือเพียง expression

ตัวอย่างการใช้คำสั่ง for

เรามาดูคำสั่ง for ในรูปแบบที่ใช้ทั่ว ๆ ไปกันดีกว่าครับ ดังตัวอย่าง

package info.doesystem.howto;

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

define two variables in for loop

จาก Syntax จะเห็นว่า แต่ละส่วนนั้นเป็น statement ดังนั้นเราสามารถกำหนดหลาย ๆ ตัวแปรหรือหลาย ๆ statement ได้ ดังตัวอย่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) throws InterruptedException {
  for (int i = 1, j = 10; i <= 10; i++, j--) {
   System.out.println(i + " x " + j + " = " + (i * j));
  }
 }
}

สำหรับ for ในภาษา java เราก็ขอพักแค่นี้ก่อน หวังว่าจะมีประโยชน์สำหรับหลาย ๆ คนนะคับ

do-while Statement ในภาษา Java

สวัสดีครับ บทความนี้เรามาทำความรู้จัก และลองใช้คำสั่ง do-while ในภาษา java กันดูครับ ซึ่งคำสั่ง do-while จะเป็นคำสั่งเหมือน while แต่จะแตกต่างกันที่ จะทำก่อนแล้วเช็คทีหลัง มาดู Syntax กันก่อนครับ จะได้เข้าใจยิ่งขึ้น

do {
 statement(s)
} while (booleanExpression);

เมื่อเห็น Syntax แล้วจะเห็นว่า คล้าย ๆ กับ while แต่ do-while จะทำบางอย่างก่อน แล้วค่อยมาเช็ค ดังนั้นแสดงว่า โปรแกรมจะเข้า statement อย่างน้อยหนึ่งครั้งก่อนเสมอ มาลองดูตัวอย่างโปรแกรมกันดีกว่า

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) throws InterruptedException {
  int i = 0;
  do {
   System.out.println(i);
   i++;
  } while (i < 3);
 }
}

จากโค้ด ผลลัพธ์ที่ได้ คือ
0
1
2

do-while จะทำในบล็อกก่อน อย่างน้อย 1 ครั้งเสมอ นั่นคือเราประกาศ int i = 0; ในบล็อกก็จะแสดงค่า i แล้วเพิ่ม i ขึ้น 1 ค่า แล้วค่อยมาตรวจสอบ

สำหรับ do-while ก็ขอจบแค่นี้ก่อนนะคับ ลองไปเล่น ลองเขียนดูครับ

while loop ในภาษา Java

บทความนี้เรามาดู while loop ในภาษา Java กันครับ ว่ามันใช้ยังไงและข้อควรระวังอะไรบ้าง มาดู Syntax กันก่อน ตามด้านล่าง

while (booleanExpression) {
    statement (s)
}

จาก Syntax เราสามารถเขียนโค้ดตัวอย่างง่าย ๆ โดยการใช้ while loop ได้ดังตัวอย่าง

package info.doesystem.howto;

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

จากโค้ดตัวอย่าง จะเห็นว่าเราจะมี condition คือ i น้อยกว่า 3 ซึ่งถ้าเป็นจริงจะทำงานใน loop จนกว่าจะเป็นเท็จ ถึงจะออกจาก loop

ตัวอย่างโปรแกรมง่าย ๆ โดยการใช้ while

เพื่อความเข้าใจที่มากขึ้น ลองมาดูตัวอย่างโปรแกรม ที่แสดงเข็มวินาทีของนาฬิกาดูครับ ซึ่งเขียนได้ง่าย ๆ ดังนี้

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) throws InterruptedException {
  int i = 0;
  while (true) {
   System.out.println(i);
   Thread.sleep(1000);
   i++;
   if(i == 60){
    i = 0;
   }
  }
 }
}

จากโค้ดเราจะใช้ while แล้วใส่ condition เป็น true เพื่อให้ผ่านตลอด จากนั้นก็ทำการหลับ(sleep) เป็นเวลา 1000 ms ซึ่งก็คือ 1 วินาที แล้วก็แสดงค่า i

จากโค้ดจะเห็นว่า loop while ที่เราเขียนขึ้นนั้น ไม่มีที่สิ้นสุด

แค่นี้เราก็ได้รู้จัก while loop ในภาษา Java กันมาเยอะแล้ว งั้นพักเบรก while loop กันแค่นี้ก่อนดีกว่า สวัสดีครับ แล้วเจอกันใหม่

switch Statement ในภาษา Java

บทความนี้เรามาดูวิธีการใช้คำสั่ง switch ในภาษา Java กันครับ คำสั่ง switch ก็เป็นคำสั่งประเภทเงื่อนไขเหมือนกับ if นั่นแหละ เรามาดู Syntax สำหรับคำสั่ง switch กันครับ ตามด้านล่างเลย

switch (expression) {
case value_1 :
     statement (s);
     break;
case value_2 :
     statement (s);
     break;
case value_n :
     statement (s);
     break;
default:
     statement (s);
}

จาก Syntax ของ switch เรามาดูตัวอย่างโค้ดที่ใช้ switch แบบง่าย ๆ กันตามด้านล่างเลย

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  int i = 1;
  switch (i) {
  case 1:
   System.out.println("One.");
   break;
  case 2:
   System.out.println("Two.");
   break;
  case 3:
   System.out.println("Three.");
   break;
  default:
   System.out.println("Default value.");
  }
 }
}

จากโค้ดตัวอย่างและ Syntax เราจะใช้ i เทียบกับ case ต่าง ๆ และมีสิ่งที่น่าสนใจคือ break

break ใน switch นั้น ถ้าเราไม่ใส่ก็ไม่เกิด Error จะ compile ได้ตามปกติ แต่ว่า ควรระวังไว้ให้ดีเพราะถ้าหากเราไม่ใส่ break โปรแกรมจะทำการรันบล็อกของ case ต่อไป ตัวอย่างโค้ด switch แบบไม่มี break

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  int i = 0;

  switch (i) {
  case 0:
   System.out.println("i is 0");
  case 1:
   System.out.println("i is 1");
  case 2:
   System.out.println("i is 2");
  default:
   System.out.println("Free flowing switch example!");
  }
 }
}

ผลลัพธ์ที่ได้จากการรันโค้ดข้างบน คือ
i is 0
i is 1
i is 2
Free flowing switch example!

จะเห็นว่าเมื่อเข้า case แรก คือ case 0: แล้ว จะทำการรันโค้ดในบล็อกนี้ เมื่อไม่มี break ก็จะรันในบล็อกต่อไปด้วย

เพียงแค่นี้เราก็ได้รู้ Syntax ตัวอย่างโค้ด และวิธีการใช้งานแล้ว ก็ขอจบเพียงแค่นี้คับสำหรับ switch ในภาษา Java หวังว่าจะมีประโยชน์สำหรับหลาย ๆ คน

If Statement ในภาษา Java

บทความนี้เรามาดูวิธีการใช้ if Statement ในภาษา Java กันครับ

คำสั่ง if ในภาษา java เป็นคำสั่งประเภทเงื่อนไข เช่น ถ้าเป็นยังงั้น ให้ทำอย่างงี้ ถ้าไม่ใช่ให้ทำอย่างงี้ อะไรประมาณนี้ เรามาดู Syntax กันก่อน ตามโค้ดด้านล่าง

if (booleanExpression) {
    statement (s)
}

หรือ

if (booleanExpression) {
    statement (s)
} else {
    statement (s)
}

จาก Syntax จะเป็นว่า if นั้นเขียนได้หลายแบบ หลายเงื่อนไข ตามต้องการ ตัวอย่างโค้ดที่ใช้ if

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  int a = 5;
  
  // if
  if(a == 2){
   // statement
  }
  
  // if else
  if(a == 4){
   // statement
  }
  else{
   // statement
  }
  
  // if else if
  if(a == 1){
   // statement
  }
  else if(a == 2){
   // statement
  }
  else{
   // statement
  }
 }
}

ใช้ if หลาย ๆ เงื่อนไข

จาก Syntax เราจะเห็นว่าเราสามารถใช้ if ได้หลาย ๆ เงื่อนไข ดังตัวอย่าง

ตัวอย่าง ให้แสดงคำว่า Win เมื่อ a = 0 หรือ a = 100

จากโจทย์ จะเห็นว่ามีเงื่อนไขอยู่สองตัว นั่นคือ a = 0 และ a = 100

ตัวอย่างการแก้โจทย์วิธีแรก โดยใช้ if ซ้อน if

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  int a = 1;
  
  if(a == 0){
   if(a == 10){
    System.out.println("Win");
   }
  }
 }
}

วิธีนี้เราจะทำการ เช็ค a = 0 ก่อน จากนั้นก็มาเช็ค a = 10 แล้วค่อยแสดงคำว่า Win

ตัวอย่างการแก้โจทย์วิธีที่สอง โดยใช้ or มาคั่นกลาง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  int a = 1;
  
  if(a == 0 || a == 10){
   System.out.println("Win");
  }
 }
}

วิธีนี้จะเป็นการลดรูป โดยการใช้ or เข้ามาช่วยในเงื่อนไข

เพียงแค่นี้เราก็ได้รู้จัก ได้ใช้งาน และได้ดูตัวอย่างการใช้ if ในภาษา Java กันแล้ว

World Trigger เรื่องย่อ

เมืองมิกะโดชิ มีจำนวนประชากรประมาร 280,000 คน มีอยู่วันหนึ่งประตูสู่โลกคู่ขนานก็ได้ปรากฎขึ้นมาอย่างกระทันหัน เนเวอร์ ผู้รุกรานจากอีกฟากของประตูได้บุกรุกเข้ามา เมืองแห่งนี้ตกอยู่ในความหวาดกลัว เทคโนโลยีของอีกโลกหนึ่งเหนือชั้นกว่าอาวุธชีวภาพของโลกนี้มาก ไม่ว่าใครก็เชื่อว่านี่เป็นช่วงเวลาแห่งการล่มสลาย

ในตอนนั้นเอง ได้มีกลุ่มลึกลับปรากฎตัวออกมาจัดการพวกเนเบอร์จนหมดสิ้น และนับจากวันนั้นเป็นต้นมา พวกเขาศึกษาเทคโนโลยีที่ก้าวหน้าของเนเบอร์ ก่อตั้งองค์กรที่คอยปกป้องโลกใบนี้เพื่อสู้กับพวกมัน หน่วยงานป้องกันภัย บอเดอร์ พวกเขาได้สร้างฐานทัพที่ใหญ่โตภายในเวลาไม่นาน และเตรียมพร้อมป้องกันในขณะที่เนเบอร์บุกเข้ามา

หลังจากนั้น 4 ปี ประตูนั้นก็ยังเปิดและมีพวกเนเบอร์เข้ามาเหมือนเดิม ประชากรในเมืองมิกะโดชิ ส่วนใหญ่เลือกที่จะอยู่เดิม อาจเป็นเพราะพวกเขาเชื่อใน บอเดอร์ หรือไม่ก็ชินกับระเบิดและแสงวาบนี้แล้วก็เป็นได้ จนแทบไม่ทำให้คนในเมืองกังวลเลย

PHP ดึง url รูปแล้วนำมาแสดง เปลี่ยน url ของรูป

ไม่รู้จะเขียนหัวข้อบทความว่าอะไร เอาเป็นว่า PHP ดึง url ของรูป แล้วนำรูปมาแสดง หรือจะบอกว่าเปลี่ยน url ของรูปก็ได้มั้ง

ความเป็นมา

เนื่องจาก ต้องการจะนำรูปภาพ ซึ่งมี Url อยู่ใน Google Photo ดังตัวอย่าง url ของรูปคือ https://lh3.googleusercontent.com/cAWsvkUoH0-wRyuWqvJf9tg0btLtsHN_Uo_T6FgeBG2gYSXMTw มาแสดง แต่ว่า ก็มีหลายเหตุผลที่ไม่อยากแสดง Url ตรง ๆ เช่น ไม่อยากให้ใครรู้ Url รูปภาพที่แท้จริง หรือต้องการจะให้รูปภาพเป็น Url ที่มีความหมาย หรือเหตุผลอื่น ๆ

ตัวอย่างวิธีการแก้ปัญหา ก็คือให้ใช้ mod_rewrite เพื่อเปลี่ยน Url ที่ต้องการ จากนั้นก็ใช้ PHP ดึงค่า Url ของรูปภาพ แล้วก็ส่งรูปภาพนั้นกลับไปใน Url ที่ต้องการ

ในการใช้ PHP นั้น ใช้คำสั่ง

echo file_get_contents($decode);

เพียงแค่นี้เราก็ดึง Url ของรูปจากนั้นก็ส่งกลับไปได้เลย

Short ในภาษา Java

Short ในภาษา Java นั้นเป็นการเก็บข้อมูลชนิดตัวเลข ซึ่งมีค่าอยู่ระหว่าง –32,768 ถึง 32,767 ซึ่งในการหาค่าต่ำสุดและค่าสูงสุดของ Short นั้นหาได้จากตัวอย่างโค้ด

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  System.out.println(Short.MIN_VALUE);
  System.out.println(Short.MAX_VALUE);
 }
}

Cast to short

ในการบวกกันของ short นั้น ผลลัพธ์จะออกมาเป็น int ดังนั้นถ้าเราต้องการที่จะได้ short เราจะต้อง cast กลับมาเป็น short ดังตัวอย่างโค้ดด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  short a, b, c;
     c = 2;
     b = 9;
     a = (short) (b + c);
     System.out.println("a is " + a);
 }
}

Convert String to Short

ในการแปลง String ไปเป็น Short นั้นเราสามารถทำได้หลายวิธี ดังตัวอย่างโค้ด

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  Short sObj1 = new Short("100");
  System.out.println(sObj1);
  
  String str = "100";
  
  Short sObj2 = Short.valueOf(str);
  System.out.println(sObj2);
  
  Short sObj3 = new Short(str);
  System.out.println(sObj3);
 }
}

Douluo Dalu ระดับพลัง ระดับสปิริต และวงแหวนพลัง

เรามาดูชื่อและระดับพลังของผู้ใช้สปิริตกันครับ ซึ่งมีทั้งหมด 10 ระดับ คือ

Level 1-10 ผู้ใช้สปิริตฝึกหัด

Level 11-20 สปิริตมาสเตอร์

Level 21-30 แกรนด์สปิริตมาสเตอร์

Level 31-40 เอกเพิร์ทสปิริตมาสเตอร์

Level 41-50 สปิริตลีดเดอร์

Level 51-60 สปิริตลอร์ด

Level 61-70 สปิริตคิง

Level 71-80 สปิริตเซนต์

Level 81-90 สปิริตต้าหลัว

Level 91-99 ทอปนอชต้าหลัว

ในทุก ๆ 10 เลเวลของแต่ละขั้นเมื่อผู้ใช้วิญญาณมีเลเวลเต็มขั้น จะต้องดูดกลืนวงแหวนเพื่อเลื่อนไปขั้นต่อไป ถ้าไม่ทำก็ไม่สามารถเพิ่มเลเวลต่อได้ และถ้าเลเวลไม่เต็มก็จะยังดูดกลืนวงแหวนไม่ได้

สีของวงแหวนพลัง

สีของวงแหวนพลังจะแสดงถึงระดับพลังของสัตว์วิญญาณ แบ่งออกเป็น 5 ระดับ

สัตว์วิญญาณ 10 ปี จะมีวงแหวนวิญญาณเป็นสีขาว

สัตว์วิญญาณ 100 ปี จะมีวงแหวนวิญญาณเป็นสีเหลือง

สัตว์วิญญาณ 1,000 ปี จะมีวงแหวนวิญญาณเป็นสีม่วง

สัตว์วิญญาณ 10,000 ปี จะมีวงแหวนวิญญาณเป็นสีดำ

สัตว์วิญญาณ 100,000 ปี จะมีวงแหวนวิญญาณเป็นสีแดง

ระดับวงแหวนวิญญาณที่ดูดกลืนจะต้องสัมพันธ์กับระดับพลังด้วย ถ้าวงแหวนวิญญาณมีพลังมากเกินไป จะเป็นอันตราย

วงแหวนวิญญาณนอกจากจะเพิ่มระดับพลังวิญญาณให้แล้ว ก็ยังมีสิ่งสำคัญที่มากับมันด้วย นั่นคือ ทักษะวิญญาณ ถ้าวงแหวนวิญญาณเข้ากันได้ดีกับสปิริตก็จะได้รับทักษะวิญญาณที่เหมาะสมด้วย

ดังนั้น ในการเลือกวงแหวนวิญญาณเพื่อที่จะดูดกลืนวงแหวนวิญญาณ ต้องคำนึงถึงเลเวลของผู้ใช้กับสีของวงแหวนวิญญาณที่สัมพันธ์กับอายุสัตว์วิญญาณ และสปิริตที่มีกับทักษะที่จะได้รับจากวงแหวนวิญญาณอีกด้วย

Douluo Dalu เรื่องย่อ

การ์ตูน Douluo Dalu นั้นจะเป็นการ์ตูนของทางจีน ซึ่งก็มีจุดเด่นตรงวรยุทธ์ที่จะก้าวหน้าและแข็งแกร่งได้จากการฝึก ๆ ๆ แล้วก็ฝึก ซึ่งเรื่องย่อนั้นก็ประมาณนี้

ณ ดินแดนแห่งหนึ่ง นิกายถังซึ่งมีวิชาลับของนิยายอยู่ซึ่งอยู่ในคำภีร์สรวงสวรรค์ชั้นฟ้า ถังซาน ผู้หลงไหลในวิชาได้แอบเข้าพื้นที่ต้องห้าม ซ้ำยังลอบศึกษาวิชาลับของนิกาย โทษนั้นคือ ความตาย ซึ่งถังซานเพื่อที่จะได้เรียนรู้สิ่งที่อยู่ในคำภีร์ ไม่เคยเสียใจกับสิ่งที่ทำ และเพื่อเป็นการตอบแทนบุญคุณของนิกายถัง ถังซานได้กระโดดหน้าผา เพื่อฆ่าตัวตาย และหวังว่าหากเกิดชาติหน้าคงมีชีวิตที่เต็มไปด้วยความสุข

ถังซานลืมตาขึ้นมาพร้อมกับโลกใบใหม่ โลกนี้มีนามว่า ทวีปแห่งการต่อสู้ และพบว่าตัวเองเป็นเด็กน้อย จึงได้รู้ว่าตัวเองเกิดมาในโลกใบใหม่ ในโลกใบใหม่นี้ถังซานได้เกิดในตระกูลถังและถูกตั้งชื่อตามมารดาที่เสียชีวิตไปดังนั้นจึงได้ชื่อว่า ถังซานตามเดิม และถังซานได้นำสิ่งที่หาค่าไม่ได้ติดตัวมาด้วย นั่นก็คือ ความทรงจำของชาติก่อนวรยุทธนิกายถัง

ในโลกใบใหม่นี้มีสิ่งที่ทุกคนเรียกมันว่า พลังวิญญาณ และก็มีสปิริตที่หลับไหลอยู่ในตัวของแต่ละคน ถังซานจะมีสปิริตแบบไหน ถังซานจะนำความทรงจำและวรยุทธของนิกายถังมาใช้ได้ในโลกใบใหม่นี้ได้มากน้อยเพียงใด ชีวิตเค้าจะเป็นยังไง ติดตามกันได้กับการ์ตูนเรื่อง Douluo Dalu รับรองสนุกและมันแน่ ๆ

Byte ใน Java

บทความนี้เรามาทำความรู้จักกับ Byte ในภาษา Java กันครับ ว่าคืออะไร และใช้ยังไง

Byte เป็นตัวเลขในภาษา Java ที่เก็บและมีขนาดน้อยที่สุด มีเพียง 8 bit ซึ่งมีค่าอยู่ระหว่าง -128 ถึง 127

ตัวอย่างการใช้ Byte ในภาษา Java แบบง่าย ๆ ตามโค้ดด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  byte b1 = 100;
  byte b2 = 20;
  System.out.println("b1 is : " + b1);
  System.out.println("b1 is : " + b2);
 }
}

Convert byte to String

มาดูตัวอย่างการแปลง byte เป็น String กันดูบ้าง ซึ่งก็มีหลาย ๆ วิธีด้วยกัน ดังตัวอย่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  byte b = 65;
  
  // Using the static toString method of the Byte class
  String sol1 = Byte.toString(b);
  
  // Using simple concatenation with an empty String
  String sol2 = b + "";
  
  // Creating a byte array and passing it to the String constructor
  String sol3 = new String(new byte[] {b});
 }
}

convert byte primitive type to Byte object

ต่อไปลองมาดูการแปลงค่าจาก byte primitive type ไปเป็น Byte Object ตามตัวอย่างโค้ด

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  byte i = 10;

  Byte bObj = new Byte(i);
 }
}

การ Convert Byte ไปเป็น Primitive ที่เป็นชนิดตัวเลข

Byte จัดอยู่ในกลุ่มตัวเลข ดังนั้นเราสามารถแปลง Byte ไปเป็น Primitive Type ที่เป็นตัวเลขได้ ตามตัวอย่างโค้ด

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  Byte bObj = new Byte("10");
  
  // convert to byte
  byte b = bObj.byteValue();
  System.out.println(b);
  
  // convert to short
  short s = bObj.shortValue();
  System.out.println(s);
  
  // convert to int
  int i = bObj.intValue();
  System.out.println(i);
  
  // convert to float
  float f = bObj.floatValue();
  System.out.println(f);
  
  // convert to double
  double d = bObj.doubleValue();
  System.out.println(d);
  
  // convert to long
  long l = bObj.longValue();
  System.out.println(l);
 }
}

ตัวอย่าง Output ที่ได้

10
10
10
10.0
10.0
10

Hinomaru Zumou เรื่องย่อ

ซูโม่ เป็นศิลปะการต่อสู้ของญี่ปุ่นที่มาตั้งแต่โบราณ โดยผู้เข้าต่อสู้จะต้องสวม มาวาชิ(ผ้านุ่งซูโม่) และสู้กันบนโดโยะ(สนามซูโม่)

ซูโม่ ถือว่าเป็นกีฬาชนิดหนึ่งที่ ไม่จำกัดอายุ สำหรับผู้ที่เข้าต่อสู้

ดังนั้น คนที่มีรูปร่าง ใหญ่ และ หนัก จึงได้เปรียบ และโนโลกของซูโม่นั้นเราจะพบเห็นผู้เข้าต่อสู้ที่มีน้ำหนักมากกว่า 100 กิโลเป็นเรื่องปกติ และผู้ที่จะก้าวไปสู่ตำแหน่ง โยโกสุนะ ซึ่งเป็นตำแหน่งสูงสุดที่ทุกคนต้องการ

อุชิโอะ ฮิโนะมารุ เด็กชายตัวเล็กที่รักและชื่นชอบในกีฬา ซูโม่ จึงต้องการและคาดหวังตำแหน่ง โยโกสุนะ ที่เป็นตำแหน่งสูงสุดของซูโม่ แต่ว่าก็มีอุปสรรคต่าง ๆ ขวางอยู่ ซึ่งอุปสรรคที่สำคัญของเขาก็คือ ขนาดตัวของเขาที่เล็กกว่าปกติ ทำให้เป็นปัญหาในการเล่นซูโม่อย่างมาก เค้าจะฝ่าฟันอุปสรรคไปได้อย่างไร ติดตามอ่านกันได้ที่ Hinomaru Zumou เรื่องราวของเด็กหนุ่มผู้รักซูโม่ ติดตามเรื่องราวของโลกซูโม่กันได้เลย รับรองมันแน่ ๆ

Boolean ใน Java

บทความนี้เรามาทำความรู้จักกับ Boolean ในภาษา Java กันครับ ว่าคืออะไร และใช้ยังไง

Boolean ที่เรากล่าวถึงจะอยู่ใน java.lang.Boolean ซึ่งเป็นตัว Wrapper Class ของ boolean ที่เป็น Primitive Type

เราสามารถสร้าง Bolean Object ได้จาก boolean หรือจาก String ก็ได้ ถ้าเราไปดูใน constructor ของ Boolean จะเห็นว่ารับได้ทั้ง boolean และก็ String ตามรูปด้านล่าง

ถ้าเราเขียนโค้ดก็จะได้ดังตัวอย่างด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  Boolean b1 = new Boolean(false);
  Boolean b2 = new Boolean("true");
 }
}

การ convert Boolean เป็น boolean

เราสามารถสร้าง Boolean Object ได้จาก boolean ในทำนองเดียวกัน เราก็สามารถแปลง Boolean ไปเป็น boolean ได้เหมือนกัน ตามตัวอย่างโค้ดด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  Boolean b1 = new Boolean(false);
  Boolean b2 = new Boolean("true");

  boolean bool1 = b1.booleanValue();
  boolean bool2 = b2.booleanValue();
 }
}

การแปลง boolean เป็น Boolean โดยใช้ valueOf

จากข้างบนจะเห็นว่าเราสามารถแปลง boolean เป็น Boolean ได้โดยการ new แต่ก็ยังมีวิธีการแปลง boolean เป็น Boolean ได้โดยใช้ method valueOf ตามตัวอย่างโค้ดด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  Boolean b1 = Boolean.valueOf(false);
  Boolean b2 = Boolean.valueOf("true");
 }
}

การแปลง String เป็น boolean

จากหลาย ๆ ตัวอย่างที่ผ่านมาเราได้แปลง String เป็น Boolean ซึ่งเป็น Object กันไปแล้ว เรามาดูวิธีการแปลง String เป็น boolean ที่เป็น primitive type กันดูบ้างครับ ตามตัวอย่างด้านล่าง

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  String strBoolean = "true";

  // String to boolean conversion
  boolean theValue = Boolean.parseBoolean(strBoolean);

  System.out.println(theValue);
 }
}

จากโค้ดตัวอย่างด้านบน ในการแปลง String เป็น boolean ที่เป็น primitive type นั้น เราได้ใช้ method parseBoolean ที่อยู่ใน Class Boolean ในการแปลง เรามาลองสังเกตุ Class Boolean นี้ซักหน่อยตามรูปด้านล่าง

ตามรูปจะเห็นว่าในการแปลง String เป็น Boolean นั้นโดยผ่าน constructor หรือ valueOf ก็ต้องผ่าน parseBoolean เช่นเดียวกัน

การใส่ค่าตัวแปร args method main ใน Eclipse

ถ้าเราลองสังเกตุดี ๆ จะเห็นว่า method main ในภาษา Java นั้นจะมีการรับพารามิเตอร์ที่เป็น array ที่ส่วนมากจะตั้งชื่อว่า args อยู่ เราสามารถส่งค่าเข้าไปได้ ดังนั้นบทความนี้เราจะมาดูวิธีการส่งค่าไปให้กับตัวแปร args โดยใช้ Eclipse กันครับ

เริ่มด้วยสร้าง Method main จากนั้นก็ให้คลิกขวาเลือก Run As แล้วก็เลือก Run Configurations... ตามรูปด้านล่าง

จะปรากฎหน้าต่าง Run Configurations ขึ้นมา ให้เราเลือก Class จากด้านซ้าย ซึ่งจะเป็น Default จากที่เราเปิด แล้วมาในแถบของ Arguments ให้เราใส่ค่าลงในช่อง Program arguments ตามรูปด้านล่าง

จากนั้นให้เราลองกด Run ดูผลลัพธ์ก็จะออกมาประมาณนี้

จากผลลัพธ์จะเห็นว่าเราสามารถใส่ค่าให้กับตัวแปร args ได้ การเว้นบรรทัดเป็นการบอกว่าคือตัวใหม่

แค่นี้เราก็ได้วิธีใส่ค่าให้กับตัวแปร args ได้แล้ว

ค่า MAX กับค่า MIN ของ Primitive Type

เรามาดูค่า MAX กับค่า MIN ของ Primitive Type กันครับ ซึ่งก็รู็กันอยู่แล้วว่าค่า Primitive Type นั้นมีอยู๋ด้วยกัน 8 ชนิด ซึ่งแต่ละชนิดก็มีขนาดที่ต่างกันไป เรามาดูค่าที่เป็นไปได้ของแต่ละชนิดกัน

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  System.out.println("Byte.MIN = " + Byte.MIN_VALUE);
  System.out.println("Byte.MAX = " + Byte.MAX_VALUE);
  System.out.println("Short.MIN = " + Short.MIN_VALUE);
  System.out.println("Short.MAX = " + Short.MAX_VALUE);
  System.out.println("Integer.MIN = " + Integer.MIN_VALUE);
  System.out.println("Integer.MAX = " + Integer.MAX_VALUE);
  System.out.println("Long.MIN = " + Long.MIN_VALUE);
  System.out.println("Long.MAX = " + Long.MAX_VALUE);
  System.out.println("Float.MIN = " + Float.MIN_VALUE);
  System.out.println("Float.MAX = " + Float.MAX_VALUE);
  System.out.println("Double.MIN = " + Double.MIN_VALUE);
  System.out.println("Double.MAX = " + Double.MAX_VALUE);
 }
}

จากโค้ดจะเป็นการแสดงค่าต่ำสุดกับค่าสูงสุดใน Primitive Type แต่ละชนิด ซึ่งใน Wrapper Class ก็จะมี Constant อยู่ เมื่อรันโค้ดด้านบนแล้วเราก็จะได้คำตอบดังด้านล่าง

Byte.MIN = -128
Byte.MAX = 127
Short.MIN = -32768
Short.MAX = 32767
Integer.MIN = -2147483648
Integer.MAX = 2147483647
Long.MIN = -9223372036854775808
Long.MAX = 9223372036854775807
Float.MIN = 1.4E-45
Float.MAX = 3.4028235E38
Double.MIN = 4.9E-324
Double.MAX = 1.7976931348623157E308

การ Wrapping Primitive ใน Wrapper Object

เรามาดูตัวอย่างโค้ดการแปลง Primitive Type มาเป็น Wrapper class กันครับ เรามาดูคู่ Primitive Type กับ Wrapper Class กันก่อน

Primitive Type	Wrapper class
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

ตัวอย่างโค้ดการ Wrapping

package info.doesystem.howto;

public class DoesystemInfo {
 public static void main(String[] args) {
  // wrapping boolean
  Boolean refBoolean = new Boolean(true);
  boolean priBool = refBoolean.booleanValue();

  // wrapping byte
  Byte refByte = new Byte((byte) 123);
  byte priByte = refByte.byteValue();

  // wrapping character
  Character refChar = new Character('x');
  char priChar = refChar.charValue();

  // wrapping short
  Short refShort = new Short((short) 123);
  short priShort = refShort.shortValue();

  // wrapping integer
  Integer refInt = new Integer(123);
  int priInt = refInt.intValue();

  // wrapping long
  Long refLong = new Long(123L);
  long priLong = refLong.longValue();

  // wrapping Float
  Float refFloat = new Float(12.3F);
  float priFloat = refFloat.floatValue();

  // wrapping Double
  Double refDouble = new Double(12.3D);
  double priDouble = refDouble.doubleValue();
 }
}

จากโค้ดจะสังเกตุเห็นว่าในการสร้าง Wrapper Class จะมี constructor ที่รับพารามิเตอร์ Primitive Type นั้น ๆ อยู่

ขนาดและค่าเริ่มต้นของ Primitive Types ในภาษา Java

ในภาษา Java นั้นจะมีข้อมูลที่เรียกว่า primitive type อยู่ ซึ่งมีอยู่ด้วยกัน 8 ชนิด คือ byte, short, int, long, char, float, double และ boolean

ถ้าเราจะจัดกลุ่มของ primitive type เราสามารถแบ่งออกได้เป็น 4 กลุ่ม คือ
1. Integers ประกอบด้วย byte, short, int และ long
2. Floating-point numbers ประกอบไปด้วย float และ double
3. Characters ประกอบไปด้วย char
4. Boolean ประกอบด้วย boolean

ขนาดของ primitive type

int A 32-bit (4-byte) integer value
short A 16-bit (2-byte) integer value
long A 64-bit (8-byte) integer value
byte An 8-bit (1-byte) integer value
float A 32-bit (4-byte) floating-point value
double A 64-bit (8-byte) floating-point value
char A 16-bit character using the Unicode encoding scheme
boolean A true or false value

ค่าเริ่มต้นของ primitive type

boolean false
byte 0
short 0
int 0
long 0L
char \u0000
float 0.0f
double 0.0d

ค่าคงที่ constant ในภาษา Java

บทความนี้เรามาดูการประกาศค่าคงที่ หลักการในการประกาศค่าคงที่ กฎต่าง ๆ สิ่งที่ควรทำ และตัวอย่างการใช้งานค่าคงที่กันครับ

ในการกระกาศค่าคงที่นั้นจะมีแบบแผนในการประกาศอยู่ ซึ่งเราจะใช้คำว่า final ในการบอกว่าเป็นค่าคงที่ แล้วตามด้วยตัวแปร กรณีของตัวแปรในเราจะใช้ตัวพิมพ์ใหญ่ทั้งหมด และจะคั่นคำด้วยเครื่องหมาย underscore ตามตัวอย่าง

package info.doesystem.howto;

public class DoesystemInfo {
 static final int NUMBER_OF_MONTHS = 12;

 public static void main(String[] args) {
  System.out.println(DoesystemInfo.NUMBER_OF_MONTHS);
 }
}

จากตัวอย่างนี้เราใช้ static final เพื่อบอกว่าเป็นค่าคงที่ประจำ Class จากนั้นก็ตั้งชื่อตัวแปร NUMBER_OF_MONTHS โดยใช้เครื่องหมาย underscore คั่นแต่ละคำและเป็นตัวพิมพ์ใหญ่หมด

ในการเรียกใช้ static final นั้นก็ให้เราพิมพ์ชื่อ Class จากนั้นก็ตามด้วยชื่อตัวแปรได้เลย

package info.doesystem.howto;

public class DoesystemInfo {
 static final int NUMBER_OF_MONTHS = 12;

 public static void main(String[] args) {
  System.out.println(DoesystemInfo.NUMBER_OF_MONTHS);
  System.out.println(sumOne(2));
 }

 public static int sumOne(int value) {
  final int ONE = 1;
  return value + ONE;
 }
}

ตัวอย่างนี้เป็นการประกาศค่าคงที่ใน method เราก็ใช้ final เลย