要實現(xiàn)Java中的代理設計模式，首先需定義一個公共接口，接著實現(xiàn)真實主題類，然後創(chuàng)建代理類控制對真實對象的訪問，最後在主程序中使用代理。 1. 定義公共接口Image，確保代理和真實對象可互換；2. 實現(xiàn)RealImage類，負責實際圖像加載和顯示；3. 創(chuàng)建ImageProxy類，在其display方法中實現(xiàn)懶加載；4. 在Main類中使用ImageProxy，延遲加載圖像資源，提升效率。該模式支持多種用途，如安全控制、日誌記錄或遠程調(diào)用。

Sure, here's a practical and straightforward explanation of how to implement the Proxy design pattern in Java .

The Proxy pattern is useful when you want to control access to an object or add behavior without changing its actual implementation. This can be helpful for things like lazy initialization, security checks, or adding logging. Let's go over how to do it step by step.

1. Define a Common Interface

Start by creating an interface that both the real object and the proxy will implement. This allows them to be used interchangeably.

 public interface Image {
    void display();
}

This keeps your code flexible and clean. Any class using this interface doesn't need to care whether it's dealing with the real thing or a proxy.

2. Implement the Real Subject

Now create the actual class that does the work. This is the object you might want to wrap later with a proxy.

 public class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk(filename);
    }

    private void loadFromDisk(String filename) {
        System.out.println("Loading image: " filename);
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " filename);
    }
}

This class could represent something expensive to create — like loading a large file from disk. That's where the proxy becomes handy.

3. Create the Proxy Class

The proxy holds a reference to the real object and controls access to it. It often delays instantiation until necessary (lazy loading).

 public class ImageProxy implements Image {
    private RealImage realImage;
    private String filename;

    public ImageProxy(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename); // Lazy initialization
        }
        realImage.display();
    }
}

You'll notice that RealImage is only created when display() is called for the first time. That saves resources if the image never actually needs to be shown.

4. Use the Proxy

Finally, test it out. The calling code doesn't know (or care) whether it's using the proxy or the real image.

 public class Main {
    public static void main(String[] args) {
        Image image1 = new ImageProxy("photo1.jpg");
        Image image2 = new ImageProxy("photo2.jpg");

        image1.display(); // Loads and displays
        image1.display(); // Only displays

        image2.display(); // Loads and displays
    }
}

As you can see, the proxy helps avoid unnecessary resource usage by deferring creation until it's truly needed.

There are other types of proxies too — like remote proxies (for distributed systems), virtual proxies (like the one above), and protection proxies (for access control). But the structure stays mostly the same.

So yes, implementing the Proxy pattern in Java isn't hard once you understand the flow. Just define an interface, build the real class, then wrap it with a proxy that adds value.

基本上就這些。

以上是如何在Java中實現(xiàn)代理設計模式？的詳細內(nèi)容。更多資訊請關注PHP中文網(wǎng)其他相關文章！