The NL-requirements specified by user are lexically analyzed to extract the knowledge in the form of classes, objects and their respective, attributes, methods and associations. It also extracts Actors and Messages between the actors. Then UML diagrams are generated on the bases of previously extracted information. The designed system also generates the JAVA code automatically of the already generated diagrams. The designed system provides a quick and reliable way to generate UML diagrams (Class Diagram & Sequence Diagram) to save the time and budget of both the user and system analyst. Additional feature of the system is that it also generates JAVA code.
This paper is not intended to simply survey object-orientedspecification approaches; we thus refer the reader to Wieringa’s survey of an additional 19 object-oriented spec- ification methods , such as Shlaer-Mellor, Booch and OMT. Some of the methods, notably Fusion, OMT and UML, provide mechanisms for analysts to produce explicit descriptions of system behavior, usually in some form of scenarios. Most, but not all, of the methods provide some specification of object behavior in various forms of fi- nite state machines, sometimes augmented by use cases or conditions. The cooperative behavior of the group of objects that make up a system thus provide a specification of the system’s behavior. Wieringa notes that few of the 19 methods he examines, such as JSD and Syntropy, make a clear distinction between components in the envi- ronment of a system and components of the system itself; and that this blurring was already present in the Entity Relationship Diagram , of which object-oriented class diagrams are extensions.
Development of a flight schedule at Lufthansa starts approximately 4 to 5 years prior to the date of flight operation. Complex interrelationships exist between objects and/or events which form the appropriate environment for the application objectoriented data base: to make sure that the flight schedule meets all the operational constraints such as maintenance requirements, station limitations, etc., to evaluate the schedule robustness with respect to unpredictable events and delays as well as integrate long term maintenance operations with the flight schedule. Lufthansa Airlines's intention it is not (yet) to substitute the planners capabilities with Statice and an expert system but rather to use Statice as an up-to-date database and use its semantic structure to provide as much as possible direct access and support to the planners in schedule evaluation. That is achieved partially by providing an appropriate user interface (presentation types) and partially by using a ruled based system for statistical analysis on the collected data which answers "schedule inquiries"
The fourth category of (16% [59-66]) solutions are inspections focused. Reviews are conducted during development to refine the SRS to avoid ambiguity. Inspection is used when SRS is supposed to be completed just to detect ambiguities. Effective inspection method can reduce the ambiguity and can improve the quality of Software requirements document. Reading is one of the inspection techniques which can be applied by the reviewer to put more focus on the significant parts of an entity while inspection. Kamsties et al. in  proposed a checklist and scenario-based inspection technique. Another type of reading is Usage-based reading focuses on user’s point of view of a software artifact to help reviewer so that they can focus only the important parts . As per Berling & Runeson, (2003) , perspective based inspection is more effective than checklist based inspection. Tjong, Hartley, & Daniel, (2008)  in their thesis gave some guiding rules on the basis of the corpus which can serve as an Inspection checklist to find ambiguities. In  author perspective-based inspection methodology is developed based on Pragmatic Quality Model to recognize 198 total inspection points to prepare a quality inspection report.
Here, new is used to construct an instance of NullPointerException. Many of Java’s built-in run-time exceptions have at least two constructors: one with no parameter and one that takes a string parameter. When the second form is used, the argument specifies a string that describes the exception. This string is displayed when the object is used as an argument to print( ) or println( ). It can also be obtained by a call to getMessage( ), which is defined by Throwable.
Passing this as the first argument indicates that you want the new thread to call the run( ) method on this object. Next, start( ) is called, which starts the thread of execution beginning at the run( ) method. This causes the child thread’s for loop to begin. After calling start( ), NewThread’s constructor returns to main( ). When the main thread resumes, it enters its for loop. Both threads continue running, sharing the CPU in single- core systems, until their loops finish. The output produced by this program is as follows. (Your output may vary based upon the specific execution environment.)
JDK 8 added another new capability to interface: the ability to define one or more static methods. Like static methods in a class, a static method defined by an interface can be called independently of any object. Thus, no implementation of the interface is necessary, and no instance of the interface is required, in order to call a static method. Instead, a static method is called by specifying the interface name, followed by a period, followed by the method name. Here is the general form:
No programming technique solves all problems. No programming language produces only correct results. No programmer should start each project from scratch. Object-oriented programming is the current cure-all — although it has been around for much more then ten years. At the core, there is little more to it then finally applying the good programming principles which we have been taught for more then twenty years. C++ (Eiffel, Oberon-2, Smalltalk ... take your pick) is the New Language because it is object-oriented — although you need not use it that way if you do not want to (or know how to), and it turns out that you can do just as well with plain ANSI -C. Only object-orientation permits code reuse between pro- jects — although the idea of subroutines is as old as computers and good program- mers always carried their toolkits and libraries with them.
In software development scenario with high variety level, software modeling language and powerful tools to help the implementation process are among of most important things. Design-oriented languages such as Unified Mo- deling Language (UML) cannot fulfill this need because of their lack in executability. Implementation-oriented languages like Java Modeling Language (JML) are lack- ing on verifiability. This kind of lackness is tried to be solved by formal abstract language such as B-Method . However, the usability is low because it is not easy to use.
The need of encapsulating object interactions has already been pointed out by Aksit et al. . The authors suggest Abstract Communication Types (ACTs), classes describing object interactions. ACTs rely on composition filters for their integration with the remaining system. Composition filters are components that are interposed between classes, where they filter incoming and outgoing method calls. By delegating a received call to another object or by adapting the call before passing it on, composition filters interact with the surrounding compo- nents. Like Aksit et al. we consider the encapsulation of object interactions to be a legitimate goal. ACTs, however, are only reactive. They depend on calls issued from the underlying classes that are then redirected by composition filters. Relationships, on the contrary, are self-contained and independent of the events happening in the participating classes.
Kim and Carrington formalized UML class  and state diagrams ,  in Object-Z; the mapping is also formally defined. However, this work does not formalize all features of class and state diagrams. Table 2 presents the related works that have been cited widely and are more relevant to the proposed approach. This table divides these studies into two categories: 1) the studies that transform formal models in B, Z, and Object-Z into semi-formal ones in FCA and UML, and 2) the studies that transform semi-formal models in OMT and UML into formal ones in B, Z, and Object-Z. In Table 2, the related studies have been identified by their source model, target model, transformation direction (unidirectional or bidirectional), and purpose(s). Unidirectional transformations are able to do transformation just in one direction. This means that a source model can be transformed into a target model though it cannot be transformed into a source model. Bidirectional transformations are executed in both directions.
Modern object-oriented languages, like C++ and Eiffel, link the type hierarchy directly to the implementation hierarchy. Some allow further expression of type compatibility apart from the main implementation hierarchy, like Objective C and Java, which have separate interfaces to express common type relationships that cut across the main divisions in the class hierarchy. Earlier languages like POOL-T  developed completely independent implementation- and type-hierarchies, in the hope of preserving "pure subtyping" in a language with multiple, variant implementations. However, even the separate subtype hierarchy of POOL-T is defeated by recursive types and inescapably suffers from the same restrictions and lack of expressiveness that we identified previously for subtyping .
Over the last decade, there has been an overwhelming demand for different Enterprise Modelling (EM) techniques due to their benefits both in industry and in acquiring experience and know-how. Enterprise modelling represents and structures the business organisation as well as its internal structure and its relationships with the external environment. This enables enterprises to adapt to change quickly and easily, to satisfy customer requirements, and to improve their performance. Consequently, there has also been an increasing need to implement and integrate enterprise information systems with software engineering approaches. Enterprise modelling is the key fact to achieve this integration because it provides models that are used in planning and optimisation activities. According to Vernadat definition, Enterprise Modelling is “externalising and expressing enterprise knowledge” [1, 2], which allows enterprises to improve and share their knowledge between the different members of staff. This is really the key to why modelling has an important value for the enterprise. This enterprise knowledge represents the firm's operations and
Based on [83-85], one can link Event-B specica- tions with concurrent object-oriented programs using Object-oriented Concurrent-B (OC-B). In this way, specication of concurrency issues and reasoning about them in an abstract manner become possible. For this purpose, Edmunds and Butler interpreted details of concurrent features, such as processes and monitors, in Event-B. Then, they introduced an approach to rene Event-B specications to their OC-B counter- parts. Finally, they described the mapping of OC-B specications to object-oriented code (for example, in Java). Also, they have developed a tool which is based on Eclipse, and maps Event-B specications to object- oriented code.