Fenêtre JFrame Maximize

Je mets en place une animation rapide et sale en utilisant le swing. Je voudrais que la fenêtre soit maximisée. Comment puis je faire ça?

À condition que vous étendiez JFrame:

public void run() {
    MyFrame myFrame = new MyFrame();
    myFrame.setVisible(true);
    myFrame.setExtendedState(myFrame.getExtendedState() | JFrame.MAXIMIZED_BOTH);
}

Quelque chose comme this.setExtendedState(this.getExtendedState() | this.MAXIMIZED_BOTH);

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

public class Test extends JFrame
{
    public Test()
    {
        GraphicsEnvironment env =
GraphicsEnvironment.getLocalGraphicsEnvironment();
        this.setMaximizedBounds(env.getMaximumWindowBounds());
        this.setExtendedState(this.getExtendedState() | this.MAXIMIZED_BOTH);
    }

    public static void main(String[] args)
    {
        JFrame.setDefaultLookAndFeelDecorated(true);

        Test t = new Test();
        t.setVisible(true);
    }
}

Si vous utilisez un JFrame, essayez ceci

JFrame frame = new JFrame();
//...
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);

Et pourquoi pas JFrame.setExtendedState(JFrame.MAXIMIZED_BOTH)?

j'aime cette version:

import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.Toolkit;
import javax.swing.JFrame;

public class Test
{
    public static void main(String [] args)
    {
        final JFrame frame = new JFrame();
        final GraphicsConfiguration config = frame.getGraphicsConfiguration();

        final int left = Toolkit.getDefaultToolkit().getScreenInsets(config).left;
        final int right = Toolkit.getDefaultToolkit().getScreenInsets(config).right;
        final int top = Toolkit.getDefaultToolkit().getScreenInsets(config).top;
        final int bottom = Toolkit.getDefaultToolkit().getScreenInsets(config).bottom;

        final Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        final int width = screenSize.width - left - right;
        final int height = screenSize.height - top - bottom;

        frame.setResizable(false);
        frame.setSize(width,height);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);       
        frame.setVisible(true);
    }
}

La façon de définir JFrame en plein écran consiste à définir l' MAXIMIZED_BOTHoption qui représente MAXIMIZED_VERT | MAXIMIZED_HORIZ, qui définit respectivement le cadre pour maximiser verticalement et horizontalement

package Example;
import java.awt.GraphicsConfiguration;
import javax.swing.JFrame;
import javax.swing.JButton;

public class JFrameExample
{
    static JFrame frame;
    static GraphicsConfiguration gc;
    public static void main(String[] args)
    {
        frame = new JFrame(gc);
        frame.setTitle("Full Screen Example");
        frame.setExtendedState(MAXIMIZED_BOTH);

        JButton button = new JButton("exit");
        b.addActionListener(new ActionListener(){@Override
        public void actionPerformed(ActionEvent arg0){
            JFrameExample.frame.dispose();
            System.exit(0);
        }});

        frame.add(button);
        frame.setVisible(true);
    }
}

J'ai essayé les solutions dans ce fil et celles ici , mais le simple fait d'appeler setExtendedState(getExtendedState()|Frame.MAXIMIZED_BOTH);juste après l'appel setVisible(true);ne fonctionne apparemment pas pour mon environnement (Windows 10, JDK 1.8, ma barre des tâches est sur le côté droit de mon écran). Faire de cette façon laisse encore un petit espace à gauche, à droite et en bas.

Ce qui a fonctionné pour moi, c'est d'appeler setExtendedState(...lorsque la fenêtre est activée, comme ceci:

public class SomeFrame extends JFrame {

    public SomeFrame() {
        // ...
        setVisible(true);
        setResizable(true);
        // if you are calling setSize() for fallback size, do that here
        addWindowListener (
            new WindowAdapter() {
                private boolean shown = false;
                @Override
                public void windowActivated(WindowEvent we) {
                    if(shown) return;
                    shown = true;
                    setExtendedState(getExtendedState()|JFrame.MAXIMIZED_BOTH);
                }
            }
        );
    }
}

J'ai fini par utiliser ce code:

public void setMaximized(boolean maximized){
    if(maximized){
        DisplayMode mode = this.getGraphicsConfiguration().getDevice().getDisplayMode();
        Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(this.getGraphicsConfiguration());
        this.setMaximizedBounds(new Rectangle(
                mode.getWidth() - insets.right - insets.left, 
                mode.getHeight() - insets.top - insets.bottom
        ));
        this.setExtendedState(this.getExtendedState() | JFrame.MAXIMIZED_BOTH);
    }else{
        this.setExtendedState(JFrame.NORMAL);
    }
}

Ces options fonctionnaient le mieux de toutes les options, y compris la prise en charge de plusieurs moniteurs. Le seul défaut que cela présente est que le décalage de la barre des tâches est utilisé sur tous les moniteurs dans certaines configurations.

La réponse @kgiannakakis est tout à fait correcte, mais si quelqu'un est coincé dans ce problème et utilise Java 6 sur Linux (par exemple, Mint 19 Cinnamon), l' état MAXIMIZED_BOTH n'est parfois pas appliqué.

Vous pouvez essayer d'appeler la méthode pack () après avoir défini cet état.

Exemple de code:

public MainFrame() {
    setContentPane(contentPanel); //some JPanel is here
    setPreferredSize(new Dimension(1200, 800));
    setMinimumSize(new Dimension(1200, 800));
    setSize(new Dimension(1200, 800));
    setExtendedState(JFrame.MAXIMIZED_BOTH);
    pack();
}

Cela n'est pas nécessaire si vous utilisez Java 7+ ou Java 6 sous Windows.