Swing (Java) - Swing (Java)

Příklad widgetů Swing v Javě

Swing je sada nástrojů widgetů GUI pro Javu . Je součástí Oracle ‚s Java Foundation Classes (JFC) - což je API pro poskytování grafického uživatelského rozhraní (GUI) pro programy v jazyce Java.

Swing byl vyvinut tak, aby poskytoval sofistikovanější sadu komponent GUI než dřívější sada nástrojů pro abstraktní okna (AWT) . Swing poskytuje vzhled a dojem, který napodobuje vzhled a dojem několika platforem, a také podporuje připojitelný vzhled a dojem, který umožňuje aplikacím vypadat a cítit se nesouvisí s podkladovou platformou. Má výkonnější a flexibilnější komponenty než AWT. Kromě známých komponent, jako jsou tlačítka, zaškrtávací políčka a popisky, nabízí Swing několik pokročilých komponent, jako je panel s kartami, posuvníky, stromy, tabulky a seznamy.

Na rozdíl od komponent AWT nejsou komponenty Swing implementovány kódem specifickým pro platformu. Místo toho jsou napsány zcela v Javě, a proto jsou nezávislé na platformě.

V prosinci 2008 Sun Microsystems (předchůdce společnosti Oracle) vydal rámec založený na CSS / FXML , který měl být nástupcem Swingu, nazvaný JavaFX .

Dějiny

The Internet Foundation Classes (IFC) byly grafická knihovna pro Javu byl původně vyvinut firmou Netscape Communications Corporation a nejprve povolený 16. prosince 1996. Dne 2. dubna 1997, Sun Microsystems a Netscape Communications Corporation oznámila svůj záměr začlenit IFC s jinými technologiemi pro tvoří třídy Java Foundation Classes . „Java Foundation Classes“ byly později přejmenovány na „Swing“.

Swing představil mechanismus, který umožňoval měnit vzhled a chování každé součásti v aplikaci, aniž by bylo nutné zásadně měnit kód aplikace. Zavedení podpory pro připojitelný vzhled a chování umožňuje komponentám Swing napodobit vzhled nativních komponent a přitom si zachovat výhody nezávislosti na platformě. Swing, původně distribuovaný jako samostatně stahovatelná knihovna, je od verze 1.2 součástí Java Standard Edition . Třídy a komponenty Swing jsou obsaženy v hierarchii javax.swing balíčků .

Vývoj nástupce Swingu, JavaFX , byl zahájen v roce 2005 a byl oficiálně představen o dva roky později na JavaOne 2007. JavaFX byl otevřen v roce 2011 a v roce 2012 se stal součástí stahování Oracle JDK. JavaFX nahrazuje Swing kvůli několika výhodám, včetně toho, že jsou lehčí, mají styl CSS , elegantní ovládací prvky designu a použití FXML a Scene Builder. V roce 2018 byl JavaFX zařazen do OpenJDK v rámci projektu OpenJFX, aby se zvýšilo tempo jeho vývoje.

Členy týmu Java Client, který byl zodpovědný za Swing, byli James Gosling (architekt), Rick Levenson (manažer), Amy Fowler & Hans Muller (vedoucí technického týmu), Tom Ball, Jeff Dinkins, Georges Saab, Tim Prinzing, Jonni Kanerva a Jeannette Hung & Jim Graham (2D grafika).

Architektura

Swing je na platformě nezávislý GUI framework „ model-view-controller “ pro Javu, který navazuje na jednovláknový programovací model. Tento rámec navíc poskytuje vrstvu abstrakce mezi strukturou kódu a grafickou prezentací GUI založeného na Swingu.

Nadace

Swing je nezávislý na platformě, protože je kompletně napsán v Javě. Kompletní dokumentaci pro všechny třídy Swing najdete v příručce Java API Guide pro verzi 6 nebo specifikaci API Java Platform Standard Edition 8 pro verzi 8.

Rozšiřitelný

Swing je vysoce modulární architektura, která umožňuje „zapojení“ různých vlastních implementací specifikovaných rozhraní rozhraní: Uživatelé mohou poskytnout vlastní vlastní implementace těchto komponent a přepsat výchozí implementace pomocí mechanismu dědičnosti jazyka Java prostřednictvím javax.swing.LookAndFeel.

