Sử dụng các định nghĩa lớp bên trong một phương thức trong Java

Thí dụ:

public class TestClass {

    public static void main(String[] args) {
        TestClass t = new TestClass();
    }

    private static void testMethod() {
        abstract class TestMethod {
            int a;
            int b;
            int c;

            abstract void implementMe();
        }

        class DummyClass extends TestMethod {
            void implementMe() {}
        }

        DummyClass dummy = new DummyClass();
    }
}

Tôi phát hiện ra rằng đoạn mã trên là hoàn toàn hợp pháp trong Java. Tôi có những câu hỏi sau đây.

1. Việc sử dụng một định nghĩa lớp bên trong một phương thức là gì?
2. Một tệp lớp có được tạo cho DummyClass
3. Thật khó để tôi hình dung khái niệm này theo hướng Đối tượng. Có định nghĩa lớp bên trong một hành vi. Có lẽ ai đó có thể cho tôi biết với các ví dụ tương đương trong thế giới thực.
4. Đối với tôi, các lớp trừu tượng bên trong một phương thức có vẻ hơi điên rồ. Nhưng không có giao diện nào được phép. Có lý do gì đằng sau điều này?

Đây được gọi là lớp cục bộ.

2 là cái dễ: có, một tệp lớp sẽ được tạo.

1 và 3 là loại câu hỏi giống nhau. Bạn sẽ sử dụng một lớp cục bộ nơi bạn không bao giờ cần phải khởi tạo một lớp hoặc biết về chi tiết triển khai ở bất kỳ đâu ngoại trừ một phương thức.

Một cách sử dụng điển hình là tạo ra một số giao diện được triển khai ngay lập tức. Ví dụ: bạn sẽ thường thấy một cái gì đó như thế này:

  //within some method
  taskExecutor.execute( new Runnable() {
       public void run() {
            classWithMethodToFire.doSomething( parameter );
       }
  }); 

Nếu bạn cần tạo một loạt những thứ này và làm gì đó với chúng, bạn có thể thay đổi điều này thành

  //within some method
  class myFirstRunnableClass implements Runnable {
       public void run() {
            classWithMethodToFire.doSomething( parameter );
       }
  }
  class mySecondRunnableClass implements Runnable {
       public void run() {
            classWithMethodToFire.doSomethingElse( parameter );
       }
  }
  taskExecutor.execute(new myFirstRunnableClass());
  taskExecutor.execute(new mySecondRunnableClass());

Về giao diện: Tôi không chắc liệu có vấn đề kỹ thuật nào khiến các giao diện được xác định cục bộ trở thành vấn đề đối với trình biên dịch hay không, nhưng ngay cả khi không có, chúng sẽ không thêm bất kỳ giá trị nào. Nếu một lớp cục bộ triển khai một giao diện cục bộ được sử dụng bên ngoài phương thức, thì giao diện đó sẽ vô nghĩa. Và nếu một lớp cục bộ chỉ được sử dụng bên trong phương thức, thì cả giao diện và lớp sẽ được triển khai trong phương thức đó, vì vậy định nghĩa giao diện sẽ là dư thừa.

Chúng được gọi là các lớp địa phương . Bạn có thể tìm thấy giải thích chi tiết và ví dụ ở đây . Ví dụ trả về một triển khai cụ thể mà chúng ta không cần biết bên ngoài phương thức.

1. Không thể nhìn thấy lớp (tức là được khởi tạo, các phương thức của nó được truy cập mà không có Reflection) từ bên ngoài phương thức. Ngoài ra, nó có thể truy cập các biến cục bộ được định nghĩa trong testMethod (), nhưng trước định nghĩa lớp.

2. Tôi thực sự đã nghĩ: "Sẽ không có tệp nào như vậy được viết." cho đến khi tôi vừa thử nó: Ồ vâng, một tệp như vậy được tạo ra! Nó sẽ được gọi là A $ 1B.class, trong đó A là lớp bên ngoài và B là lớp cục bộ.

3. Đặc biệt đối với các hàm gọi lại (trình xử lý sự kiện trong GUI, như onClick () khi một Nút được nhấp, v.v.), việc sử dụng "các lớp ẩn danh" là khá bình thường - trước hết vì bạn có thể kết thúc với rất nhiều trong số chúng. Nhưng đôi khi các lớp ẩn danh không đủ tốt - đặc biệt, bạn không thể định nghĩa hàm tạo trên chúng. Trong những trường hợp này, các lớp địa phương của phương thức này có thể là một sự thay thế tốt.

Mục đích thực sự của việc này là cho phép chúng ta tạo các lớp nội tuyến trong các lệnh gọi hàm để điều khiển những người trong chúng ta, những người thích giả vờ rằng chúng ta đang viết bằng một ngôn ngữ hàm;)

Trường hợp duy nhất khi bạn muốn có một hàm đầy đủ bên trong lớp so với lớp ẩn danh (hay còn gọi là Java bao đóng) là khi các điều kiện sau được đáp ứng

1. bạn cần cung cấp một giao diện hoặc triển khai lớp trừu tượng
2. bạn muốn sử dụng một số tham số cuối cùng được xác định trong hàm gọi
3. bạn cần ghi lại một số trạng thái thực hiện lệnh gọi giao diện.

