__{ideal}__Lối lập trình Java

Quy ước:
- Từ gạch chân trong phần mô tả code là ý tiêu đề của phần code đó.
- Mầu tím: khái niệm, các định nghĩa.

---

Tìm hiểu sơ qua:
Ý tưởng: Java được thiết kế bởi các class riêng rẽ, giống MFC (C++) là cách lập trình hướng đối tượng khá hay.
*Thiết kế 1 or nhiều lớp vào 1 file & có 1 lớp chính có Tên lớp trùng với tên của file. ie:
ví dụ:
Nội dung của file: lop1.java
class lop1{
//do-here
}
Note:
+File nguồn chứa code có định dạng .java , sau khi biên dịch & chạy thì trở thành file .class
+Khi chạy vào file sẽ chạy vào lớp chính đầu tiên (gọi là lớp đầu vào). Gọi vào hàm:
public static void main(String[] args) {

}
=> Không được thay đổi cấu trúc của hàm main.
Vì hàm này không phải là constructor của lớp, hàm này tách biệt với lớp. Muốn kích hoạt lớp phải tạo instance cho lớp.
Ví dụ:

public class vd {
    public vd(){
    System.out.print("constructor \n");
    }
    public static void main(String[] args) {
    vd t=new vd();
    // TODO, add your application code
    System.out.println("skfhguidsfs");
    }
}
+ Định danh nghĩa quyền cho các đối tượng: public, protected, private, abstract, final => sẽ áp dụng cho từng loại đối tượng sẽ tìm hiểu kỹ dưới đây.

------------------------------------------------------------------------------------------------------------

/*Điểm lưu ý:
-Thành phần, đối tượng trong java không được khai báo lại .
-Có phân biệt chữ hoa, chữ thường.
-Đối tượng trong java phải thiết lập giá trị or được khởi tạo mới có thể sử dụng được.
ie:
*/
int i;
System.out.print(i);   //lỗi.

/*java khá linh hoạt, trong việc sử dụng giá trị & biến là sử dụng biến cũng như giá trị của nó.
ie:
*/
String str="hoang";
str.getClass();
or:
"hoang".getClass();

/*
java cũng khá linh hoạt trong việc chuyển tiếp các đối tượng. Có thể chuyển tiếp ngay, chứ không cần nhớ vào 1 đối tượng khác.
ie: hàm A trả về đối tượng A1, đối tượng A1 có thành phần B.
*/
A().A1.B
new Lop1().ham1();

Kiểu dữ liệu

/*Note:
- java không tự động chuyển kiểu. ie: kiểu int không tự động chuyển được sang kiểu boolean.
*/

//Kiểu số:

int, long: kiểu số nguyên.

float, double : số thực.

- Sử dụng các phép toán cộng, trừ, nhân, chia, số dư.

//Kiểu chuỗi:

char, String: kiểu chuỗi.

//Không kiểu:

void: không có kiểu. Chỉ áp dụng cho hàm.

//Kiểu đúng/sai:

boolean: Kiểu đúng/sai.

-Chỉ chứa 2 giá trị true/false không được chứa kiểu int & tất nhiên không chuyển được sang kiểu int.

//Kiểu rỗng:

-Chuỗi rỗng: ""

-null: là dạng kiểu chuỗi or đối tượng, nó được gán để xóa giá trị của biến.

ie: 

int t;

t=null;  //sai vì null không phải là kiểu số.

Ngoài ra còn có các kiêu đối tượng lớp, cấu trúc tự định nghĩa:

/*nguyên tắc chuyển kiểu: A chuyển được về B khi B được kế thừa vào A. Hay nói cách khác: B bao A thì B chuyển được về kiểu A. Ngược lại thì không.
*/

class B extends A{}

A ham1(){

     B bien=new B();

     return bien;

}

Hàng xóm, phạm vi biến

/*Một số lưu ý:

- Biến trong java không tự khai báo.

- Biến được khai báo ở  phạm vi trong đối tượng, lệnh nào thì chỉ sử dụng riêng cho nó.
- Tuân theo quy tắc đặt tên biến chung như: không được trùng với từ khóa, không bắt đầu bằng số, không được viết cách....sử dụng ký tự đặc biệt.

- Các danh nghĩa cho đối tượng gồm: public, private, protected, abstract, final, static
Trong đó:
//Các thành phần của lớp được sử dụng:
public, private, protected, final, static


//các biến thông thường được sử dụng.
final


//danh nghĩa dùng cho class
public, abstract, final


Note: Có thể sử dụng danh nghĩa or không.

*/

