JFrame Maximize-Fenster

Ich stelle eine schnelle und schmutzige Animation mit Swing zusammen. Ich möchte, dass das Fenster maximiert wird. Wie kann ich das machen?

Vorausgesetzt, Sie erweitern JFrame:

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

Etwas wie 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);
    }
}

Wenn Sie einen JFrame verwenden, versuchen Sie dies

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

Wie wäre es mit JFrame.setExtendedState(JFrame.MAXIMIZED_BOTH)?

Ich mag diese 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);
    }
}

Um JFrame auf Vollbild einzustellen, müssen Sie die MAXIMIZED_BOTHOption festlegen , für MAXIMIZED_VERT | MAXIMIZED_HORIZdie der Frame jeweils so eingestellt ist, dass er vertikal und horizontal maximiert wird

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);
    }
}

Ich habe die Lösungen in diesem und den hier aufgeführten Threads ausprobiert , aber ein einfacher Anruf setExtendedState(getExtendedState()|Frame.MAXIMIZED_BOTH);direkt nach dem Aufruf setVisible(true);funktioniert anscheinend nicht für meine Umgebung (Windows 10, JDK 1.8, meine Taskleiste befindet sich auf der rechten Seite meines Bildschirms). Wenn Sie dies auf diese Weise tun, bleibt links, rechts und unten immer noch ein winziger Raum.

Was für mich jedoch funktioniert hat, ist das Aufrufen, setExtendedState(...wenn das Fenster aktiviert ist, wie folgt:

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);
                }
            }
        );
    }
}

Am Ende habe ich diesen Code verwendet:

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);
    }
}

Diese Option funktionierte am besten von allen Optionen, einschließlich der Unterstützung mehrerer Monitore. Der einzige Fehler, den dies hat, ist, dass der Taskleistenversatz auf allen Monitoren in einigen Konfigurationen verwendet wird.

Die Antwort von @kgiannakakis ist völlig korrekt, aber wenn jemand an diesem Problem festhält und Java 6 unter Linux verwendet (z. B. Mint 19 Cinnamon), wird der Status MAXIMIZED_BOTH manchmal nicht angewendet.

Sie können versuchen, die pack () -Methode aufzurufen , nachdem Sie diesen Status festgelegt haben.

Codebeispiel:

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();
}

Dies ist nicht erforderlich, wenn Sie Java 7+ oder Java 6 unter Windows verwenden.