Skapa ett grafiskt gränssnitt med Qt. Varje widgetklass har ett ganska brett urval av både ärvda och ytterligare resurser som är specifika för den. De låter dig kontrollera sådana viktiga egenskaper hos objekt som bakgrundsfärg, plats

Lämna en kommentar 6,950

När man utvecklar applikationsprogram verkar det vara användbart att skapa grafiskt användargränssnitt... I själva verket är detta skapandet av en miljö för att beräkna problem för en viss klass utan programmering av användaren. Som regel är det vettigt att utveckla sådana gränssnitt för uppgifter med flera parametrar om sådana uppgifter ska lösas upprepade gånger. I det här fallet är det tillrådligt att utveckla ett grafiskt gränssnitt som hjälper användaren att få resultaten av att lösa problemet (vanligtvis i en grafisk form) med ett visst val av parametrar. Ett sådant gränssnitt kan också vara praktiskt när man skapar pedagogiska problem, eftersom studenten i det här fallet lägger sin huvudsakliga uppmärksamhet inte på programmering eller att lösa problemet, utan på valet av de nödvändiga parametrarna, analys och förståelse av de erhållna resultaten.

Från ovanstående korta introduktion är det tydligt att de obligatoriska delarna av det grafiska gränssnittet vid lösning av vetenskapliga och/eller utbildningsuppgifter bör vara:

1. Ett eller flera fönster för att visa grafiska beräkningsresultat.

2. Flera redigerbara fönster, med hjälp av vilka värdena för uppgiftsparametrarna ställs in och/eller ändras.

3. Kontrollknappar som låter dig starta och stoppa beräkningsprocessen, rita om resultaten, avsluta uppgiften.

4. Förklarande etiketter (statisk text).

Naturligtvis är andra kontroller möjliga, såsom rullningslistor, radioknappar för att välja ett av många alternativ och så vidare, men i den här handledningen kommer vi bara att täcka de fyra typerna som anges i detalj. Figur 8 visar det enklaste gränssnittet utformat för att studera de slag som genereras genom tillägg av två övertonssvängningar med nära frekvenser. Som du kan se från figuren finns alla ovanstående element i den.

För att skapa ett sådant gränssnitt kan du använda de grafiska utdatafunktionerna, såväl som en speciell funktion utformad för interaktiv användarinteraktion med ritningen. Denna funktion kallas uicontrol. Men för att förenkla arbetet och skapa samma typ av gränssnittselement i MATLAB-systemet finns det ett speciellt program som låter dig skapa de nödvändiga elementen på nivån för visuell programmering, nästan utan att skriva kod.

Ris. 8. Enkelt grafiskt användargränssnitt för att lösa problemet med "Beating".

9.1. Skapa utseendet på gränssnittet

I det här avsnittet kommer vi att titta på att använda MATLAB för att designa utseendet på ett grafiskt gränssnitt (GUI -GraphicsUserInterface) med hjälp av grafiska (visuella) programmeringsverktyg. För att anropa den visuella redigeraren, skriv guidekommandot i MATLAB-kommandofönstret. Efter en viss tid, som bestäms av din dators hastighet, kommer två nya fönster att visas, som visas i Fig. 9. En av dem är en kontrollpanel (Kontrollpanelen, i figuren till vänster) och en form eller rityta (Figur, i figuren till höger). Dessa fönster kan överlappa varandra, men vi har placerat dem sida vid sida för tydlighetens skull. Ovanstående bild kommer att visas på skärmen om det inte finns någon öppen bild innan du ringer guide. Om guidefunktionen anropas efter att ha ritat en bild, öppnas den istället för en tom. Vi kommer att titta på att skapa ett grafiskt gränssnitt från allra första början.

Innan du skapar ett grafiskt gränssnitt är det lämpligt att "designa ett projekt" av vad du vill ha som gränssnitt. Vi kommer att överväga ett exempel på att mata ut tre olika signaler i tre underfönster, som i termer av högnivågrafik skulle bestämmas av subplot-operatorerna (3,1, k), där k är numret på grafen. Förutom,

Ris. 9. Allmän vy av den visuella grafikredigeraren och redigeringsfönstret

till höger om de faktiska underfönstren med grafer vill vi ha tre redigerbara underfönster

för där du kan ange / redigera de numeriska värdena för tre

variabler. Låt dessa variabler ta godtyckliga värden.

I den här presentationen kommer vi inte att utrusta våra redigerbara kryssrutor.

som, om de angivna värdena uppfyller några villkor, även om en sådan

burk. Låt oss kalla dessa variabler N, R, C. I det här exemplet menar vi beräkningen

ström i RC-kretsen när signalen med numret N appliceras på terminalerna, och R och C - motstånd

spänning och kapacitans i kretsen (för en detaljerad beskrivning av problemet, se punkt 10 i huvudboken

texten i manualen).

Vårt gränssnitt bör tillåta att byta skylt

värden på N, R och C, kommer i tre lokaliserade

en ovanför den andra subwindows signal (spänning,

levereras till terminalerna), härledd från signalen

la och spänningen över resistansen U r. Dessutom

fönster för att visa diagram och redigerbara fönster

R u n E x i t

ingången måste placeras på gränssnittspanelen

det finns ytterligare två knappar - KÖR - starta programmet på

Ris. 10. Gränssnittsvy

konto och EXIT - uppsägning och radering

grafikfönster.

Det första steget är att utveckla gränssnittets utseende. Låt förbi

vår preliminära skiss ska gränssnittet se ut

enligt följande (fig. 10). Elementen i detta gränssnitt är tre fönster

grafutdata (axlar när det gäller kontrollpanelen), tre statiska etiketter N, R, C (text), tre datainmatnings-/redigeringsfönster (redigera) och två knappar (tryck).

För att skapa underfönster där graferna kommer att visas, använd knappen som visas till höger i figuren (fönster och axlar). Genom att klicka på det här elementet på kontrollpanelen och flytta musen till ritpanelen måste du placera krysset, som kommer att vara på spetsen av musen, i det

platsen där det övre vänstra hörnet av det första underfönstret ska vara. Genom att trycka och hålla nere vänster musknapp måste du sträcka ut den resulterande rektangeln till önskad storlek. Därefter upprepas proceduren för att konstruera de andra två fönstren på samma sätt.

Använd redigeringsknappen som visas till höger för att skapa redigerbara inmatningsrutor. Det används på samma sätt som när man skapar underfönster med axlar. Först dyker en mus upp, laddad med ett kors, med hjälp av vilken ingångsrektangeln är konstruerad.

Etiketterna på bildpanelen skapas med hjälp av textknappen, som lindas och justeras på samma sätt som beskrivits ovan. För att någon typ av text ska dyka upp inom området för statisk text

inskription måste du arbeta med egenskapsredigeraren, som kallas antingen genom att använda knappen Egenskapsredigerare eller genom att dubbelklicka med vänster musknapp på motsvarande objekt i bildpanelen.

En panel märkt Push används för att skapa och placera knappar. Metoden för att placera knappen och välja dess storlek är helt densamma som metoden som beskrivs ovan för redigeringsfönstret och det statiska textfönstret.

Konstruerat på detta sätt kan utmatnings- och redigeringsfönster, statiska textfönster och knappar, såväl som andra objekt, justeras och ställa in specifikt avstånd mellan dem med hjälp av justeringsverktygen.

För att göra detta, klicka på motsvarande knapp på kontrollpanelen, så kommer inriktningspanelen att visas. För att ställa in ett antal objekt med vilka åtgärder ska utföras, måste du markera dem genom att klicka på vart och ett av dem samtidigt som du håller ned Skift-tangenten. Utvalda objekt markeras

svarta prickar runt motsvarande föremål. Om du behöver ändra storleken på något objekt (knappar, fönster, etc.), måste du klicka på detta objekt med vänster musknapp och använda musen för att ändra önskad storlek på samma sätt som storleken på alla fönster fönster.

