Khi học Java, chúng ta thường bắt gặp những chương trình đơn giản về animation trong các sách dạy AWT và Swing, chẳng hạn như chương trình sau đây:

import java.awt.*;
import javax.swing.*;

public class Animation1 {

  public static void main( String[] args ) {

     Animation1 gui = new Animation1();
     gui.go();

  }

  private void go() {

     JFrame frame = new JFrame();
     frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

     panel_ = new MyPanel();
     frame.getContentPane().add( panel_, BorderLayout.CENTER );

     frame.setSize( 500, 500 );
     frame.setVisible( true );

     for( int i = 0; i < 400; i++ ) {

        x_++;
        y_++;

        panel_.repaint();

        try {
          Thread.sleep( 10 );
        } catch( Exception ex ) { }

     }

  }

  class MyPanel extends JPanel {

     public void paintComponent( Graphics g ) {

         g.setColor( Color.white );
         g.fillRect( 0, 0, this.getWidth(), this.getHeight() );

         g.setColor( Color.green );
         g.fillOval( x_, y_, 40, 40 );

     }

  }

  private JPanel panel_;
  private int x_ = 0;
  private int y_ = 0;

}

Chương trình này vẽ ra một vòng tròn trên một panel, tính toán lại tọa độ của nó rồi gọi repaint() để vẽ lại vòng tròn. Phương thức repaint() yêu cầu các component trên frame tự vẽ lại.Thao tác vẽ lại liên tục với các vị trí khác nhau sẽ tạo ra cảm giác vòng tròn chạy trên panel. Câu lệnh Thread.sleep(10) làm giảm tốc độ di chuyển của vòng tròn giúp người dùng dễ theo dõi.

Chúng ta thử sáng tạo thêm một chút bằng cách thêm vào frame một button dùng kể kích hoạt animation (học event handler và inner class luôn). Animation sẽ được kích hoạt khi người dùng ấn nút “Start animation”. Chương trình được cải tiến như sau:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Animation2 {

    public static void main( String[] args ) {

	Animation2 gui = new Animation2();
	gui.go();

    }

    private void go() {

	JFrame frame = new JFrame();
	frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

	panel_ = new MyPanel();
	frame.getContentPane().add( panel_, BorderLayout.CENTER );

	button_ = new JButton( "start animation" );
	button_.addActionListener( new StartAnimationAction() );
	frame.getContentPane().add( button_, BorderLayout.SOUTH );

	frame.setSize( 500, 500 );
	frame.setVisible( true );

    }

    class MyPanel extends JPanel {

	public void paintComponent( Graphics g ) {

	    g.setColor( Color.white );
	    g.fillRect( 0, 0, this.getWidth(), this.getHeight() );

	    g.setColor( Color.green );
	    g.fillOval( x_, y_, 40, 40 );

	}

    }

    class StartAnimationAction implements ActionListener {

	public void actionPerformed( ActionEvent e ) {

	    for( int i = 0; i < 400; i++ ) {

		x_++;
		y_++;

		panel_.repaint();

		try {
		  Thread.sleep( 10 );
		} catch( Exception ex ) { }

	    }

	}

    }

  private JPanel panel_;
  private JButton button_;
  private int x_ = 0;
  private int y_ = 0;

}

Phiên bản mới nhìn qua thì rất “đẹp”, nhưng thực ra nó không chạy đúng như chúng ta mong đợi! Chúng ta không nhìn thấy vòng tròn di chuyển trên panel mà chỉ thấy nó nhảy từ vị trí ban đầu đến vị trí cuối cùng, các trạng thái trung gian đã bị mất. Vậy đâu là nguyên nhân của hành vi kì lạ này?

Thực ra, khi chúng ta đặt phương thức repaint() vào trong một vòng lặp, AWT sẽ trộn các lời gọi repaint() lại với nhau và chỉ có lời gọi repaint() cuối cùng được thực hiện. Bởi vậy chúng ta không thể nhìn thấy các trạng thái trung gian của vòng tròn trên panel.

Vậy làm thế nào giải quyết vấn đề này? Một giải pháp là đưa các lời gọi repaint() sang một thread khác như sau:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Animation3 {

    public static void main( String[] args ) {

	Animation3 gui = new Animation3();
	gui.go();

    }

    private void go() {

	JFrame frame = new JFrame();
	frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

	panel_ = new MyPanel();
	frame.getContentPane().add( panel_, BorderLayout.CENTER );

	button_ = new JButton( "start animation" );
	button_.addActionListener( new StartAnimationAction() );
	frame.getContentPane().add( button_, BorderLayout.SOUTH );

	frame.setSize( 500, 500 );
	frame.setVisible( true );

    }

    class MyPanel extends JPanel {

	public void paintComponent( Graphics g ) {

	    g.setColor( Color.white );
	    g.fillRect( 0, 0, this.getWidth(), this.getHeight() );

	    g.setColor( Color.green );
	    g.fillOval( x_, y_, 40, 40 );

	}

    }

    class StartAnimationAction implements ActionListener, Runnable {

	public void actionPerformed( ActionEvent e ) {

	    Thread thread = new Thread( this );
	    thread.start();

	}

	public void run() {

	    for( int i = 0; i < 400; i++ ) {

		x_++;
		y_++;

		panel_.repaint();

		try {
		  Thread.sleep( 10 );
		} catch( Exception ex ) { }

	    }

	}

    }

  private JPanel panel_;
  private JButton button_;
  private int x_ = 0;
  private int y_ = 0;

}

