Appendix C
by Anand Vasappanavara, Gautam Vasappanavara, Ramesh Vasappanavara
Object-oriented Programming Using C++ and Java
- Cover
- Title Page
- Brief Contents
- Contents
- About the Author
- Dedication
- Preface
- How to Use This Book and Web Resources
- 1. Object-oriented Programming Basics
- 1.1 Introduction
- 1.2 Programming Concepts
- 1.3 Programming Paradigms
- 1.4 History and Development of Object-oriented Languages
- 1.5 Software Development Methodologies
- 1.6 Need for Objects
- 1.7 Object-oriented Language Features
- 1.8 Definition of OOP Language Classes and Objects
- 1.9 Extendibility and Reusability of OOP Paradigms
- 1.10 Extending/Deriving New Classes
- 1.11 Virtual Functions
- 1.12 Run-time Polymorphism and Dynamic Data Binding
- 1.13 Class as Abstract Data Type (ADT)
- 1.14 Standard Template Library (STL)
- 1.15 OOPS - Object-oriented Programming and Systems
- 1.16 Object-oriented Analysis and Design (OOAD)
- 1.17 Summary
- 2. Object Modelling
- 3. Extensibility and Reusability - Inheritance at Work
- 3.1 Extendibility and Reusability of OOP Paradigm
- 3.2 Extending/Deriving New Classes
- 3.3 Overriding Base Class Functions
- 3.4 Overloading
- 3.5 Single and Multiple Inheritances
- 3.6 Virtual Inheritance
- 3.7 Problems with Multiple Inheritance
- 3.8 Interface
- 3.9 Access Specifiers in Inheritance
- 3.10 Run-time-type Information - RTTI
- 3.11 Virtual Functions
- 3.12 Pure Virtual Functions
- 3.13 Run-time Polymorphism and Dynamic Data Binding
- 3.14 Class as Abstract Data Type
- 3.15 Separation of Behaviour and Implementation
- 3.16 Decoupling
- 3.17 Standard Template Library
- 3.18 Summary
- 4. Dynamic Modelling
- 4.1 Introduction to Static and Dynamic Modelling
- 4.2 Lifetime of an Object
- 4.3 Unified Modelling Language - A Tool for OOAD
- 4.4 User Requirements - Use Cases
- 4.5 Architecture and Domain: What Are They?
- 4.6 Sequence Diagram
- 4.7 Collaboration (Communication) Diagram
- 4.8 Events and State
- 4.9 Activity Diagram
- 4.10 Packages and Components – A Way to Organize Large and Complex Projects
- 4.11 Component and Deployment Diagram
- 4.12 Summary
- 5. Analysis and Design Methodologies
- 5.1 Introduction
- 5.2 Stages and Methodologies for Systems Development
- 5.3 Structured Analysis and Design (SASD)
- 5.3.1 Conceptual Design - Functional Modelling and Data Modelling
- 5.3.2 Modular Design
- 5.3.3 Analysis and Design Techniques and Tools
- 5.3.4 Context Diagrams
- 5.3.5 Event List
- 5.3.6 Data Flow Diagrams
- 5.3.7 Data Dictionary
- 5.3.8 Multilevel DFDs
- 5.3.9 Entity Relationship Diagram
- 5.3.10 Process Specifications
- 5.3.11 Specifying Constraints
- 5.4 Case Study on Structured Analysis and Design
- 5.5 Object-oriented Software Analysis and Design (OOAD)
- 5.6 OOAD: A Case Study
- 5.7 Design for Reuse
- 5.8 Comparison of SASD and OOAD Methodologies
- 5.9 Summary
- 6. C++ Fundamentals and Basic Programming
- 7. C++ Programming Basics and Control Loops
- 8. Functions, Storage Class Preprocessor Directives, and Arrays and Strings
- 8.1 Introduction
- 8.2 Why Use Function Templates?
- 8.3 Call by Value
- 8.4 Call by Reference
- 8.5 Call by Constant Reference
- 8.6 Recursion
- 8.7 Inline Functions
- 8.8 Function Overloading
- 8.9 Default Arguments
- 8.10 Memory Management of C++
- 8.11 Header Files and Standard Libraries
- 8.12 C++ Preprocessor
- 8.13 Arrays
- 8.14 Summary
- 9. Pointers and References
- 9.1 Introduction
- 9.2 What, Why and How of Pointers
- 9.3 Pointers Declaration and Usage
- 9.4 Call by Value and Call by Reference (Pointers)
- 9.5 Dynamic Memory New and Delete Functions
- 9.5.1 Memory Leak
- 9.5.2 Dangling Pointer
- 9.5.3 Pointers and Arrays
- 9.5.4 Pointers and Two-dimensional Arrays
- 9.5.5 Array Declaration on Heap Memory
- 9.5.6 Pointer to Pointer
- 9.5.7 Dynamic Memory for a Two-dimensional Array
- 9.5.8 Pointers and Three-dimensional Arrays
- 9.5.9 Array of Pointers
- 9.5.10 Pointers to Void
- 9.5.11 Pointer to a Constant vs const Pointer
- 9.5.12 Pointers to Function
- 9.6 What, Why and How of References
- 9.7 Summary
- 10. Classes
- 10.1 Introduction
- 10.2 Classes and Objects
- 10.3 Friend Function
- 10.4 Class Within a Class: Container Class
- 10.5 Objects and Data Members on Heap Memory
- 10.6 This Pointer
- 10.7 Pointers vs Objects: Use of Constant Declarations
- 10.8 Passing of Objects by Reference and Pointers to a Function
- 10.9 Constant Pointers and Constant References
- 10.10 Static Member Data
- 10.11 Static Member Functions
- 10.12 Summary
- 11. C++ Special Features: Errors and Exceptions and Operator Overloading
- 12. Inheritance
- 12.1 Introduction
- 12.2 Inheritance Hierarchy
- 12.3 Types of Inheritance
- 12.4 Constructors and Destructors
- 12.5 Base Class Function Overriding
- 12.6 Base Class Function Hiding
- 12.7 Virtual Functions
- 12.8 Multiple Virtual Functions
- 12.9 Virtual Destructors: Why and How?
- 12.10 Hybrid Inheritance with Multiple Inheritances
- 12.11 Virtual Inheritance
- 12.12 Run-time Polymorphism and Dynamic Binding
- 12.13 Abstract Data Types (ADTs)
- 12.14 Pure Virtual Functions
- 12.15 Summary
- 13. IO Streaming
- 14. Generic Programming and Templates
- 15. Object-oriented Programming with Java
- 15.1 Introduction
- 15.2 Internet and the World Wide Web
- 15.3 C and C++ are Around - Then Why Java?
- 15.4 Java Story
- 15.5 Java Features
- 15.6 Developing First Java Application
- 15.6.1 Installing and Using Java Development Kit
- 15.6.2 Setting Path and Classpath
- 15.6.3 Java Program Structure
- 15.6.4 Java Documentation Comments
- 15.6.5 Java Development Environment
- 15.6.6 Our First Java Application
- 15.6.7 Application with Swing Components
- 15.6.8 Eclipse-integrated Development Environment
- 15.6.9 Command Line Arguments
- 15.7 Summary
- 16. Java Fundamentals and Control Loops
- 16.1 Introduction
- 16.2 Constants/Literal Constants
- 16.3 Variables and Assignment of Values to Variables
- 16.4 Data Types
- 16.5 Scope and Life Time of Variables
- 16.6 Arithmetic Operators
- 16.7 Type Conversion and Type Casting
- 16.8 Unary Operators
- 16.9 Logical Operators
- 16.10 Bit-wise Operators
- 16.11 Other Operators
- 16.12 Conditional and Branching Statements
- 16.13 Control Loops
- 16.14 Break
- 16.15 Continue Statement
- 16.16 Summary
- 17. Simple IO and Arrays and Strings Vectors
- 17.1 Introduction
- 17.2 Input from Keyboard
- 17.3 Arrays
- 17.3.1 Declaring and Creation of an Array
- 17.3.2 Initialization of Arrays
- 17.3.3 How Are Arrays Stored in the Memory?
- 17.3.4 Accessing and Modifying Array Elements
- 17.3.5 Passing Arrays as Arguments to Methods
- 17.3.6 Returning Arrays as Arguments to Methods
- 17.3.7 Multi-dimensional Arrays
- 17.3.8 Java.util. Arrays Class
- 17.4 String
- 17.5 Collection Framework
- 17.6 Summary
- 18. Class Objects and Methods
- 18.1 Introduction
- 18.2 Classes and Objects
- 18.3 Declaring a Class and Creating of Instances of Class Variables
- 18.4 Constructors
- 18.5 Specifying Private Access Specifiers and Use of Public Methods
- 18.6 Usage of this Keyword
- 18.7 Garbage Collection
- 18.8 Finalizer and Finalize() Methods
- 18.9 Final Variable
- 18.10 Access Control and Accessing Class Members
- 18.11 Static Members
- 18.12 Factory Methods
- 18.13 Nested Classes
- 18.14 Inner Classes
- 18.15 Summary
- 19. Inheritance: Packages: Interfaces
- 19.1 Introduction
- 19.2 Basic Concepts of Inheritance
- 19.3 Member Access Rules
- 19.4 Using Super Class
- 19.5 Methods Overriding
- 19.6 Multilevel Inheritance
- 19.7 Run-time Polymorphism
- 19.8 Abstract Classes
- 19.9 Using Final with Inheritance
- 19.10 Object Class
- 19.11 Packages
- 19.12 Path and Classpath
- 19.13 Importing of Packages
- 19.14 Access Specifiers Revisited for Packages
- 19.15 Interfaces
- 19.16 Summary
- 20. Errors and Exceptions in Java and Multithreaded Programming
- 20.1 Introduction
- 20.2 Errors and Exceptions
- 20.3 Try and Catch Blocks
- 20.4 Handling of Multiple Exceptions by Try and Catch Blocks
- 20.5 Using Finally Block
- 20.6 Throw Exceptions
- 20.7 Throws Exceptions
- 20.8 Re-throwing of an Exception
- 20.9 Defining Our Own Exception
- 20.10 Concepts of Multithreading
- 20.11 Process vs Threads
- 20.12 How to Create and Run the Threads?
- 20.13 Life Cycle of Thread
- 20.14 Thread Priorities
- 20.15 Synchronization
- 20.16 Inter-thread Communications
- 20.17 Deadlock in Multithreaded Programming
- 20.18 Summary
- 21. Java IO Files
- 21.1 Introduction
- 21.2 IO Streaming
- 21.3 Java IO Stream Classes
- 21.4 IO Errors and Exceptions
- 21.5 FilterInputStream and FilterOutputStreams
- 21.6 Using BufferedInput and BufferedOutput Streams
- 21.7 Writing Primitive Data Types to File: DataInputStream/DataOutputStream
- 21.8 File Class
- 21.9 Random Access Files
- 21.10 Serialization of Objects and Object Streams
- 21.11 Summary
- 22. Networking in Java
- 23. Graphics Using Swing Components and Applets
- 24. Collections and Software Development Using Java
- 24.1 Introduction
- 24.2 Collection Framework of Java
- 24.3 Collection Interface
- 24.4 Set Interface
- 24.5 Iterators
- 24.6 List Interface
- 24.7 Collection Algorithms
- 24.8 Map Interface
- 24.9 Collection View of Map
- 24.10 JDBC Database Connectivity
- 24.11 Access Database Records Using MS Access Database
- 24.12 Access Database Records Using MySql Open Source Database
- 24.13 Access Database Records Using Oracle Database
- 24.14 Prepared Statement and Callable Statements
- 24.15 Servlets
- 24.16 Java Beans
- 24.17 Summary
- Appendix A
- Appendix B
- Appendix C
- Acknowledgements
- Copyright
Appendix C
NetBeans IDE
Installation
Netbeans 6.9 is an open source and is available at several locations on the Internet. One such location is www.netbeans.org. Down-load and install it on your computer.
Step 1: The first screen that opens on execution of Netbeans package is as shown below:
Step 2: File 
new java java Application
Step 3: Select Project Name, Location and folder and select Create Main Class and Set Main Project.
Step 4: Enter the java code in the program template provided by Netbeans:
Step 5: Select run command from the task bar:
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.