Ví dụ: ai đó muốn a Runnablevà bạn muốn ghi lại khi quá trình thực hiện bắt đầu và kết thúc.

Với lớp ẩn danh thì không thể làm được, với lớp bên trong bạn có thể làm được điều này.

Đây là một ví dụ chứng minh quan điểm của tôi

private static void testMethod (
        final Object param1,
        final Object param2
    )
{
    class RunnableWithStartAndEnd extends Runnable{
        Date start;
        Date end;

        public void run () {
            start = new Date( );
            try
            {
                evalParam1( param1 );
                evalParam2( param2 );
                ...
            }
            finally
            {
                end = new Date( );
            }
        }
    }

    final RunnableWithStartAndEnd runnable = new RunnableWithStartAndEnd( );

    final Thread thread = new Thread( runnable );
    thread.start( );
    thread.join( );

    System.out.println( runnable.start );
    System.out.println( runnable.end );
}

Tuy nhiên, trước khi sử dụng mẫu này, vui lòng đánh giá xem lớp cấp cao nhất cũ đơn thuần hay lớp bên trong hoặc lớp bên trong tĩnh có phải là lựa chọn thay thế tốt hơn hay không.

Lý do chính để xác định các lớp bên trong (trong một phương thức hoặc một lớp) là để xử lý khả năng truy cập của các thành viên và các biến của lớp và phương thức bao quanh. Một lớp bên trong có thể tra cứu các thành viên dữ liệu riêng tư và hoạt động trên chúng. Nếu bên trong một phương thức, nó cũng có thể xử lý với biến cục bộ cuối cùng.

Có các lớp bên trong giúp đảm bảo rằng lớp này không thể tiếp cận với thế giới bên ngoài. Điều này đúng đặc biệt đối với các trường hợp lập trình giao diện người dùng trong GWT hoặc GXT, v.v. trong đó mã tạo JS được viết bằng java và hành vi cho mỗi nút hoặc sự kiện phải được xác định bằng cách tạo các lớp ẩn danh

Tôi đã xem qua một ví dụ điển hình vào mùa xuân. Khung đang sử dụng khái niệm định nghĩa lớp cục bộ bên trong phương thức để xử lý các hoạt động cơ sở dữ liệu khác nhau một cách thống nhất.

Giả sử bạn có một đoạn mã như sau:

JdbcTemplate jdbcOperations = new JdbcTemplate(this.myDataSource);
jdbcOperations.execute("call my_stored_procedure()")
jdbcOperations.query(queryToRun, new MyCustomRowMapper(), withInputParams);
jdbcOperations.update(queryToRun, withInputParams);

Đầu tiên chúng ta hãy xem xét việc triển khai thực thi ():

    @Override
    public void execute(final String sql) throws DataAccessException {
        if (logger.isDebugEnabled()) {
            logger.debug("Executing SQL statement [" + sql + "]");
        }

        /**
         * Callback to execute the statement.
         (can access method local state like sql input parameter)
         */
        class ExecuteStatementCallback implements StatementCallback<Object>, SqlProvider {
            @Override
            @Nullable
            public Object doInStatement(Statement stmt) throws SQLException {
                stmt.execute(sql);
                return null;
            }
            @Override
            public String getSql() {
                return sql;
            }
        }

        //transforms method input into a functional Object
        execute(new ExecuteStatementCallback());
    }

Hãy lưu ý dòng cuối cùng. Spring cũng thực hiện "mẹo" chính xác này đối với các phương pháp còn lại:

//uses local class QueryStatementCallback implements StatementCallback<T>, SqlProvider
jdbcOperations.query(...) 
//uses local class UpdateStatementCallback implements StatementCallback<Integer>, SqlProvider
jdbcOperations.update(...)

"Thủ thuật" với các lớp cục bộ cho phép khuôn khổ xử lý tất cả các tình huống đó trong một phương thức duy nhất chấp nhận các lớp đó thông qua giao diện StatementCallback. Phương thức đơn này hoạt động như một cầu nối giữa các hành động (thực thi, cập nhật) và các hoạt động phổ biến xung quanh chúng (ví dụ: thực thi, quản lý kết nối, dịch lỗi và đầu ra bảng điều khiển dbms)

public <T> T execute(StatementCallback<T> action) throws DataAccessException    {
        Assert.notNull(action, "Callback object must not be null");

        Connection con = DataSourceUtils.getConnection(obtainDataSource());
        Statement stmt = null;
        try {
            stmt = con.createStatement();
            applyStatementSettings(stmt);
            //
            T result = action.doInStatement(stmt);
            handleWarnings(stmt);
            return result;
        }
        catch (SQLException ex) {
            // Release Connection early, to avoid potential connection pool deadlock
            // in the case when the exception translator hasn't been initialized yet.
            String sql = getSql(action);
            JdbcUtils.closeStatement(stmt);
            stmt = null;
            DataSourceUtils.releaseConnection(con, getDataSource());
            con = null;
            throw translateException("StatementCallback", sql, ex);
        }
        finally {
            JdbcUtils.closeStatement(stmt);
            DataSourceUtils.releaseConnection(con, getDataSource());
        }
    }