Table of content

	Table of Contents

Technical Java: Developing Scientific and Engineering Applications
By Grant Palmer
Publisher	: Prentice Hall PTR
Pub Date	: April 21, 2003
ISBN	: 0-13-101815-9
Pages	: 496

                            

		Copyright
		About the FTP Site
		Preface
			Why Is Java a Good Technical Programming Language?
			The Structure of This Book
			What This Book Is Not
		Acknowledgments
		Chapter 1.  Introduction To Java
			A Brief History of Java
			What Java is
			Installing Java on Your Machine
			Compiling and Running Java Programs
		Chapter 2.  Moving from Fortran to Java
			Program Structure
			Basic Syntax
			Variables
			Subroutines, Functions, and Methods
			Arrays
			Dynamic Memory Allocation
			Pointers
			Exception Handling
			Libraries
			Built-in Math Functions
			Input/Output Capability
			GUIs and Web-Based Applications
		Chapter 3.  Moving from C to Java
			Program Structure
			Basic Syntax
			Java Classes vs. C Structs
			Variables
			Pointers
			Functions and Methods
			Arrays
			Dynamic Memory Allocation
			Exception Handling
			C Libraries and the Java APIs
			Strings
			Built-in Math Functions
			Basic Printing
			Input/Output Capability
			GUIs and Web-Based Applications
		Chapter 4.  Moving from C++ to Java
			Basic Syntax
			Preprocessor Directives
			Data Types
			Pointers
			Structures, Unions, Enumerations
			Inheritance and Interfaces
			Built-In Math Functions
			Standard I/O
			Strings
			Memory Management
		Chapter 5.  An Overview of Object-Oriented Programming Concepts
			Objects
			Classes
			Encapsulation
			Inheritance
			Polymorphism
		Chapter 6.  Basic Syntax
			General Syntax and a Simple Java Program
			Comments
			Operators
			Loops and Other Flow of Control Structures
			Transfer of Control Statements
			Basic Printing and Keyboard I/O
		Chapter 7.  Classes
			Class Declaration Syntax
			Access Privileges
			Objects
			Declaring Fields
			Declaring Methods
			Constructors
			Static Initialization Blocks
			Making Copies of Objects
			Nested Classes
			Encapsulation
			Inheritance
			The super Keyword
			The this Keyword
			Abstract Classes
			Final Classes
			The Garbage Collector
		Chapter 8.  Variables
			Primitive and Reference Type Variables
			Instance and Class Variables
			Creating Variables
			Naming Conventions and Restrictions
			Access Modifiers
			Accessing Variable Values
			Final Variables
			Transient and Volatile Variables
			Casting
			Variable Scope
		Chapter 9.  Methods
			Declaring Methods
			Naming Conventions
			Access Modifiers
			Instance Methods
			Static Methods
			The main() Method
			Input Parameters
			Abstract Methods
			Final Methods
			The native and synchronized Keywords
			Method Chaining
			Method Overloading
			Method Overriding
			The return Statement
		Chapter 10.  Interfaces
			Differences Between Interfaces and Abstract Classes
			Declaring an Interface
			Interface Members
			Implementing an Interface
			Interfaces and Inheritance
			Interface Instances as Input Parameters and Return Types
		Chapter 11.  Packages and JAR Files
			Defining a Package
			import Declarations
			CLASSPATH Environment Variable
			Packages and Access Control
			JAR Files
		Chapter 12.  Exception Handling
			The Exception Class Hierarchy
			try Statements
			The throw and throws Keywords
		Chapter 13.  Arrays
			One-Dimensional Arrays
			Two-Dimensional Arrays
			Arrays of More Than Two Dimensions
			Initializing Array Elements
			Accessing Array Elements
			Arrays as Method Arguments and Return Types
			Array Length
			Collection Classes in the Java API
		Chapter 14.  The Java Class Libraries
			Package Naming Conventions
			The Core J2SE Libraries
			The GUI Libraries
		Chapter 15.  Primitive Variable Wrapper and String Classes
			Primitive Variable Wrapper Classes
			Creating Primitive Variable Wrapper Class Objects
			Converting a Wrapper Class Object to a Primitive Value
			The parse() Methods
			The String Class
			Obtaining String Objects
			Concatenating Strings
			Other Important String Class Methods
			Converting Primitive and Reference Types to Strings
			Converting Strings to Primitive Values
		Chapter 16.  Built-in Math Functions
			Math and StrictMath Classes
			Mathematical Constants
			Absolute Value Methods
			Power and Square Root Methods
			Transcendental Math Functions
			Trigonometric Methods
			Conversion Methods
			Minimum and Maximum Methods
			Rounding and Remainder Methods
			Random Number Generator Methods
			The java.math Package
			Comparing the Built-in Math Capability of C, C++, Fortran, and Java
			References
		Chapter 17.  User-Defined Math Functions
			Basic Plan of Attack
			The Math2 Class
			Logarithm Methods
			Hyperbolic Trigonometric Methods
			The Gamma Function
			The Final Version of the Math2 Class
			Compiling the Math2 Class
			Using Math2 Class Methods
			Comparing Java, C, and Fortran Values
			References
		Chapter 18.  Building Class Hierarchies
			Defining the State and Behavior of a Gas Mixture
			The General Class Hierarchy Structure
			AbstractGas Class
			PerfectGas Class
			Air Class
			Realgas Class
			Species Class
			N2 Class
			N Class
			NitrogenGas Class
			Summary
			References
		Chapter 19.  Solving Systems of Equations
			General Considerations
			The EqnSolver Class
			Test Case
			Pivoting
			Gauss-Jordan Elimination
			Gaussian Elimination
			Lower-Upper Decomposition
			Matrix Inversion
			Testing the EqnSolver Class Methods
			Real Gas Viscosity Method
		Chapter 20.  Solving Differential Equations
			Ordinary Differential Equations
			The ODE Class
			Initial Value Problems
			Runge-Kutta Schemes
			Example Problem: Damped Spring Motion
			Embedded Runge-Kutta Solvers
			Other ODE Solution Techniques
			Two-Point Boundary Problems
			Shooting Methods
			Example Problem: Compressible Boundary Layer
			Other Two-Point Boundary Solution Techniques
			Partial Differential Equations
			References
		Chapter 21.  Integration of Functions
			General Comments
			Trapezoidal Algorithms
			Simpson's Rule
			Solving Improper Integrals
			Gaussian Quadrature Methods
			General Integral Types
			Example: Thin Airfoil Theory
			References
		Chapter 22.  Fourier Transforms
			The Fourier Transform
			Discrete Fourier Transform
			Analyzing Composite Signals
			Sampling Theory
			Spectral Leakage
			Fast Fourier Transform
		Chapter 23.  Generic Class Libraries
			Analyzing the Problem
			Example: Least Squares Fit
			Implementing the Generic Part
			Implementing the Problem-Specific Part
			Testing the Generic Class Library
		Chapter 24.  Data Modeling and Curve Fits
			Least Squares Fit to a Polynomial Equation
			The DataModeling Class
			The Polynomial Class
			Example Problem: Curve Fitting Specific Heat Data
			Fitting to Nonpolynomial Equations
			The Power Class
			Other Data Modeling Techniques
			References
		Chapter 25.  Java I/O
			General Concepts
			Byte Input Streams
			Byte Output Streams
			Character Input Streams
			Character Output Streams
			Test Case: An Atmosphere Modeling Tool
			Getting Input from Command Line Arguments
			Using the Standard I/O Streams
			Reading and Writing to a File
			Saving and Restoring Objects
			The java.nio Packages
			References
		Chapter 26.  An Introduction to Java GUIs
			The Java GUI Libraries
			The AtmGUI Class
			Choosing a Container
			Selecting the GUI Components
			Adding the Components to the Container
			Event Handlers
			Other GUI elements
			The Final Form of the AtmGUI class
		Chapter 27.  Creating Web-Based Applications Using Java Servlets
			Web-Based Application Basics
			Java Servlets
			Required Libraries and Tools
			Example: A Web-Based Atmosphere Modeling Tool
			HttpServlet Class
			General Form of an HttpServlet Subclass
			Extracting Input Parameters
			Running Server-Based Applications
			Sending Output Back to the Client Machine
			The AtmServlet Class
			Deploying the Web-Based Application
		Appendix Java Keywords