När du arbetar med grafiska objekt i ritpanelen är det lämpligt att utöka (med motsvarande knapp i Windows-fönstret) ritpanelen till helskärm och välja storleken på alla objekt i ritpanelen.

Eftersom alla objekt som standard är dimensionerade i pixlar, kan detta leda till att när utdatafönstret ändras, kan knappar och/eller fönster stöta på varandra. För att undvika ett sådant oönskat fenomen är det nödvändigt att ställa in enheterna för storleken på alla objekt i dimensionslösa variabler - bråkdelar av fönsterstorleken. Denna storlek kallas normaliserad. För att göra detta behöver du ringa fastighetsredaktören genom att klicka på knappen på kontrollpanelen med ovanstående

av fastighetsredaktören. Efter att ha valt alla objekt som vi har skrivit in i det övre fönstret i egenskapsredigeraren (genom att hålla nere Ctrl-tangenten och välja objekt med vänster musknapp), i det nedre fönstret i egenskapsredigeraren hittar vi egenskapen Units och väljer den genom att klicka på vänster musknapp. Därefter, i mitten av editorn, i ett speciellt fönster till vänster, kommer egenskapen Units att visas, och till höger - värdevalsfönstret, där det finns en rullgardinslista med tillåtna egenskapsvärden. Egenskapen Units måste ställas in på normaliserad. På samma sätt måste du ställa in värdet på egenskapen FontUnits - måttenheten för storleken på teckensnitten. Detta säkerställer att teckensnittet ändrar storlek när fönstret ändras.

För att placera etiketter på knappar och i området med statisk text, välj motsvarande objekt (antingen genom att dubbelklicka direkt i ritområdet eller i det övre fönstret i egenskapsredigeraren) och hitta egenskapen String i det nedre fönstret i egenskapsredigeraren, och efter att ha valt den anger du den önskade texten mellan citattecken (t.ex. 'Starta' på motsvarande knapp). För att ställa in etiketter ovanför vart och ett av utdatafönstren, välj motsvarande fönster och anropa egenskapsredigeraren8, i det nedre fönstret som du behöver hitta egenskapen Titel.

8 Egenskapsredigeraren kan inte bara anropas med knappen på kontrollpanelen utan också

och dubbelklicka på motsvarande objekt.

DOKUMENTETS STRUKTUR

4.1. Visuell programmeringsteknik

4.1.2. Visual Studios huvudfönster

4.1.3. VS huvudmeny och verktygsfält

4.1.4. Visual Studio Panel Windows

4.1.5... Konfigurera VS-utvecklingsmiljöinställningar

4.1.6. Testuppgifter

4.1.7. VS .NET Development Environment Lab

4.1. Visuell programmeringsteknik
och grundläggande begrepp

Jämfört med tidigare generationer av programmeringsspråk, språket programmering på hög nivå- Visual Basic .Net (VB) har ett antal grundläggande skillnader. Det är ett kraftfullt, professionellt programmeringssystem som låter dig snabbt och effektivt skapa applikationer för MS Windows . Eftersom systemet är « visuell», programmeraren kan skapa den synliga delen av MS Windows-applikationen , utan att skriva nästan en enda rad kod. Denna synliga del är grunden för användargränssnittet « mjukvaruprojekt - användare », med hjälp av vilken användaren interagerar med mjukvaruprojektet. Utvecklingen av både programkoden för klasser och metoder för att lösa uppgiften och applikationens programgränssnitt utförs enligt principerna objektorienterat förhållningssätt , implementerad i Visual Studio .Net (VS) . Applikationer (projekt) körs under MS Windows med hjälp av Integrated Development Environment (IDE).

För applikationer skapade med IDE är en karakteristisk egenskap att det finns många objekt på skärmen vid varje given tidpunkt: formulär, fönster, knappar, menyer, text- och dialogrutor, rullningslister, etc. Användaren har en viss (beroende på algoritmen för det problem som ska lösas) valfrihet när det gäller användningen av dessa objekt. Han kan göra klick med hjälp av musknappen, dra objektet, skriv in data i fönstret, etc. I de flesta fall antas inte en fördefinierad sekvens av åtgärder. Typiskt utvecklaren programvara(Programvara), som skapar ett programvaruprojekt, bör inte begränsa applikationsanvändarens åtgärder. Han måste utveckla programvara som adekvat svarar på alla användaråtgärder, även fel (i ett bra program bör det inte förekomma oavsiktliga åtgärder). Därför finns det ett antal möjliga händelser för varje objekt på skärmen. Vissa av dem görs av användaren: klicka eller dubbelklicka på en musknapp, dra ett objekt, trycka på en tangentbordstangent, skriva in text i ett fönster, etc. andra händelser inträffar som ett resultat av andra händelser: till exempel öppnas eller stängs ett fönster, en kontroll blir aktiv (tillgänglig) eller förlorar aktivitet. Dessutom manifesterar varje händelse sig i vissa handlingar (svar, reaktioner, beteende) i mjukvaruprojektet. Dessa åtgärder kan delas in i två grupper.



Den första är en konsekvens av objektets egenskaper. Dessa egenskaper ställs in av mjukvaruutvecklaren från en viss standardlista med egenskaper som ställs in av programmeringssystemet och/eller MS Windows själv. . Ett exempel på sådana åtgärder är att minimera fönstret efter att ha klickat på knappen Minimera. I sådana fall kan programmeraren inte ändra beteendet hos ett objekt. Men i många fall finns det en viss möjlighet att variera ett objekts respons på en händelse (text, typsnitt, färg, storlek, skärmutrymme etc.) genom att ställa in vissa egenskaper.

Den andra gruppen av åtgärder (svar) på händelser bestäms helt av mjukvaruutvecklaren. Detta tillhandahålls av möjligheten att definiera en VB-procedur för varje möjlig händelse. Till en början är varje sådan procedur tom, utan procedurkropp, och därför händer ingenting när en händelse inträffar. I teorin är det möjligt att skapa en procedur för vilken händelse som helst, men i praktiken fyller programmeraren i procedurkoden med programkoden endast för de händelser som är av intresse.

Således ger VB användaren en händelsebaserad objektorienterad programmeringsmiljö. För att uttrycka det enkelt går processen att utveckla ett mjukvaruprojekt i den här miljön ner till att välja en uppsättning objekt och deras egenskaper, ställa in händelser och procedurer för deras bearbetning och skapa mjukvara för att lösa problemet, som tillsammans säkerställer funktionen hos skapad applikation.

Huvudvillkoren för visuell programmering, som nämnts ovan, är ett objekt, formen, egendom, klass, händelse, förfarande, metod dr., som i alla visuella applikationsutvecklingsmiljöer har samma innebörd.

ObjektÄr en slags separat enhet som skiljer sig från andra enheter i speciella egenskaper, beteende, interaktion med andra objekt i applikationen. I det objektorienterade tillvägagångssättet är varje applikation en uppsättning sammanlänkade objekt som implementerar de nödvändiga funktionskraven för applikationen. Ett objekt är alltid konkret och existerar faktiskt på formuläret (som kontroller) eller i applikationen (som klassinstanser).

Grundenheten i objektorienterad programmering är ett programobjekt som kombinerar både de data (egenskaper) som beskriver det och sätten att bearbeta dessa data (metoder). Det vill säga att mjukvaruobjekt har egenskaper, kan använda metoder och svara på händelser.

Huvudobjekten för visuell programmering är formen och dess kontroller.

Form (Form ) Är ett objekt som representerar ett fönster där kontroller är placerade, till exempel en knapp (Knapp); Märka (Märka); Textfält (Textruta); Kryssruta (Kryssruta); Lista (ListBox); Rullgardinslista (Kombinationsrutan); Växla (Radio knapp)och så vidare .

