Chương III. Lớp và đối tượng

CHƯƠNG 3
LỚP VÀ ĐỐI TƯỢNG

Nội dung chương 3
3.1- Khaí niệm về lớp và đối tượng
3.2- Cú pháp tạo lớp
3.3- Xây dựng và khởi tạo đối tượng.
3.4- Tính thừa kế (Inheritance)
3.5- Tính đa hình (Polymorphism)
3.6- Lập trình với dữ liệu nhập
3.7- Một số lớp có sẵn của Java.
3.8- Giao diện (Interface)
3.9- Lớp trừu tượng (Abstract class)
3.10- Lớp nội (Inner class)
3.11- Gói phần mềm (Package)
3.12- Tóm tắt và câu hỏi.
3.13- Bài tập
3.1- Khái niệm về lớp và đối tượng
Đối tượng (Object): vật,người,… cụ thể
Đối tượng = Properties + Methods
Lớp (class): Mô hình (template) mô tả cho 1 nhóm đối tượng  Đối tượng là 1 hiện hữu, thực thể (instance) của class.
Một lớp có thể là lớp con (derived class- lớp dẫn xuất, lớp thừa kế, lớp mở rộng-extend) của 1 lớp khác  Quan hệ cha-con
Class Hierarchy- Phân cấp các class:Cấu trúc 1 lớp cùng các lớp con của nó (tree)
3.2- Cú pháp khai báo class
Khai báo 1 class là khai báo một mẫu (template) chung mô tả cho 1 nhóm đối tượng cùng đặc tính.
Thực thể (entity): Một biểu diễn cho một đối tượng bao gồm properties và behaviors  Là một biểu diễn cho một đối tượng vật lý hoặc quan niệm của tự nhiên.
Mỗi ngôn ngữ OOP hỗ trợ khác nhau về cách khai báo class cũng như các hỗ trợ các kỹ thuật OOP khác nhau.

Cú pháp khai báo class trong Java
class CLASSNAME extends FATHERCLASSNAME
{ DataType1 Property1 [=Value];
DataType2 Property1 [=Value];
CLASSNAME (DataType Arg,…) // constructor
{… }
[Modifier] DataType MethodName( DataType Arg,…)
{ … }
}