Bây giờ thì chương trình của chúng ta đã chạy ngon lành. Để giải thích cặn kẽ về vấn đề gọi repaint() nhiều lần có lẽ cần đến những hiểu biết nhất định về thread trong Java. Bởi vậy “tác giả”, với trình độ còn rất hạn chế, đành tạm thời hài lòng với giải pháp nói trên

Tài liệu tham khảo: The repaint() method and the GUI thread

Khi đã quen viết code trên vi/vim rồi thì chuyển sang editor khác thật khó chịu. Phiền hà nhất là các thao tác di chuyển con trỏ (phải dùng các phím mũi tên lên xuống rất mất thời gian), xóa một từ hoặc một dòng (phải giữ Backspace mỏi cả tay), nhảy giữa các từ…Tóm lại với những ai đã quen lập trình trên vi/vim thì việc phải chuyển sang các IDE khác sẽ không khác gì cực hình.

Giải pháp cho vấn đề này là cài đặt vim plugin cho IDE đang sử dụng. Một IDE đang được sử dụng rộng rãi là NetBeans. Để cài đặt vim plugin cho NetBeans, vào link dưới đây để tải về file cài đặt:

http://sourceforge.net/projects/viex/

Giải nén để nhận được file start-module-myvim.nbm. Từ menu của NetBeans, chọn Tools->Plugins->Downloaded->Add Plugins rồi chọn file start-module-myvim.nbm. Chúng ta sẽ thấy biểu tượng của vim nằm bên cạnh các icon khác như trong hình dưới đây. (Chú ý hình dáng của con trỏ, chúng ta đang ở chế độ lệnh của vim).

Bây giờ thì chúng ta đã có thể tận hưởng sự tiện lợi trong việc viết code bằng vim kết hợp với những tính năng phức tạp cung cấp bởi NetBeans. Tuy nhiên, plugin này vẫn chưa hỗ trợ một số thao tác edit trong vim như

- Không tự động indent khi xuống dòng bằng phím o.

- Không hỗ trợ shift-o

- Không hỗ trợ ctrl-r (redo).

- Không hỗ trợ xoá nhiều từ liền nhau (d 2 w, d 3 w, d $,…)

Tuy nhiên với những tính năng hiện có của plugin này thì công việc lập trình trên NetBeans đã trở nên thú vị hơn rất nhiều. Hi vọng những khiếm khuyết nói trên sẽ được khắc phục trong những phiên bản sau.

Một trong những điểm khó khăn (và gây tranh cãi) cho những lập trình viên C++ khi lập trình Java là việc pass-by-value hay pass-by-reference. Ví dụ:

Object a = new Object("Object A"); //kỳ quặc với C++: Object* a = new ...
Object b = a;
b.setNewName("Object B");

Theo cách hiểu của C++ devs thì rõ ràng Object b thay đổi tên chẳng liên quan gì đến Object a cả. Thực tế theo Java thì khác, Object a sẽ có name là “Object B” chẳng khác gì Object b cả.

Để Object b hoàn toàn “độc lập” với Object a thì:

Object b = a.clone();

Thế nhưng hàm swap() trong Java lại chẳng hoạt động theo cách pass-by-reference.

private void swap(Type arg1, Type arg2) {
    Type temp = arg1;
    arg1 = arg2;
    arg2 = temp;
}

Vậy đấy!!! Java thực sự đã làm như thế nào? Ẩn sau những cái lằng nhằng gây tranh cãi như vậy là gì?

Trước hết cần hiểu rằng pass-by-value là cách truyền bằng cách copy giá trị của tham số vào một “biến” được sử dụng trong nội hàm đó. Do đó khi hàm trả về thì sẽ hủy đi các tham số copied, và các tham số truyền vào thì không bị ảnh hưởng thay đổi gì. Trái ngược với nó là pass-by-reference thì thực sự tạo ra một alias tới các tham số thực sự. Khi trong hàm thay đổi các tham số đó thì nó cũng thay đổi trực tiếp các tham số truyền vào. Việc không phải tạo một bản copy ở trong C++ nhiều khi tiết kiệm được CPU với object lớn, có quá trình copy/khởi tạo phức tạp.