Den visuella programmeringsmiljön låter dig se objekt på skärmen vid designstadiet av applikationen, gör det möjligt att anpassa objekt genom att ändra deras plats, storlek och andra egenskaper. Formen är containerföremål, och samtidigt är sig själv också ett objekt. När du placerar ett objekt på formuläret sparas objektets huvudparametrar i den körbara programkoden. I det här fallet är objekt också programblock eller fragment av programkod (klasser, procedurer, metoder, moduler), från vilka det designade projektet (applikationen) "monteras".

ObjektegenskapÄr ett värde eller egenskap som lagras av ett objekt. Samtidigt bestämmer uppsättningen egenskaper för ett objekt dess tillstånd. Till exempel, Text ( Text ) eller Färg ( Bakfärg ) form, sätt Textjustering ( Inriktning ) eller Karaktärsfärg ( ForeColor ) textrutan är egenskaper. I programmet nås objektet efter objektnamn ... Objektegenskaper kan ställas in i fönstret Egenskaper och ändra egenskaperna för objekt i programkoden.

I programkoden finns det vissa regler (specifikt format) för att ställa in en egenskap - objektnamn och egenskapsnamn enligt reglerna för punktnotation separeras med en punkt .

KlassÄr en samling föremål med gemensamma egenskaper och beteende. Till exempel, Knapp1( Knapp1 ) på Form1(Formulär 1 ) med alla dess specifika egenskaper och handling är ett objekt i klassen Knapp . Klassen kännetecknas av sådana grundläggande koncept för objektorienterad programmering som:

· arv - klassobjektet har alla egenskaper, metoder och händelser för klassen;

· inkapsling - dölja objektets komplexa verkningsmekanism;

· polymorfism - objekt av olika klasser kan använda metoder med samma namn, som fungerar olika för olika objekt.

Samling av föremålÄr en uppsättning objekt förenade med ett gemensamt namn, och inte nödvändigtvis objekt av samma klass. Ett exempel på en samling är samlingarna inbyggda i VB, inklusive:

· Blanketter(Blanketter) - många laddade ansökningsformulär;

· Kontroller(Kontroller) - Set med alla kontroller på ett formulär.

NamnutrymmeÄr ett hierarkiskt klassbibliotek organiserat under unika namn som t.ex System.Windows eller System.Math . För att komma åt klasser och objekt baserade på dem som ingår i namnutrymmet kan operatören placeras i början av programkoden Importer . Varje projekt i VS innehåller också ett rotnamnområde. Namnutrymmet i VS-dokumentationen kallas också klassbibliotek .

HändelseÄr ett medel för interaktion mellan objekt med varandra. Händelsen kan skapas av användaren eller uppstå som ett resultat av påverkan av andra programvaruobjekt. Objekt kan generera händelser och utföra åtgärder som svar på specificerade händelser. Exempel på händelser - form , Klick ( Klick ) musen över objektet, DblClick ( Dubbelklicka ) mus och andra . Som en reaktion på händelser anropas en händelseprocedur, som kan ändra objektets egenskaper, kalla det

På VB-språk , som i många andra programmeringsspråk designade för att skriva applikationer för MS Windows , Använd av
händelsestyrd programmeringsmodell. Detta innebär i praktiken att ingen applikation kan fungera på egen hand utan att interagera med andra applikationer och med operativsystemet. Låt oss till exempel ta det enklaste fallet när ett kommando anges genom att trycka på en tangent på tangentbordet. Det kan inte direkt påverka någon av applikationerna, och MS Windows fungerar i det här fallet som en mellanhand. Vid avkänning av händelsen som är associerad med knapptryckningen bestämmer operativsystemet var händelsehanteringen ska passera. Tangenttryckningsmeddelandet skickas sedan till applikationen. Applikationen bearbetar den genom att analysera tangentbordsinmatningen och visar till exempel ett meddelande i ett aktivt textfält.

Appar skapade av med använder VB , arbeta på grund av samma princip. Samtidigt utför VB ett slags internt arbete. Till exempel, när en knapp klickas i applikationen inträffar en händelse - VB fångar upp motsvarande MS Windows-meddelande och höjer händelsen Klick objekt Knapp .

Observera att i händelsestyrda program, det finns ingen kontinuerlig programkod som körs från början till slut. Detta betyder att efter att ha startat programmet har användaren inte en klar uppfattning om den specifika vägen för algoritmexekveringen. Det vill säga, du kan när som helst klicka på valfri knapp i applikationen eller utföra till exempel att skriva in text i ett fält, eller så kan du, om så önskas, stoppa bearbetningen. Därför måste applikationen vänta tills en av dessa händelser inträffar, och först då exekverar den angivna programkoden. Således, en händelse behövs alltid för att börja exekvera programkoden - detta är en av de viktigaste reglerna för att skapa applikationer i MS Windows-miljön .

Svaret på händelser är att ringa händelseförfarande , som tidigare skapats av en mjukvaruutvecklare. Innebörden av en sådan procedur är exekveringen av programmerade åtgärder: ändra egenskaperna hos ett objekt, anropa metoder, utföra beräkningar enligt en given algoritm med resultatet av resultatet till vissa platser i applikationen, etc., till exempel om användaren trycker på en knapp, sedan utförs en viss sekvens av åtgärder som ett svar. definieras i händelseproceduren enligt den specificerade algoritmen.

Utöver händelseprocedurer kan användaren skapa allmänna procedurer (användarprocedurer).

AnvändarprocedurÄr en komplett programkod som implementerar en separat algoritm för det problem som ska lösas. Ett sådant förfarande kallas dock för detta förfarande, och inte som ett resultat av någon händelse.

MetodÄr en procedur som implementerar de åtgärder som är möjliga med ett objekt. Som ett resultat av dessa handlingar förändras något i objektet. VB förser användaren med ett stort antal inbyggda biblioteksrutiner som är redo att användas. Dessa rutiner är en integrerad del av klassbiblioteket, det vill säga de är klassmetoder i .NET Framework.

Procedurprogrammeringsverktyg (procedurer) är en integrerad del av alla programmeringsspråk på hög nivå, vilket är en av huvuddelarna i det moderna programmeringsparadigmet. Men det var först med tillkomsten av språk som stöder objektorienterad programmering som speciella typer av inbyggda procedurer introducerades, så kallade metoder . Metoder "Fungerar" som procedurer, men de tillhör specifika objekt, precis som egenskaper. I programkoden kan man referera till metoden på samma sätt som till egenskapen – använder punktnotation.

I VB-miljö kan du skapa egen procedurer, skapad av mjukvaruutvecklaren .

Observera att varje programkod för ett projekt skrivet med hjälp av VB består av en uppsättning procedurer, det vill säga all programkod är så att säga inuti en uppsättning subrutinprocedurer och funktionsprocedurer, och själva procedurerna finns i en klass (modul).

Subrutinrutiner börjar med ett nyckelord Sub Avsluta Sub, och funktionsprocedurer börjar med nyckelordet Fungera och avsluta med nyckelord Avsluta funktion , mellan vilken programkoden för denna procedur placeras. Programkoden för varje procedur består av en eller flera operatörer av VB-programmeringsspråket.

HändelsehanteringsmetodÄr en komplett programkod som implementerar en separat algoritm. För varje händelse kan du programmera ett svar, det vill säga objektets reaktion på en händelse som har inträffat, som ett resultat kommer en viss sekvens av åtgärder att utföras - en metod för att hantera händelsen.

Namnet på en händelseprocedur har tre delar (inklusive ett understreck): Objektnamn_Händelsenamn.

På så sätt, varje gång du skriver kod som måste exekveras som svar på en händelse, skapar du en händelseprocedur som anropas automatiskt när motsvarande händelse inträffar (till exempel ett knappklick).

