`

java设计模式(2)--观察者模式Swing 多线程事件处理进度条和Observer的一个具体应用

    博客分类:
  • java
阅读更多

适合使用环境: 当自身发生改变时,通知其它对象,其他对象会跟着改变。例如:swing中分页的程序,当你点击上一页下一页时需要重新激发事件,从数据库获得新数据时,等。

Swing的事件处理中,对于非常费时的处理如果不用多线程会造成主界面的阻塞,即界面一片白色,这样非常不好的,也是不提倡的,而起用多线程进行事件 处理又面临一个问题即如果通知用户事件处理的进度,是否处理完成,所以最好在处理的过程中给用户一提示,标明处理的进度信息。这种提示可以用进度条的信息 来表示出来,以下就是一个用进度条来标示事件进度的一个简单实例,这个例子中还使用了Observer模式
进度窗口:
package pro;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observable;
import java.util.Observer;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class Progress extends javax.swing.JDialog implements ActionListener {
    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private JProgressBar pro_JPB;

    private JPanel btn_JP;

    private JButton cancel_JB;

    private JLabel show_JL;

    NewJFrame jf;

    public Progress(NewJFrame frame) {
        super(frame, true);
        this.jf = frame;
        initGUI();
    }

    set se = new set();

    private void initGUI() {
        try {

            se.addObserver(new setObserver());
            BorderLayout thisLayout = new BorderLayout();
            getContentPane().setLayout(thisLayout);
            {
                show_JL = new JLabel();
                getContentPane().add(show_JL, BorderLayout.NORTH);
                show_JL.setPreferredSize(new java.awt.Dimension(354, 22));
            }
            {
                pro_JPB = new JProgressBar();
                pro_JPB.setMinimum(0);
                pro_JPB.setMaximum(100);
                getContentPane().add(pro_JPB, BorderLayout.CENTER);
                pro_JPB.setPreferredSize(new java.awt.Dimension(392, 27));
            }
            {
                btn_JP = new JPanel();
                getContentPane().add(btn_JP, BorderLayout.SOUTH);
                {
                    cancel_JB = new JButton();
                    btn_JP.add(cancel_JB);
                    cancel_JB.setText(""u53d6"u6d88");
                    cancel_JB.addActionListener(this);
                }
            }
            this.setBackground(Color.DARK_GRAY.brighter());
            this.setUndecorated(true);
            this.setSize(392, 90);
            this.setLocationRelativeTo(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void setMinmum(int i) {
        pro_JPB.setMinimum(i);
    }

    public void setMaxmem(int i) {
        pro_JPB.setMaximum(i);
    }

    public void setVal(int i) {
        se.setPrice(i);
    }

    /**
     *
     * set Class->function:观察者模式的具体应用
     * 2007-4-17
     */
    class set extends Observable {
        private int price;

        public int getPrice() {
            return price;
        }

        public void setPrice(int price) {
            this.price = price;
            setChanged();
            notifyObservers(new Integer(price));
        }

    }

    class setObserver implements Observer {
        public void update(Observable obj, Object arg) {
            if (arg instanceof Integer) {
                int i = ((Integer) arg).intValue();
                pro_JPB.setValue(i);
                show_JL.setText((i - pro_JPB.getMinimum()) * 100
                        / (float) (pro_JPB.getMaximum() - pro_JPB.getMinimum())
                        + "%");
            }
        }

    }

    public void actionPerformed(ActionEvent e) {
        jf.setTh_Flag(false);
        this.setVisible(false);
    }

}

主程序:
package pro;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.WindowConstants;

public class NewJFrame extends javax.swing.JFrame {
    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private JPanel cen_JP;

    private JButton jb;

    public static void main(String[] args) {
        NewJFrame inst = new NewJFrame();
        inst.setVisible(true);
    }

    public NewJFrame() {
        super();
        initGUI();
    }

    Progress pro;

    private void initGUI() {
        try {
            setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            {
                cen_JP = new JPanel();
                getContentPane().add(cen_JP, BorderLayout.CENTER);
                {
                    jb = new JButton();
                    cen_JP.add(jb);
                    jb.setText("jButton1");
                    jbAction ja = new jbAction();
                    pro = new Progress(this);
                    jb.addActionListener(ja);
                }
            }
            pack();
            setSize(400, 300);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    boolean th_Flag = true;

    class jbAction implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            pro.setMaxmem(100);
            pro.setMinmum(0);
            new Thread() {
                public void run() {
                    for (int i = 1; i < 100; i++) {
                        if (!isTh_Flag()) {
                            setTh_Flag(true);

                            break;
                        }
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        pro.setVal(i);
                        System.out.println("===" + i);
                    }
                }
            }.start();
            pro.setVal(0);
            pro.setVisible(true);
        }

    }

    public boolean isTh_Flag() {
        return th_Flag;
    }

    public void setTh_Flag(boolean th_Flag) {
        this.th_Flag = th_Flag;
    }
}

分享到:
评论

相关推荐

    设计模式--观察者模式java例子

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...

    Java设计模式-第22章-观察者模式.ppt

    Java设计模式中的观察者模式(Observer Pattern)是一种对象行为型模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于事件处理和实时...

    java设计模式---诙谐易懂版

    代理模式(Proxy Pattern)、单例模式(Singleton Pattern)、工厂方法模式(...观察者模式(Observer Pattern)、责任链模式(Chain of Responsibility Pattern)、访问者模式(Visitor Pattern)、状态模式(State ...

    设计模式之观察者模式Java实现

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...

    设计模式-观察者模式-作业-observer.zip

    观察者模式(Observer Pattern)是软件设计模式中的行为模式之一,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或发布-...

    java常用设计模式-观察者模式

    观察者模式(Observer Pattern)是一种行为设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖它的对象都会得到通知并自动更新。该模式适用于需要在对象间建立动态的、松散耦合的关系的...

    Java 设计模式-观察者模式(Observer)

    结合微信公众号讲解观察者模式,生动形象,关键是上手快啊

    设计模式之观察者模式(Observer)

    观察者模式(Observer)是软件设计模式中的一种行为模式,其主要目的是在对象之间建立一种松散耦合的关系,使得当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式广泛应用于事件驱动...

    进度条 观察者

    ### 进度条观察者模式在Java Swing中的应用 #### 概述 进度条与观察者模式结合,是处理UI更新和后台任务执行之间通信的一种常见解决方案。在Java Swing框架中,这种组合尤为实用,因为它允许用户界面在长时间运行的...

    java 设计模式 观察者模式 简单实例 包括测试test类

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或者发布...

    Observer设计模式实例

    在实际应用中,Observer模式可以用于处理事件驱动编程,例如在GUI系统中,当用户进行某个操作时,可以触发事件,而多个组件可以作为观察者来监听并处理这些事件。另一个例子是在多线程环境中,一个线程的状态变化...

    Java 多线程编程中的设计模式~

    2. **观察者模式**:在多线程环境中,观察者模式常用于实现线程间的通信,其中一个对象(主题)的状态改变时会通知所有依赖于它的观察者对象,使得它们能够自动更新自己的状态。 3. **职责链模式**:这种模式可以...

    Java线程池及观察者模式解决多线程意外死亡重启问题

    `zdJcbk`可能是一个Java类或接口,而`xfire`可能是另一个类或配置文件,用于展示如何结合线程池和观察者模式来处理线程死亡问题。分析这些代码可以帮助我们更深入地理解这个解决方案的实现细节。 总之,通过Java...

    Observer 观察者模式 示例 源码 ----设计模式

    可以有任意多个观察者观察同一个目标。 提供注册和删除观察者对象的接口。 2.Observer(观察者) 为那些在目标发生改变时需获得通知的对象定义一个更新接口。 3.ConcreteSubject(具体目标) 将有关状态存入...

    详解Observer Pattern(观察者模式)在Java中的使用原理

    我们说学习Java应该从Swing开始,那么学习Swing最重要的思想就是对于观察者模式的理解(Observer Pattern)。因为,该设计模式在Java Swing框架中贯穿了始终。对于C#的委托、代理概念所使用的Callback(回调模式--...

    java23种设计模式之观察者模式

    这个模式的核心思想是“一对多”的依赖关系,即一个主题对象(Subject)可以被多个观察者(Observer)关注,当主题状态发生变化时,会自动通知所有观察者进行相应的更新。 ### 1. 观察者模式的概念与结构 - **主题...

    设计模式-观察者

    7. **其他变体**:除了基本的观察者模式,还有复合观察者模式,允许一个观察者对象包含多个观察者,以及异步观察者模式,通知过程在不同的线程中执行,以避免阻塞主线程。 在实际开发中,理解并熟练运用观察者模式...

    设计模式之观察者模式(Observer Pattern)

    观察者接口(Observer)定义了一个`update()`方法,用于接收和处理来自主题的通知。 扩展增强: "ObserverPattern(扩展增强)2.rar"可能包含更复杂的设计,例如支持多态观察者、区分同步和异步通知、或者提供更灵活...

    [行为模式]head first 设计模式之观察者模式(observer)

    观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式在软件开发中广泛应用于事件驱动...

    设计模式C++学习之观察者模式(Observer)

    观察者模式(Observer)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式在C++中广泛应用,特别是在需要...

Global site tag (gtag.js) - Google Analytics