pcalcado wrote:Bom, Sérgio, basta você discutir com a Sun que foi quem especificou.

Olhe esses links:

http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/JSPBeans2.html#63735
http://java.sun.com/j2ee/tutorial/1_3-fcs/examples/src/web/bookstore2/util/Currency.java


Quem criou o conceito tem o direito de alterá-lo

Eu acho importante mencionar a especificação falida do JavaBeans mas não adianta dar murro em ponta de faca, a 'comunidade' já estragou o conceito faz muito tempo.

louds wrote:

sergiotaborda wrote:
O detalhe importante é que um javabean não é algo que tem get/set, é algo que lança eventos quando o seu estado muda (ou seja, todos os set lançam eventos). É isso que diferencia um JavaBean de um POJO

No caso da tua definição, nenhum dos componentes do Swing são javabeans, porque eventos e setter não estão atrelados.

Uma propertie não precisa suportar notificação, assim como um evento não precisa estar associado somente a propriedades.

Fora isso, a forma como era usada em 98, quando o JBF foi criado já morreu, é uma especificação morta, são conceitos mortos. Você pode continuar pensando em 98, mas não reclame quando as pessoas te acharem estranho por não usar o entendimento contemporâneo destes conceitos.

http://java.sun.com/javaee/5/docs/tutorial/doc/JSPIntro8.html#wp70748 wrote:
JavaBeans Component Design Conventions

JavaBeans component design conventions govern the properties of the class and govern the public methods that give access to the properties.

A JavaBeans component property can be

* Read/write, read-only, or write-only
* Simple, which means it contains a single value, or indexed, which means it represents an array of values

A property does not have to be implemented by an instance variable. It must simply be accessible using public methods that conform to the following conventions:

* For each readable property, the bean must have a method of the form

PropertyClass getProperty() { ... }

* For each writable property, the bean must have a method of the form

setProperty(PropertyClass pc) { ... }

In addition to the property methods, a JavaBeans component must define a constructor that takes no parameters.

The Duke's Bookstore application JSP pages bookstore.jsp, bookdetails.jsp, catalog.jsp, and showcart.jsp use the com.sun.bookstore2.database.BookDB and com.sun.bookstore2.database.BookDetails JavaBeans components. BookDB provides a JavaBeans component front end to the access object BookDBAO. The JSP pages showcart.jsp and cashier.jsp access the bean com.sun.bookstore.cart.ShoppingCart, which represents a user's shopping cart.

The BookDB bean has two writable properties, bookId and database, and three readable properties: bookDetails, numberOfBooks, and books. These latter properties do not correspond to any instance variables but rather are a function of the bookId and database properties.

package database;
public class BookDB {
private String bookId = "0";
private BookDBAO database = null;
public BookDB () {
}
public void setBookId(String bookId) {
this.bookId = bookId;
}
public void setDatabase(BookDBAO database) {
this.database = database;
}
public Book getBook() throws
BookNotFoundException {
return (Book)database.getBook(bookId);
}
public List getBooks() throws BooksNotFoundException {
return database.getBooks();
}
public void buyBooks(ShoppingCart cart)
throws OrderException {
database.buyBooks(cart);
}
public int getNumberOfBooks() throws BooksNotFoundException {
return database.getNumberOfBooks();
}
}

http://java.sun.com/developer/onlineTraining/Beans/bean01/page2.html#classes wrote:
Definition: What is a Bean?

If you use builder tools, such as Delphi or Visual Basic, you are already familiar with the notion of a bean. A JavaBean is a reusable software component that is written in Java programming language. It can be visually manipulated in builder tools. A JavaBean is often referred to simply as a Bean.

Software components are self-contained, reusable software units. Using visual application builder tools, software components can be composed into applets, applications, servlets, and composite components. You perform this composition within a graphical user interface, and you can immediately see the results of your work.

...
What Distinguishes JavaBeans from Widgets?

JavaBeans define a design-time interface. This interface allows application designer tools, or builder tools, to query components to determine the kinds of properties the components define and the kinds of events they generate or to which they respond.

In visual application builder environments, Beans are sometimes referred to as reusable software components or custom controls. Software components such as JavaBeans are packaged differently from standard Windows controls or Motif widgets. They are packaged with design-time information (properties and methods) that allow builder tools to determine their capabilities.

In addition, end users, or third party suppliers, can build custom beans independently of the GUI platform or operating system. IS departments can distribute these third-party components to internal enterprise clients, or they can be sold as add-on components to anyone who uses builder tools to construct applications.


What Distinguishes JavaBeans from Java Classes?

Any Java class that adheres to certain conventions regarding property and event interface definitions can be a JavaBean. Beans are Java classes that can be manipulated in a visual builder tool and composed into applications.

Introspection, the process by which a builder tool analyzes how a Bean works, differentiates Beans from typical Java classes. Because Beans are coded with predefined patterns for their method signatures and class definitions, tools that recognize these patterns can "look inside" a Bean and determine its properties and behavior.

Introspection allows a Bean's state to be manipulated at design time?that is, at the time it is being assembled as a part within a larger application. For this to work, method signatures within Beans must follow a certain pattern so that introspection tools recognize how Beans can be manipulated, both at design time and at run time.

In effect, Beans publish their attributes and behaviors through special method signature patterns that are recognized by beans-aware application construction tools. However, these construction tools are not required to build or test your beans. The pattern signatures are easily recognized by human readers, as well as builder tools. One of the first things you'll learn when building beans is how to recognize and construct methods that adhere to these patterns.

pcalcado wrote:Ai ai ai...