OperatörÄr en programmeringsspråkskonstruktion som specificerar en eller flera operationer , produceras över operander . Operanderna kan vara konstanter, variabler, uttryck, funktioner osv. Alla operatörer skrivs i enlighet med de syntaktiska reglerna för programmeringsspråket. Till exempel, i uppdragsoperatören tecknet " = "Läser" för att tilldela "och betyder att ett värde lika med värdet av uttrycket till höger om" = ". Till exempel linjen

Form4.1.Text = "Formulär med bild" betyder att i minnet heter Form4.1.Text värde skrivs - text "Formulär med bild" och linjen P = A + B + C används i ett program för att beräkna värdet av ett uttryck och tilldela det till en variabel R .

ProjektÄr en utvecklad applikation (applikationsprogramkod) - en uppsättning filer som lagrar information om alla programvarukomponenter som används i denna applikation. Sedan VB , å ena sidan är det objektorienterat visuellt programmeringssystem, eftersom det tillåter programmeringsalgoritmer på detta språk, och å andra sidan är det detta system mjukvarudesignmiljö, Resultatet av programmerings- och designprocesserna är ett projekt som kombinerar programmeringskod och ett grafiskt gränssnitt. Därför, för att bränna till skiva eller ladda något programvaruprojekt från skiva, är det nödvändigt att bränna eller ladda projektet, som innehåller alla komponenter (filer). Vanligtvis består en VB-applikation av många filer, inklusive en projektfil med tillägget .vbproj . En projektfil innehåller information relaterad till en mjukvaruuppgift - en applikation.

Projektet är också en sammanställningsenhet. Sammanställningen av projektet resulterar i en sammanställning. Varje projekt innehåller en eller flera namnrymder. I det inledande skedet av att skapa ett projekt för en given projekttyp automatiskt byggd projektram bestående av klasser som är arvtagare till de klasser som ingår i biblioteket FCL(Framework Class Library) - .NET Framework-klassbibliotek. Så, om utvecklaren indikerar att han kommer att skapa ett projekt av typen " Windows Forms Application", Då kommer objektet att inkluderas i projektramverket som standard Form1- biblioteksklassens arvtagare Form... Utvecklaren av mjukvaruprojektet kommer att komplettera det skapade formuläret med kontroller - objekt av motsvarande klasser, och därigenom utöka kapaciteten för standardformuläret.

Varje projekt innehåller all information som behövs för att bygga en sammanställning. Projektet inkluderar alla filer med klasser, byggda automatiskt när projektet skapas, och filer med klasser, skapad av projektutvecklare. I projektet ingår också installationer och resurser krävs för arbete. Filen som innehåller monteringsbeskrivningen (manifest) är också en del av projektet.

Beroende på vald typ kan projektet vara körbar eller ogenomförbar... Pågående projekt inkluderar till exempel projekt av typen Konsolapplikation eller Windows Forms Application... När man bygger skelettet av ett pågående projekt, inkluderar det en klass som innehåller en statisk procedur som heter Huvudsaklig ()... Som ett resultat av att sammanställa ett sådant projekt, PE-file - körbar bärbar fil med tillägget .exe... Sådan PE-filen kan endast köras på datorer där den är installerad Framework .Net eftersom det är en hanterad kodfil.

Icke-körbara projekt inkluderar till exempel projekt som
Klassbibliotek (DLL) som har förlängningen. dll, och är dynamiskt länkat bibliotek, de där. dessa projekt är avsedda att inkluderas (kopplas) till andra projekt. Som ett resultat av att sammanställa ett projekt som
Klassbibliotek sammansättningen kommer att innehålla en fil med filtillägget .dll... Sådana projekt (sammansättningar) kan inte utföras direkt på en dator. De är kopplade till de körbara sammansättningarna, varifrån metoderna för klasserna som finns i det icke-körbara projektet kallas ( DLL).

Stadier av genomförandet av de enklaste projekten- kan delas upp i flera steg:

· Skapande av ett grafiskt gränssnitt för projektet (användargränssnitt), som bör säkerställa projektets interaktion med användaren under projektets arbete;

· Inställning av värden för egenskaper för objekt i det grafiska gränssnittet;

· Skapande, redigering och felsökning av projektets programkod;

· Spara projektet för framtida bruk;

· projektgenomförande.

LösningÄr en applikation under utveckling, vars filer innehåller information om ett eller flera projekt, vanligtvis relaterade till ett gemensamt tema. Lösningsfilen används för att hantera flera sammankopplade projekt och har tillägget .sln. Dessutom placeras varje projekt som skapas i VS i ett skal som kallas Beslut.

När ett nytt projekt skapas kan det placeras i ett befintligt. Lösning eller en ny kan skapas Lösning som innehåller projektet.

Så lägg märke till följande igen:

KlassÄr det centrala konceptet för objektorienterad programmering. VB projektutvecklare använder standardklasser från biblioteket FCL och skapar sina egna klasser. Dessutom har klassen två olika roller:

· Klass - för det första är det en modul - en arkitektonisk enhet för att bygga ett projekt på modulbasis. Att klara av komplexiteten i ett stort projekt är endast möjligt genom att dela upp det i moduler - relativt små enheter som tillåter oberoende utveckling och efterföljande integration i ett stort system.

· Klass - för det andra är det en datatyp, det vill säga en semantisk enhet som beskriver egenskaperna och beteendet hos en uppsättning objekt som kallas klassinstanser. Syntaktisk representerar en klass en beskrivning av data som kallas klassfält, beskrivning klassmetoder och beskrivning klasshändelser ... För en klass som betraktas som en datatyp, definierar fält objektens tillstånd, metoder - objektens beteende. Händelser är några speciella tillstånd som ett objekt kan vara i och som kan hanteras av händelsehanterare utanför klassen. Så till exempel ett objekt i klassen MÄNSKLIG kan ha en händelse" Födelsedag"Och var och en av de som hanterar det här evenemanget kan ge sina lyckönskningar till objektet vid detta tillfälle.

Vanligtvis spelar klasser båda rollerna. Men i VB kan du definiera klasser som bara spelar rollen som en modul. den moduler för vilka det är omöjligt att skapa objekt.

Bra programmeringsstil kräver att varje klass sparas i en separat fil med namnet efter klassnamnet. Detta är ett stilkrav som kanske inte uppfylls i praktiken. I våra exempel kommer vi att försöka behålla denna stil.

Genom att definiera en klass kan projektutvecklaren dynamiskt skapa klassobjekt. Det är ett vanligt misstag för programmerare som är nya i objektstil att blanda ihop begreppen objekt och klass. Du måste förstå skillnaden från första början. En utvecklargenererad objektklass representerar en statisk beskrivning av en uppsättning objekt. Ett objekt är ett dynamiskt koncept, det skapas under exekveringen av ett mjukvarusystem, det finns faktiskt i datorns minne och försvinner vanligtvis i slutet av projektexekveringen. En projektutvecklare kan skapa ett mjukvarusystem som innehåller två eller tre klasser, men under driften av ett sådant system kan hundratals objekt dynamiskt dyka upp och interagera med varandra på ett komplext sätt.

VS huvudfönster

Observera att processen att skapa en enkel applikation i VS-miljön kommer att beskrivas i detalj i nästa Ämne 4.2, samt i laborationer på Ämne 4.1."Visual Studio .NET Integrated Development Environment". Bekanta dig nu med VS-miljöns gränssnitt.

Springa MS Visual Studio.

Skärmen visas startsida- MS VS ( ris. 4.1.2-1).

Det finns flera huvudpaneler i det här fönstret: Standardmeny, fönster Standard verktygsfält, fönster Startsida anitz en, fönster Lösningsutforskare, fönster Verktygslåda.

Ris. 4.1.2-1. Startsida -Microsoft Visual Studio

