Język Ruby – lekkie i krótkie wprowadzenie :)

Inspiracja rozdziałem 29-tym, Joel Spolsky, „Sztuka pisania oprogramowania”

W zamieszłych czasach, których wielu z nas zapewne nie zaznała (aczkolwiek nie tak bardzo odległych, nie mówię tutaj o epoce gdy składano komputer Odra z części przywiezionych wagonem, około 10-15 lat później), istniał taki komputer Apple II (8-bitowy komputer domowy z lat 70-tych), który to dostarczany był z podręcznikiem napisanym w iście artystycznym stylu.

Nie chciałbym się rozpisywać o historii informatyzacji, w tym celu można sprawdzić na Wiki takie hasła, jak: Odra, Apple, Commodore (na którym zresztą znajomy rodzinny podobno pisał pracę dyplomową), a pragnąłem pokazać, w jaki sposób zmienił się styl pisania wszelkiej maści książek użytkownika, podręczników i tutoriali.

Chwytano się iście Monty-Pythowskiego humoru, historyjek komiksowych, anegdot, przede wszystkim aby zaciekawić użytkownika i łagodnie wprowadzić go w temat z danej dziedziny, który mógł być następnie poszerzony już w różnej innej technicznej literaturze.

Dzisiaj? Niektórzy powiedzieliby, że dominują książki o możliwie grubym grzbiecie i koncentracji faktów w jednym. Niech spojrzę na swoją półkę: „Java 2 Podstawy”, „Thinking In Java”, „SCJP..” (ta jeszcze zachowała odpowiednią dozę humoru), „EJB 3.0”, „PHP Programming”.. każdą z tych pozycji można z sukcesem nastawić bark w przychodni (tak jak to kiedyś ujrzałem w filmie, ale tam użyto Tołstoja „Wojna i pokój”).

Ale w temacie wyraźnie jest napisane że miało być o Rubym.

Ruby nie koniecznie jest językiem komputerowym, jest po prostu językiem. Językiem programowania zrozumiałym również dla szarych ludzi (aczkolwiek nie od razu). Spójrzcie na składnię:

5.times { print „Odelay!” }
co można przeczytać jako:
Five times print “Odelay”

exit unless „restaurants”.include? „aura”
czyli:
Exit unless the word restaurant includes the word aura

[toast, cheese, wine].each { |food| eat food }
to chyba trudniejsze:
With toast, cheese, and wine, take each type of food and eat that food.

Zaciekawiłem?
Do sprawdzenia:
http://whytheluckystiff.net/

komiksowy humor w służbie edukacji

http://poignantguide.net/ruby/

w jaki sposób można w przyjemny sposób przedstawić język z 1995 roku stworzony przez Yukihiro Matsumoto, czyli RUBY

Parser SQL w C – Flex, Bison czyli YACC problem

Ktoś by pewnie spytał się po co generować własny parser plików zapytań SQL, skoro są one walidowane w każdym silniku bazodanowym. Jedne z możliwych odpowiedzi to: hobbistycznie, lub też dla celów akademickich, czyli aby pokazać zasadę działania uniksowych parserów.

Bison (generator utworzony w ramach projektu GNU) zazwyczaj jest używany razem z programem flex (program podobny do lex, też wolny). Te dwa narzędzia pozwolą również na napisanie pretty-printera, a w zasadzie nieograniczona ilość na kod C w instrukcji main() pozwala pisać całkiem przyzwoite programy.

Pliki z gramatyką, które będziemy tworzyć, są to pliki tekstowe składające się z trzech części oddzielonych od siebie podwójnym znakiem procentu (“%%”) w kolejności: deklaracje, reguły gramatyczne, kod w języku C. Plik z rozszerzeniem .y jest to program dla bisona, natomiast plik z rozszerzeniem .l jest to program flex’a.

Pisanie parserów w C++ jest dużo trudniejsze (z wykorzystaniem g++ a nawet flex++), tutaj można znaleźć przykładowy tutorial:
http://tldp.org/HOWTO/Lex-YACC-HOWTO-5.html

sql.l:

%{
#include “sql.tab.h” //<>
#include <stdlib.h>
#include <string.h>

/*prototypy funkcji*/
void lexError(const char *);
static int getToken(const char *);

%}

%option yylineno