Swing je framework založený na komponentách , jehož komponenty jsou nakonec odvozeny od javax.swing.JComponenttřídy. Swing objekty asynchronně spouštějí události, mají svázané vlastnosti a reagují na zdokumentovanou sadu metod specifických pro komponentu. Komponenty Swing jsou komponenty JavaBeans , které jsou v souladu se specifikací JavaBeans .

Konfigurovatelné

Silná závislost Swingu na běhových mechanismech a nepřímých kompozičních vzorcích mu umožňuje reagovat za běhu na zásadní změny v jeho nastavení. Například aplikace založená na Swingu je schopná za běhu vyměnit své uživatelské rozhraní za běhu. Kromě toho mohou uživatelé poskytovat vlastní implementaci vzhledu a chování, která umožňuje jednotné změny vzhledu a chování stávajících aplikací Swing bez jakékoli programové změny kódu aplikace.

Lehké uživatelské rozhraní

Vysoká úroveň flexibility Swingu se odráží v jeho vlastní schopnosti přepsat ovládací prvky GUI nativního hostitelského operačního systému (OS) pro samotné zobrazení. Swing „maluje“ své ovládací prvky pomocí Java 2D API, místo aby volal sadu nástrojů nativního uživatelského rozhraní. Komponenta Swing tedy nemá odpovídající nativní komponentu grafického uživatelského rozhraní OS a může se libovolně vykreslovat jakýmkoli způsobem, který je možný s podkladovými grafickými GUI.

Ve svém jádru se však každá součást Swing spoléhá na kontejner AWT , protože (Swing's) JComponentextends (AWT's) Container. To umožňuje Swingu zapojit se do rámce správy GUI hostitelského OS, včetně zásadních mapování zařízení/obrazovky a interakcí uživatelů, jako jsou například stisknutí kláves nebo pohyby myši. Swing jednoduše „transponuje“ svou vlastní (OS-agnostickou) sémantiku nad základní (OS-specifické) komponenty. Například každá komponenta Swing maluje své ztvárnění na grafickém zařízení v reakci na volání komponenty.paint (), která je definována v (AWT) Container. Ale na rozdíl od komponent AWT, které přenesly obraz na svůj „nativní“ widget nativní pro OS, jsou komponenty Swing zodpovědné za vlastní vykreslování.

Tato transpozice a oddělování není pouze vizuální a rozšiřuje se na správu a aplikaci Swing vlastní sémantiky nezávislé na operačním systému pro události spuštěné v rámci jejích hierarchií omezení obsahu. Obecně lze říci, že architektura Swing deleguje úkol mapovat různé varianty sémantiky OS GUI na jednoduchý, ale zobecněný vzor na kontejner AWT. Na základě této generalizované platformy vytváří vlastní bohatou a komplexní sémantiku GUI ve formě JComponentmodelu.

Volně spřažené a MVC

Knihovna Swing dělá těžké použití Model-View-Controller software návrhový vzor , který koncepčně odděluje údaje jsou při pohledu z ovládacích prvků uživatelského rozhraní, jehož prostřednictvím je prohlíželi. Z tohoto důvodu má většina komponent Swing přidružené modely (které jsou specifikovány z hlediska rozhraní Java ) a programátoři mohou používat různé výchozí implementace nebo poskytovat své vlastní. Rámec poskytuje výchozí implementace modelových rozhraní pro všechny jeho konkrétní součásti. Typické použití rámce Swing nevyžaduje vytváření vlastních modelů, protože rámec poskytuje sadu výchozích implementací, které jsou ve výchozím nastavení transparentně přidruženy k odpovídající JComponentpodřízené třídě v knihovně Swing. Obecně platí, že implementaci vlastního modelu kolem datových struktur specifických pro aplikaci mohou vyžadovat pouze složité komponenty, jako jsou tabulky, stromy a někdy i seznamy. Abyste získali dobrý pocit z potenciálu, který architektura Swing umožňuje, vezměte v úvahu hypotetickou situaci, kdy vlastní modely pro tabulky a seznamy jsou obaly nad službami DAO a/nebo EJB .

Objekty modelu komponenty Swing jsou obvykle zodpovědné za poskytování stručného rozhraní definujícího spuštěné události a přístupné vlastnosti pro (koncepční) datový model pro použití přidruženým JComponent. Vzhledem k tomu, že celkový vzor MVC je volně spřažený vzorec spolupráce mezi objekty, model poskytuje programové prostředky pro připojení posluchačů událostí k objektu datového modelu. Obvykle jsou tyto události zaměřeny na model (např. Událost „vložený do řádku“ v modelu tabulky) a jsou specializací JComponent mapovány na smysluplnou událost pro komponentu GUI.