Det bör noteras att när du arbetar med VB i VS IDE kan du använda både knapparna på standardverktygsfältet och huvudmenyalternativen längst upp på skärmen.

VS ger användaren en mängd olika verktygsfält. Dessa verktygsfält innehåller knappar vars funktion beror på funktionen hos det specifika verktygsfältet.

Fönster startsida låter dig öppna nyligen använda projekt, söker efter exempel, innehåller olika länkar till webbplatser som kan hjälpa när du arbetar med VS . Förutom processen att arbeta med ett projekt kommer olika fönster att visas i stället för startsidan, till exempel ett fönster Formkonstruktör, fönster Kodredigerare och så vidare.

I fönstret Lösningsutforskare filerna för den aktuella lösningen (projekten) visas. Detta fönster används för att få detaljerad information om objekt. . Det låter dig söka och utforska element, deras egenskaper, metoder, händelser som finns i projekt och referenser till dem.

Verktyg utformade för att underlätta applikationsutveckling inkluderar också ett fönster. Verktygslåda, visar kontroller som används i VB-projekt .

För att skapa ett nytt projekt, använd dialogrutan
Skapa ett projekt(fig. 4.1.2-2). För att öppna den måste du göra något av följande:

Utför kommando Skapa ett projekt från huvudmenyn - Fil;

tryck på knappen Skapa ett projekt, finns i standardverktygsfältet.

Ris. 4.1.2-2. Dialogfönster Skapa ett projekt

I VB kan du skapa applikationer enligt olika mallar. I den här handledningen kommer vi bara att använda mallen Windows Forms Application.

Denna applikation är utformad för att skapa traditionella Windows-applikationer, vars användargränssnitt är utformat med MS Windows Forms. Dessutom, för formen av denna mall, kan du ställa in vissa egenskaper och placera olika kontroller på den.

Låt oss titta på ett exempel på de grundläggande stegen som krävs för att skapa ett projekt. Windows Forms Application.

Exempel 4.1.2-1. Skapa ett projekt med namnet Exempel 4.1.2-1 och ett grafiskt gränssnitt som består av ett formulär med en knapp och ett textfält. När du trycker på knappen bör "Hej, MTUSI!" visas.

Projektform Exempel-4.1.2-1 kan se ut som i fig. 4.1.2-3.

Ris. 4.1.2-3. Projekt GUI (formulär)Exempel 4.1.2-1

Att genomföra projektet Exempel 4.1.2-1 följande steg krävs:

1) Starta VS.

2) Skapa ett nytt projekt:

Fil och kör sedan kommandot Skapa ett projekt;

Välj en projektmall Windows Forms Application .

Som ett resultat kommer ett fönster att öppnas Form1.vb [Konstruktör] – Formkonstruktör(som indikeras av motsvarande flik) som låter dig implementera programmets grafiska gränssnitt.

Välj ett element i huvudmenyn Fil och kör sedan kommandot Rädda alla ;

detta öppnar en dialogruta Spara projekt;

Ange i fältet namn namnet på projektet Exempel-4.1.2-1(som standard namnger VB WindowsApplication1) och skriv sedan in Platskatalognamn var projektet kommer att ligga, eller använd knappen Översikt för att söka efter önskad katalog (Fig. 4.1.2-4);

Klicka på knappen Spara ;

som ett resultat kommer utvecklingsmiljön att se ut som i fig. 4.1.2-5.

Ris. 4.1.2-5. Utvecklingsmiljö

Visual Studio Panel Windows

Panelfönster startsida(Fig. 4.1.1-1) låter dig se de senast använda projekten, söka efter till exempel program, både från Hjälp och Internet, och även se länkar till webbplatser som innehåller nyheter om VS-produkten , dokumentation, tutorials.

Ris. 4.1.4-1. PanelfönsterFormkonstruktör och dess sammanhangsmeny

Startsidan öppnas automatiskt när VS startar . Om fönstret startsida inte visades, kan det anropas med kommandot startsida huvudmenyalternativ Se

Panelfönster Form1.vb[Constructor] (Form constructor)
Huvudfönsterär en Det huvudsakliga arbetsfönstret , där den visuella designen av applikationen utförs (Fig. 4.1.4-1). Detta fönster kan visas på skärmen genom att klicka på fliken Form1.vb[Konstruktör] eller genom att dubbelklicka på formulärets namn i fönstret Lösningsutforskare.

I fönstret Formkonstruktör alla former av applikationen skapas visuellt med hjälp av utvecklingsmiljöns verktygslåda. Du kan använda ett rutnät för att exakt placera objekt på ett formulär i ett fönster.

Storleken på formuläret i fönstret kan ändras med hjälp av formulärvalshandtagen och musen. För att ändra storlek på formuläret, placera muspekaren över markören och flytta den till önskad storlek när den blir en dubbelpil.

Att arbeta i ett fönster Form1.vb[Konstruktör] du kan använda kontextmenyn (Fig. 4.1.4-1).

Ris. 4,1-2. PanelfönsterKodredigerareoch hennes och snabbmenyn

Panelfönster Form1.vb (kodredigerare)Är en kraftfull textredigerare med många möjligheter, som är huvudprogrammerarens verktyg för att skapa och felsöka programkod. Den kan även placeras i Huvudarbetsfönster(fig. 4.1-2) .

Panelfönster Solution Explorer och dess sammanhangsmeny visas i fig. 4.1.4-3.

Ris. 4.1.4-3. PanelfönsterLösningsutforskare och dess sammanhangsmeny

Panel Kontrollelement grupperade efter sektioner
(Fig. 4.1.4-4). För att skapa förmånsformulär behöver du huvuddelen Standard kontroller ( ris. 4.1.4-5).

Panelfönster Egenskaperär avsedd för att visa och ställa in egenskaperna för projektobjekt, inklusive formen och de objekt som placeras i den. Detta fönster innehåller till exempel sådana egenskaper för det valda objektet som position i form, höjd, bredd, färg och andra (fig. 4.1.4-6).

För att öppna en dialogruta Egenskaper Gör en av följande:

I huvudmenyn Se Välj lag Egenskapsfönster;

Klicka på knappen Egenskaper i fönstret Standard
verktygsfält;

Välj ett lag Egenskaper sammanhangsmeny för det valda objektet;

Tryck på en tangent på tangentbordet .

Ris. 4.1.4-4. Verktygslådan fönster 4.1.4-5. Panel

kontroller grupperade efter sektion (standardartiklar)

Ris. 4.1.4-6. PanelfönsterEgenskaper

Eftersom formuläret och kontrollerna i sig själva är objekt, ändras uppsättningen egenskaper i det här fönstret beroende på det valda objektet. Använda knapparna I alfabetisk ordning och
Efter kategori objektegenskaper kan ses alfabetiskt eller efter grupp (kategori).

Ett verktygstips visas längst ned i fönstret som förklarar syftet med den valda objektegenskapen. En mer detaljerad förklaring finns i hjälpsystemet. Du kan också använda dynamisk hjälp genom att välja önskat avsnitt i fönstret Dynamisk hjälp.

Använda en dialogruta Egenskaper, du kan ändra standardegenskaperna för objekt. Vissa av egenskaperna för ett objekt, till exempel storlek och position, kan ställas in genom att flytta objektet och ändra storlek på det med musen i formulärdesignern. Egenskaperna som ställs in i fönstret Egenskaper kan ändras under körning genom att skriva lämpliga koder i procedurer som du skapar med kodredigeraren.

Vanligtvis innehåller ett formulär många objekt. Om du markerar flera objekt samtidigt kan du i egenskapsfönstret se egenskaperna som är gemensamma för dessa objekt.

4.1.5. Ställa in parametrarna för den integrerade
utvecklingsmiljöer

Verktygsfönstren, hjälpsystemet, kompilatoralternativen för VS-utvecklingsmiljön är lätta och mycket flexibelt konfigurerbara.