for(int i=0;i<10;i++);  //i chỉ sử dụng trong for.

System.out.print(i);  //lỗi vì i không tìm thấy.

//Khai báo biến sử dụng thông thường, sử dụng danh nghĩa or không.

Kieu_du_lieu Ten_bien;

//Khai báo nhiều biến có cùng kiểu
Kieu_du_lieu bien1, bien2,...;

//khai báo đồng thời gán giá trị cho biến.

type var=value;

Làm việc với số

//Cộng, trừ, nhân, chia & lấy dư.
1+2;
2-1;
3*4;
6/2;
6%4;

/*Tăng/giảm với 1.
lấy giá trị của i trước sau đó tăng i thêm 1
*/
i++;

//cộng thêm 1 vào i, sau đó lấy giá trị mới của i.
++i;
=>tương tự với trừ.

Làm việc với chuỗi

- Chuỗi được đưa vào trong dấu ngoặc "", không được đưa vào 2 dấu nháy đơn -> chỉ dành cho 1 ký tự.

- Kết hợp công chuỗi sử dụng +. ie: "a"+"b

Lệnh của ngôn ngữ

//Lệnh hay còn gọi là biểu thức. Mỗi một lệnh kết thúc bởi dấu ;
lenh1;
lenh2;

So sánh hơn, bé, hoặc bằng
//lớn, lớn hơn or bằng.
>, >=

//bé, bé hơn or bằng.
<, <=

Bằng 100%
//Kiểu thông thường.
==


//biến bien có phải là bản sao (instance) của Kiểu lớp.
bien instanceof Lop1;

Không phải nó
//khác
!=


//phủ định
!
-----------------------------------------------

//Điều kiện hoặc, và
||, &&

Biểu thức điều kiện:


/*ký hiệu: <condition>
Là gồm các đối tượng kết hợp với nhau tạo thành biểu thức. Biểu thức này được đánh giá  giá trị về kiểu boolean true/false.
note: biểu thức chỉ là điều kiện khi nó được định giá trị về kiểu boolean (true/false).
*/
3+4 < 10   //true.

Phép gán
//chỉ gán giá trị vào biến. Sử dụng dấu '='
int a=10;


//không được gán kiểu.
Object a=int;  //sai.


//lấy biến đó & thực hiện phép toán sau đó gán trở lại.
t+=10;
=> tương tự với: -=, /=, *=, %=