Tuy nhiên thì ở trong Java hàm swap không hoạt động vì nó hoạt động theo cách thức pass-by-value. Sau khi hàm swap trả về thì arg1 và arg2 không đổi chỗ cho nhau. Nhưng kỳ lạ hơn nếu trong thân hàm swap gọi một phương thức của Type làm thay đổi object, ví dụ như:

arg1.setValue("Change");

Theo cách nghĩ pass-by-value thì sau khi thoát khỏi hàm swap thì arg1 chẳng bị thay đổi gì. Thực tế lại khác, arg1 đã gọi phương thức setValue() do đó khi thoát khỏi hàm thì value của arg1 đã thay đổi.

Hãy nhớ lại rằng trong C cũng không có khái niệm reference (&). Thế nhưng C lại có pointer (con trỏ) và nó làm cho C mạnh mẽ uyển chuyển không cần có reference. Java có pointer không?

Nhiều người cho rằng: Object thì là pass-by-reference còn các kiểu primitive thì là pass-by-value (In Java, Objects are passed by reference, and primitives are passed by value.) Mệnh đề này chỉ đúng một nửa. Object không phải được pass-by-reference mà là object reference được pass-by-value. Chúng ta sẽ hiểu rõ ở câu trả lời:

Câu trả lời cho tất cả các sự kỳ quặc trên ở Java đó chính là Java đã “làm sạch” cú pháp pointer trong C. Java có pointer nhưng pointer được khai báo và sử dụng một cách rất clean. Và tất nhiên nó tuy không mạnh bằng pointer trong C nhưng nó cũng “fix” tất cả những lỗi tiềm tàng và nguy hiểm (casting, releasing pointer hay pointer arithmetic) của pointer trong C.

Trong Java,

Object a;

giống như trong C/C++

Object* a;

Do đó khi

Object b = a;

có nghĩa trong C/C++

Object* b = a; // b và a đều là pointer

và

b.setName("Object B");

tương đương với

b->setName("Object B");

Thế nên b.setName(“Object B”) cũng đặt object “trỏ” bởi a có tên là “Object B” vì a và b trỏ cùng vào một object.

Và

private void swap(Object a, Object b)
{
     Object temp = a;
     a = b;
     b = temp;
}

tương ứng với

void swap(Object* a, Object* b)
{
     Object* temp = a;
     a = b;
     b = temp;
}

Rõ ràng hàm này trong C không hoạt động trừ phi thay đổi thế này:

void swap(Object* a, Object* b)
{
     Object temp = *a;
     *a = *b;
     *b = temp;
}

“Con trỏ” a và b được truyền theo kiểu pass-by-value (có thể hiểu rằng Java giống như C, tất cả các tham số được truyền theo kiểu pass-by-value) nên sau khi hàm swap trả về thì a, b không bị thay đổi hay phép gán a = b không có ý nghĩa. Thế nhưng a.setValue(“…”) thì đã thay đổi object trỏ bởi con trỏ.

Tham khảo

• http://javadude.com/articles/passbyvalue.htm
• http://www.ibm.com/developerworks/library/j-praxis/pr1.html

Nguồn: http://mannu.livejournal.com/131085.html

Bài viết này là một thảo luận nhỏ được đề cập đến trong bài báo của Tahir rằng tại sao anh ta thích C++ hơn Java: “Why I Program in C++” (mà tôi sẽ đề cập khi có dịp).

Java thiếu rất nhiều đặc điểm của C++ và ngược lại. Nhưng có một đặc điểm của C++ mà tôi vẫn chưa quen được trong Java là khả năng có một const reference tới objects, làm cho những object là immutable khi sử dụng những references như vậy. Trong Java thì không phải tất cả instances (thể hiện) của một class nào là immutable (ví dụ java.lang.String) hoặc bất cứ một thể hiện nào là immutable. Mutability của một object được xác đính bởi design (thiết kế) của class đó và không có cách nào để nó chịu ảnh hưởng bởi cái reference đến trong hệ thống. Do đó tất cả đối tượng “String” trong Java là immutable, trong khi tất cả ArrayLists là mutable.

Để rõ hơn, sau đây là một lớp contact trong C++:

class Contact
{
private:
    string name;
public:
    void setName(const string& name)
    {
        this->name = name;
    }
    const string& getName() const
    {
        return name;
    }
};

Một vài đoạn mã C++ mà một đối tượng của Contact được tạo ra và refer đến.

void print(const Contact&);
Contact myContact;

myContact.setName("Manish");
print(myContact);
void print(const Contact& c)
{
    cout << c.getName() << endl;
}