single_line_comment        “//”.*|”///”.*
white_space                [ \t\n\r]

%%

“select” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return SELECT;}
“from” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return FROM;}
“where” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return WHERE;}
“order” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return ORDER;}
“group” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return GROUP;}
“by” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return BY;}
“like” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return LIKE;}
“as” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return AS;}
“insert” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return INSERT;}
“update” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return UPDATE;}
“delete” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return DELETE;}
“set” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return SET;}
“into” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return INTO;}
“values” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return VALUES;}
“join” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return JOIN;}
“on” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return ON;}

“primary” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return PRIMARY;}
“foreign” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return FOREIGN;}
“references” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return REFERENCES;}
“key” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return KEY;}
“grant” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return GRANT;}
“create” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return CREATE;}
“alter” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return ALTER;}
“to” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return TO;}
“with grant option” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return WITHGRANT;}

“table” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return TABLE;}
“database” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return DATABASE;}

“–” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return SC;}

“(” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return START;}
“)” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return END;}

=|==|=!|<=|>=|<|> {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return ZNAK;}

“;” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return SR;}
“*” {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return AST;}

[0-9]+ {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext));  return LICZBA;}
[0-9A-Za-z"',]+ {yylval=(char*) malloc (strlen(yytext)); strncpy(yylval, yytext, strlen(yytext)); return TEXT;}

[:space:]+    ;
[ \n|\t]+     ;
“/*”(.|\n)*”*/”  ;

%%

/*metoda zwraca opis bledu leksykalnego*/
void lexError(const char *msg)
{
fprintf(stderr,”LINE:%d:lexical error (%s) [TEXT: %s]\n”, yylineno, msg, yytext);
}

sql.y:

%{
#include <stdio.h>
#include <stdlib.h>
#include “lex.yy.c”

typedef char* string;

int test = 1;
char* beg;

int yyerror(char *s){
printf(“Linia nr %d\nBlad %s\n”, yylineno, s);
fprintf(yyout, “Linia nr %d\nBlad %s\n”, yylineno, s);
test = 0;
};

int yylex(void);

#define YYERROR_VERBOSE
#define FALSE 0
#define TRUE 1

/*Numer linii parsera.*/
extern int yylineno;

/*Plik wejscia i wyjscia.*/
extern FILE *yyin, *yyout;

struct Intern{
string pl;
string en;
};

%}

%token SELECT
%token FROM
%token WHERE
%token ORDER
%token GROUP
%token BY
%token LIKE
%token AS
%token INSERT
%token UPDATE
%token DELETE
%token SET
%token INTO
%token VALUES
%token JOIN
%token ON

%token PRIMARY
%token FOREIGN
%token KEY
%token GRANT
%token CREATE
%token DROP
%token ALTER
%token REFERENCES
%token TO
%token WITHGRANT

%token DATABASE
%token TABLE

%token START
%token END
%token SR
%token AST
%token ZNAK
%token LICZBA
%token TEXT

%token SC

/*poczatek programu*/

%%

/* SQL 1992 */

statement_sql92: statement_sql92 SELECT TEXT FROM TEXT SR {
printf(“select %s from %s;\n”, $3, $5);
fprintf(yyout, “select %s from %s;\n”, $3, $5);
}
| statement_sql92 select_ast_st
| statement_sql92 select_where_st
| statement_sql92 delete_st
| statement_sql92 insert_st
| statement_sql92 update_st
| statement_sql92 statement_ddl
| statement_sql92 grant_st
| statement_sql92 other_statement {printf(“\n”);}
| ‘\n’
|
;

select_ast_st: SELECT AST FROM TEXT
{
printf(“select * from %s;\n”, $4);
fprintf(yyout, “select * from %s;\n”, $4);
}
| select_ast_st WHERE TEXT ZNAK TEXT
| select_ast_st ORDER BY TEXT
| select_ast_st SR
;

select_where_st: SELECT TEXT FROM TEXT WHERE TEXT ZNAK TEXT {
printf(“select %s from %s where %s %s %s”, $2, $4, $6, $7, $8);
fprintf(yyout, “select %s from %s where %s %s %s”, $2, $4, $6, $7, $8);
}
| select_where_st ORDER BY TEXT {
printf(” order by %s”, $4);
fprintf(yyout, ” order by %s”, $4);
}
| select_where_st SR {
printf(“;\n”);
fprintf(yyout, “;\n”);
}
;

delete_st: DELETE FROM TEXT SR {
printf(“delete from %s;\n”, $3);
fprintf(yyout, “delete from %s;\n”, $3);
}
| DELETE FROM TEXT WHERE TEXT ZNAK TEXT SR {
printf(“delete from %s where %s %s %s;\n”, $3, $5, $6, $7);
fprintf(yyout, “delete from %s where %s %s %s;\n”, $3, $5, $6, $7);
}
;

insert_st: INSERT INTO TEXT START TEXT END VALUES START TEXT END SR {
printf(“insert into %s (%s) values (%s);\n”, $3, $5, $9);
fprintf(yyout, “insert into %s (%s) values (%s);\n”, $3, $5, $9);
}
;

update_st: UPDATE TEXT SET TEXT ZNAK TEXT WHERE TEXT ZNAK TEXT SR {
printf(“update %s set %s %s %s where %s %s %s;\n”, $2, $4, $5, $6, $8, $9, $10);
fprintf(yyout, “update %s set %s %s %s where %s %s %s;\n”, $2, $4, $5, $6, $8, $9, $10);
}
;

/* DATABASE DESIGN LANGUAGE – DLL */

statement_ddl: drop_st
| create_st
| alter_st
;

drop_st: DROP TABLE TEXT SR {
printf(“drop table %s;\n”, $3);
fprintf(yyout, “drop table %s;\n”, $3);
}
;

create_st: CREATE create_table
| CREATE create_database
;

create_table: TABLE TEXT START TEXT {
printf(“create table %s(%s”, $2, $4);
fprintf(yyout, “create table %s(%s”, $2, $4);
}
| create_table TEXT {
printf(” %s”, $2);
fprintf(yyout, ” %s”, $2);
}
| create_table END SR {
printf(“);\n”);
fprintf(yyout, “);\n”);
}
;

create_database: DATABASE TEXT SR {
printf(“create database %s;\n”, $2);
fprintf(yyout, “create database %s;\n”, $2);
}
;

alter_st: ALTER TEXT START TEXT END SR {
printf(“alter %s (%s);\n”, $2, $3);
fprintf(yyout, “alter %s (%s);\n”, $2, $3);
}
;

/* STATEMENTS DATA CONTROL LANGUAGE */

grant_st: GRANT TEXT ON TEXT TO TEXT WITHGRANT SR {
printf(“grant %s on %s to %s with grant option;\n”, $2, $4, $6);
//fprintf(yyout, ” on %s to %s with grant option;”, $3, $5);
}
;

/* OTHER STATEMENTS LIKE SINGLE LINE COMMENTS AND BLOCK COMMENTS */

other_statement: SC {
printf(“– “);
fprintf(yyout, “– “);
}
| other_statement TEXT {
printf(” %s”, $2);
fprintf(yyout, ” %s”, $2);
}
;

%%

main(int argc, char *argv[]) {

int revokeL = TRUE;

struct Intern lang[] = { {“1) Wybierz standard jezyka zapytan\n”, “1) Choose SQL standard\n”},
{“2) Wybierz jezyk\n”, “2) Choose language\n”},
{“3) Waliduj skrypt SQL\n”, “3) Validate SQL file\n”},
{“4) Formatuj skrypt SQL\n”, “4) Pretty-print SQL script\n”},
{“5) Wyjscie\n”, “5) Exit from program\n” }
};

