Thứ Ba, 4 tháng 6, 2013

Phần 2: Khái niệm về Package – Import – Class – Modifier và Interface trong Java

I - Cấu trúc mã nguồn của Java:

package : Định nghĩa gói
imports : Chỉ định các gói sử dụng
classes : Định nghĩa các lớp
interfaces : Định nghĩa các Interface
Comments : Các loại ghi chú
- Chỉ có một class hay một Interface được định nghĩa là public. Khi đó, tên của class hay interface đó phải trùng với tên của file java. (Nói dễ hiểu là tên của file java phải cùng tên với class chứa hàm main() ).
- Mỗi class hay interface khi dịch ra sẽ sinh ra file *.class thuộc vào thư mục của gói.
VD:
-----------------
package lessons.java;
import java.util.*;
import java.io.*;

class C1
{
// variables, methods, inner class
}
public class C2
{
// variables, methods, inner class
}
interface I
{
// Khai báo variables, methods
}
-----------------
Khi biên dịch, sẽ sinh ra file C1.class, C2.class, I.class và cách file này sẽ được chứa trong Folder lessons\java (Nghĩa là nếu file java lưu ớ ổ D: thì khi biên dịch chương trình sẽ tạo ra Folder C:\lesson\java và lưu các file *.class vào. Vì ở trên bạn đã định nghĩa "package lessons.java;")

II - package và import:

- Mỗi package chứa các class và interface.
- Dùng package để tránh trùng tên class hay interface trong các gói.
- Khi ta muốn sủ dụng một class nào đó trong 1 package thì ta phải import vào.
- Các class trong java.lang được import tự động.
VD:
-----------------
package lessons.java.test;
import java.lang.*; // không cần thiết
import java.io.File; // chỉ class File trong gói java.io
import lessons.java.*; // tất cả các class trong lessons.java
-----------------

III - Class - Khai báo lớp:
Cú pháp:
-----------------
class [extends <SuperClass>] [implements [,]…]
{
// Khai báo biến thành viên
// Khai báo phương thức khởi dựng
// Khai báo phương thức thành viên
// Khai báo Inner classes
}
-----------------
Ghi chú: Khai báo lớp với tên <ClassName>, thừa kế từ lớp cha <SuperClass> và thực hiện theo các interface <Interface1>, <Interface2>,…
Mặc định của SuperClass là Object

VI - Khai báo các lớp thành viên:
1. Cú pháp:
-----------------
<modifiers> <datatype> <var1>[=val1][, <var2>[=val2]];
-----------------
2. VD:
-----------------
String x, y = “ABC”;
private static final int c = 55; // c là hằng số
-----------------
x, y, c : các biến
private, static, final, {} : modifier
“ABC”, 55 : giá trị khởi tạo

V - Constructor - Khai báo Constructor:

1. Là phương thức được gọi để xây dựng nên đối tượng của class.

2. Khai báo:
-----------------
<modifiers> <ClassName>([arguments]) [throws Exception1[, Exception2]]{…}
-----------------
3. Đặc điểm:
- Trong một class có thể có nhiều constructor khác nhau nhưng phải khác nhau về kiểu danh sách các tham số
- Nếu class không khai báo constructor nào thì constructor mặc định là constructor không tham số. Ngược bắt buộc phải dùng constructor đã khai báo.
- Để gọi một constructor từ một constructor khác ta sử dụng this(tham số phù hợp)

4. Thừa kế:
- Constructor không được thừa kế. Hãy sử dụng super(tham số phù hợp) để gọi constructor của lớp cha.
- Trong một constructor nếu gọi super(…) hay this(…) thì lời gọi này phải xuất hiện đầu tiên trong constructor đó.
- Khi gọi phương thức khởi dựng của lớp con, nếu constructor đó không gọi this(…) hay super(…) thì constructor không tham số của lớp cha tự động được kích hoạt.

