JFrame.setExtendedState 实际上并没有最大化

Question

public static void main(String args[]){
    JFrame frame = new JFrame();
    frame.setExtendedState(JFrame.MAXIMISED_BOTH);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setVisible(true);
}

I've used this code to maximise a JFrame, but instead of actually maximising the frame, it just sets the window size to that of the screen, without actually changing the state, so clicking the maximize button doesn't actually downscale it again.

Am I using the wrong command or something?

Answer 1

You have an error in frame.setExtendedState(JFrame.MAXIMISED_BOTH);

You should write frame.setExtendedState(JFrame.MAXIMIZED_BOTH); instead

Answer 2

You must want it maximized by default. Because the maximize button works out-of-the-box.

frame.setExtendedState(JFrame.MAXIMIZED_BOTH) works on Linux x64. Here's the program I tested with:

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

public class Test implements ActionListener {

  public static void main(String... args) {
    new Test();
  }

  private JFrame frame;

  public Test() {
    frame = new JFrame();
    frame.add(new JLabel("Hi!"), BorderLayout.CENTER);
    JButton button = new JButton("maximize");
    button.addActionListener(this);
    frame.add(button, BorderLayout.SOUTH);
    frame.pack();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setVisible(true);
  }


  @Override
  public void actionPerformed(ActionEvent e) {
    frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
  }
}

Answer 3

你试过这个吗？

f.setExtendedState(f.getExtendedState() | JFrame.MAXIMIZED_BOTH);

Answer 4

Based on your provided example and run on Windows 7...

"Maximised" state (this is cropped version of window as the original is quite large)

"Normal" state

import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class ExtendedFrame {

    public static void main(String[] args) {
        new ExtendedFrame();
    }

    public ExtendedFrame() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame();
//                frame.setExtendedState(JFrame.MAXIMISED_BOTH);
                frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }
}

Answer 5

This worked for me:

We need to combine the setSize () and setExtendedState together JFrame frame=new JFrame();

frame.setExtendedState(JFrame.MAXIMIZED_BOTH); // aligns itself with windows task bar
// set maximum screen   
frame.setSize((int)Toolkit.getDefaultToolkit().getScreenSize().getWidth(), (int)Toolkit.getDefaultToolkit().getScreenSize().getHeight());

Answer 6

您应该在应用更改时使用它

frame.setResizable(true);

Answer 7

Seven years late is better than never, right?

The question does not provide an SSCCE presumably because this is not all of the code involved. The tiny fragment of code provided work as it is, so practically all previous answers are saying "works for me". So, the problem certainly lies with the rest of the code, which is not shown.

We cannot be sure what the rest of the code does, but I suspect that it tries to persist the state and bounds of the frame, and to restore that state and bounds later, and that is what fails. The OP did not receive an answer 7 years ago because they did not explain what the actual problem was, but this question will be viewed by many more, so here it goes:

In theory, persisting the state and bounds of a frame should be piece of cake, but in practice it is not.

This is a very common problem in GUI applications, and it is basically due to a common mistake on behalf of the programmer. However, it should be noted that various widely used GUI frameworks (and certainly both Swing and SWT in the Java world) operate in a specific perverse way which makes it a very easy mistake to make.

The problem begins with the fact that these frameworks do not support a 'maximized' event, (duh!) so the only way you can detect that your frame has been maximized is to listen to the 'resized' event. So, you are presumably persisting the state and dimensions of your frame from within your 'resized' event handler.

The problem is further compounded by the fact that once the 'resized' event has occurred as a result of maximizing the frame, the frame bounds are the maximized bounds of your frame, which are irrelevant, and you will be shooting yourself in the foot if you make the mistake of persisting them.

So, the solution is to manually keep track of the "normal state" bounds of your frame, and only persist those. This can be accomplished as follows:

    addComponentListener( new ComponentAdapter()
    {
        @Override public void componentResized( ComponentEvent e )
        {
            if( (getExtendedState() & MAXIMIZED_HORIZ) == 0 )
                normalStateBounds.width = getWidth();
            if( (getExtendedState() & MAXIMIZED_VERT) == 0 )
                normalStateBounds.height = getHeight();
            stateAndOrSizeChanged();
        }
        @Override public void componentMoved( ComponentEvent e )
        {
            if( (getExtendedState() & MAXIMIZED_HORIZ) == 0 )
                normalStateBounds.x = getX();
            if( (getExtendedState() & MAXIMIZED_VERT) == 0 )
                normalStateBounds.y = getY();
            stateAndOrSizeChanged();
        }
    } );

...where:

• normalStateBounds is defined as private final Rectangle normalStateBounds = new Rectangle(); and contains the bounds of your component when in the "normal" (ie not minimized, nor maximized) state

• stateAndOrSizeChanged() is your function which handles persisting the state and bounds of your frame, being careful to only persist normalStateBounds instead of the values returned by getX() , getY() , getWidth() , and getHeight() .

When loading the state and bounds from persistence, you can simply invoke setBounds() followed by setExtendedState() , and you should do that before invoking setVisible( true ) to avoid the possibility of your frame appearing restored for a blink of an eye before maximizing. The call to setBounds() will set the non-maximized bounds, and the call to setExtendedState() might maximize your frame, but if you then restore it, it will assume the non-maximized bounds that you have set.

Answer 8

It works for me running Java 7 on a WinXP machine.

For the record, this is what an SSCCE should look like:

import javax.swing.*;

public class JFrameExtendedDemo
{
  public static void main(String[] args)
  {
    SwingUtilities.invokeLater(new Runnable()
    {
      public void run()
      {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(300, 200);
        f.setLocationRelativeTo(null);
        f.setVisible(true);

        // Then:
        f.setExtendedState(JFrame.MAXIMIZED_BOTH);
      }
    });
  }
}