Följande steg visar hur du ändrar inställningarna för VB-utvecklingsmiljön enligt riktlinjerna för bästa praxis:

1) I huvudmenyn Service kör kommando Import och export av parametrar... Du kan använda guiden som visas för att spara dina miljöinställningar för användning på en annan dator, ladda inställningar från en annan dator eller återställa inställningarna - det alternativ du vill välja nu.

2) Välj Återställ alla inställningar och klicka sedan på knappen Ytterligare... VS kommer att fråga om det är nödvändigt att spara de aktuella inställningarna i en fil innan konfigurering. Du bör alltid säkerhetskopiera dina nuvarande inställningar så att du kan återgå till dem om de nya inställningarna visar sig vara "obekväma".

3) Kontrollera att ett alternativ är valt Ja, och var uppmärksam på namnet på filen och mapparna där VS kommer att spara dessa inställningar.

4) Om du behöver återgå till dessa inställningar, samma guide och alternativet Importera valda miljöinställningar.

5) För att se en lista över standardalternativen som används för VS, klicka på knappen Ytterligare.

6) Klicka på Alternativ för VB-utveckling, och klicka sedan på knappen Redo.

7) Guiden kommer att byta IDE-alternativ, inklusive menykommandon, verktygsfält och inställningar för vissa dialogrutor, fönster Verktyg och Kodredigerare.

8) Du kan upprepa den här konfigurationsprocessen när som helst du behöver återställa dina nuvarande inställningar (till exempel om du gjorde ett misstag i inställningarna), eller om du behöver konfigurera VS för att använda ett annat programmeringsverktyg.

9) För att stänga guiden, klicka på knappen Stänga.

Om miljöparametrarna för att arbeta med VB är konfigurerade kan du utföra uppgifter. Men om de har ändrats måste följande steg följas för att verifiera att inställningarna som är associerade med projekten och VB-kompilatorn matchar de som används i praktiken. För att kontrollera projekt- och kompilatorinställningarna måste du göra följande:

1) Klicka på kommando alternativ menyalternativ Service och öppna en dialogruta Alternativ.

2) Dialogfönster alternativÄr fönstret som innehåller många av VS Tuning Options. För att se alla parametrar som kan ändras, klicka på kryssrutan Visa alla alternativ finns i det nedre vänstra hörnet av dialogrutan.

3) I dialogrutan alternativ klicka på kategorier Projekt och lösningar och sedan på avsnittet Allmän. Denna grupp av kryssrutor och alternativ konfigurerar inställningarna för VS-projekt och lösningar. För att programvaran ska matcha inställningarna som används i denna handledning måste du konfigurera och

GUI-standard.

En av de viktigaste förändringarna i datorbranschen är framväxten av det grafiska gränssnittet. Så det fanns ett behov av att anta GUI-standarder som definierar hur Windows-applikationer ska se ut? Macintosh, etc. Det finns till och med certifieringsprogram som leverantörer skräddarsyr sina applikationer för att få Windows-märket. Detta görs av flera skäl.

En av styrkorna med Windows eller Mac är deras standardutseende. När du har lärt dig att arbeta i en av dem, tänk på att du äger resten. De flesta Windows-program använder samma konventioner, så att du vet hur du öppnar, sparar, skriver ut, stänger och kopierar en fil från någon av dem. Standardgränssnittet är mycket användarvänligt. Du måste försöka få dina applikationer att se ut som andra Windows-applikationer som användare redan har lärt sig att arbeta med. Det finns sju allmänna principer för GUI-design. Om du studerar dem och följer dem kommer din applikationsdesign att vara bra.

Sju principer för GUI-design.

De sju allmänna principerna för GUI-utveckling är hämtade från Micrisoft Windows Interface Guide. De ger en ram från vilken du kan skapa dina egna standarder. Detta schema ger utvecklare och användare två betydande fördelar. För det första ser apparna professionella ut. För det andra är de funktionella, överensstämmer med andra applikationer och lätta för användare att lära sig.

Naturligtvis, för att en ansökan ska bli framgångsrik måste den vara välskriven och användbar - det är huvudkravet. Principerna vi pratar om ger bara utvecklaren en tankeställare.

1. Låt användaren styra applikationen.

2. Följ objekt-/handlingsparadigmet.

3. Var konsekvent.

4. Gör arbetet med applikationer enkelt och okomplicerat.

5. Sträva efter harmoni.

6. Ge användarfeedback.

7. Var nedlåtande

Princip ett: låt användaren styra applikationen.

Användaren måste hantera applikationen, det vill säga ha tillgång till varje modul i applikationen från vilken annan modul som helst. Tidigare användes en hierarkisk meny för denna åtkomst.


Låt oss säga att en användare vill lägga till en ny kund.I exemplet måste användaren gå till modulen KONTO RECCIEVable och sedan lägga till en ny kund från. Hur vet han vad han ska göra? Förmodligen från min erfarenhet av denna app. Och i GUI-världen väljer användaren helt enkelt Ny från menyn, sedan Kund, som visas i figur 1-4. I detta moderna system kan du lägga till en ny kund, säljare eller lagerpost via Arkiv-menyn. Detta gör att du kan ändra kundposten medan du är på säljarens skärm och vice versa. Användaren behöver inte längre förstå den komplexa och förvirrande hierarkiska menyn.

Princip två: följ objekt/handlingsparadigmet.

Objekt/handlingsparadigmet säger att en operation kan utföras på alla objekt i systemet. Det enklaste och mest uppenbara exemplet är supportskärmen för kundbasen (fig). Skärmen innehåller en uppsättning knappar och var och en av de nedre låter dig utföra vissa åtgärder på information om den valda klienten. Du kan ta bort den, redigera den, skriva ut den osv. Åtgärder som kan utföras på en specifik klient måste vara tillgängliga eller otillgängliga vid lämpliga tidpunkter. Till exempel, när en kundpost är i redigeringsläge, bör knapparna Ta bort och Ny inaktiveras.

Princip tre: Var konsekvent.

Konsistens är en av de viktigaste principerna för GUI-utveckling. GUI - Låter användare utforska fler applikationer än äldre program. Och allt detta tack vare principen om konsekvens. När en användare står inför ett nytt program är han redan bekant med de grundläggande kommandona: öppna, skriva ut och spara filer. Applikationer som utvecklats på dessa plattformar är vanligtvis överensstämmande med varandra.

Var därför konsekvent när du skapar nya applikationer. Om du använde kommandot Ny för att lägga till en ny post, använd det överallt. Du bör inte ersätta detta ord med andra - till exempel ordet Lägg till 9Lägg till). Med din sekvens kommer användarna att veta att var de än stöter på kommandot New kan de användas för att lägga till en ny post.

Princip fyra: gör din ansökan enkel och okomplicerad.

Du kan uttrycka det så här: använd inte jargong. Det finns en skärm med två knappar. En av dem säger "Pack Database", och den andra säger "Ta bort poster markerade för radering." Den andra posten kommer förmodligen att vara mer förståelig för användaren.

När man utvecklar applikationer är det ofta frestande att använda programmeringsslang i gränssnittet. Försök undvika detta så mycket som möjligt.

Princip fem: Sträva efter harmoni

Även i svartvitt har den här skärmen en betydande estetisk nackdel: en vit bakgrund och kontrasterande föremål på den. I fig. Samma skärm ser välbalanserad ut färgmässigt.

Det finns miljontals färgkombinationer som kan överföras till Windows. Betyder detta att alla ska användas? Naturligtvis nej. Du bör välja enkla, lugna färger och undvika deras slumpmässiga blandning, vilket av någon anledning gläder vissa programmerare.

Sjätte principen. Ge användarfeedback.