public - private- protected : giống C++
final : Không cho phép con mở rộng( override)
Không có modifier : Mặc định là friend, cho phép các đối tượng thuộc các class cùng package truy cập
Đặc tính truy xuất
Ôn lại về chỉ thị static
static property: Dữ liệu chung cho mọi đối tượng cùng lớp Nằm ngoài vùng nhớ của đối tượng (mang ý nghĩa của 1 biến toàn cục)
class STATIC_DEMO
{ static int Count =0 ;
STATIC_DEMO() { Count++;}
}
Tham khảo static property của 1 lớp:
Tham khảo qua 1 đối tượng của lớp này.
STATIC_DEMO D1= new STATIC_DEMO();
D1.Count=100; TestVar1 = D1.Count ;
(2) Tham khảo qua tên lớp.
TestVar2 = STATIC_DEMO.Count ;
Ôn lại về chỉ thị static
static method: Phương thức cho phép sử dụng mà không cần khai báo đối tượng thuộc lớp.
import java.io.*;
class STATIC_CLASS
{ static void Test() { System.out.println("Hello1!");}
}
class STATIC_CLASS2 extends STATIC_CLASS
{ void Test(){ System.out.println("Hello2!");}
}
class STATIC_TST
{ public static void main (String args[])
{ STATIC_CLASS.Test(); }
}
Lỗi:
Static method can’t overridden
import java.io.*;
class STATIC_CLASS
{ static void Test() { System.out.println("Hello1!");}
}
class STATIC_CLASS2 extends STATIC_CLASS
{ static void Test(){ System.out.println("Hello2!");}
}
class STATIC_TST
{ public static void main (String args[])
{{ STATIC_CLASS.Test();
STATIC_CLASS2.Test();
}
}
Hello1!
Hello2!
Press any key to continue…
Sửa lại
3.3- Xây dựng và khởi tạo đối tượng.
Chú ý về constructor:
Default Constructor: Nếu 1 lớp không hiện thực constructor, constructor mặc định của Java sẽ thực thi khi định nghĩa đối tượng (xóa trống bộ nhớ, các bit đều là 0 cho mọi properties).
ClassName ObjName = new ClassName () ;
User-defined Constructor: Nếu 1 lớp có hiện thực constructor, Java sẽ thực thi constructor tự tạo này mà không dùng constructor mặc định nữa Phải định nghĩa đối tượng theo cú pháp của constructor tự tạo.
ClassName ObjName = new ClassName (Args) ;
Thí dụ:
import java.io.*; // file FruitDemo.java
class FRUIT
{ boolean Seedness; // có hột hay không
boolean Seasonal; // có theo mùa hay không
int Price ; // Giá
public FRUIT () // constructor 1- override default constructor
{ Seedness= false; Seasonal= false; Price= 0; }
public FRUIT (boolean aSeedness, boolean aSeasonal,
int aPrice)
{ Seedness= aSeedness; Seasonal= aSeasonal; Price= aPrice; }
public void SetProperties(boolean aSeedness,
boolean aSeasonal, int aPrice)
{ Seedness= aSeedness; Seasonal= aSeasonal;Price= aPrice;}
void PrintPropertes() // friend method
{ if (Seedness) System.out.println("Fruit is seedness.");
else System.out.println("Fruit is seeded.");
if (Seasonal) System.out.println("Fruit is seasonal.");
else System.out.println("Fruit is not seasonal.");
System.out.println("Price is :" + Price);
}
} // end of FRUIT class
class FruitDemo
{ public static void main (String args[])
{ System.out.println("First fruit:");
FRUIT f1 = new FRUIT(); f1.PrintPropertes();
System.out.println("Second fruit:");
FRUIT f2 = new FRUIT(true, false,10000); f2.PrintPropertes();
}
}
Thí dụ (tt)- Kết qủa chạy chương trình
First fruit:
Fruit is seeded.
Fruit is not seasonal.
Price is :0
Second fruit:
Fruit is seedness.
Fruit is not seasonal.
Price is :10000
Press any key to continue...
Chú ý:
Method PrintProperties() có tính chất Friend nên class FruitDemo nằm cùng file với class FRUIT (cùng gói) nên được phép truy xuất method này.
Chỉ thị final
Từ khóa final có thể đứng trước 1 khai báo class, 1 khai báo method, 1 khai báo property mang ý nghĩa “Đây là cái cuối cùng”  Không cho lớp con mở rộng.
1 final class là 1 class không thể có lớp con.
import java.io.*;
final class FINAL_CLASS1
{ int t=6;
void Show() { System.out.println(t);}
}
class FINAL_CLASS extends FINAL_CLASS1
{ public static void main(String args[])
{ }
}
LỖI: 6-Cannot inherit from final class FINAL_CLASS1
Sửa lại bằng cách bỏ final trong khai báo FINAL_CLASS1 hoặc xây dựng mới class FINAL_CLASS
Chỉ thị final (tt)
Một final method là 1 method không thể override ở lớp con
import java.io.*;
class FINAL_CLASS1
{ int t=6;
void Show() { System.out.println(t);}
}
class FINAL_CLASS extends FINAL_CLASS1
{ int t2=8;
public static void main(String args[])
{ FINAL_CLASS obj= new FINAL_CLASS(); obj.Show(); }
}

6
Press any key to continue...
chương trình này OK
Chỉ thị final (tt)
import java.io.*;
class FINAL_CLASS1
{ int t=6;
final void Show() { System.out.println(t);}
}
class FINAL_CLASS extends FINAL_CLASS1
{ int t2=8;
void Show() { System.out.println(t2);}
public static void main(String args[])
{ FINAL_CLASS obj= new FINAL_CLASS(); obj.Show();}
}
Lỗi: Cannot override Show() vì Show() là final method đã khai báo trong lớp cha
Chỉ thị final (tt)
final property là 1 hằngcục bộ, KHÔNG thể gán lại trị.
import java.io.*;
class FinalVar
{ public static void main (String args[])
{ final int t=1;
t=2;
System.out.println(t);
}
}

LỖI: 5- Cannot assign a value to final variable t
3.4- Tính thừa kế (Inheritance)
Thừa kế: Kỹ thuật cho phép tái sử dụng thông tin (properties+methods).
Lớp con = Lớp cha + một tí
Lớp con không thể truy xuất thành phần private của lớp cha.
Cú pháp:
class SON extends FATHER
{ …
}
Chú ý: khi hiện thực code của class
Tham số của các method: chỉ có dạng THAM TRỊ (pass by value) vì Java với định hướng lập trình mạng, hướng OOP, bao gói triệt để  Không thể truy cập trực tiếp properties của 1 đối tượng.
Từ khóa this : Đối tượng hiện hành. khi truy xuất member chính là dạng viết tắt của this.member.
Từ khóa super tham khảo đến lớp cha
Cho phép overload method –các method cùng tên nhưng khác tham số.
Thí dụ về this và super
import java.io.*;
class T_This1
{ int x1, y1;
T_This1(int xx,int yy) { x1=xx; this.y1=yy;}
void OutData()
{System.out.println("x1="+x1+","+"y1="+y1);}
}
class T_This2 extends T_This1
{ double x2, y2;
T_This2(int xx1,int yy1,double xx2, double yy2)
{ super(xx1,yy1); x2=xx2; this.y2=yy2;}
void OutData()
{ super.OutData();
System.out.println("x2="+x2+","+"y2="+y2);}
}
Gọi constructor của lớp cha
Gọi method của lớp cha
this- super (tt)
class TestThis
{
public static void main (String args[])
{ T_This2 t= new T_This2(4,5,6,7);
t.OutData();
}
}
Kết qủa
x1=4,y1=5
x2=6.0,y2=7.0
Press any key to continue...
Thí dụ về overloading methods
import java.io.*;
class C1
{ int x,y,z;
void SetData(int t1, int t2) { x=t1; y=t2;};
void SetData(int t1, int t2,int t3) { x=t1; y=t2; z=t3;}
void OutData() { System.out.println(x+","+y+","+z); };
}

class OverLoad1
{ public static void main(String args[])
{ C1 Obj1= new C1(); Obj1.SetData(3,4); Obj1.OutData();
C1 Obj2 = new C1(); Obj2.SetData(7,8,9); Obj2.OutData();
}
}
3,4,0
7,8,9
Thành phần z của Obj1 là 0 do default constructor
3.4- Tính Đa Hình (Polymorphism)
Đa hình: Kỹ thuật tạo những sắc thái khác nhau trên cùng 1 methods của các lớp trong phân cấp thừa kế, bảo đảm thực thi đúng code của 1 hành vi của 1 đối tượng trong 1 phân cấp.
Đa hình chỉ có trong 1 phân cấp thừa kế và các class của phân cấp có cùng method.Kỹ thuật đa hình cho phép 1 lớp con override 1 method ở lớp cha ( cùng 1 method nhưng code trong lớp cha và code trong lớp con khác nhau)
overload methods: methods cùng tên nhưng khác tham số trong cùng 1 class.
Thí dụ về toán tử instanceof- Kiểm tra lớp của đối tượng
import java.io.*; // InstanceOfDemo.java
class Student
{ String Name; int Score1, Score2, Score3;
public Student(String aName, int S1, int S2,int S3)
{ Name= aName; Score1=S1; Score2=S2; Score3=S3;}
String GetName() { return Name;}
}
public class InstanceOfDemo
{ public static void main(String args[])
{ Student st= new Student("Hoa", 5,6,7) ;
if (st instanceof Student)
System.out.println(st.GetName()+" is a student.");
else System.out.println("This isn`t a student.");
}
}
Hoa is a student.
Press any key to continue...
Thí dụ về ép kiểu (type casting)
Nhiều khi cần phải ép kiểu khi viết code
import java.io.*; // TypeCaseDemo.java
class TypeCastDemo
{ public static void main(String args[])
{ byte b ; int i= 35; double d= 908.23;
b= (byte)i ;
System.out.println("i=" + i +" b=" + b);
i=205;
System.out.println("i=" + i +" b=" + b);
i= (int)d;
System.out.println("d=" + d +" i=" + i);
b= (byte)d;
System.out.println("d=" + d +" b=" + b);
}
}
i=35 b=35
i=205 b=35
d=908.23 i=908
d=908.23 b=-116
Để ý tình huống tràn số (overflow)
Thí dụ về tính đa hình
import java.io.*;
class SHAPE
{ double Area() { return 0; }
}
class CIRCLE extends SHAPE
{ double x,y,r;
CIRCLE(double rr) { r=rr>0?rr:0;}
double Area() { return Math.PI* r*r; }
}
class RECTANGLE extends SHAPE
{ double a,b;
RECTANGLE (double aa, double bb) { a=aa>0?aa:0; b=bb>0?bb:0;}
double Area() { return a*b; }
}
Thí dụ về tính đa hình (tt)
class PolyTest1
{ public static void main (String args[])
{ SHAPE S[]= { new SHAPE(), new CIRCLE(5),
new RECTANGLE(2,3)};
for (int i=0;i<3;++i) System.out.println(S[i].Area());
}
}
Kết qủa
0.0
78.53981633974483
6.0
Press any key to continue...
3.6- Chạy ứng dụng với tham số
Chương trình Java có thể đưa vào dữ liệu nhập khi chạy chương trình 1 công cụ nhập dữ liệu.
Cú pháp: java File.class arg0 arg1 …

import java.io.*;
class InputCommandLine
{ public static void main (String args[])
{ for (int i=0;i< args.length; ++i)
System.out.print(args[i]+ (i< args.length?",":""));
}
}

D:SuBaiGiang2004JavaBtCh3>java InputCommandLine Mat Uot Mi
Mat,Uot,Mi
D:SuBaiGiang2004JavaBtCh3>
3.7- Một số lớp có sẵn của Java.
Lớp Object
Lớp String
Các lớp gói (wrapper)

3.7.1- Lớp Object
Là lớp cha của mọi lớp trong java ( trực tiếp/gián tiếp)
Được để trong gói java.lang (java.lang.Object)
Định nghĩa các trạng thái cơ bản và các phương thức cơ bản của mọi lớp phải có như: So sánh nó với 1 đối tượng khác (equals), chuyển đổi mô tả thành chuỗi (toString), đợi (wait) 1 biến điều kiện, nhận biết (notify) các đối tượng khác khi biến điều kiện có thay đổi, lấy Class (getClass)

Lớp Object (tt)
Lớp Object (tt)
import java.io.*; // ObjectDemo.java
class Student2
{ String Name; int t1,t2;
Student2(String aName, int tt1, int tt2)
{ Name=aName; t1=tt1; t2=tt2;}
}
Student2@111f71
Kết qủa của method toString() :
Tên lớp + @ + Địa chỉ hệ 16 của thực thể
class ObjectDemo
{ public static void main(String args[])
{ Integer InObj1= new Integer (1);
Integer InObj2= new Integer (1);
Integer InObj3= new Integer (3);
if (InObj1.equals(InObj2))
System.out.println("Obj1 and Obj2 are the same");
else System.out.println("Obj1 and Obj2 are Separately");
if (InObj1.equals(InObj3))
System.out.println("Obj1 and Obj3 are the same");
else System.out.println("Obj1 and Obj3 are separately");
Student2 St= new Student2("Hoa", 5,6);
System.out.println(St.toString());
System.out.println(St.getClass().getName()+ "@" +
Integer.toHexString(St.hashCode()));
}
}

Obj1 and Obj2 are the same
Obj1 and Obj3 are separately
Student2@111f71
Student2@111f71
3.7.2- Lớp String - chuỗi ký tự
Định nghĩa 1 String:
String Str1=“Hello”;
String Str2= new String(“Hi”);
Nối String
String Str3= Str1 + Str2; // Str3=“HelloHi”
String Str4 = Str3 + 1; // Str4= “HelloHi1”
String pool ( hồ/ bảng chứa chuỗi)
Khi nhiều biến String cùng mang 1 nội dung, chúng cùng chỉ đến 1 phần tử trong String pool
Thí dụ:
String Str1 = “Hello”;
String Str5= “Hello”;

I love you
Hello
Forget me not
Str1
Str5
Lớp String (tt)- Methods
Thí dụ về lớp String
import java.io.*; // StringDemo.java
class StringDemo
{ public static void main (String args[])
{ String Str="Halogen";
System.out.println(Str.charAt(4));
System.out.println(Str.toUpperCase());
System.out.println(Str.indexOf(“oge",2));
System.out.println(Str.toLowerCase());
}
}

g
HALOGEN
3
halogen
indexOf: tìm vị trí xuất hiện đầu của 1chuỗi con
3.7.3-Các lớp gói (wrappers)
Là các lớp bao lấy các kiểu dữ liệu cơ bản nhằm tạo ra tính OOP cho các kiểu cơ bản

Đọc Documentation để biết về các hành vi của các wrapper class
import java.io.*; // WrapperDemo.java
class WrapperDemo
{ public static void main(String args[])
{ Boolean varBool = new Boolean ("true");
System.out.println(varBool);
Integer varInt1= new Integer(125);
System.out.println(varInt1);
Integer varInt2= new Integer ("809");
System.out.println(varInt2);
int Sum= varInt1.intValue() + varInt2.intValue();
System.out.println("Sum=" + Sum);
String S1= "1024";
int an_int= Integer.parseInt(S1);
System.out.println( an_int);
}
}
true
125
809
Sum=934
1024
3.8- Interface- Giao tiếp
Là một khai báo trước cho sự khái quát hóa của một nhóm xử lý.
Thí dụ: Xử Lý Hồ Sơ bao gồm:
(1) Nhận hồ sơ. (2) Kiểm tra tính hợp lệ của hồ sơ (3) Lưu trữ hồ sơ.
Thí dụ: Xử lý biến cố gồm:
(1) Chờ tác vụ (ActionListener)
(2) Xử lý khi có cập nhật dữ liệu
(3) Xử lý khi bàn phím bị gõ
(4) Xử lý biến cố chuột…
Là một khai báo cho một khái niệm (một tập đặc điểm gồm constants và methods) mà không muốn xây dựng lớp.
Interface- cont.
Là một đặc điểm chính của java.
Interface chỉ mới khai báo các hành vi.
Hiện thực (implement) 1 interface là xây dựng 1 lớp có đặc điểm này trong đó các methods đã khai báo trong interface được hiện thực cụ thể trong lớp này. Ở mỗi tổ chức có cách xử lý hồ sơ riêng  Lúc xây dựng lớp cụ thể hóa các hành vi .
Một lớp có thể có nhiều đặc điểm khác nhau Một lớp có thể là implement của nhiều interface.
Java không cho phép đa thừa kế nhưng cho phép một lớp có thể là một cụ thể hóa của nhiều interface  Interface là công cụ để hiện thực tính ĐA THỪA KẾ của java.
Cú pháp khai báo 1 interface




[Modifier] interface InterfaceName
{ return_type Method1( param_list);
Datatype final_var1 = Value1; // khai báo hằng
return_type Method2( param_list); // prototype
Datatype final_var2 = Value2;
….
}
public hoặc bỏ qua
public: Mọi nới đều có thể truy xuất
Không có modifier: (default) Chỉ trong cùng gói mới có thể truy xuất
Một public interface đòi hỏi: Tên file chứa khai báo interface phải cùng tên với tên interface
Một thí dụ về interface
// Khai báo các interfaces
import java.io.*; // InterfaceDemo.java
interface CheckRecord // Kiem tra ho so
{ boolean Valid();
public void OutRecord();
}
interface ScoreTable // Bang diem
{ public double Avg(); // calculate avg of scores
}
// Sử dụng interfaces vào 1 lớp
class Student3 implements CheckRecord, ScoreTable
{ String Name; int s1,s2;
public Student3(String name, int t1, int t2)
{ Name= name; s1=t1; s2=t2; }
public boolean Valid() // implementing CheckRecord interface
{ return (s1>=0 && s1<=10 && s2>=0 && s2<=10); }
public void OutRecord()
{ System.out.println(Name + " " + s1 + "," + s2 + "
avg=" + Avg()); }
public double Avg() // implementing ScoreTable interface
{ return (s1+s2)/2.0; }
}
// chương trình minh họa
class InterfaceDemo
{ public static void main(String args[])
{ Student3 St= new Student3( "Hoa", 5,6);
if (St.Valid()) St.OutRecord();
Student3 St2 = new Student3( "Tuan", -1,6);
if (St2.Valid()) St2.OutRecord();
}
}

KẾT QỦA

Hoa 5,6 avg=5.5
Press any key to continue...
3.9- Lớp trừu tượng (Abstract class)
Là lớp có những methods chưa biết code thế nào. Nên chỉ khai báo methods, để dành việc hiện thực các methods ở lớp dẫn xuất (override).
Là kết qủa của qúa trình khái quát hóa qúa cao.
class ANIMAL
void Travel(); // Di chuyển- chỉ khai báo
class Bird
void Travel()
class Fish
void Travel()
class Snake
void Travel()
Abstract class (cont.)
Một class là class trừu tượng nếu:
Có phương thức trừu tượng Lớp con của 1 lớp trừu tượng lại có phương thức trừu tượng ( có thể là phương thức trừu tượng kế thừa từ lớp cha nhưng chưa hiện thực) thì lớp con này cũng là lớp trừu tượng.
Lớp này có khai báo implement cho 1 interface mà lại chưa viết code cụ thể cho 1 method.
Cú pháp tạo và sử dụng lớp trừu tượng
import java.io.*; // AbstractClassDemo.java
abstract class Employee
{ int BasicSalary = 100;
String Name;
abstract void OutSalary();
}
class Manager extends Employee
{ Manager(String aName, int salary)
{ Name=aName; BasicSalary=salary;}
void OutSalary()
{ System.out.println(Name +" :" + BasicSalary*5); }
}
Bỏ abstract  Lỗi: Method void OutSalary() requires a method body. Otherwise declare it as abstract.
Cú pháp tạo và sử dụng lớp trừu tượng(tt)
class Worker extends Employee
{ Worker(String aName) { Name=aName;}
Worker(String aName, int Salary)
{ Name=aName; BasicSalary=Salary;}
void OutSalary()
{ System.out.println(Name +" :" + BasicSalary*3);}
}
class AbstractClassDemo
{ public static void main(String args[])
{ Manager m = new Manager ("Trung", 200);
m.OutSalary();
Worker w= new Worker("Hoang");
w.OutSalary();
}
}
Trung :1000
Hoang :300
3.10-Lớp con(trong/inner)
Là 1 lớp khai báo bên trong 1 lớp khác.
Quan hệ : lớp ngoài (enclosing, outter class) , lớp trong (nested, inner class).
Lớp trong có quyền truy xuất lớp ngoài.
Lớp ngoài chỉ truy xuất được lớp trong khi có một instance của lớp trong
Inner class(cont.)
Cú pháp:
class Outter
{ ….
class Inner
{ …
}
}
Lợi ích:
Có thể viết code truy xuất lớp ngoài từ lớp trong mà không cần định nghĩa đối tượng lớp ngoài
Lớp ngoài muốn truy cập lớp trong thì phải định nghĩa 1 đối tượng lớp trong ( bằng toán tử new )
Inner class (cont.)
import java.io.*; // InnerClassDemo.java
class Outter
{ String Str="This is outter" ;
boolean OutterAccess=true;
Outter()
{
System.out.println(Str+", Outter Access=" +
OutterAccess);
System.out.println("InnerAccessible=" +
InnerAccess);
}

Có lỗi:Undefined variable: InnerAccess
Thêm code:
Inner I=new Inner();
Sửa thành I.InnerAccess
Inner class (cont.)
class Inner
{ String str="I`m inner" ;
boolean InnerAccess=true;
Inner()
{ System.out.println("Inner access outer:");
System.out.println(Str + ", Outter Access=" +
OutterAccess);
System.out.println("Inner Accessible=" +
InnerAccess);
}
}
} // hết Outter class
class InnerClassDemo
{ public static void main (String args[])
{ Outter Obj = new Outter(); }
}
Kết qủa
Inner access outer:
This is outter, Outter Access=true
Inner Accessible=true
This is outter, Outter Access=true
InnerAccessible=true
Do constructor lớp trong thực hiện
Do constructor lớp ngoài thực hiện
3.11- Gói phần mềm (Package)
Là một nhóm các class, interface, các gói khác đã được biên dịch thành Java bytecode.
Tổ chức của 1 package là 1 thư mục có tên là tên của package  Sub-package là 1 gói con (thư mục con) của 1 package mức cao hơn (giống cấu trúc thư mục).
Gói là công cụ tạo khả năng tái sử dụng mã (reusable code).
Cú pháp tạo package
package PackageName;
import OtherPackage.*;
public class Class1
{ …
}
Thí dụ: Tạo gói MyPackage có cấu trúc:




Tên file phải là tên lớp
Mỗi lớp để trong 1 file riêng biệt
Phải là dòng code đầu tiên của tập tin .java
(không kể chú thích)
package MyPackage; // file BtCh3/Calculate.java
public class Calculate
{ public static double Volume(double l,
double w, double h)
{return l*w*h;}
public static double Add(double n1,
double n2)
{ return n1+n2;}
}
Sau khi biên dịch, cấu trúc gói theo yêu cầu sẽ được tự động sinh ra.
package MyPackage.Shape; // BtCh3/Circle.java
public class Circle
{ double r;
public Circle(double rr) { r=rr;}
public double Circumference()
{ return 2*Math.PI*r;}// chu vi
public double Area()
{ return Math.PI* r*r; }
}
Sử dụng gói với chỉ thị import
Dùng chỉ thị import
import Package.*; // Dùng mọi lớp của gói
import Package.Class; // dùng 1 class
import Package.Sub_Package.*;
import Package.Sub_Package.Class;

Thí dụ:
import java.io.*;
import MyPackage.
import MyPackage.Shape.Circle;
class TestMyPackage
{ public static void main(String args[])
{ System.out.println(Calculate.Volume(3,4,5));
Circle C= new Circle(5);
System.out.println(C.Area());
}
}

60.0
78.53981633974483