FILE *fp = NULL;
fpos_t dlugosc;
char stringInput;
if(argc != 3) {
printf(“Uzycie: %s <nazwa pliku wejscia> <nazwa pliku wyjscia>\n”, argv[0]);
do{
printf(“Czy chcesz przejsc do trybu interaktywnego (menu programu) ? [T/N]“);
stringInput = getchar();
__fpurge(stdin);
}while(stringInput != ‘T’ && stringInput != ‘N’);
if(stringInput == ‘N’)
return 1;
}
int choice = 0;

yyin = stdin;
yyout = stdout;

/* Jezeli zostal zdefiniowany plik wejscia i/lub wyjscia */
if (argc >= 2)
{
/* Otworz plik do czytania */
yyin = fopen(argv[1], “r”);

/* Jezeli nie udalo sie otworzyc pliku */
if(yyin == NULL)
{
fprintf(stderr, “ERROR: Input file not exists.\n”);
return 1;
}

/* Jezeli zostal zdefiniowany plik wyjscia */
if(argc >= 3)
{
/* Otworz plik do zapisu */
yyout = fopen(argv[2], “w”);
}

/* Jezeli nie udalo sie otworzy pliku wyjscia */
if(yyout == NULL)
{
fprintf(stderr, “ERROR: Output file not exists.\n”);

return 1;
}
}