Khi đoạn mã bên trên gọi void print(const Contact&) thì đã đảm bảo rằng đối tượng Contact truyền vào sẽ tiếp tục không được thay đổi, vì vậy sẽ là không hợp lệ khi gọi một hàm không phải const như void Contact::setName(const string&) trong một const reference. Bằng cách này, lập trình viên có thể chắc chắn rằng hàm void print(const Contact&) không làm ảnh hưởng gì đến dữ liệu của đối tượng Contact. Điều đó rất quan trọng, cho dù là cái cách mà hàm làm thay đổi một đối tượng được truyền tới nó là một phần thỏa thuận giữa hàm gọi và đối tượng được gọi.

Không thể viết được một đoạn mã tương ứng với đoạn mã trên trong Java:

class Contact
{
    private String name;
    public void setName(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }
}
...

Contact myContact = new Contact();
myContact.setName("Manish");
print(myContact);

void print(Contact c)
{
    System.out.println(c.getName());
    /* XXX: It is possible to call c.setName(String) here */
    /* Vẫn có thể gọi c.setName(String) ở đây */
}

Trong Java, khi một reference tới một đối tượng Contact được truyền trong chương trình thì không có cách nào để đối tượng đó là không được thay đổi. Trong C++, thì truyền const reference sẽ làm việc này. Đó là khả năng của C++ để chia rẽ các phương thức mutator từ phương thức non-mutator; trong Java, toàn bộ class cẩn phải là immutable – java.lang.String là một ví dụ tốt nhất – điều đó rất lãng phí, bởi vì mỗi khi một đối tượng immutable cần phải thay đổi, một bản copy mới của nó sẽ cần phải được khởi tạo với nội dung được thay đổi. Bên cạnh đó, trong Java, không có cách nào để nói một mutable class từ một immutable class mà không nhìn vào tài liệu của nó. Mutability (immutability) không phải là một đặc điểm ngôn ngữ của Java, giống như vtables (dùng để enable tính đa hình trên C++) không phải là đặc điểm ngôn ngữ của C (có thể hack được nhưng rất phức tạp).

Java newbies (và tương tự C++ newbies) có khuynh hướng so sánh từ khóa “final” trong Java với từ khóa “const” trong C++. Trong khi “final” đáp ứng một trong những mục đích của const là có một giá trị không đổi của một biến (primitives và references), nhưng nó không làm một đối tượng là “không thay đổi”.

Hãy nhìn vào đoạn mã Java, khi mà lớp Contact được sử dụng

class AddressBook
{
    /** A list of {@link Contact} objects. */
    private List contacts;
    public void addContact(Contact c)
    {
        contacts.add(c);
    }
    public Contact getContactByName(String name)
    {
        Contact c = null;

        /* find contact by name */
        return c;
    }
}

Giờ thì bất kỳ một reference tới AddressBook, final hay không thì:

- Có thể được sử dụng để thay đổi trạng thái của đối tượng bằng cách thêm vào contacts.

- Có thể được sử dụng để thay đổi tất cả đối tượng được chứa (contact), bằng cách gọi getContactByName và gọi hàm setName của đối tượng contact đó.

Một thiết kế lớp nghèo nàn như vậy làm cho kiến trúc public-private trong Java dường như rất hời hợt (Chúng không giúp ích nhiều trong việc để Contact.name và AddressBook.contacts trở nên private, đúng không? Tôi vẫn chưa thể có thời gian giải thích chúng với Java programmers).

Với C++, thậm chí có thể có 2 version của phương thức getContactByName, một gọi thông qua non-const reference và một gọi qua const-reference:

Contact& getContactByName(const string& name);

const Contact& getContactByName(const string& name) const;
/* Note the difference in return types (const-ness) */

Trong Java thì hiệu quả mong muốn của việc tạo ra một đối tượng AddressBook như là mutable với phần chắc chắn của hệ thống và immutable của với các phần khác có thể đạt được bằng cách sử dụng các access specifiers (private, public, protected, và package-level). Phương thức addContact có thể được tạo ở mức package, và những phần kia của mã mà phải thêm contacts vào một AddressBook có thể trở thành một phần của cùng package đó. Chúng được gọi là phần đáng tin cậy của hệ thống. Phương thức getContactByName có thể trả về một copy của đối tượng Contact. (Gợi ý: Chồng phương thức clone).

Tôi tin rằng đây là một đặc điểm hết sức cơ bản của C++ mà đã được loại bỏ khỏi Java để tránh cho ngôn ngữ trở nên quá phức tạp (có thể nhằm làm dễ dàng hơn khi nó mới và phát triển ngày càng phình ra). Tuy vậy thì rất khó khi không có đặc điểm này.

Ngôn ngữ ảnh hưởng đến cách chúng ta nghĩ, và nhiều như cách những người theo chủ nghĩa thuần túy thích từ chối nó, một ngôn ngữ lập trình ảnh hưởng rất lớn đến những quyết định thiết kế chương trình.