Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
setSize(screenSize);

解决方案 »

  1.   

    可以在初始化时调用如下方法:
        Toolkit kit = Toolkit.getDefaultToolkit();
        Dimension screenSize = kit.getScreenSize();
        int screenHeight = screenSize.height;
        int screenWidth = screenSize.width;
        setSize(screenWidth , screenHeight );
      

  2.   

    Frame1 f = new Frame1();
        f.show();
        f.setExtendedState(JFrame.MAXIMIZED_BOTH);
      

  3.   

    f.setExtendedState(JFrame.MAXIMIZED_BOTH);
    It's good.What have same function in JInternalFrame?
      

  4.   

    楼上说的没错,就是这个方法啊
    f.setExtendedState(JFrame.MAXIMIZED_BOTH);
      

  5.   

    不好意思,俺用的是jdk1.3.1
    JFrame里面是还没有这个方法的
    在jdk1.3.1下,怎么实现阿
      

  6.   

    Jframe.setSize(1024,768);
    不知对不
      

  7.   

    如果要最大化的话setExtendedState(JFrame.MAXIMIZED_BOTH);就可以如果要全屏的话给你代码!
      

  8.   

    package com.Dorian.Util;import java.awt.DisplayMode;
    import java.awt.EventQueue;
    import java.awt.Graphics2D;
    import java.awt.GraphicsConfiguration;
    import java.awt.GraphicsDevice;
    import java.awt.GraphicsEnvironment;
    import java.awt.Toolkit;
    import java.awt.Window;
    import java.awt.image.BufferStrategy;
    import java.awt.image.BufferedImage;
    import java.lang.reflect.InvocationTargetException;import javax.swing.JFrame;/**
     * <p>屏幕管理器</p>
     * <P>---------------------------------------------------------
     * <p>屏幕管理初始化,显示全屏图形方式(不适用与Windows Server 2003)
     * <P>---------------------------------------------------------
     * <P>Copyright (c) 2004 Dorian. All rights reserved</p>
     * <P>(#)ScreenManager.java</p>
     * <P>创建日期 2004-6-30</p>
     * <P>更新日期 2004-6-30</p>
     * @author 史徐华</p>
     * @version 1.0.0</p>
     */
    public class ScreenManager {
        /**
         * 构造函数
         * 创建屏幕管理器实例
         */
        public ScreenManager() {
            GraphicsEnvironment environment =
                GraphicsEnvironment.getLocalGraphicsEnvironment();
            device = environment.getDefaultScreenDevice();
        }    /**
         * 对系统缺省设备返回一列兼容显示方式
         * @return DisplayMode[]
         */
        public DisplayMode[] getCompatibleDisplayModes() {
            return device.getDisplayModes();
        }    /**
         * 获取所有兼容显示方式列表中的第一个方式
         * @param modes[] 一列显示方式
         * @return DisplayMode 如果没有,则返回NULL
         */
        public DisplayMode getFirstCompatibleMode(DisplayMode modes[]) {
            DisplayMode goodModes[] = device.getDisplayModes();
            for (int i = 0; i < modes.length; i++) {
                for (int j = 0; j < goodModes.length; j++) {
                    if (equalDisplayModes(modes[i], goodModes[j])) {
                        return modes[i];
                    }
                }
            }
            return null;
        }    /**
         * 返回系统当前的显示方式
         * @return DisplayMode
         */
        public DisplayMode getCurrentDisplayMode() {
            return device.getDisplayMode();
        }    /**
         * 确定两个显示方式是否匹配。
         * 两个显示方式匹配指具有相同分辨率、位深度、和刷新率。
         * 如果一个显示方式的位深度为DisplayMode.BIT_DEPTH_MULTI,则忽略刷新率。
         * 如果一个显示方式的刷新率为DisplayMode.REFRESH_RATE_UNKNOWN,则忽略位深度。
         * @param mode1 模式一
         * @param mode2 模式二
         * @return boolean
         */
        public boolean equalDisplayModes(DisplayMode mode1, DisplayMode mode2) {
            if (mode1.getWidth() != mode2.getWidth()
                || mode1.getHeight() != mode2.getHeight()) {
                return false;
            }
            if (mode1.getBitDepth() != DisplayMode.BIT_DEPTH_MULTI
                && mode2.getBitDepth() != DisplayMode.BIT_DEPTH_MULTI
                && mode1.getBitDepth() != mode2.getBitDepth()) {
                return false;
            }
            if (mode1.getRefreshRate() != DisplayMode.REFRESH_RATE_UNKNOWN
                && mode2.getRefreshRate() != DisplayMode.REFRESH_RATE_UNKNOWN
                && mode1.getRefreshRate() != mode2.getRefreshRate()) {
                return false;
            }
            return true;
        }    /**
         * 进入全屏方式和改变显示方式。如果指定显示方式为NULL或与这个设备不兼容,
         * 或这个系统无法改变显示方式,则使用当前显示方式。
         * <p>显示所用BufferStrategy有2个缓存区。
         * @param displayMode 显示模式
         */
        public void setFullScreen(DisplayMode displayMode) {
            final JFrame frame = new JFrame();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setUndecorated(true);
            frame.setIgnoreRepaint(true);
            frame.setResizable(false);        device.setFullScreenWindow(frame);        if (displayMode != null && device.isDisplayChangeSupported()) {
                try {
                    device.setDisplayMode(displayMode);
                } catch (IllegalArgumentException ex) {}
                // 固定窗体的大小,防止在Mac OS X中发生错误
                frame.setSize(displayMode.getWidth(), displayMode.getHeight());
            }
            // 消除可能的死锁 in 1.4.1
            try {
                EventQueue.invokeAndWait(new Runnable() {
                    public void run() {
                        frame.createBufferStrategy(2);
                    }
                });
            } catch (InterruptedException ex) {
                // 忽略
            } catch (InvocationTargetException ex) {
                // 忽略
            }
        }    /**
         * 取得显示的图形描述表ScreenManager使用双缓存,因此应用程序要
         * 调用update()方法,显示绘制的任何图形。
         * @return Graphics2D
         */
        public Graphics2D getGraphics() {
            Window window = device.getFullScreenWindow();
            if (window != null) {
                BufferStrategy strategy = window.getBufferStrategy();
                return (Graphics2D) strategy.getDrawGraphics();
            } else {
                return null;
            }
        }    /**
         * 更新显示
         */
        public void update() {
            Window window = device.getFullScreenWindow();
            if (window != null) {
                BufferStrategy strategy = window.getBufferStrategy();
                if (!strategy.contentsLost()) {
                    strategy.show();
                }
            }
            // 这个方法保证显示与窗口系统同步。
            // 如果不调用这个方法在Linux系统中可能遇到延迟的鼠标和键盘输入事件。
            Toolkit.getDefaultToolkit().sync();
        }    /**
         * 返回全屏方式中当前使用的窗口,如果设备不在全屏方式中,则返回NULL
         * @return JFrame
         */
        public JFrame getFullScreenWindow() {
            return (JFrame) device.getFullScreenWindow();
        }    /**
         * 返回全屏方式中当前使用的窗口宽度,如果设备不在全屏方式中,则返回0
         * @return int 宽
         */
        public int getWidth() {
            Window window = device.getFullScreenWindow();
            if (window != null) {
                return window.getWidth();
            } else {
                return 0;
            }
        }    /**
         * 返回全屏方式中当前使用的窗口高度,如果设备不在全屏方式中,则返回0
         * @return int 高
         */
        public int getHeight() {
            Window window = device.getFullScreenWindow();
            if (window != null) {
                return window.getHeight();
            } else {
                return 0;
            }
        }    /**
         * 恢复屏幕的显示方式
         */
        public void restoreScreen() {
            Window window = device.getFullScreenWindow();
            if (window != null) {
                window.dispose();
            }
            device.setFullScreenWindow(null);
        }    /**
         * 生成与当前显示器兼容的图像
         * @param width 宽
         * @param height 高
         * @param transparancy 透明度
         * @return BufferedImage 缓冲图片
         */
        public BufferedImage createCompatibleImage(int width,int height,
                                                   int transparancy) {
            Window window = device.getFullScreenWindow();
            if (window != null) {
                GraphicsConfiguration gc = window.getGraphicsConfiguration();
                return gc.createCompatibleImage(width, height, transparancy);
            }
            return null;
        }    private GraphicsDevice device;
    }
      

  9.   

    JFrame ---------------->setExtendedState(JFrame.MAXIMIZED_BOTH);JInternalFrame -------->setMaximum(true);