Například JTablemá model s názvem, TableModelkterý popisuje rozhraní pro přístup tabulky k tabulkovým datům. Výchozí implementace tohoto funguje na dvourozměrném poli .

Komponenta zobrazení Swing JComponent je objekt používaný k grafické reprezentaci koncepčního ovládacího prvku GUI. Rozlišení Swingu jako rámce GUI spočívá v jeho spoléhání na programově vykreslené ovládací prvky GUI (na rozdíl od používání ovládacích prvků GUI nativního hostitelského OS). Před aktualizací Java 6 Update 10 bylo toto rozlišení zdrojem komplikací při míchání ovládacích prvků AWT, které používají nativní ovládací prvky, s ovládacími prvky Swing v grafickém uživatelském rozhraní (viz Míchání komponent AWT a Swing ).

A konečně, pokud jde o vizuální kompozici a správu, Swing upřednostňuje relativní rozložení (které určují polohové vztahy mezi komponentami) na rozdíl od absolutních rozložení (které určují přesné umístění a velikost komponent). Tato zaujatost vůči „tekutému“ vizuálnímu uspořádání je dána jeho původem v operačním prostředí appletu, které rámovalo návrh a vývoj původní sady nástrojů Java GUI. (Koncepčně je tento pohled na správu rozložení dosti podobný tomu, který informuje o vykreslování obsahu HTML v prohlížečích a řeší stejný soubor problémů, které motivovaly ty první.)

Vztah k AWT

Hierarchie tříd AWT a Swing

Od raných verzí Javy poskytuje část sady nástrojů pro práci s okny (AWT) abstraktní platformu API pro komponenty uživatelského rozhraní. V AWT je každá komponenta vykreslena a řízena nativní peer komponentou specifickou pro podkladový okenní systém.

Naproti tomu komponenty Swing jsou často popisovány jako odlehčené, protože nevyžadují alokaci nativních prostředků v sadě nástrojů pro okna operačního systému. Komponenty AWT jsou označovány jako těžké součásti .

Většina API Swing je obecně spíše doplňkovým rozšířením AWT než přímou náhradou. Ve skutečnosti, každý Swing lehký interface nakonec existuje v rámci AWT těžké váze složky, protože všechny složky nejvyšší úrovně v Swing ( JApplet, JDialog, JFramea JWindow) prodloužit kontejner s AWT nejvyšší úrovně. Před aktualizací Java 6 Update 10 bylo používání nekomplikovaných a těžkých komponent ve stejném okně obecně nedoporučováno kvůli nekompatibilitě pořadí Z. Novější verze Javy však tyto problémy vyřešily a komponenty Swing i AWT lze nyní používat v jednom grafickém uživatelském rozhraní bez problémů s uspořádáním Z.

Základní funkce vykreslování, kterou Swing používá k kreslení svých odlehčených komponent, poskytuje Java 2D , další část JFC.

Vztah k SWT

Standard Widget Toolkit (SWT) je soutěží toolkit původně vyvinutý společností IBM a nyní vedeném Eclipse komunity . Implementace SWT má více společného s těžkými komponentami AWT. To poskytuje výhody, jako je přesnější věrnost podkladové sadě nástrojů nativních oken, za cenu zvýšené expozice nativní platformě v programovacím modelu.

O výkonu SWT versus Swing došlo k významné debatě a spekulacím; někteří naznačovali, že silná závislost SWT na JNI by zpomalila, když komponenta GUI a Java potřebují komunikovat data, ale rychlejší při vykreslování, když byl datový model načten do GUI, ale ani to nebylo potvrzeno. Poměrně důkladný soubor referenčních hodnot v roce 2005 dospěl k závěru, že ani Swing, ani SWT v obecném případě jasně nepřekonaly ostatní.

Příklady

Ahoj světe

Tento příklad aplikace Swing vytvoří jediné okno s nápisem „Hello, world!“ uvnitř: 

// Hello.java (Java SE 5)
import javax.swing.*;