Lệnh Điều kiện
//sử dụng khối (blocks) nếu có nhiều lệnh.
//dạng 1
if(<condition>){ //lệnh đúng;}

//dạng 2
if(<condition>){//lệnh đúng;}else {//lệnh sai; }

//dạng 3: ngắn gọn
<condition>? true : false;

Lệnh Rẽ nhánh:

//note: từ phiên bản JAVA 7 có thể sử dụng kiểu String thay vì chỉ int.
switch(<biểu thức có kiểu int>)
{
case A: break;
case B: break;
...
default: break;
}


Lệnh Vòng lặp:


//lặp số thông thường
for(int i=0;i<10;i++){//lệnh; }

/*Duyệt các phần tử của mảng: 
duyệt các phần tử kiểu int trong mảng a. i là giá trị các phần tử).
*/
for(int i: a) System.out.println(i);


/*Duyệt các thành phần của đối tượng Iterable.
note: chỉ duyệt các phần tử của mảng or đối tượng kiểu Iterable, chứ không là 1 đối tượng của lớp khác.
*/


//Lặp khi kiểm tra điều kiện vẫn còn giá trị (boolean) true của biểu thức (lệnh).
//kiểm tra trước.
while(<condition>){ //lệnh; }

//kiểm tra sau.
do{
    ....
}while(<condition>);


//Lệnh chuyển hướng:   lệnh ngắt ra khỏi vòng lặp.
break;

//Lệnh chuyển hướng:  lệnh tiếp tục với phần tử tiếp theo.
continue;

/* Khi sử dụng chuyển hướng, có thể mang ý nghĩa chuyển hướng đến 1 nhãn đại diện cho 1 đối tượng. Nhãn được sử dụng hữu ích trong vòng lặp !
*/
//nhãn của vòng lặp.
label_1:
for(int i=0;i<10;i++)
for(int j=0;j<10;j++)
{
         if(i>5) break label_1;   //ngắt đến vòng lặp ngoài.
}

Làm việc với mảng

/*
Kiểu ngăn chứa hay mảng biểu thị [] sau tên kiểu. Mỗi 1 cặp [] là mảng 1 chiều, 2 cặp [][] là mảng 2 chiều....

+Coi mảng là 1 lớp phải được instance, để định trước số phần tử của mảng.
*/

//2 cách khai báo mảng.

cách 1: int[] bien;

cách 2: int bien[];

//khai báo & gán luôn giá trị.

int bien[]={1,2,3,...};

int[][] bien1={{1,2},{3,4}}

//Chỉ khai báo số phần tử của mảng.

int bien2[]=new int[10];

int[] bien2=new int[10];

//truy cập, thiết lập giá trị vào phần tử của mảng

bien[0];

bien1[0][0]; bien1[0][1];...

Vận chuyển dữ liệu

Hàm, cấu trúc, lớp, interface

Hàm
//tạo hàm có kiểu cần phải được trả về giá trị
Kieu Ten_ham(<tham_so_neu_co>){

             //lệnh trả giá trị về cho hàm.
     return value;

}

//hàm không kiểu, không được trả về giá trị.
void Ten_ham(<tham_so_neu_co>){}

//Khai báo biến tham số rõ ràng, mỗi tham số cách nhau dấu , :
ie: (int a, int b,..)
(int a,b)  //sao


/*Phương thức có tên trùng nhau (overloading methods):
Các phương thức có thể có tên trùng nhau nhưng kiểu or các tham số phải khác nhau.
ie:
*/
void get(){}
void get(String txt){}



/*Nếu không xác định có bao nhiêu tham số cho kiểu dữ liệu này được truyền vào, thì sử dụng: 
Kieu_3 dấu (.)_dấu cách_thamSo.
Lúc này thamSo là mảng các tham số & Chúng được truy cập theo kiểu mảng.
*/
void ham1(int... t){
t[0];t[1];..
}
void ham2(Object...t){}
void ham3(String t1, int... t2){}
...


/*Truyền biến đơn vào hàm là truyền tham trị:  
tức mọi thay đổi của biến diễn ra trong hàm đều không có tác dụng khi ra khỏi hàm => áp dụng cho các biến đơn thông thường (tức chỉ chứa 1 giá trị). 
*/
int a=10;
cong_them_2(a);

/*Truyền đối tượng/mảng vào hàm là truyền tham biến: 
tức truyền biến vào hàm, mọi thay đổi của biến diễn ra trong hàm đều có ảnh hưởng tới biến khi ra khỏi hàm => áp dụng cho các đối tượng có nhiều giá trị, thành phần. ie: mảng, đối tượng. 
*/
int[] bien={1,2,3};
void set(int[] tm){
     tm[0]=10;
}
System.out.println(bien[0]);



Interface
Interface chứa các hàm prototype chưa có nội dung để ràng buộc cho lớp phải có nó.
tạo interface.


//tạo interface.
interface rangbuoc1{
public ham1();
....
}

//thực thi 1 or nhiều interface sử dụng từ kháo implement. Các interface cách nhau bởi dấu ( , ) nếu có nhiều.
class lop1 implement racbuoc1, racbuoc2,...{}


Lớp


//Tạo lớp đơn giản:
class ten_lop{


}

//Danh nghĩa của lớp:
public, final, abstract.


Kế thừa lớp khác để sử dụng các thành phần của nó, sử dụng từ khóa : extends
note: 1 lớp chỉ được kế thừa tối đa 1 lớp khác. Để 1 lớp có nhiều kế thừa thì các lớp trực tiếp của nó cũng  phải được kế thừa.


//Kế thừa 1 or nhiều lớp.
class lop1 extends lop2{}


class a{}
class b extends a{}
class c extends b{} --> được kế thừa a & b.

//nếu có cả kế thừa & thực thi interface, thì kế thừa trước & thực thi interface sau.
class a extends b implements c,d..{}



Thành phần trong lớp có 2 tên gọi: Biến & phương thức (hàm).
Danh nghĩa của chúng:
Nhóm thuộc instance:
public: truy cập được cả trong lẫn ngoài, cho phép kế thừa.
private: chỉ truy cập được bên trong đối tượng, không cho phép kế thừa.
protected: chỉ truy cập được bên trong đối tượng, cho kế thừa.
Nhóm thuộc lớp:
static: không thuộc thành phần riêng của instance mà thuộc lớp (chung) . Thành phần này các instance của lớp đều được chia sẻ.


Note: 
- Mặc định danh nghĩa của thành phần là public.
- Có thể kết hợp danh nghĩa, không quan trọng thứ tự nhưng vẫn tuân theo 2 nhóm: thuộc instance & thuộc lớp.
final static/public/private/protected
public/private/protected static








//tạo lớp trực tiếp ở root thì không ở dạng static
class lop1{}


//tạo thành phần phải trực tiếp trong lớp, không được trong 1 phương thức.
class lop1{
     public int bien1;
     static float bien2;
     void hello(){
            public String txt="Hoang";   //sai !
            System.out.println("Hello world !");
     }
}

//Thành phần constructor:
Ten_Lop(<doi_so_neu_co>){....}


//Tạo 1 instance.
Lop1 bien = new Lop1(<tham_so_neu_co>);


//Sử dụng this để chỉ định thành phần của lớp, nếu tham số trùng tên.
class c2{
  public int i;
  c2(int i)
  {
      this.i=i;
  }
}


//this để chỉ instance trong lớp.
class lop1{
   public int i;
   lop1()
   {
      this(10);
   }
   lop1(int a)
   {
      i=a;
   }
}

//Truy cập vào thành phần static (thông qua tên lớp or qua 1 instance =>bên ngoài lớp) or (trực tiếp bên trong lớp instance).
Lop1.static_member;
or:
new Lop1().static_member;


//Truy cập vào thành phần không static: chỉ từ 1 thành phần không static or truy cập vào nó từ bên ngoài.


class c1{
  static int t;
  void get(){return "Hoang";}
  public c1(){
      t=10;
      get();
  }
}


/*Truy cập vào thành phần static & không static (public/ no identifer) từ bên ngoài lớp: Sử dụng dấu '.' để truy cập vào các thành phần thông qua instance.
*/
doituong.ham1();  //gọi hàm
doituong.item1;  //lấy giá trị của biến.

//tạo thành phần biến không cho phép sửa đổi (hằng) bởi final, phải được khởi tạo giá trị & ko cho phép sửa đổi.
final int PI=3.14;

//hàm static chạy ngay khi khởi tạo instance. => mục đích khởi tạo biến static.
static{
       //lenh;
}

//hàm không static chạy ngay khi khởi tạo instance. => mục đích khởi tạo thành phần static & ko static.
{
        //lenh;
}


Tạo lớp bên trong lớp (lớp con) chỉ thuộc về lớp đó, quyền: truy cập được các thành phần của lớp & instance.
danh nghĩa lớp cũng có 2 dạng: static or không static.
-Lớp static chỉ truy cập được các thành phần static của lớp mẹ.

-Lớp không static thì truy cập được các thành phần của lớp mẹ.


//tạo lớp trực tiếp ở trong lớp

class lop1{
     static class lop1_1{}
     class lop2{}
}


//truy cập lớp con static từ thành phần lớp mẹ như thành phần static của lớp: thông qua tên lớp mẹ or trực tiếp.
LopMe.LopCon bien=new LopMe.LopCon(...);
or:
LopCon bien=new LopCon(...);

//truy cập lớp con không static trực tiếp từ thành phần của lớp mẹ.
LopCon bien=new LopCon(...);

Enum:
-Là 1 kiểu dữ liệu được sử dụng như lớp nhưng đặc biệt có chứa các giá trị hằng, với tên hằng là giá trị của chúng.
-Khi khởi tạo biến kiểu enum, sẽ gọi lớp enum n lần (n: là số lượng các hằng có trong enum).


//tạo enum trực tiếp trong lớp, chứa những hằng (kết thức bởi ;) & có thể chứa các biến - phương thức
enum day{
    thu2, thu3, thu4;  //gọi lớp enum 3 lần, bằng số lượng hằng.
    void get(){}
}



//truy cập enum từ mọi thành phần của lớp mẹ/ lớp con thông qua tên enum.
enum day{thu2, thu3}
void get{
     System.out.print(day.thu2);


}

//biến kiểu enum có giá trị là 1 trong các giá trị của enum.
enum day{thu2, thu3, thu4}
void get(day t1){
      if(t1==day.thu2) System.out.print(t1.thu2);
      switch(t1)
      {
           case thu3: System.out.print("Thu 3");
      }
}

//chỉ gán giá trị vào biến enum, chứ không gán cả enum. Từ biến có thể truy cập được các trị khác của nó.
enum day{thu2, thu3}
day t1=day.thu2;
day t2=day;    //Sai.
t1.thu3;