5. Ví dụ
public class C1{
int index = 0;
public C1(int index) {this.index = index;}
public void print() {
System.out.println(this.index);}
}

Khởi dựng : C1 c = new C1(15); c.print();

VI - method - Khai báo method:
1. Cú pháp:
<modifiers> <datatype> <method>([arguments]) [throws Exception1[, Exception2]]{…}

2. Ví dụ:
-----------------
public static long add(int x, int y)
public void readFile(String file) throws FileNotFoundException
-----------------
<modifiers> : public, static
<datatype> : long, void
<method> : add, readFile
[arguments] : int x, int y, String file
[Exceptions] : FileNotFoundException

VII - Inner class:

1. Inner class bao gồm:
Member class : Các inner class ngang cấp với phương thức, biến thành viên
Anonymous class : Các class nặc danh (không tên)
Local class : các class được định nghĩa trong khồi.

2. Member class được chia thành 2 loại:
- Static inner class
- Non-static inner class

3. Ví dụ:
Class C
{
class IC1{}
static class IC2{}
public void method()
{
IC1 ic1 = new IC1();
}
}

VIII - VD về cấu trúc của 1 class:
class Test
{
public static void main(String[] args)
{
// Khởi dựng để tạo object c
C c = new C(“LT-Aptech”);

// Gọi phương thức add()
System.out.println(c.add(5, 2));

// Tạo object của inner class IC
C.IC ic = c.new IC();

// Gọi phương thức của inner class
ic.display(“Hello”);
}
}

IX - Danh sách các Modifier:
1. Dach sách.

user posted image

2. Cách Modifier truy xuất :
- Modifier truy xuất là các modifier dùng để định nghĩa tính chất truy xuất của class, variable, method.
- Chúng gồm: public , protected , {default} , private.
- Khả năng che dấu tăng dần theo : public -> protected -> {default} ->private

3. Modifier - final:
- final có thể dùng để định nghĩa:

Class : không cho thừa kế class này
Variable : hằng số
Method : không cho phép override ở subclass

- Ví dụ:
final class C{
final int x = 5;
final void method() {
// statements
}
}

4. Modifier - abstract:
- abstract có thể dùng để định nghĩa:

Class : phải được thừa kế mới có thể sử dụng các thành viên của nó.
Method : bắt buộc phải override ở subclass. Method này chỉ định nghĩa mà không viết đầy đủ thân.

- Nếu trong class có một phương thức abstract thì class đó buộc phải là abstract

- Ví dụ:
abstract class C{
abstract void method();

}

5. Modifier - static:

- static có thể dùng để định nghĩa :

Variable : tài nguyên chung cho các instance của cùng 1 process.
Method và Variable : được truy xuất trực tiệp thông qua tên class mà không cần khởi dựng đối tượng.
Block : chứa các biểu thức tác động lên biến static

- Ví dụ:
class C{
static int x = 5, y = 7;
static void method() {
}
static{
x += y+5;
}

}

6. Một số Modifier khác:

- native : định nghĩa cho phương thức được viết mã lệnh trong một ngôn ngữ khác (C chẳn hạn)

- transient : định nghĩa biến không cho phép tuần tự hóa.

- volatile : định nghĩa biến cho phép thay đổi dị bộ trong quá trình thực hiện chương trình, được quan tâm trong môi trường nhiều bộ vi xử lý.

- synchronized : định nghĩa phương thức, khối lệnh cái mà được thực hiện duy nhất tại một thời điểm trong các chương trình đa luồng xử lý (được xét sau).

- Ví dụ

Class C{
native void method();
transient String x = “PHANTOM_NDK”;
synchronized void method1(){…}
C1 c1 = new C1();
synchronized(c1){…}
}
=====================
Qua phần II này, các bạn có thể viết được một file java với các class cơ bản rùi đó. Còn tiếp . . .

0 nhận xét:

Đăng nhận xét