public class Hello extends JFrame {
    public Hello() {
        super("hello");
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        this.add(new JLabel("Hello, world!"));
        this.pack();
        this.setVisible(true);
    }

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

První importzahrnuje všechny veřejné třídy a rozhraní z javax.swingbalíčku.

HelloTřída třída; třída implementuje okno s záhlaví a úzké kontroly . extendsJFrameJFrame

Hello() Konstruktor inicializuje rámeček nejprve volá konstruktor nadtřídy, předávání parametr "hello", který se používá jako název okna. Potom zavolá setDefaultCloseOperation(int)metodu zděděnou z, JFrameaby nastavila výchozí operaci, když je vybrán ovládací prvek zavírání na záhlaví WindowConstants.EXIT_ON_CLOSE - to způsobí, že JFramebude odstraněn, když je rám zavřený (na rozdíl od pouze skrytého), což umožňuje virtuálnímu počítači Java ukončit a program ukončit. Dále JLabelje vytvořeno a pro řetězec „Hello, world!“ a add(Component)metoda zděděná z Containernadtřídy je volána k přidání popisku do rámečku. pack()Metoda dědí z Windowrodičovské třídy se nazývá velikosti okna a rozvržení jeho obsahu.

main()Metoda se nazývá virtuálním strojem Javy při spuštění programu. Vytváří instanci nového Hellorámce a způsobí jeho zobrazení voláním setVisible(boolean)metody zděděné z Componentnadtřídy s booleovským parametrem true. Jakmile se zobrazí rámec, ukončení mainmetody nezpůsobí ukončení programu, protože vlákno pro odeslání události AWT zůstane aktivní, dokud nebudou odstraněna všechna okna nejvyšší úrovně Swing.

Okno s tlačítkem

Základní ukázkový kód běžící na Windows 7

Následuje celkem jednoduchý program založený na Swingu. Zobrazí se okno (a JFrame) obsahující štítek a tlačítko. 

import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;
import javax.swing.SwingUtilities;
 
public class SwingExample implements Runnable {

    @Override
    public void run() {
        // Create the window
        JFrame f = new JFrame("Hello, !");
        // Sets the behavior for when the window is closed
        f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        // Add a layout manager so that the button is not placed on top of the label
        f.setLayout(new FlowLayout());
        // Add a label and a button
        f.add(new JLabel("Hello, world!"));
        f.add(new JButton("Press me!"));
        // Arrange the components inside the window
        f.pack();
        // By default, the window is not visible. Make it visible.
        f.setVisible(true);
    }
 
    public static void main(String[] args) {
        SwingExample se = new SwingExample();
        // Schedules the application to be run at the correct time in the event queue.
        SwingUtilities.invokeLater(se);
    }

}

Všimněte si, jak jsou všechny instance a manipulace s komponentami Swing prováděny vytvořením instance třídy, která implementuje rozhraní Runnable. To se pak spustí na vlákně odeslání události pomocí metody SwingUtilities.invokeLater(Runnable)), vytvořené v hlavní metodě (viz Swing a bezpečnost vláken ). Přestože kód Swing lze spustit bez použití této techniky (například neimplementací Runnable a přesunutím všech příkazů z metody run do hlavní metody), považuje se za dobrou formu, protože Swing není bezpečný pro vlákna , což znamená, že vyvolání zdrojů z více vláken může mít za následek rušení vláken a chyby konzistence paměti.

Další příklad

V tomto případě nechte javax.swing.JFrame super třídu a přidejte do ní vlastní widgety (v tomto případě JButton). 

import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;

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

public class Sample extends JFrame {
	private final JButton b = new JButton();

	public Sample() {
		super();
		this.setTitle("HelloApp");
		this.getContentPane().setLayout(null);
		this.setBounds(100, 100, 180, 140);
		this.add(makeButton());
		this.setVisible(true);
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
	}

	private JButton makeButton() {
		b.setText("Click me!");
		b.setBounds(40, 40, 100, 30);
		b.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				JOptionPane.showMessageDialog(b, "Hello World!");
			}
		});
		return b;
	}

	public static void main(String[] args) {
		// Swing calls must be run by the event dispatching thread.
		SwingUtilities.invokeAndWait(() -> new Sample());
	}
}

Rozložení je pomocí Container.setLayout(LayoutManager)metody nastaveno na null, protože JFrame používá jako výchozí správce rozložení java.awt.BorderLayout. S BorderLayout je cokoli, co je přidáno do kontejneru, umístěno uprostřed a roztaženo tak, aby vyhovovalo jakýmkoli dalším widgetům. Většina GUI aplikací ve skutečném světě by samozřejmě raději použila správce rozložení místo toho, aby vše umístila na absolutní souřadnice.

Viz také

Reference

Citace

Prameny

externí odkazy