Föreställ dig att din ansökan har en process som tar lång tid att slutföra. Under denna tid kan du visa ett meddelande som liknar följande på skärmen: "Programmet körs, vänligen vänta." Bekväm lösning; men hur vet användaren att den inte är frusen? Därför är det mycket troligt att han kommer att ge applikationen en trefingerhälsning (Ctrl + Alt + Del), även om programmet kommer att fungera bra.

Bättre att visa användaren vilken del av processen som görs. Då kommer han inte att avbryta programmet förgäves, kommer att kunna bedöma hur långt arbetet har kommit och att göra andra saker tills processen är avslutad. Därmed kommer användarens produktivitet att öka med cirka 25 procent. Detta resultat kan uppnås genom att helt enkelt visa mätaren på skärmen. Vanligtvis visas meddelanden som "10 av 100 poster bearbetade" eller "40 % klar". Ännu bättre, visa både antalet bearbetade poster och deras procentandel "

Princip sju: Var förlåtande

Var och en av oss raderade ibland en post genom att av misstag trycka på fel knapp. Lämna därför användaren möjligheten att ändra sig eller avbryta de åtgärder de just utfört. Om processen tar lång tid, ändrar en stor mängd data eller kräver att användaren skapar en säkerhetskopia av data innan åtgärden utförs, är det nödvändigt att utfärda en motsvarande varning. Jag har sett applikationer som kräver bekräftelse två gånger, och sedan också be om ett lösenord. Behöver dina program denna skyddsnivå? Kanske. Utvecklarens uppgift är att hjälpa användaren om han gjorde ett misstag i något skede av arbetet.

Vikten av GUI-konventioner.

Som du kan se är principerna för GUI-design mycket enkla och bör användas när du skapar skärmar. Innan du designar en skärm måste du dock fastställa hur den kommer att se ut. Välj dess storlekar, teckensnitt, färger, meddelandestilar, etc. Genom att lösa dessa frågor i förväg kommer du att påskynda ditt arbete avsevärt. När det kommer till typsnittet eller stilen på meddelandena i efterhand så tittar man bara på standarden.

Med tillstånd av Saleem Gul och Tomas Pavek

Den här handledningen leder dig genom att skapa ett enkelt grafiskt användargränssnitt och lägga till några enkla funktioner på serversidan. Specifikt kommer vi att titta på koden som definierar beteendet för knappar och fält i en Swing-form.

Vi tar en titt på layouten och strukturen för det grafiska användargränssnittet och lägger sedan till några knappar och textrutor. Textfält är utformade för att ta emot information som användaren anger och mata ut resultatet av programmet. Knappen kommer att initiera arbetet med funktioner som är inbyggda i klientdelen av programmet. Applikationen du skapar är en enkel men fullt fungerande miniräknare.

För en mer detaljerad guide till utvecklingsfunktionerna för GUI-designern, inklusive videodemonstrationer av de olika utvecklingsfunktionerna, se.

Beräknad längd: 20 minuter

Övning 1: skapa ett projekt

Det första steget är att skapa ett IDE-projekt för applikationen du utvecklar. Låt oss namnge projektet NumberAddition.

  1. Välj Arkiv> Nytt projekt. Alternativt kan du klicka på ikonen Nytt projekt i IDE:s verktygsfält.
  2. I området Kategorier väljer du Java-noden. I området Projekt väljer du Java Application. Tryck på "Nästa".
  3. Ange NumberAddition i fältet Projektnamn och ange en sökväg, till exempel i din hemkatalog, som projektplats.
  4. Markera kryssrutan Använd en separat mapp för att lagra bibliotek och ange platsen för biblioteksmappen (valfritt). Mer information finns i Dela ditt bibliotek med andra i ditt dokument Utveckla applikationer med NetBeans IDE.
  5. Avmarkera kryssrutan "Skapa huvudklass" om den är markerad.
  6. Klicka på knappen Slutför.

Övning 2: Skapa en frontend

För att fortsätta med processen att skapa gränssnitt måste du skapa en Java-behållare som innehåller de andra nödvändiga GUI-elementen. I det här steget kommer behållaren att skapas med JFrame-elementet. Behållaren kommer att placeras i ett nytt paket, som kommer att visas i källpaketsnoden.

Skapa en JFrame-behållare

  1. I fönstret Projekt högerklickar du på NumberAddition-noden och väljer Nytt> Annat.
  2. I dialogrutan Ny fil väljer du kategorin Swing GUI Forms och filtypen JFrame Form. Tryck på "Nästa".
  3. Ange NumberAdditionUI som klassnamn.
  4. Välj paketet my.numberaddition.
  5. Klicka på knappen Slutför.

IDE skapar NumberAdditionUI-formuläret och NumberAdditionUI-klassen i NumberAddition-applikationen och öppnar NumberAdditionUI-formuläret i GUI Builder. Paketet my.NumberAddition ersätter standardpaketet.

Lägga till element: Bygga användargränssnittet

Därefter, med hjälp av "Palette"-fönstret, fylls programmets externa gränssnitt med JPanel. Detta lägger till tre JLabels (textetiketter), tre JTextField-element (textfält) och tre JButtons (knappar). Om du inte tidigare har arbetat med GUI Designer för information om komponentplacering, se Utveckla ett Swing GUI i NetBeans IDE.

Efter att ha dragit och släppt ovanstående element bör JFrame se ut som bilden nedan.

Om det inte finns något palettfönster i det övre högra hörnet av IDE, välj Fönster> Palett.

  1. Välj först en panel från kategorin Swing Containers i paletten och dra den till JFrame.
  2. JPanel är markerad. Gå till fönstret Egenskaper och klicka på ellipsknappen (...) bredvid rutan Kant för att välja en kantstil.
  3. I dialogrutan Border, välj TitledBorder från listan och ange Number Addition i fältet Titel. Klicka på OK för att spara dina ändringar och stänga dialogrutan.
  4. Skärmen ska nu visa en tom JFrame med rubriken Number Addition, som visas. Som visas, lägg till tre JLabels, tre JTextFields och tre JButtons till den.

Byta namn på objekt

Detta steg kommer att byta namn på elementen som lades till i JFrame-elementet.

  1. Dubbelklicka på jLabel1 och ändra ntrcn ("text"-egenskapen) till First Number.
  2. Dubbelklicka på jLabel2 och ändra texten till Second Number.
  3. Dubbelklicka på jLabel3 och ändra texten till Result.
  4. Ta bort standardtexten från jTextField1. Den visade texten kan konverteras till redigerbar. För att göra detta, högerklicka på textrutan och välj Redigera text från popup-menyn. Om du gör det kan du behöva återställa jTextField1 till dess ursprungliga storlek. Upprepa detta steg för jTextField2 och jTextField3.
  5. Ändra visningstexten för jButton1 till Rensa. (För att ändra knapptexten, högerklicka på knappen och välj "Redigera text." Alternativt kan du klicka på knappen, pausa och klicka igen.)
  6. Ändra visningstexten för jButton2 till Lägg till.
  7. Ändra visningstexten för jButton3 till Exit.

Det färdiga grafiska gränssnittet ska nu se ut som bilden nedan:

Övning 3: Lägga till funktionalitet

I den här övningen kommer du att lägga till den nödvändiga funktionaliteten till knapparna Lägg till, Rensa och Avsluta. Fälten jTextField1 och jTextField2 kommer att användas för användarinmatning, och jTextField3 kommer att användas för att visa utdata från programmet. Det skapade programmet är en enkel miniräknare. Så låt oss börja!

Lägger till funktionalitet till "Avsluta"-knappen

