Các lớp lồng.
Giới thiệu
Ngôn ngữ lập trình Java cho phép bạn định nghĩa một lớp
trong một lớp khác. Một lớp như vậy được gọi là một lớp lồng và được
minh họa như sau:
class OuterClass {
...
class NestedClass {
...
}
}Thuật ngữ: Các lớp lồng được chia thành hai thể loại: non-static và static. Lớp lồng non-static được gọi là lớp trong. Lớp lồng được khai báo static được gọi là lớp lồng tĩnh.
class OuterClass {
...
class InnerClass {
...
}
static class StaticNestedClass {
...
}
}
Một lớp lồng là một thành viên của lớp bao quanh nó. Lớp lồng
non-static (lớp trong) có được truy cập các thành viên khác trong lớp
bao quanh nó, nếu chúng được khai báo là private. Lớp lồng tĩnh không
truy cập được các thành viên khác trong lớp bao quanh nó. Như một thành viên của
lớp OuterClass, một lớp lồng có thể được định nghĩa private, public,
protected, hoặc packate-private. (Gọi lại lớp ngoài có thể chỉ được
định nghĩa public hoặc package-private).
Tại sao sử dụng các lớp lồng?
Các lý do thuyết phục để sử dụng các lớp lồng bao gồm:
·
Nó là một cách cục bộ các nhóm lớp chỉ được sử dụng
trong một nơi: Nếu một lớp là được sử dụng chỉ với một lớp khác, thì là hợp lý
để nhúng nó vào lớp đó và giữ chúng bên nhau. Lớp lồng như “các lớp hỗ trợ” tạo
cho các gói của chúng sắp xếp hợp lý hơn.
·
Tăng tính đóng gói: Xem xét hai mức đột các lớp,
A và B, nơi B cần truy cập các thành viên của lớp A mà hơn nữa chúng được khai
báo private. Bằng cách ẩn lớp B trong lớp A, các thành viên cùa lớp A có
thể được khai báo private và B có thể truy cập được chúng. Ngoài ra, bản thân B
có thể được ẩn đi từ bên ngoài.
·
Nó có thể dẫn đến dễ đọc và dễ bảo trì mã nguồn
hơn: Việc đặt lớp lồng trong lớp ở mức cao nhất sẽ đặt mã gần nhất với nơi nó
được sử dụng.
Các lớp trong.
Giống như instance methods và các biến, một lớp trong
được liên kết với một cá thể của lớp bao quanh nó và truy cập trực tiếp vào các
phương thức và thuộc tính của đối tượng. Ngoài ra, bởi vì một lớp bên trong được
liên kết với một cá thể, nó không thể định nghĩa bất kỳ một thành viên tĩnh nào
bên trong nó.
Các đối tượng là cá thể của một lớp trong tồn tại trong một
cá thể của lớp ngoài. Xem xét lớp sau:
class OuterClass {
...
class InnerClass {
...
}
}
Một cá thể của lớp InnerClass có thể chỉ tồn tại trong một
cá thể OuterClass và có thể truy cập trực tiếp đến các phương thức và các thuộc
tính của cá thể lớp ngoài.
Để khởi tạo một lớp trong, bạn trước hết phải khởi tạo lớp
bên ngoài. Sau đó, tạo một đối tượng lớp trong bên trong lớp ngoài với cú pháp
này:
OuterClass outerObject = new OuterClass();
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
Có hai loại đặc biệt của các lớp trong: lớp cục bộ và lớp vô
danh sẽ được bàn đến ở phần sau.
Các lớp lồng tĩnh.
Như các phương thức
class methods và các biến, một lớp lồng tĩnh được liên kết với các lớp bên
ngoài. Và giống như phương thức tĩnh (static class methods), một lớp lồng tĩnh
không thể tham chiếu trực tiếp đến các biến instance variable hoặc các phương
thức định nghĩa bên trong lớp bao bọc nó: nó có thể sử dụng chúng chỉ trong một
đối tượng tham chiếu. Trong phần ví dụ lớp trong và lớp lồng sẽ minh họa vấn đề
này.
Chú ý: một lớp lồng tĩnh tương tác với các thành viên
instance của lớp ngoài (và các lớp khác) chỉ như bất kỳ lớp khác ở mức cao nhất.
Minh chứng là, một lớp lồng tĩnh về mặt hành vi là của một lớp mức cao nhất để
thuận lợi cho việc đóng gói. Trong ví dụ về lớp trong và lớp lồng tĩnh cũng
mình họa điều này.
Bạn khởi tạo một lớp lồng tĩnh như cách khởi tạo của một lớp
mức cao nhất:
StaticNestedClass staticNestedObject = new StaticNestedClass();
Ví dụ về các lớp trong và các lớp lồng tĩnh.
Trong ví dụ, OuterClass, cùng với lớp TopLevelClass
minh họa các thành viên lớp của OuterClass một lớp trong (InnerClass),
một lớp lồng tĩnh (StaticNestedClass), và một lớp mức cao nhất (TopLevelClass)
cần truy cập:
Kết quả của chương trình này là:
Inner class:
------------
Outer field
Static outer field
Static nested class:
--------------------
Outer field
Static outer field
Top-level class:
--------------------
Outer field
Static outer field
Chú ý rằng một lớp lồng tĩnh tương tác với các thành viên
instance của lớp ngoài chỉ như bất kỳ lớp mức độ cao nhất khác. Trong lớp lồng
tĩnh StaticNestedClass không thể truy cập trực tiếp vào thuộc tính outerField
bởi vì nó là một biến instance của lớp bao bọc nó, OuterClass. Trình biên dịch sẽ tạo ra lỗi tại câu lệnh được
in đậm dưới đây:
static class StaticNestedClass {
void accessMembers(OuterClass outer) {
// Compiler error: Cannot make a static reference to the non-static
// field outerField
System.out.println(outerField);
}
}
Để sửa lỗi này, truy cập vào outerField thông qua một
đối tượng tham chiếu:
System.out.println(outer.outerField);
Làm mờ (Shadowing)
Nếu một khai báo cho một kiểu (như là một biến thành viên hoặc
một tên tham số) trong một phạm vi cụ thể (như trong một lớp trong hoặc một
khai báo phương thức) có tên giống với khai báo của phạm vi ngoài, thì khai báo
làm mờ shadows phạm vi xunh quanh. Bạn không thể tham chiếu đến một khai báo
làm mờ bằng tên độc lập. Trong ví dụ ShadowTest, minh họa điều này:
public class ShadowTest {
public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
}
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}
Kết quả của chương trình này:
x = 23
this.x = 1
ShadowTest.this.x = 0
Ví dụ này định nghĩa ba biến tên x: biến thành viên của lớp ShadowTest,
biến thành viên của lớp trong FirstLevel, và tham số trong phương thức methodInFirstLevel.
Biến x được định nghĩa là một tham số của phương thức methodInFirstLevel
làm mở đi biến trong lớp FirstLevel. Hệ quả là khi bạn sử dụng biến x
trong phương thức methodInFirstLevel, nó tham chiếu đến tham số phương
thức. Để tham chiếu đến biến thành viên của lớp FirstLevel, sử dụng từ
khóa this để đại diện cho phạm vi bao quanh:
System.out.println("this.x = " + this.x);
Tham chiếu đến biến thành viên của phạm vi bao quanh lớn hơn
bằng tên lớp mà chúng thuộc về. Ví dụ, câu lệnh truy cập biến thành viên của lớp
ShadowTest từ phương thức methodInFirstLevel:
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
Tuần tự hóa
Tuần tự hóa của các lớp trong, bao gồm các lớp địa
phương và các lớp vô danh, rất không được khuyến khích. Khi chương
trình Java biên dịch cấu trúc nhất định, như các lớp trong, nó tạo ra cấu
trúc tổng hợp; có các lớp, các phương thức, các thuộc tính, và các cấu trúc
khác không có cấu trúc tương ứng trong mã nguồn. Các cấu trúc tổng hợp cho phép
Java biên dịch thực hiện các tính năng ngôn ngữ không có sự thay đổi JVM.
Tuy nhiên, các cấu trúc tổng hợp có thể thay đổi khác nhau giữa các trình biên
dịch thực hiện, có nghĩa là file .class có thể thay đổi giữa các cách triển
khai khác nhau. Hệ quả là bạn có thể giải quyết những vấn đề tương thích nếu bạn
tuần tự hóa một lớp trong và sau đó giải mã hóa nó bằng một triển khai JRE khác.
Xem trong phần các tham số ngầm và tổng hợp cho nhiều thông tin hơn về các cấu
trúc ngầm được tạo ra khi một lớp trong được biên dịch.
Ví dụ về lớp trong
Để xem một lớp trong được sử dụng, trước hết xem xét một mảng.
Trong ví dụ, bạn tạo một mảng, điền các giá trị số nguyên, và sau đó đầu ra chỉ
các giá trị có chỉ số chẵn tăng dần của mảng.
public class DataStructure {
// Create an array
private final static int SIZE = 15;
private int[] arrayOfInts = new int[SIZE];
public DataStructure() {
// fill the array with ascending integer values
for (int i = 0; i < SIZE; i++) {
arrayOfInts[i] = i;
}
}
public void printEven() {
// Print out values of even indices of the array
DataStructureIterator iterator = this.new EvenIterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
System.out.println();
}
interface DataStructureIterator extends java.util.Iterator<Integer> { }
// Inner class implements the DataStructureIterator interface,
// which extends the Iterator<Integer> interface
private class EvenIterator implements DataStructureIterator {
// Start stepping through the array from the beginning
private int nextIndex = 0;
public boolean hasNext() {
// Check if the current element is the last in the array
return (nextIndex <= SIZE - 1);
}
public Integer next() {
// Record a value of an even index of the array
Integer retValue = Integer.valueOf(arrayOfInts[nextIndex]);
// Get the next even element
nextIndex += 2;
return retValue;
}
}
public static void main(String s[]) {
// Fill the array with integer values and print out only
// values of even indices
DataStructure ds = new DataStructure();
ds.printEven();
}
}
Đầu ra của chương trình là:
0 2 4 6 8 10 12 14
Chú ý rằng lớp EvenIterator tham chiếu trực tiếp đến arrayOfInts
là biến instance của đối tượng DataStructure.
Bạn có thể sử dụng các lớp trong để thực hiện các lớp tiện
ích như một thể hiện trong ví dụ này. Để xử lý các dữ kiện của giao diện người
dùng, bạn phải biết sử dụng các lớp trong, bởi vì cơ chế xử lý các sự kiện sử dụng
rộng rãi.
Các lớp cục bộ và lớp vô danh.
Có hai kiểu được thêm vào cho các lớp trong. Bạn có thể khai
báo một lớp trong bên trong phần thân của một phương thức. Các lớp như vậy được
biết đến là các lớp cục bộ. Bạn có thể cũng khai báo một lớp một lớp trong bên
trong một phương thức nhưng không khai báo tên. Các lớp như vậy được biết đến
là các lớp vô danh.
Các bổ ngữ.
Bạn có thể sử dụng các bổ ngữ giống nhau cho các lớp trong
như bạn sử dụng cho các thành viên khác trong lớp ngoài. Ví dụ, bạn có thể sử dụng
từ chỉ định truy cập như private, public, protected để hạn chế truy cập đến các
lớp trong, giống như bạn sử dụng chúng để hạn chế truy cập cho các thành viên
khác của lớp.
Các lớp cục bộ
Giới thiệu.
Các lớp cục bộ là các lớp được khai báo trong một khối, bao
gồm nhóm lệnh trong cặp mở/ đóng ngoặc nhọn. Bạn thường tìm thấy các lớp cục bộ
được định nghĩa trong một phương thức.
Phần này bao gồm các chủ đề sau:
·
Khai báo các lớp cục bộ.
·
Truy cập các thành viên trong lớp bao quanh.
o
Làm mờ và các lớp cục bộ.
·
Các lớp cục bộ tương tự các lớp trong.
Khai báo các lớp cục bộ.
Bạn cần định nghĩa một lớp cục bộ bên trong một khối (Xem phần
biểu thức, các câu lệnh và các khối để thêm thông tin). Ví dụ, bạn có thể định
nghĩa một lớp cục bộ trong thân một phương thức, một vòng lặp for hoặc một câu
lệnh điều kiện if.
Ví dụ LocalClassExample, kiểm tra hai số điện thoại.
Định nghĩa một lớp cục bộ PhoneNumber trong phương thức validatePhoneNumber:
public class LocalClassExample {
static String regularExpression = "[^0-9]";
public static void validatePhoneNumber(
String phoneNumber1, String phoneNumber2) {
final int numberLength = 10;
// Valid in JDK 8 and later:
// int numberLength = 10;
class PhoneNumber {
String formattedPhoneNumber = null;
PhoneNumber(String phoneNumber){
// numberLength = 7;
String currentNumber = phoneNumber.replaceAll(
regularExpression, "");
if (currentNumber.length() == numberLength)
formattedPhoneNumber = currentNumber;
else
formattedPhoneNumber = null;
}
public String getNumber() {
return formattedPhoneNumber;
}
// Valid in JDK 8 and later:
// public void printOriginalNumbers() {
// System.out.println("Original numbers are " + phoneNumber1 +
// " and " + phoneNumber2);
// }
}
PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);
// Valid in JDK 8 and later:
// myNumber1.printOriginalNumbers();
if (myNumber1.getNumber() == null)
System.out.println("First number is invalid");
else
System.out.println("First number is " + myNumber1.getNumber());
if (myNumber2.getNumber() == null)
System.out.println("Second number is invalid");
else
System.out.println("Second number is " + myNumber2.getNumber());
}
public static void main(String... args) {
validatePhoneNumber("123-456-7890", "456-7890");
}
}
Trong ví dụ kiểm tra một số điện thoại bằng cách lấy ra số đầu
tiên của tất cả các ký tự từ số điện thoại ngoại trừ các số từ 0 đến 9. Sau đó,
nó kiểm tra các số điện thoại bao gồm chính xác 10 số (kích thước của một số điện
thoại ở Bắc Mỹ). Ví dụ này in ra:
First number is 1234567890
Second number is invalid
Truy cập các thành viên của một lớp bao bọc bên ngoài lớp
cục bộ.
Một lớp cục bộ có thể truy cập vào các thành viên của lớp
bao bọc bên ngoài. Trong ví dụ trước, hàm khởi tạo PhoneNumber truy cập
vào thành viên LocalClassExample.regularExpression.
Ngoài ra, một lớp cục bộ có thể truy cập vào các biến cục bộ.
Tuy nhiên, một lớp cục bộ chỉ có thể truy cập vào các biến cục bộ được định
nghĩa là final. Khi một lớp cục bộ truy cập vào một biến cục bộ hoặc
tham số của khối đóng mở ({}), nó nắm bắt được biến hoặc tham số. Ví dụ hàm khởi
tạo PhoneNumber có thể truy cập vào biến cục bộ numberLength bởi vì biến
này được khai báo là final; numberLangth là một biến nắm bắt được
của lớp cục bộ, gọi là biến captured variable.
Tuy nhiên, bắt đầu từ Java SE 8, một lớp cục bộ có thể truy
cập các biến cục bộ và các tham số trong khối đóng mở ({}) được khai báo final
hoặc effectively final. Một biến hoặc tham số có giá trị không bao giờ
thay đổi sau khi khởi tạo là effectively final. Ví dụ, giả sử biến
numberLength không được khai báo là final, và trong lệnh gán được bôi đậm trong
hàm khởi tạo PhoneNumber dưới đây thay đổi độ dài của một số điện thoại đến 7 số:
PhoneNumber(String phoneNumber) {
numberLength = 7;
String currentNumber = phoneNumber.replaceAll(
regularExpression, "");
if (currentNumber.length() == numberLength)
formattedPhoneNumber = currentNumber;
else
formattedPhoneNumber = null;
}
Bởi vì ở câu lệnh gán, biến numberLength không là effectively
final. Có một kết quả, trình biên dịch Java tạo ra một lỗi tương tự như ("local variables referenced from an
inner class must be final or effectively final") tạm dịch là
các biến tham chiếu cục bộ từ một lớp trong phải được khai báo là final
hoặc effectively final, khi một lớp trong PhoneNumber có gắng truy cập
vào biến numberLenth:
if (currentNumber.length() == numberLength)Bắt đầu từ Java SE 8 trở đi, nếu bạn khai báo một lớp trong trong một phương thức, nó có thể truy cập được các tham số của phương thức. Ví dụ, bạn có thể khai báo phương thức sau trong lớp cục bộ PhoneNumber:
public void printOriginalNumbers() {
System.out.println("Original numbers are " + phoneNumber1 +
" and " + phoneNumber2);
}
Phương thức printOriginalNumbers truy cập các tham số
phoneNumber1 và phoneNumber2 của phương thức validateNumber.
Làm mờ và các biến cục bộ: Khai báo một kiểu (như là một biến)
trong một lớp cục bộ làm mờ khai báo trong phạm vi bao bọc nó thống như cái cái
tên “làm mờ”. Xem lại phần làm mờ (Shadowing trong để thêm thông tin)
Các lớp cục bộ tương đương với các lớp trong.
Các lớp cục bộ là tương đương với các lớp trong bởi chúng
không thể định nghĩa hoặc khai báo bất kỳ một thành viên tĩnh nào. Lớp cục bộ
trong phương thức tĩnh, giống như lớp PhoneNumber nó định nghĩa trong phương thức
validatePhoneNumber, chỉ có thể tham chiếu đến các thành viên tĩnh trong khối
đóng mở của lớp. Ví dụ, nếu bạn không định nghĩa một biến thành viên regularExpression
như một biến tĩnh, thì trình biên dịc Java sẽ tạo ra một lỗi là “non-static variable regularExpression
cannot be referenced from a static context”, tạm dịch là biến
regularaExpression không thể là biến tĩnh, nó không thể tham chiếu đến từ một
ngữ cảnh tĩnh (hiểu là là biến tĩnh).
Các lớp cục bộ không thể là lớp tĩnh bởi vì chúng truy cập
vào các thành viên instance bên trong khối. Hệ quả là chúng không thể bao gồm hầu
hết các loại khai báo tĩnh.
Bạn không thể khai báo một interface trong một khối; các
interface vốn dĩ là tĩnh. Ví dụ, đoạn trích mã nguồn dưới đây không thể biên dịch
được bởi interface HelloThere được khai báo bên trong thân của phương thức
greetInEnglish:
public void greetInEnglish() {
interface HelloThere {
public void greet();
}
class EnglishHelloThere implements HelloThere {
public void greet() {
System.out.println("Hello " + name);
}
}
HelloThere myGreeting = new EnglishHelloThere();
myGreeting.greet();
}
Bạn không thể khai báo các khởi tạo tĩnh hoặc các interface
thành viên trong một lớp cục bộ. Đoạn trích mã nguồn dưới đây không thể biên dịch
bởi phương thức EnglishGoodbye.sayGoodbye được khai báo là static. Trình biên dịch
sinh ra lỗi như “modifier 'static'
is only allowed in constant variable declaration”, tạm dịch là bổ ngữ
‘static’ chỉ cho phép khai báo biến hằng. Nó được định nghĩa như này:
public void sayGoodbyeInEnglish() {
class EnglishGoodbye {
public static void sayGoodbye() {
System.out.println("Bye bye");
}
}
EnglishGoodbye.sayGoodbye();
}
Một lớp cục bộ có thể có các thành viên tĩnh, chúng là các
biến hằng (Một biến hằng là một biến có kiểu nguyên thủy hoặc kiểu String,
được khai báo là final và khởi tạo với một biểu thức hằng thời gian biên
dịch. Một biểu thức hằng thời gian biên dịch thường là một chuỗi hoặc một biểu
thức số nó có thể được đánh giá bằng thời gian biên dịch. Xem lại phần hiểu về
các thành viên của lớp trong phần trước để rõ hơn thông tin.) Ví dụ đoạn trích
mã nguồn biên dịch bởi thành biên tĩnh EnglishGoodbye.farewell là một biến
hằng:
public void sayGoodbyeInEnglish() {
class EnglishGoodbye {
public static final String farewell = "Bye bye";
public void sayGoodbye() {
System.out.println(farewell);
}
}
EnglishGoodbye myEnglishGoodbye = new EnglishGoodbye();
myEnglishGoodbye.sayGoodbye();
}
Các lớp vô danh (Anonymous Classes)
Các lớp vô danh cho phép bạn tạo ra mã nguồn ngắn gọn. Chúng
cho phép bạn khai báo và khởi tạo một lớp trong cùng thời gian. Chúng giống như
lớp cục bộ ngoại trừ chúng không có tên. Sử dụng chúng nếu bạn cần sử dụng một
lớp cục bộ một lần.
Trong phần này sẽ có các chủ đề sau:
·
Khai báo các lớp vô danh.
·
Cú pháp trong các lớp vô danh.
·
Truy cập các biến cục bộ của khối, và khai báo
và truy cập các thành viên trong các lớp vô danh.
·
Các ví dụ về các lớp vô danh.
Khai báo các lớp
vô danh.
Trong khi các lớp cục bộ là các lớp khai báo, thì lớp vô
danh là một biểu thức, có nghĩa bạn định nghĩa một lớp trong một biểu thức
khác. Ví dụ HelloWorldAnonymousClasses sử dụng các lớp vô danh trong câu lệnh
khai báo của các biến cục bộ frenchGreeting và spanishGreeting, nhưng sử dụng
trong một lớp cục bộ cho khai báo các biến englishGreeting:
public class HelloWorldAnonymousClasses {
interface HelloWorld {
public void greet();
public void greetSomeone(String someone);
}
public void sayHello() {
class EnglishGreeting implements HelloWorld {
String name = "world";
public void greet() {
greetSomeone("world");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";
public void greet() {
greetSomeone("mundo");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hola, " + name);
}
};
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
}
public static void main(String... args) {
HelloWorldAnonymousClasses myApp =
new HelloWorldAnonymousClasses();
myApp.sayHello();
}
}
Cú pháp của các lớp vô danh.
Được nhắc đến trong phần trước, một lớp vô danh là một biểu
thức. Cú pháp của một biểu thức lớp vô danh là giống lời gọi một hàm khởi dựng,
ngoại trừ việc có một định nghĩa nội dung bên trong một khối mã nguồn.
Xem xét khởi tạo đối tượng frenchGreeting:
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
Biểu thức lớp vô danh bao gồm:
·
Toán tử new
·
Tên của một interface để thực hiện hoặc một lớp
kế thừa. Trong ví dụ này, lớp vô danh thực hiện interface HelloWorld.
·
Dấu ngoặc đơn bao gồm các đối số ở trong hàm khởi
tạo, chỉ giống một instance được tạo ra từ biểu thức tạo lớp. Chú ý: khi bạn thực
hiện một interface, nó không có hàm khởi tạo, do vậy bạn sử dụng một cặp
đóng mở ngoặc đơn bên trong để trống, như ví dụ này.
·
Một thân, một lớp được khai báo là một thân. Hơn
nữa ,trong thân lớp, các phương thức được phép, còn các câu lệnh thì không được
phép khai báo.
Bởi vì một lớp vô danh định nghĩa là một biểu thức, nó phải
có thành phần của một câu lệnh. Trong ví dụ, biểu thức lớp vô danh là một phần
của câu lệnh đó là một cá thể đối tượng frenchGreeting. (Điều này giải
thích tại sao có dấu chấm phẩy sau dấu ngoặc.)
Truy cập các biến cục bộ trong phạm vi bao bọc, và khai
báo và truy cập các thành viên của lớp vô danh.
Giống như các lớp cục bộ, lớp vô danh có thể nắm bắt các biến;
chúng có thể truy cập vào cùng các biến cục bộ của phạm vi bao bọc nó.
·
Một lớp ẩn danh có thể truy cập vào các thành
viên của lớp bao bọc nó.
·
Một lớp ẩn danh không thể truy cập vào các biến
trong phạm vi bao bọc nó mà không được khai báo final hoặc effectively
final.
·
Giống như một lớp lồng, một khai báo cho kiểu
(giống như một biến) trong một lớp ẩn danh làm mờ bất kỳ một khai báo khác
trong phạm vi bao bọc nếu nó cùng tên. Xem lại làm mờ ở phần trên để biết thêm
thông tin.
Các lớp ẩn danh cũng có cùng hạn chế giống các lớp cục bộ cho
các mối quan hệ cho các thành viên của chúng:
·
Bạn không thể khai báo khởi tạo tĩnh hoặc thành
viên interface trong một lớp ẩn danh.
·
Một lớp ẩn danh có thể có các thành viên tĩnh
nhưng chúng phải là các biến hằng.
Lưu ý rằng bạn có thể khai báo những điều sau cho lớp ẩn
danh:
·
Fields (các thuộc tính).
·
Các phương thức bổ sung (ngay cả khi chúng không
triển khai bất kỳ một phương thức nào cho supertype).
·
Khởi tạo cho cá thể.
·
Các lớp cục bộ.
·
Tuy nhiên, bạn không thể khai báo các hàm khởi tạo
trong một lớp vô danh.
Ví dụ vê lớp Vô danh.
Các lớp vô danh thường sử dụng trong một ứng dụng giao diện
đồ họa (GUI).
Xem xét trong JavaFX ví dụ Helloworld.java. Trong ví dụ này,
bao gồm nút Say ‘Hello World’. Lớp vô danh trong phần highlight:
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
public class HelloWorld extends Application {
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Hello World!");
Button btn = new Button();
btn.setText("Say 'Hello World'");
btn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
System.out.println("Hello World!");
}
});
StackPane root = new StackPane();
root.getChildren().add(btn);
primaryStage.setScene(new Scene(root, 300, 250));
primaryStage.show();
}
}
Trong ví dụ này, phương thức gọi btn.setOnAction xảy ra khi
bạn chọn nút Say 'Hello World'. Phương thức này yêu cầu đối tượng có kiểu
EventHandler<ActionEvent>. Interface EventHandler<ActionEvent>
bao gồm chỉ một phương thức, là: thay thế thực thi phương thước này bằng một lớp
mới, trong ví dụ sử dụng một biểu thức lớp vô danh. Chú ý rằng biểu thức này là
đối số truyền vào cho phương thức btn.setOnAction.
Bởi vì interface EventHandler<ActionEvent> chỉ
bao gồm một phương thức, bạn có thể sử dụng một biểu thức lambda thay thế biểu
thức lớp vô danh. Bạn tìm hiểu nhiều hơn ở phần biểu thức Lambda.
Các lớp vô danh là một ý tưởng cho thực hiện một interface
mà chứa từ hai phương thức trở lên. Trong phần highlight mã nguồn tạo một thuộc
tính văn bẳn chỉ cho phép nhập giá trị số. Nó định nghĩa lại thực hiện mặc định
cho lớp TextField với một lớp vô danh bằng việc ghi đè replaceText và replaceSelection
kế thừa từ lớp TextInputControl class.
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;
public class CustomTextFieldSample extends Application {
final static Label label = new Label();
@Override
public void start(Stage stage) {
Group root = new Group();
Scene scene = new Scene(root, 300, 150);
stage.setScene(scene);
stage.setTitle("Text Field Sample");
GridPane grid = new GridPane();
grid.setPadding(new Insets(10, 10, 10, 10));
grid.setVgap(5);
grid.setHgap(5);
scene.setRoot(grid);
final Label dollar = new Label("$");
GridPane.setConstraints(dollar, 0, 0);
grid.getChildren().add(dollar);
final TextField sum = new TextField() {
@Override
public void replaceText(int start, int end, String text) {
if (!text.matches("[a-z, A-Z]")) {
super.replaceText(start, end, text);
}
label.setText("Enter a numeric value");
}
@Override
public void replaceSelection(String text) {
if (!text.matches("[a-z, A-Z]")) {
super.replaceSelection(text);
}
}
};
sum.setPromptText("Enter the total");
sum.setPrefColumnCount(10);
GridPane.setConstraints(sum, 1, 0);
grid.getChildren().add(sum);
Button submit = new Button("Submit");
GridPane.setConstraints(submit, 2, 0);
grid.getChildren().add(submit);
submit.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent e) {
label.setText(null);
}
});
GridPane.setConstraints(label, 0, 1);
GridPane.setColumnSpan(label, 3);
grid.getChildren().add(label);
scene.setRoot(grid);
stage.show();
}
public static void main(String[] args) {
launch(args);
}
}