while(choice != 4)
{
printf(“\nSQL miniStudio:\n”);
if(revokeL) printf(lang[0].pl); else printf(lang[0].en);
if(revokeL) printf(lang[1].pl); else printf(lang[1].en);
if(revokeL) printf(lang[2].pl); else printf(lang[2].en);
if(revokeL) printf(lang[3].pl); else printf(lang[3].en);
if(revokeL) printf(lang[4].pl); else printf(lang[4].en);

scanf(“%d”,&choice);

switch(choice)
{
case 1:
{ // wybierz standard
break; }

case 2:
{ // wybierz jezyk
if(revokeL){
revokeL = FALSE;
printf(“\nLanguage changed to ENGLISH!\n”);
} else{
revokeL = TRUE;
printf(“\nZmieniono jezyk na POLSKI!\n”);
}

break; }

case 3:
{ // waliduj skrypt

yyparse();
if(test){
printf(“Test OK!\n”);
fprintf(yyout, “Test OK!\n”);
}

break; }

case 4:
{ // formatuj
break; }

case 5:
{ // wyjscie
exit(0);
break; }

default:
{ break; }
}

}

}

dane wejściowe:

select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select
fasdfagtergddfa49384934
from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select * from tabelka;

select kolumna
from tabela;

select dsfy87dsayfsadf7 from ffsadfadsfasdfasfs;
select kjfds8ay7f8as8f    from ffsadfadsfasdfasfs;
delete from pracownicy;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;

update tabelka set umowa = ‘OK’ where umowa = NULL;

delete from pracownicy where imie = ‘andrzej’;