För att knapparna ska bli funktionella måste var och en av dem tilldelas en händelsehanterare som ansvarar för att svara på händelser. I vårt fall måste vi identifiera händelsen med att trycka på knappen - genom att klicka med musen eller använda tangentbordet. Därför kommer "ActionListener"-gränssnittet att användas för att hantera "ActionEvent"-händelser.

  1. Högerklicka på knappen Avsluta. Från popup-menyn, välj Händelser> Åtgärd> ActionPerformed. Observera att menyn innehåller många andra evenemang som programmet kan reagera på! När actionPerformed-händelsen är vald kommer IDE automatiskt att lägga till en ActionListener till Exit-knappen och skapa en hanterarmetod för att hantera lyssnarens actionPerformed-metod.
  2. IDE öppnar automatiskt källkodsfönstret, som visar insättningspunkten för åtgärden som ska utföras när knappen trycks ned (med mus eller tangentbord). Källkodsfönstret bör innehålla följande rader: privat void jButton3ActionPerformed (java.awt.event.ActionEvent evt) (// TODO lägg till din hanteringskod här :)
  3. Låt oss nu lägga till koden för åtgärden som "Avsluta"-knappen ska utföra. Ersätt TODO-raden med System.exit (0); ... Den färdiga koden för "Avsluta"-knappen ska se ut så här: private void jButton3ActionPerformed (java.awt.event.ActionEvent evt) (System.exit (0);)

Lägger till funktionalitet till knappen "Rensa".

  1. Högerklicka på knappen Rensa (jButton1). I menyn som visas väljer du "Händelser> Åtgärd> åtgärd Utförd".
  2. Om du klickar på knappen Rensa bör all text tas bort från alla jTextField-textfält. För att göra detta, lägg till kod som liknar den ovan. Den färdiga källkoden ska se ut så här: privat void jButton1ActionPerformed (java.awt.event.ActionEvent evt) (jTextField1.setText (""); jTextField2.setText (""); jTextField3.setText ("");)

Den här koden tar bort text från alla tre JTextFields och lämnar dem tomma.

Lägger till funktionalitet till knappen "Lägg till".

"Lägg till"-knappen bör göra tre saker.

  1. Den accepterar först användarinmatning i jTextField1 och jTextField2 och konverterar den från String till Float.
  2. Sedan lägger hon till de två siffrorna.
  3. Slutligen konverterar den summan till en sträng och placerar den i jTextField3.
Låt oss börja!
  1. Klicka på fliken Design högst upp i arbetsytan för att återgå till skärmen Form Design.
  2. Högerklicka på knappen Lägg till (jButton2). Från popup-menyn, välj Händelser> Åtgärd> ActionPerformed.
  3. Lägg till koden för de åtgärder som knappen Lägg till ska utföra. Den färdiga källkoden ska se ut så här: private void jButton2ActionPerformed (java.awt.event.ActionEvent evt) (// Först definierar vi floatvariabler.float num1, num2, resultat; // Vi måste analysera texten till en typ float . num1 = Float.parseFloat (jTextField1.getText ()); num2 = Float.parseFloat (jTextField2.getText ()); // Nu kan vi utföra additionen. resultat = num1 + num2; // Vi kommer nu att skicka värdet av resultat till jTextField3. // Samtidigt kommer vi att // ändra värdet på resultatet från en float till en string.jTextField3.setText (String.valueOf (result));)

Nu är programmet helt klart och du kan börja bygga och köra det.

Övning 4: Exekvera ett program

Följ dessa steg för att köra ditt program i IDE:

  1. Välj Kör> Kör huvudprojekt (alternativt tryck på F6).

    Notera. När ett fönster öppnas som indikerar att ingen huvudklass har ställts in för Project NumberAddition, välj my.NumberAddition.NumberAdditionUI som huvudklass i samma fönster och klicka på OK.

Följ dessa steg för att köra programmet utanför IDE:

Efter några sekunder kommer applikationen att starta.

Notera. Om programmet inte startar när du dubbelklickar på en JAR-fil, för mer information om hur du ställer in JAR-filassociationer för ditt operativsystem, se:

Du kan också köra programmet från kommandoraden.

För att köra programmet från kommandoraden, följ dessa steg:

  1. Ta fram en kommandorad eller terminalfönster.
  2. På kommandoraden ändrar du den aktuella katalogen till katalogen NumberAddition / dist.
  3. Vid kommandotolken anger du följande sats: java -jar NumberAddition.jar

    Notera. Se till att my.NumberAddition.NumberAdditionUI är inställd som huvudklass innan du startar programmet. För att testa detta, högerklicka på NumberAddition-projektnoden i projektpanelen, välj Egenskaper från popup-menyn och välj kategorin Kör i dialogrutan Projektegenskaper. Fältet Main Class ska visa my.numberaddition.NumberAdditionUI.

Händelsehanteringsmekanism

Denna handledning har behandlat att svara på en enkel knappklickshändelse. Det finns många händelser som en ansökan kan svara på. Du kan se listan över tillgängliga händelser i IDE som kan hanteras av GUI-element enligt följande:

  1. Gå tillbaka till NumberAdditionUI.java-filen i editorn. Klicka på fliken Design för att se strukturen för GUI i GUI Builder.
  2. Högerklicka på valfritt element i GUI och välj "Händelser" från menyn som visas. Nu kan du helt enkelt utforska innehållet i menyn utan att välja några objekt.
  3. Alternativt kan du välja Egenskaper från menyn Fönster. Klicka på fliken Händelser i fönstret Egenskaper. Fliken Händelser låter dig visa och ändra händelsehanterare som är associerade med det för närvarande aktiva GUI-elementet.
  4. Applikationen kan också svara på tangenttryckningar, enkla, dubbel- eller trippelklick, flytta muspekaren, ändra storlek på fönstret och flytta ingångsfokus. Händelsemenyn låter dig skapa händelsehanterare automatiskt för alla dessa händelser. Den vanligaste av dessa är händelsen "Action". (För mer information, se Sun Java Events Tutorial för bästa praxis för att hantera händelser.)

Hur går händelsehanteringen till? Varje gång du väljer en händelse från händelsemenyn skapar IDE automatiskt en så kallad händelseavlyssnare och associerar den med en utvecklarkomponent. Följ dessa steg för en mer detaljerad förståelse av händelsehanteringsprocessen.

  1. Gå tillbaka till NumberAdditionUI.java-filen i editorn. Klicka på fliken Källa för att se källkoden för det grafiska användargränssnittet.
  2. Scrolla ner och se de implementerade metoderna jButton1ActionPerformed (), jButton2ActionPerformed () och jButton3ActionPerformed (). Dessa metoder kallas händelsehanterare.
  3. Gå nu till metoden initComponents (). Om den här metoden saknas, leta reda på Generated Code-raden och klicka på +-tecknet bredvid den raden för att visa metoden hidden initComponents ().
  4. Lägg märke till den blå rutan som omger metoden initComponents (). Denna kod genererades automatiskt av IDE och kan inte ändras av användaren.
  5. Ta nu en titt på själva metoden initComponents (). Den innehåller bland annat kod som initialiserar GUI-elementen och placerar dem på formuläret. Denna kod genereras och uppdateras automatiskt när du placerar och ändrar element i designläge.
  6. I metoden initComponents () hittar du följande kodavsnitt: jButton3.setText ("Avsluta"); jButton3.addActionListener (ny java.awt.event.ActionListener () (public void actionPerformed (java.awt.event.ActionEvent evt) (jButton3ActionPerformed (evt);)));

    Vid denna tidpunkt läggs en ActionListener till i GUI-elementet, i detta fall jButton3. ActionListener-gränssnittet har ett ActionEvent-objekts actionPerformed-metod, som implementeras genom att helt enkelt anropa händelsehanteraren jButton3ActionPerformed. Den här knappen svarar nu på åtgärdshändelser. Varje gång knappen klickas, höjs en "ActionEvent"-händelse och skickas till "actionPerformed"-metoden i händelseavlyssnargränssnittet, som exekverar koden som utvecklaren tillhandahåller för den händelsen i händelsehanteraren.

  7. Java GUI Applications Learning Trail


© Copyright 2017, https://qzoreteam.ru