insert into tabelka(kol1,kol2) values(‘JaN’,'Kowalski’);

select TYTUL from BOOK WHERE   autor = ‘Profesor’   ORDER BY tytul;

select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
delete from zamowienia;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;

– komentarz, ponizej instrukcje ddl czyli tworzenia baz

create database testowa;
create database drugabazka;

create table waznedane (kol1 int, wartosc varchar);

create table fjdskfjkldsfkl (kol2 int, kol4 int, kol3 bool);

grant uprawnienie on employee to piotr with grant option;

wyjście:

select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fasdfagtergddfa49384934 from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select * from tabelka;
select kolumna from tabela;
select dsfy87dsayfsadf7 from ffsadfadsfasdfasfs;
select kjfds8ay7f8as8f from ffsadfadsfasdfasfs;
delete from pracownicy;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
update tabelka set umowa = ‘OK’ where umowa = NULL;
delete from pracownicy where imie = ‘andrzej’;
insert into tabelka (kol1,kol2) values (‘JaN’,'Kowalski’);
select TYTUL from BOOK where autor = ‘Profesor’ order by tytul;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
delete from zamowienia;
select fadsiouuwaruwf from ffsadfadsfasdfasfs;
–  komentarz, ponizej instrukcje ddl czyli tworzenia bazcreate database testowa;
create database drugabazka;
create table waznedane(kol1 int, wartosc varchar);
create table fjdskfjkldsfkl(kol2 int, kol4 int, kol3 bool);
Test OK!

Dzięki programowi w flexie możemy skopiować string dla każdego tokena (zamiast alokować pamięć i używać strcpy wystarczy użyć instrukcji yylval=text; , jednak kopiowanie stringów jest bezpieczniejsze jeżeli mamy zamysł pisania pretty-printera kodu), natomiast w bisonie każda instrukcja jest przetwarzana pod kątem naszej gramatyki i jeżeli w pliku wejściowym wpiszemy nieprawidłową instrukcję (niezgodną z nasza gramatyką), otrzymamy komunikat o błędzie.

Program kompiluje się w następujący sposób:

#!/bin/bash
flex -i sql.l
bison -d sql.y
gcc -o sql sql.tab.c -lfl

Jak w kodzie dodać kontrolki w .NET 3.5 (WPF) ?

Jak w kodzie dodać kontrolki w .NET 3.5 (WPF) ?

W pracy dyplomowej mam funkcjonalność do zaimplementowania – mapa stolików w restauracji. Na mapie stolików wykonanej w AutoCAD nakładam przyciski, więc wczytuje z pliku XML położenia moich stolików na mapie bitowej (wysokość i szerokość w pikselach), po czym właśnie w tym miejscu dodaję nową kontrolkę – button, posiadającą handler dla Click.

foreach (Seat seat in seats)

{

System.Windows.Controls.Button button = new Button();

button.Content = seat.Sala + “-” + seat.Stolik;

//ustawienie pozycji przycisku

button.Width = 40;

button.Height = 40;

Thickness thick = new Thickness();

thick.Left = seat.Width + 160;

thick.Top = seat.Height + 20;

thick.Right = 0;

thick.Bottom = 0;

button.Margin = thick;

// ulozenie

button.HorizontalAlignment = HorizontalAlignment.Left;

button.VerticalAlignment = VerticalAlignment.Top;

// przypisanie akcji przyciskowi

button.Click += new RoutedEventHandler(newButt_Click);

// koloryzacja

button.IsEnabled = false;

button.Background = buttonBrushes[2];

// dodanie do layoutu

{… implementacja …}

if (seat.Sala == Image.selected + 1) LayoutRoot.Children.Add(button);

}

}

private void newButt_Click(object sender, RoutedEventArgs e)

{

Button button = (Button)sender;

if (button.Background.Equals(buttonBrushes[3]))

{

// odzaznaczenie rezerwacji w przypadku edycji

}

{…kod implementacji…}

}

Polecam lekturę:

http://arcanecode.wordpress.com/2007/09/07/adding-wpf-controls-progrrammatically/

No i jestem..

po kolejnym wdrożeniu. Zainstalowałem serwer IIS u klienta na systemie Win XP (a czemu nie ) ), dołączyłem webaplikację w aspach za pomocą konsoli mmc i odpowiedniej przystawki. Za pierwszym razem nie zadziałało, dostałem komunikat iż nie mam dostępu do metadanych IIS. Spowodowane to było złą kolejnością instalacji, najpierw należy instalować IIS, dopiero potem .NET framework 2.0 . Opcja repair w intalatorze .net frameworka pomogła poradzić sobie z tym problemem. Następnie konfiguracja wyjątków w firewallu, otwarcie portu 80, i wszystko hula w całej sieci.

Teraz powoli rozkręcam z innymi studentami projekt za pomocą metodyki PRINCE 2 na warsztaty z Project Management. Miałem przyjemność uczestniczyć w wykładzie dr. Kosieradzkiego (firma P2Ware , oprogramowanie Product Base Planner) i wszystko powoli staje się jasne na temat procesu planowania. Może dojdzie do realizacji pewnego portalu internetowego w Polsce o tematyce…. , kto wie

FUJABA

Przeglądając płytę CD dołączoną do książki „Język UML 2.0” natrafiłem na narzędzie do modelowania w języku UML o nietuzinkowej nazwie – Fujaba, co znaczy „From UML to Java And Back Again”. Jest ono systematycznie rozwijane przez pracowników naukowych uniwersytetu w Paderborn (Niemcy, Nadrenia Północna – Westfalia)

Poniżej prosty, wręcz banalny model klasy, oraz.. kod Java wygenerowany przez to narzędzie.

 

 

package ZaJavka;

import java.util. *;

/**

* UMLClass: ‘Komunikator’.

*/

public class Komunikator

{

/**

* UMLAttr: ‘userName : String’.

*/

private String userName = “”;

/**

* UMLMethod: ‘- getUserName (): String’.

*/

private String getUserName ()

{

return this.userName;

}

/**

* UMLMethod: ‘- setUserName (newUserName: String): Void’.

*/

private void setUserName (String newUserName)

{

if ((this.userName == null) || (this.userName != null && !this.userName.equals (newUserName)))

{

this.userName = newUserName;

} // if

}

/**

* UMLMethod: ‘+ removeYou (): Void’.

*/

public void removeYou ()

{

//Statement

}

}

 

Jak widać, nie zapomniano nawet o hermetyzacji zmiennych.