History of Java and Tour of JDK Java is an object-oriented programming language developed by Sun Microsystems, and modeled on C++, the Java language was designed to be small, simple, and portable across platforms and operating systems, both at the source and at the binary level, which means that Java programs (applets and applications) can run on any machine that has the Java virtual machine installed One might be surprised to learn that Java did not come into being because of Internet or World Wide Web (WWW), although it was WWW which propelled into java what it is as a language today and a de-facto standard for Server Side Softwares. Because of the similarities between C++ and Java, it is tempting to think of Java as the “Internet version of C++”, but it would be a big mistake since Java has practical and philosophical difference with C++. The history of java goes back to 1991, when a group of Sun Engineers led by Mr. Patrick Naughton and James Gosling wanted to design a small computer language that was to be used for consumer and electronic devices like Remote Controls, TV Switchboxes etc. Now since these devices were manufactured by different manufacturers who may choose different CPUs (Central Processing Units), the program should not be tied down to any single architecture. The project was code named “Green”. The languages was then called as Oak and since Oak was already an existing computer languages, it was code named as JAVA. But unfortunately, Sun did not get the project for which they were bidding and it was in 1994 with the advent of the WWW and browsers, java was propelled back in to the main stream. The JAVA as a language was reveled to the world in the Sun world 1995 conference and from there onwards different versions have come out with all the latest technologies being incorporated. The different versions are being dealt with separately in the coming modules. Java was basically invented as a platform independent software to be run on various electronic devices like remote controls, micro-wave ovens etc. The emphasis was on platform independence. Platform independence-that is, the ability of a program to move easily from one computer system to another-is one of the most significant advantages that Java has over other programming languages, particularly if your software needs to run on many different platforms. If you're writing software for the World Wide Web, being able to run the same program on many different systems is crucial to that program's success. It was with the increasing popularity of the Internet, java became as a language for the internet which lays emphasis on the client-server programming. Java achieves this platform independence by breaking up the process of compilation and interpretation in to two individual steps. We have two separate executable files for this purpose called the Compiler and the Interpreter. In the earlier programming languages, any code written was compiled and immediately interpreted to the underlying operating system machine standard and hence if the same program was taken to another machine having a different operating system, it would not work.

In Java, after compilation a class file is generated which is also called as byte code file and this class file is then interpreted as per the underlying machine standard. If we take this class file from one machine to another, it would still run, because interpretation is done as per that machine’s operating system. The Java compiler takes your Java program and, instead of generating machine codes from your source files, it generates bytecodes. Bytecodes are instructions that look a lot like machine code, but are not specific to any one processor. To execute a Java program, you run a program called a Bytecode interpreter, which in turn reads the bytecodes and executes your Java program. The Java Bytecode interpreter is often also called the Java virtual machine or the Java runtime Java bytecodes are a special set of machine instructions that are not specific to any one processor or computer system. A platform-specific Bytecode interpreter executes the Java bytecodes For running java programs, we would require software called as Java Development Kit, which can be downloaded from www.java.sun.com site. The earlier version of JDK was 1.0 and the other major versions were 1.1, 1.2 and the present version 1.3. Many authors and books also call JDK 1.3 as Java 3 and this is specifically stated to ensure that there is no confusion. We will be studying on Java Development Kit 1.3 and all the codes and error messages are of this version. Please note that the description of error messages differs from version to version. Once we download the software and install the same on the machine, the directory structure would like this and the important directories and files are explained herewith.

Name of the Folder Description

bin

Contains all the executable files which is required to run the java programs like java.exe, javac.exe

demo

Contains some demo applets and applications along with source codes.

jre

Contains the run-time environment and officially called as the Java Runtime Environment

lib

Contains the library files that support the executable and UI development.

src.jar file

archive that contains the class library source ode (a collection of files with .java extension)

Uninst.isu file

The un-installation file

Tools of JDK After having successfully installed the JDK, we will quickly go through the various tools which will be required for execution of the java programs. Now for executing our tools, we would first require to set the path in the autoexec.bat directory or we can individually create a batch file and run the same before executing java codes. We need to insert the following line in the autoexec.bat file or in the user defined batch file and the same is set path= c:\jdk1.3\bin where jdk1.3 is the directory name (default directory in which u have your jdk installed) Once we have executed the batch file, to ensure that our jdk is properly installed, we just need to just type javac on the dos prompt and it would give us a list of options. (Incase our jdk is not properly installed or the path is not properly given then it would give us a bad command output)

Name of the Executable Description

javac Compiler

java Interpreter

appletviewer Applet viewer

javadoc Documentation generator

The first executable used would obviously be javac which would generate a class file from the source code file. We can see what the various options of javac are by just calling javac on the dos prompt. To compile a particular source we will have to say javac Test.java wherein Test.java is the source code file name. (Note: All java files should end with the .java extension). The java executable is for interpreting the .class file generated from the earlier compiler option. Not interpreting a class file, we do not need to give the .java extension and it would simply be java Test, wherein Test is the name of the class file automatically generated. The appletviewer is a mini browser inbuilt into JDK specifically for running the java Applets. (Java Applets are not a part of the certification exam and is not explained hence forth). The javadoc is a document generator by which automatic documentation will be generated from the java codes based on special comments given in the source code file. (This is also not a part of the SL 275 objectives). Java’s popularity is because of the following 3 important points:-

a) Applets b) Security c) Portability

Java Applets are simple java class files embedded in an html file which is dynamically downloaded across the network by the web server when an appropriate APPLET Tag is encountered. Java Applets are dynamic in the sense that they can respond to events and user inputs and not just simple animations or sounds. Java programs are secure because they run within the JVM (Java Virtual Machine) which will be talked in depth later on. Java achieves the security by confining a java program to the java execution environment and not allowing it to access to other parts of the computer. The other main popularity of java is the fact that it is portable (as already explained earlier).

Features of Java The authors of java had written an influential White Paper that explains the design goals and accomplishments of Java and they are the following which is also called as the features of java. In each of the points the excerpts from the white paper is taken what the java designers say about each buzzword. 1 Simple “We wanted to build a system that could be programmed easily without a lot of esoteric training and which leveraged today’s standard practice. So even though we found that C++ was unsuitable, we designed java as close to C++ as possible in order to make the system more comprehensible. Java omits many rarely used, poorly understood, confusion features of C++ that in our experience bring more grief than benefit”. The basic syntax of Java is a cleaned up version of C++, there is no need for header files, pointer arithmetic, structures etc. There has been a lot of improvement of the C++ language, keeping in touch with the basics of C++. Hence anyone coming into java from the C++ background would find the same very simple. Also a lot of IDEs (Integrated Development Environment) Softwares like JBuilder, Visual Café etc have been made for easy execution of java programs. 2 Object Oriented “Simply stated, object-oriented design is a technique for programming that focuses on the data (= objects) and on the interfaces to that object. To make an analogy with carpentry, an object oriented carpenter would be mostly concerned with the chair he was building and secondarily with the tools used to make it, a non object oriented carpenter would think primarily of his tools. The object facilities of java are essentially those of C++” Java is based on the C++ Model of OOPs which is fundamental in the achievement of the other features of java. Java language is based on the purist’s “everything is an object” paradigm which is simple and easy to extend. The advantages of OOPs are explained in the later sections. The major difference between Java and C++ lies in multiple inheritance for which java has found a better solution. The reflection mechanism and object serialization features make it much easier to implement persistent objects and GUI builders that can integrate off the shelf components. 3 Distributed “Java has an extensive library of routines for coping with TCP/IP protocols like HTTP and FTP. Java applications can open and access objects across the Net via URLs with the same ease as when accessing a local file System.”

The networking capabilities of Java are fantastic and there is a separate package called java.net having classes related to both Socket Oriented and Packet Oriented data communication. Java also improves on the CGI scripting and uses an elegant mechanism called Servlets and JSP which makes server side programming in java extremely efficient. Java was originally designed for the distributed environment of the internet by properly handling the TCI / IP protocols. In many of the earlier languages the distributed environment was an after thought but not Java. Java has a complete package called java.net which contains classes which take care of the distributed environment like URL, Datagram Packet, Datagram Socket, and URLConnection etc. 4 Robust “Java is intended for writing programs that must be reliable in a variety of ways. Java puts a lot of emphasis on early checking for possible problems, later dynamic (run-time) checking and eliminating situations that are error prone. The single biggest difference between Java and C/C++ is that java has a pointer model that eliminates the possibility of overwriting memory and corrupting data.” Java program is robust by which it will successfully execute reliably in a variety of systems. It was possible to achieve this because of the following features / tools of Java

a) Strictly Typed: Java is a strictly typed language and forces the programmer to find the mistakes early in the program development and it also check the code at compile time and at run time also. It follows strict naming principles also.

b) Good Memory Management: Memory Management is a tedious and difficult

task in the traditional programming environments and it was the duty of the programmer to allocated and de-allocated memory from the programs. In java the de-allocation of memory is completely automatic because there is a Garbage Collection which will automatically reclaim the unused objects. (Garbage Collection is dealt in depth later on in this module).

c) Proper Handling of Exceptions: One of the reasons for the program failure

in the earlier programming languages was the mishandling of exceptional conditions (specifically the run-time errors). Java provides for a proper object oriented way of exceptional handling by which all errors (including run-time errors) can and should be managed by the program.

5 Secure “Java is intended to be used in networked / distributed environments. Towards that end a lot of emphasis has been placed on security. Java enables the construction of virus - free, tamper free systems.” Java achieves this security with the concept of Java Virtual Machine (JVM) which has been explained in depth in the later sections. 6 Architecture - Neutral “The compiler generates an architecture neutral object file format - the compiled code is executable on many processors, given the presence of the Java run-time system. The java compiler does this by generating byte code instructions which have nothing to do with particular

computer architecture. Rather they are designed to be both easy to interpret on any machine and easily translated into native machine on the fly.” With the advantage of byte codes, it is possible for a java code which is compiled on one machine to be executed on any other machine. This is possible due to the concept of Byte Codes explained earlier. The goal of java was “write once, run anywhere, anytime, forever”. 7 Portable “Unlike the C and C++, there are no implementation dependent aspects of the specification. The sizes of the primitive data types are specified as is the behavior of arithmetic on them.” The main advantages of java are that once written on any platform, it can be executed in the similar way in other platforms also. This is because the data types in Java are having a fixed size and having a fixed size of number types eliminates a major porting headache. The Strings are saved in standard Unicode format. “The libraries that are a part of the system define portable interfaces” 8 Interpreted “The java interpreter can execute Java bytecodes directly on any machine to which the interpreter has been ported. Since linking is a more incremental and light weight process, the development process can be much more rapid and exploratory.” As said earlier Java enables the creation of cross platform programs by compiling into an intermediate representation called Java Bytecode. There is a great advantage while we are developing an application with java being an interpreted language. 9 High Performance “While the performance of interpreted bytecodes is usually more than adequate, there are situations where higher performance is required. The bytecodes can be translated on the fly (at run time) into machine code for the particular CPU the application is running on” The earlier attempts at cross platform were done at the expense of performance. But java although interpreted, was carefully designed so that it would be easy to translate directly into native machine code for very high performance by using a Just-In-Time Compiler. The java runtime systems that provide this feature lose none of the benefits of the platform independent code. 10 Multi-Threaded “The benefits of multithreading are better interactive responsiveness and real time behavior” Multi-Threading is very simply in java and threads in java also have the capacity to take advantage of multi-processor systems if the base operating system does so. The code for the multi-threading remains the same across machines, but the implementation of multithreading is off-loaded to the underlying operating systems. Java supports multi-threaded programming, which allows a programmer to write programs that do many things simultaneously. Java comes with a elegant yet sophisticated but simple and easy solutions for multi-process synchronization that enables a programmer to construct smoothly running interactive systems.

11 Dynamic “In a number of ways, Java is more dynamic languages that C or C++. It was designed to adapt to an evolving environment. Libraries can freely add new methods and instance variables without any effect on their clients. In java, finding out run time information is straight forward.” Java programs carry with them substantial amounts of runtime type information that is used to verify and resolve accesses to objects at run time. This makes it possible to dynamically link code in a safe and expedient manner.

Concept of JVM The JVM stands for the Java Virtual Machine, an imaginary machine within which all the java programs are executed. The three parts of the JVM are

a) Class Loader b) Byte-Code Verifier c) Interpreter

The duty of the Class Loader is to load all the classes necessary for the successful compilation of the code. Infact the package java.lang is automatically loaded without the need for importing the same (equivalent to the famous first line include statement in C language). After the compilation, a .class file is generated and when we execute the .class file, first of all the Byte Code Verifier is called, whose duty is to check whether any changes have been made to the byte codes after the same have been generated (whether the .class file have been tampered with or not). Incase there is infact a change, it generated an exception or else allows the Interpreter to go ahead with the code. The Interpreter interprets the code and generates the necessary output. The actual working of the Class Loader and Byte Code Verifier will be explained in the first code module. Setting the Path By default the codes can be stored anywhere and when you type javac in the dos-prompt, it would not know whether to look for the javac executable file and hence we need to type as under:- set path=c:\jdk1.3\bin Here we assume that the directory of the JDK is jdk1.3. Once we do this, then we do not have to worry and we can store the .java file where and just type the above set path on the dos-prompt or even put it in the autoexec.bat file, so that we do not have to type it every time.

Mis-Conceptions of Java The following are the common Mis-conceptions of Java: Java is the Internet version of C++ Although it is very true that java became a popular programming language because of the World Wide Web and have a lot of features of C++, as it is also an Object Oriented Programming language, it would be very wrong to take java as an extension of C++ Java has many advantages over C++ in the form of better memory management and exception handling mechanism. Java is Interpreted language and hence is slow for serious applications The earlier versions of Java was slow and hence a JIT (Just in Time Compiler) and introduce and with this the performance issues simply goes away. Java is great for network related programs because of its intrinsic in-built classes. All Java Programs run inside a Web Page Java Applets run inside a web page, but it is quite possible to write stand alone java programs that run independently of the web browser. Java Applets are major security risk This would not be true because all the java applets run within the Java Virtual Machine and it would not be possible for applets to be in touch with the local file system, which the basic requirement of Java Applets.

Brief explanation of the Important Terminology in Java JDK This is the short form for Java Development Kit. The Java Development Kit is the software which is required for running Java Programs. The development environment for Java is very rich and contains everything they need to get started creating powerful java programs The JDK is available for most operating systems and the current version is JDK 1.3, with the beta version 1.4 due to release very shortly. We have already seen earlier what programs are available under the JDK and the directory structure of JDK. J2SE Java software can be broadly divided into 3 parts namely:

a) Java 2 Standard Edition (J2SE)

b) Java 2 Enterprise Edition (J2EE) c) Java 2 Micro Edition (J2ME)

J2SE is for developing normal applications and applets, but not for the server side programs for which we required J2EE Software. The program which we work for executing our code is J2SE which we have seen earlier in the module. The structure of the J2SE API is also discussed earlier. The J2SE JDK can be downloaded from the site as under:- http://java.sun.com/j2se/1.3/ Note: J2SE is the same thing as JDK 1.3. J2EE This stands for Java 2 Enterprise Edition, which is specifically for writing server side programs like Servlets, Java Server Pages and Enterprise Java Beans. The J2EE is a set of specifications based on which various Web Servers and Application Servers are said to be J2EE compliant. Java™ 2 Platform Enterprise Edition enables solutions for developing, deploying and managing n-tier server-centric enterprise applications To reduce costs and fast-track enterprise application design and development, the Java 2 Platform, Enterprise Edition (J2EE ) technology provides a component-based approach to the design, development, assembly, and deployment of enterprise applications. The J2EE platform offers a multi-tiered distributed application model, the ability to reuse components, integrated Extensible Markup Language (XML)-based data interchange, a unified security model, and flexible transaction control. Not only can you deliver innovative customer solutions to market faster than ever, but your platform-independent J2EE component-based solutions are not tied to the products and application programming interfaces (APIs) of any one vendor. Vendors and customers enjoy the

freedom to choose the products and components that best meet their business and technological requirements. J2ME Java 2 Micro Edition is specifically used for writing embedded programs which can be executed on Mobile Phones, PDAs (Personal Digital Assistant) and Palm Tops. Java™ 2 Platform, Micro Edition (J2ME™) encompasses VMs and core APIs specified via Configurations as well as vertical or market-specific APIs specified in Profiles J2ME specifically addresses the vast consumer space, which covers the range of extremely tiny commodities such as smart cards or a pager all the way up to the set-top box, an appliance almost as powerful as a computer. Like the other editions, J2ME maintains the qualities that Java technology has become famous for:

- built-in consistency across products in terms of running anywhere, any time, over any device

- portability of the code - leveraging of the same Java programming language - safe network delivery - applications written with J2ME are upwardly scalable to work with J2SE and

J2EE With the delivery of J2ME, Sun provides a complete, end-to-end solution for creating state-of-the-art networked products and applications for the consumer and embedded market. J2ME enables device manufacturers, service providers, and content creators to gain a competitive advantage and capitalize on new revenue streams by rapidly and cost-effectively developing and deploying compelling new applications and services to their customers worldwide. JVM This stands for Java Virtual Machine and it is within this imaginary machine all the codes whether it is a java application or a java applet is executed. The details of the JVM are explained later on this module. Java Hotspot The Java HotSpot product line delivers the highest possible performance for Java applications. Sun Microsystems has a version of Java HotSpot-technology-based VM for server-side performance and now a version for client-side performance. These two solutions share the Java HotSpot runtime environment, but have different compilers suited to the distinctly different performance characteristics of clients and servers. The Java HotSpot virtual machine (VM) is a key component in maximizing deployment of enterprise applications. It is a core component of Java 2 Platform, Standard Edition (J2SE) software, supported by leading application vendors and technologies. The Java HotSpot VM supports virtually all aspects of development, deployment, and management of corporate applications, and is used by: Integrated development environments (IDEs), including Forte for Java, Community Edition, Borland JBuilder, WebGain VisualCafé, Oracle JDeveloper, Metrowerks CodeWarrior, and the NetBeans Open Source Project

Application server vendors, such as BEA Systems (WebLogic Server) and iPlanet (iPlanetApplication Server) Plugin Many browsers include a JVM that is used to execute applets. Unfortunately browser JVMs typically does not include the latest java features. The java Plugin solves this problem for us. By using a plugin It directs a browser to use a specific JRE rather than the browser’s JVM. The JRE is a subset of JDK. It does not include the tools and classes that are used in a development environment. Java API API stands for Application Programming Interface and Java API is a set of pre-defined classes which we will be using in our applications and applets. The Java API is not a part of the software download and needs to be downloaded separately from the sun site. JRE JRE stands for Java Runtime Environment. Every java program would require a JRE for the programs to be executed. When we install the JDK, the JRE is automatically installed in the machine and the JRE for the applets is inbuilt into the browser. Hot Java HotJava was initial browser build by Sun Microsystems to show off the powers of java. The builders had in mind the power of what is now called as applets so they made the HotJava browser capable of interpreting the intermediate bytecodes. Nowadays most of the browsers have in-build JRE in the system. JAR This stands for Java Archive and is an executable file which is present in the bin directory of the JDK. The jar.exe is used for creating jar files and has various options by which we can add to an archive, or extract from the archive or delete some files from the archive. JAR (Java Archive) is a platform-independent file format that allows you to bundle a Java applet and its requisite components (.class files, images and sounds) into a single file. Using the new ARCHIVE attribute of the <APPLET> tag, this JAR file can be downloaded to a browser in a single HTTP transaction, greatly improving the download speed. In addition, JAR supports compression, which reduces the file size, further improving the download time. The concept of JAR is very important for the preparation of Java Beans in which we will combine all the java bean codes and then load the jar file in the bean box. This will be explained in Unit 2 when we do Java Beans. AWT This stands for Abstract Window Toolkit which is the GUI part of Java. All the class files related to the GUI part like Buttons, Checkboxes, Menus are all a part of the awt package present in the core java API. We will be doing AWT in Section II of this module later on and all the class files will be explained at that time.

Swing Swing is a part of the Java Foundation Class and it is used for creating 100% pure java components. The AWT class components rely more on the underlying operating system for their look and feel and hence a component created in Windows will look slightly different from the same component created in Mac machine. However Swing components are pure and full java components and a swing Button created in windows will look exactly the same created in Mac. All the swing components are present in the swing package in the core API. Applets Applets are java class files which are embedded in an html file which is loaded and executed by a web browser. The important classes and interfaces for Applets are present in the applet package of the core java API. Applets are executed within the JVM present in the Web Browser and cannot interact with the local files in the system and hence cannot transmit viruses. Servlets Java Servlets are server-side Java programs that web servers can run to generate content in response to a client request in much the same way as CGI programs do. Servlets can be thought of as applets that run on the server side without a user interface. Servlets are invoked through URL invocation. The main advantage of Servlet is that once started all the future requests are serviced by the service () method of the Generic Servlet or the doGet() and doPost() method of the HttpServlet class. Servlets are a part of the J2EE specifications and we can have session tracking, Http Tunneling and a lot of other server side features with Servlets. JSP It stands for Java Server Pages. A Java Server Page (JSP) is a page much like an HTML page that can be viewed in a web browser. However, as well as containing HTML tags, it can include a set of JSP tags (understood by the server) that extend the ability of the web page designer to incorporate dynamic content in a page. These tags provide functionality such as displaying property values using simple conditionals, and are understood by the server's JSP engine. One of the main benefits of Java Server Pages is that, like HTML pages, they do not need to be compiled. The web page designer simply writes a page that uses HTML and JSP tags, and puts it on their web server. The web page designer does not need to learn how to define Java classes or use Java compilers. JSP pages can access full Java functionality in the following ways:

• by embedding Java code directly in scriptlets in the page • by accessing Java beans • by using server-side tags that include Java Servlets

Both beans and Servlets are Java classes that need to be compiled, but they can be defined and compiled by a Java programmer who then publishes the interface to the bean or the Servlet. The web page designer can access a pre-compiled bean or servlet from a JSP page without having to do any compiling themselves.

Java Beans

JavaBeans brings component technology to the Java platform. With the JavaBeans API you can create reusable, platform-independent components. Using JavaBeans-compliant application builder tools, you can combine these components into applets, applications, or composite components. JavaBean components are known as Beans. The JavaBeans architecture defines Java's reusable software component model.

Java Beans is a software Component. A bean is a reusable, platform neutral component, which can be visually manipulated in a builder tool. Primarily Java Bean is taken as a black box that is a software device with a known functionality, but unknown internal functioning. The 3 interface facets that can be developed to independent degrees are:

a) The methods that can be invoked on a bean b) The readable and / or writeable properties that the bean expose c) The events that a bean can signal to the outside world or accept from it.

EJB EJB architecture is component architecture for the development and deployment of transactional distributed object applications based server side software components. Applications written using EJB is scalable, transactional and multi user secure. These applications may be written once and then deployed on any server platform that supports the EJB specs.

EJB specifies a server side component model. Using a set of classes and interfaces from the javax.ejb packages, developers can create, assemble and deploy components that conform to the EJB specs. The various parties in the EJB are:

- The Bean: These are reusable business components that companies can purchase and use

to help solve business problems. Beans are not complete applications, but rather are deployable components that can be assembled into a complete solution.

- The Container: This supplies the low-level runtime execution environment needed to run

EJB applications. - The Service Provider: This is the application server logic to contain, manage and deploy

components. BEA, SilverStream, WebSphere, iPlanet etc. - The Application Assembler: This is the overall application architect, for a specific

deployment. The mail goal is to combine various components and write the applications that use components.

- The Deployer: The application made is deployed or installed into one or more application

servers. - The System Administrator: Overall supervision of the deployed systems.

RMI Remote Method Invocation (RMI) enables programmers to create distributed Java-to-Java applications, in which the methods of remote Java objects can be invoked from other Java virtual machines, possibly on different hosts.

A Java program can make a call on a remote object once it obtains a reference to the remote object, by receiving the reference as an argument or a return value. A client can call a remote object in a server, and that server can also be a client of other remote objects. RMI uses object serialization to marshal and unmarshal parameters and does not truncate types, thereby supporting true object-oriented polymorphism JDBC JDBC is a standard SQL database access interface that provides uniform access to a wide range of relational databases. It also provides a common base on which higher level tools and interfaces can be built. This comes with an ODBC Bridge. All the classes related to database connectivity are in the java.sql package. JDBC does the following things:

a) establish connection with a database b) send SQL statements c) processes the results

JDBC is the interface between the database and java end user application, servlet applet. The Steps in JDBC are

1) Import the necessary classes. 2) Load the JDBC Driver 3) Identify the Data Source 4) Allocate a Connection Object 5) Allocate a Statement Object 6) Execute a Query using the Statement Object 7) Retrieve Data from the returned Result Set Object 8) Close the RS 9) Close the Statement 10) Close the Connection

JNI Java Native Interface (JNI) is a standard programming interface for writing Java native methods and embedding the Java virtual machine into native applications. The primary goal is binary compatibility of native method libraries across all Java virtual machine implementations on a given platform.

The Java 2 SDK extends JNI to incorporate new features in the Java platform. The changes are driven by licensee and user comments.

The Java 2 SDK still supports the old native method interface (NMI), which was originally implemented in Java Development Kit (JDKTM) 1.0. The old NMI is not part of the Java platform standard, and is not supported by the Java HotSpot performance engine.

The JNI allows Java code that runs within a Java Virtual Machine (VM) to operate with applications and libraries written in other languages, such as C, C++, and assembly. In addition, the Invocation API allows you to embed the Java Virtual Machine into your native applications.

Java 2D The Java 2D API introduced in JDK 1.2 provides enhanced two-dimensional graphics, text, and imaging capabilities for Java programs through extensions to the Abstract Windowing Toolkit

(AWT). This comprehensive rendering package supports line art, text, and images in a flexible, full-featured framework for developing richer user interfaces, sophisticated drawing programs and image editors. The Java 2D is used to display and print 2D graphics in the java programs. Java 2D API enables us to display complex charts and graphs that use various lines and fill styles to distinguish sets of data and also enables you to store and to manipulate image data--for example, you can easily perform image-filter operations, such as blur and sharpen Java 3D

Developers can easily incorporate high-quality, scalable, platform-independent 3D graphics into Java technology-based applications and applets.

The Java 3DTM application programming interface (API) provides a set of object-oriented interfaces that support a simple, high-level programming model. This enables developers to build, render, and control the behavior of 3D objects and visual environments.

By leveraging the inherent strengths of the Java language, Java 3D technology extends the concept of "Write Once, Run Anywhere" to 3D graphics applications.

JNDI The Java Naming and Directory Interface (JNDI) is a standard extension to the Java platform, providing Java technology-enabled applications with a unified interface to multiple naming and directory services in the enterprise. As part of the Java Enterprise API set, JNDI enables seamless connectivity to heterogeneous enterprise naming and directory services. Developers can now build powerful and portable directory-enabled applications using this industry standard. The Java Naming and Directory Interface (JNDI) 1.2 is a major new upgrade release that adds new functionality to the basic naming and directory support offered in the 1.1.x releases. New features include event notification, and LDAPv3 extensions and controls. This release contains valuable contributions from the following companies: Netscape, Novell, Tarantella Inc, Sun, BEA. Java IDL Java TM IDL is a technology for distributed objects--that is, objects interacting on different platforms across a network. Java IDL is similar to RMI (Remote Method Invocation), which supports distributed objects written entirely in the Java programming language. However, Java IDL enables objects to interact regardless of whether they're written in the Java programming language or another language such as C, C++, COBOL, or others.

This is possible because Java IDL is based on the Common Object Request Brokerage Architecture (CORBA), an industry-standard distributed object model. A key feature of CORBA is IDL, a language-neutral Interface Definition Language. Each language that supports CORBA has its own IDL mapping--and as its name implies, Java IDL supports the mapping for Java. CORBA and the IDL mappings are the work of an industry consortium known as the OMG, or Object Management Group. Sun is a founding member of the OMG, and the Java IDL team has played an active role in defining the IDL-to-Java mapping.

To support interaction between objects in separate programs, Java IDL provides an Object Request Broker, or ORB. The ORB is a class library that enables low-level communication between Java IDL applications and other CORBA-compliant applications.

Java Collections This is the new API introduced in Jdk 1.2. A collection (sometimes called a container) is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve and manipulate data, and to transmit data from one method to another. Collections typically represent data items that form a natural group, like a poker hand (a collection of cards), a mail folder (a collection of letters), or a telephone directory (a collection of name-to-phone-number mappings). Java 2 provides several types of collections, such as linked lists, dynamic arrays and hash tables for our use. Collections offer a new way to solve several common programming problems. The core of the Collection API is the new set of Interface called Set, Map and List. X.509 Certificates Certificates are digital documents attesting to the binding of a public key to an individual or other entity. They allow verification of the claim that a given public key does in fact belong to a given individual. Certificates help prevent someone from using a phony key to impersonate someone else. In their simplest form, certificates contain a public key and a name. As commonly used, a certificate also contains an expiration date, the name of the certifying authority that issued the certificate, a serial number, and perhaps other information. Most importantly, it contains the digital signature of the certificate issuer. The most widely accepted format for certificates is defined by the ITU-T X.509 international standard and thus, certificates can be read or written by any application complying with X.509 ITU-T Recommendation X.509 [CCI88c] specifies the authentication service for X.500 directories, as well as the widely adopted X.509 certificate syntax. The initial version of X.509 was published in 1988, version 2 was published in 1993, and version 3 was proposed in 1994 and considered for approval in 1995. JPDA The Java Platform Debugger Architecture (JPDA) consists of three interfaces designed for use by debuggers in development environments for desktop systems.

a) The Java Virtual Machine Debugger Interface defines the services a VM must provide for debugging.

b) The Java Debug Wire Protocol defines the format of information and requests

transferred between the process being debugged and the debugger front end, which implements the Java Debug Interface.

c) The Java Debug Interface defines information and requests at the user code level.

RSA Signature Digital Signature are used as a means of security and RSA is the most widely used digital signature algorithm and is employed by most browsers, including Netscape Navigator and Internet Explorer

In previous releases of Java Plug-in the lack of support for RSA signatures and dynamic trust management has impacted the usability and deployment of the Java security architecture.

In order for Plug-in to be able to verify RSA signatures in a browser-independent way, JDK 1.2.2 has bundled a Cryptographic Service Provider (CSP) with Plug-in. This CSP is capable of verifying RSA signatures. In particular, it supports the "MD2withRSA", "MD5withRSA", and "SHA1withRSA" digital signature algorithms.

The bundled RSA provider is automatically registered with the Java Cryptographic Architecture framework as part of the static initializer of the PluginClassLoader.

Versions of JDK and overview of Improvements and additions

in each version and classes deprecated in various versions till JDK1.2

The initial release of java was revolutionary and it continued to evolve at an explosive pace. After the release of Java 1.0, the features added by java 1.1 were more significant and substantial. JDK 1.1 added many new library elements, redefined the way events were handled by applets and deprecated several features of 1.0. Features added by 1.1

1) Introduction of Java Beans which is software components that are written in java

2) Serialization which allows you to save and restore the state of an object

3) RMI, which allows a java object to invoke the methods of another java object that is located on a different machine. This is very important for distributed applications.

4) JDBC which allows programs to access SQL databases from many different vendors

5) JNI, which provides a new way for the programs to interface with code libraries written in

other languages.

6) Reflection which is the process of determining the fields, constructors and methods of a java object at runtime

7) Various security features, such as digital signatures, message digests, access control

lists and key generation.

8) Built in support for 16 bit character streams that handle Unicode characters

9) Significant changes to event handling that improve the way in which events generated by the GUI elements are handled.

10) Inner classes which allow for one class to be defined within another

Features added by 2.0

1) Introduction of JFC of which Swing is the most important part

2) Introduction of Collection API

3) More flexible security mechanism is now available for java program. Policy files can define the permissions for code from various sources. These determine for example, whether a particular file or directory may be accessed or whether a connection can be established to a specific host and port.

4) Digital certificates provide a mechanism to establish the identify of a user. You can think

of them as electronic passport.

5) Various security tools are available that enable you to create and store digital signatures, sign JAR files and check the signature of a jar file.

6) The Accessibility library provided feature that make it easier for people with sight

impairments or other disabilities to work with computers.

7) The java 2D API provides advanced features for working with shapes, images and text.

8) Drag and drop capabilities allow you to transfer data within or between applications.

9) Text components can now receive Japanese, Chinese and Korean characters from the keyword. This is done by using a sequence of keystrokes to represent one character.

10) The CORBA defines an Object Request Broker (ORB) and an IDL (Interface Definition

Language). Classes deprecated in various versions till JDK 1.2 In JDK 1.1 The most affected class in the JDK 1.1 was the Date class in which most of the constructors have been deprecated. In JDK 1.2 The most important methods to be deprecated are the suspend (), resume and the stop () methods of the Thread class, because they can typically cause dead lock in the multi-threaded program.

Difference between Java and C / C++ Although most of the C++ syntax has been taken by java the following are the functionalities, which are present in C++ but not in Java.

1) Java does not include structures or unions 2) No automatic conversion done that result in loss of precision. For Example conversion

from long to int must be specifically casted. 3) No global functions or variables. Since code in java programs is encapsulated within one

or more classes 4) No concept multiple inheritance 5) No concept of destructors as the feature of Garbage Collector is there. 6) No goto keyword

7) Objects are passed by reference only whereas in C++ it can be passed by value or by reference.

The following are the new features in Java not present in C++

1) Multi-Threading 2) Java Package 3) Interface. Although we had the concept of abstract classes, there was not a concept of

interface. 4) There is only the new keyword and no delete keyword in Java 5) The break and continue jump statements can take labels also 6) A new >>> right shift operator 7) A new documentation comment which will be used by the javadoc utility 8) The boolean data type can take only true and false as values.

OOPs Concepts Object Oriented Programming Skills (OOPs) is one of the latest techniques in Programming and is very popular with the concept of Objects. The advantage of OOP is that everything is taken as an object and relationship between the objects. Object oriented programming is like building structures like for example building a Computer. When we use OOP our overall program is made up of lots of different self contained components called as objects. Each object has a specific role in the program and all objects can talk to each other in a well defined way The advantage of OOP is that internally each of the components might be extremely complicated and but we need not know the details of each component. We just need to know the overall system functions because each component talks to one another in a well defined way. In java everything is taken as an object and object oriented programming is the core of java. All computer programs consist of two elements - code and data and a program can be conceptually organized around its code or around its data. The process - oriented model characterizes a program as a series of liner steps (that is code) and can be thought of as code acting on data. In Object oriented programming model the program is organized around its data (that is objects) and a set of well defined interfaces to that data and can be thought of as data controlling access to code. Any object will have two sections within itself that is data and methods. The data is the variables which the object has and the methods are the functions which act on those variables in the object. These two sections can also be called as the State and Behavior where the state is the data and the behavior is the methods within the object. The four fundamental principals of OOPs are:

a) Polymorphism b) Data Encapsulation c) Inheritance d) Data Abstraction

Polymorphism is taken from the Greek work ‘poly’ which means many and ‘morphus’ which means forms and hence polymorphism would mean many forms. The simplest example of polymorphism would be the ‘+’ operator. When we say 10 + 10 it knows that it has integers on both the sides and it has to perform arithmetic calculation and would give the answer as 20, but incase we say “Hello” + “There” it would know that both the side are strings and it has to add them up or concatenate them.

Polymorphism is supported in java by means of concept of overloading which we will look later in this module. Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse. This is done in java by ensuring that the data in an object can only be accessed by the methods of that object only and incase any other object need to access the data of an object, it cannot do it directly but only through the methods of that object. This feature is like a protective capsule to the data ensuring that only the methods of an object access the data of that object. Inheritance is the process by which one object acquires the properties of another object. The object from which a class inherits is called the super class or the parent class and the class which inherits is called the sub class or child class. Take the example of Animal class which will have two sub classes called Mammal class and Reptile class and this continues. The Inheritance interacts with Encapsulation as well. For example, the Animal class encapsulates some properties / features and all the subclasses will have the same properties plus any of the properties which it adds as part of its specialization. Data Abstraction is the feature of hiding the implementation from the user. For example, when we start the computer, we are not bothered with the complexities of how the computer boots, but once the computer is fully started then we start working with our programs. Similarly when we sit in a car and drivers, we are not bothered with how the steering wheel communicates with the wheels or how the car starts up etc. Similarly when we give a program to a client, we just tell the client to click on the executable file and how the client is abstracted away from the minute details of how the programs functions.

So in simple words Data Abstraction means giving only details which are required by the user and not over-burdening him with many details

Dissecting the First Code Now let’s get to write our first code. We will open any text editor (notepad or edit command in the dos) and type in our code as under: IMP: Remember java is case sensitive, that would mean letters which are supposed to be in Capital should be in Capital only or otherwise specifically. We will now type the following 7 lines of code as specifically written in a file in the text editor (Which can be a Notepad or any other text editor)

Code public class Test { public static void main (String args []) { System.out.println (“Hello, Welcome to Learning Java with Prof Venkat Krishnan”); } } Points to be noted:

1 All source codes should be done within classes. There can be either one class or more than one class in any source code file.

2 A class is a template for data and is also an object. 3 The opening brace {and the closing brace} define the body of the class or the

method. 4 If the braces do not occur in matching pairs, the compiler indicates an error. 5 Semi-colons at the end of the line is mandatory and omitting the same at the end of a

statement is a syntax error. A syntax error is caused when the compiler cannot recognize the statement. The compiler normally issues an error message to help the programmer to locate and fix the incorrect statements. Syntax errors are violation of the language rules.

6 There should be atleast a semi-colon or an opening brace ( { ) but not both as together at the end of a line.

7 One can call the class whatever you want (within the limits of identifier, which we will see in the next sub-module), but the method, which is executed first in an application, is always called the main ().

8 When you run your java application the method main () will typically cause methods belonging to the other classes to be executed, but the simplest possible java application consist of one class containing the main () method.

9 There can be only one main () in any source code file. 10 There can only be one public class in a source code file. 11 The syntax of the main () is fixed and is public static void main (String args[]) 12 Also note the braces. There will be one set of braces for each and every class and

one for the method. 13 The class name should always be start with a capital Alphabet. This is not mandatory

but is java coding standard. Now let’s see what each of the words in the file is meant:

1 public – This keyword indicates that the class and method is globally accessible. The other access modifiers are default (nothing given), private and protected, which we will see later on.

2 static – The keyword static ensures that it is accessible even though no objects of the

class exist.

3 void – This indicates that the method has no return type. It is mandatory for every method to have a return type and incase there is no return type, the method should be pre-fixed with void keyword.

4 (String args []) – Every method has a (), thorough which we can pass any parameter

required for the method and in this main () we pass the String array having the name args. The array is defined by []. The name of the array can be anything, but it is a convention to type it as args.

5 System – This is the name of the standard class that contains variables and methods

for supporting simple keyboard input and character outputs to the display. It is contained in a package java.lang so it is always accessible just by using the simple class name, System.

6 out – The object out represents the standard output stream – your display screen and

is a data member of the class System. The member out is a special kind of member of the System class. Like the main () in our program, it is also static. This means that out exists even though there is no object of type System. The out member is referenced by using the class name, System, separated from the member name out by a full stop.

7 println () – This is the println () method that belongs to the object out and that outputs

anything that is within the parameters of the method. Over here we are printing out the text string in the println method.

Now we will name the source code file as Test.java and we will compile the file by going to the dos-prompt and writing javac Test.java. Once the class is properly compiled we will find a .class file with the same name as the source code file. Over here we will check what the class loader which we have learnt earlier is We will try to see what classes are loaded when we are compiling Test.java. We have written in the code two classes String and System. To see what classes are loaded we will compile by writing javac -verbose Test.java. To see what options are available with javac command just type javac and press enter at the console. After writing -verbose command, we will see that a lot of classes are loaded when the code is compiled and finally the .class file is generated and the total amount taken is also mentioned for our reference. Now we will see what a Byte Code Verifier is. We will open the .class file in an editor, it will all be in junk characters, but we will delete one of the legible characters and again type the same character. We have not done anything but only edit the class file to see whether the Byte Code Verifier checks it properly or not. We will now execute the .class file (without re-compiling the same) (by typing java Test) and bingo it refuses to work and will throw an exception. e.g. ClassFormatError. So the Byte Code Verifier indeed does it job. Now we will again recompile the Test.java so that the old class file is overwritten and then execute by calling java Test. When we call the interpreter we will not type any extension after the File name. The Interpreter calls the class file and not the .java file. We can check this by taking the .java file else whether and then calling the interpreter.

Source Code Layout and Comments In a source code, as we have seen earlier, it would contain the class keyword. But the other keywords in the layout would be package and import statement (which we will see later on).

In a normal source code layout, the package would be the first statement or line in the code layout and will be followed by the import statement (if any) and followed by the class keyword. The above order is mandatory and cannot be changed. Also it is very important to remember that we should not use existing system defined class names as our class names. There are 3 types of comments in java and they are

a) Single Line comment which is \\ b) Multiple Line comment which is \* and ends with *\

c) Javadoc comment which is \** and *\.

A comment is a line which is not read by the java compiler and interpreter when it goes through the source code file. Javadoc is a special comment which is read by the javadoc utility A blank space or white space have no effect in java, as the compiler does not take a white space into consideration other than when it is within a String.

Identifiers An identifier is something which identifies a class, a method name, a variable name, or a parameter name. For example, we have given the class name as Test, so here Test is the identifier and args is the identifier for the String array being passed in the main method and main the identifier etc. An identifier can begin with the following only:-

- May begin with a letter - May begin with a Dollar sign ($) - May begin with a underscore (_)

So any identifier cannot start with a numerical number or any other special character. To try this just change the Test name to 1Test and see the error coming up. Code public class 1Test { public static void main (String args []) { System.out.println ("Hello, Welcome to Gurukul Online Learning Systems"); } } Output

1Test.java:1: <identifier> expected public class 1Test ^ 1Test.java:7: '{' expected } ^ 1Test.java:1: class <error> is public, should be declared in a file named <error>.java public class 1Test ^ 3 errors

Keywords and Blocks Keywords are words having special meaning to the Java Technology Compiler. They identify a data type name or program construct name goto and const are reserved words in java, which means they are not keywords, but are reserved for future use. There are 48 basic keywords and they are as under:-

abstract do implements private throw boolean double import protected throws break else instanceof public transient byte extends int return true case final interface short try catch finally long static void char float native super volatile class for new switch while continue future null synchronized default if package this

A block is a set of codes which will be executed at once. The block should have the opening braces ( { ) and closing braces ( } ). All methods and classes have blocks which mean that they are executed in one single process.

Variables A variable is a named piece of memory that you use to store information in your java programs – a piece of data of some description. In short variables are locations in memory in which values are stored. If you define a variable to store integers, for example you cannot use it to store a value that is of decimal fraction or a string value

Before you can use a variable, you have to declare it. After it is declared, you can then assign values to it and use it. The declaration does the following -

a) Tells the compiler what the variable name is, so that it can referenced in future b) Tells the compiler the type of data the variable will or can hold. Java is very particular

about the data type and if you specify any variable can hold integer, then that variable cannot hold any other data type (i.e. String, Double, Float etc) and compiler check for the same.

c) The place of declaration decides the scope of variables, whether the variable is local

variable or class variable or instance variable. Therefore Variables are of 3 kinds namely, Local Variable, Class Variables or Instance Variables. Local Variables - They are local to the method and are visible only inside the method in which they are declared. Incase we try to access the variables outside the method it would throw an error. The important thing to note is that method / local variables need to be initialized or the compiler would throw an error.

Code class Test1 { public static void main (String[] args) { System.out.println(a); } void met1() { int a = 10; } }

Output The compiler would throw an error that it cannot resolve the symbol a. Here the compiler is trying to tell us that it does not understand what a means over here. This is because int a is defined in met1 () and hence becomes a method variable and we are trying to access the same in the main method where it does not have a scope. class Test1A { public static void main(String[] args) { int a; System.out.println(a); } } Output The compiler would throw an error stating that variable is not initialized. This is because the rule is that method variables need to be initialized before being used. Class Variables - These variables are declared outside the main method right in the beginning or right at the end. The scope of the class variable is for all the methods in that particular class.

The class variables need not be initialized as they take default values.

The Important point to be noted here is that there is only one memory location for the class variables. Default value of a class variable: Data Type Default Value boolean false char \u0000 (that is nothing) byte 0 short 0 int 0 long 0L float 0.0f double 0.0d String null Before we go to the instance variables, we need to understand what the meaning of an instance is. An instance is a copy of the object which we are creating with the new keyword and each instance shall have a copy of the class variables and methods of that object.

For example, if we have a class called Test which has a method called met1() and we need to call the method, then first of all we would be required to create an instance of the class and then call the method with that instance.

Code class Test2 { int a; public static void main(String[] args) { Test2 x = new Test2(); x.met1(); } void met1() { System.out.println(a); } } Output It would be 0 (zero) since it has taken the default value. In the above code we are creating an instance of class Test2 and x is called the instance and with the instance we are calling the method. This is the standard way any non static method needs to be called. Instance Variables: Instance variables are created when objects are instantiated and therefore they are associated with the object. They take different value for each object.

Code class Test4 { int a = 10;

public static void main(String[] args) { Test4 x = new Test4(); x.a = 20; Test4 y = new Test4(); System.out.println(y.a); } } Output: It would print out 10. This is because when we create a new instance a copy of the class variable is given to each of the instances and hence when we change x.a = 20, we are changing the value of a for the instance x and when we create a new instance it would by default have the copy of the original class variable. Over here it is important to understand that there are 3 separate memory locations, one for the class variable and two memory locations for the two different instances and a separate memory location would be created for any new instance. We learnt what is static earlier on, but now we will properly examine this keyword. static keyword can be applied either to a variable or to a method. When static keyword is applied to a class variable (it can be prefixed only to a class variable, will give a compilation error incase applied to a method variable), then it would mean that class variable would be shared by all the instance of the classes. There would only be one memory location and no different locations for the instance variables. Hence any change made by one instance would change the original class variable also. Let’s see this by way of an example. Code class Test4A { static int a = 10; public static void main(String[] args) { Test4 x = new Test4(); x.a = 20; Test4 y = new Test4(); System.out.println(y.a); } } Output: It would give 20 as the answer, because when we said x.a=20, we are infact changing the original class variable’s value also to 20, since there is only one memory location for the static class variable and instances. Non- static class variables are also called as instance variables. Now let us see what the static keyword means when applied to a method. We have already seen that for a non-static method an instance of a class is required and we can call a non-static method only with the instance of the class. Code class Test5 { public static void main(String[] args) { Test5.met1();

} static void met1() { System.out.println("Hello World!"); } } Output It would give the output of Hello World. This would mean that for a static method, there is no need for the instance of a class. We can directly call the static method with the class name, since static methods are associated with the class directly. static methods have a limitation however that it can only access static class variables and cannot access non-static class variables. Code class Test6 { int a = 10; public static void main(String[] args) { System.out.println(a); } } Output It would give an error stating that non-static variables cannot be referenced from static context. IMP: Over here one needs to understand the difference between directly printing out the class variable and printing out the class variable with an instance of the class. One of the standard questions in the exam would be why the main method should always be static? The reason is that since the main method is called first by the compiler or it is starting point of entry into a source code file and no instance of the class is created (instances can be created only the main method), hence the main method should be static.

Data Types The data types specify the size and type of values that can be stored in the variable. There is no sizeof operator in Java as the size and representation of all types is fixed and is not implementation dependent. Hence java is called as a strictly typed language. Each primitive data type has a name, specifies how much memory is required to store a data item of that data type, and identifies a legal range of values from which a data item of that data type can be obtained. Again the Primitive data types can be classified into the following 4 major categories

a) Textual Data Type b) Integral Data Type c) Logical Data Type d) Floating Data Type

Textual Data Type: This is represented by char and individual characters and can hold only single characters - The character should be put inside quotes (‘ ‘) while defining the same. Characters are stored in 16-it Unicode characters and the range is from 0 to 255 and there is no negative char. For example char c = ‘a’; It is important to note that char in C/C++ and in Java are different because in C/C++, char is an integer type with 8 bits wide. Java uses Unicode to represent characters. Unicode defines a fully international character set that can represent all the characters found in all human languages. Since java is designed to allow applets to be written for worldwide use, it makes sense that it would use Unicode to represent characters. The following table lists the special codes that can represent nonprintable characters, as well as characters from the Unicode character set. Characters escape codes.

Escape Meaning \n New line \t Tab

The Integral Data Type can be represented in 3 forms namely;

a) Decimal – Where the decimal value is two b) Octal – Where the leading zero indicates an octal value (E.g. 077) c) Hexadecimal – Where the leading OX indicates a hexadecimal value (E.g. OX22)

The default Integral type is int and for Long it has to be explicitly followed by the letter L. There are 4 types of variables that you can use to store data and all of these are signed that mean you can use both negative and positive values. The four integer types differ in the range of values they can store, so the choice of types for a variable depends on the range of data values you are likely to need. The four integer types are: Type Size Range

byte 8 bits -128 to 127 short 16 bits -32,768 to 32,767 int 32 bits -2,147,483,648 to 2,147,483,647 long 64 bits -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 The smallest integral type is byte. This is a signed 8-bit and is especially useful when you are working with a stream of data from a network or file. short is a signed 16-bit data type IMP: It is very important to note here that integer expressions using byte and short are AUTOMATICALLY PROMOTED to int before the calculation is done. This has a specific reason and will be explained later on. The type long is a 64-bit and is useful for those occasions where an int type is not large enough to hold the desired values

We should specifically write L (capital alphabet) or l (small alphabet) after the initialized value of a long to ensure that the compiler takes it as a long value, otherwise if we just declare long l = 12345678912, the compiler will take it as a int value and give an error. Code class Test7 { public static void main(String[] args) { long l = 12345678912; System.out.println(l); } } Output The error would be integer number is too large, which proves that in spite of declaring as a long data type, the compiler has taken the default of integral as int. To ensure that the compiler takes it as a long data type, the initialized value should be followed by L and then we would get the desired result. We said earlier that byte and short are automatically promoted to int before any calculation is done on them. This because their values are very small and the final result would be within the size of a byte, but in between the calculation what should be done incase it goes beyond the range. To prevent this, byte and short are automatically promoted to int. For example (10*10*10) / 100 would give answer as 100 but in between the value has gone to 1000 which is beyond the range of a byte. Code class Test8 { public static void main(String[] args) { byte b = 10; byte c = 10; byte d = b + c; System.out.println(d); } } Output: This would a error saying loss of precision since as per the rule byte gets converted into a int during calculations on byte and short and int values cannot be accommodated in a byte value (as int is 32 bits and byte is 8 bits). To ensure that the code gets properly compiled the easy way is to change the data type of d as int. However in many cases, we would want the value of d to be as a byte value only. In this case we would be required to cast the result to ensure that it gets stored in a byte data type and this is done by doing it in the following manner.

byte d = (byte) (b + c); For values which are below 127, there would be no problem and there would serious issues incase the values go beyond the value of 127. To under this let us see the following code

Code class Test8 { public static void main(String[] args) { byte b = 10; byte c = 13; byte d = (byte) (b * c); System.out.println(d); } } Output The output would be -126. Now we would be thinking how in the world did this figure comes from. Whenever we cast any value into any smaller data type, there would be issue of loss of precision. To understand loss of precision, let us take an example of putting a cup of tea into a saucer fully, it is bound to overflow and some tea would be lost. Similarly when we do casting there would be loss of values. Now let us take the above example and analyze the same. Since the value of 130 is beyond the range of a byte as the maximum value of a byte would be only 127, it again goes back and starts putting the bytes in the old blocks. Remember the range of a byte is from -128 to 127. So the value of 128 is put in -128 and so on and hence the result of -126. It is very important to note incase the value is very big, it will go on doing the above thing till it reaches -1 and then 0 and then 1 and till 127 and again -128 and till keep on going like this. In Java, the only logical data type is boolean which takes only two states, true or false. In java, unlike C and C++ boolean is neither a number nor it can be treated as one. All tests of boolean should test for true or false. Also note that boolean states are in small caps and not like other languages where true should mandatorily be declared as TRUE and vice versa. It is also important to note that boolean values cannot be converted or casted with other data types also. The boolean data type is used by the control statements like if and for etc. Floating-point numbers are also known as real numbers are used when evaluating expressions that require fractional precision. There are two kinds of floating point types, float and double which represent single and double precision numbers in the width and range as under:

Type Size Range

float 32 bit 3.4e-038 to 3.4e+038 double 64 bit 1.7e-308 to 1.7e+308

The default of floating point data type is double and hence for using float we should mandatorily use f after the values (like long). Code class Test9 { public static void main(String[] args)

{ float f = 10.11; System.out.println(f); } } Output It would give an error of loss of precision, since it has taken the default value of a double.

Coding Conventions Classes should start with Capital Alphabets. The class will compile incase we have a small alphabet class, but then it is a convention followed in the java world and hence we would like to differ from the general rules of convention. The second letter incase one is there in the class should also start with Capital alphabets. For Example IndexArrayOutOfBoundsException. The methods should start with lower alphabets and the second word in the method should be capital. For example. startsWith (), endWidth() or getDocumentBase() methods. The interfaces should also follow the rules layed down for classes. The packages should start with small alphabets. For Example java.lang, java.awt. etc All variables (class and method) should start with small alphabets and the second word should start with Capital Alphabets like the rule for methods. Although the $ sign is permitted as an identifier, we should try to limit the use of $ sign in the class names, because it was a special meaning when we are using the Inner classes.

Arrays Array is a group of similar kind of data types that is reference by a common name. Suppose if we want a group of integers from 1 to 100 to be reference by a common name, we create an array of them. Each variable in an array is called array element. It is important to note that the array numbering stars from 0 and not 1. Array is an object and not a primitive, even if it is made up of primitives. Like objects, array required initialization and declaration only creates a reference to the array. To explain in depth, to create a array is to 3 steps

a) Declaration b) Creation c) Initialization

Declaration One is not obliged to create the array itself when you declare the array variable. The array variable is distinct from the array itself. This is how one declares a array.

int a [] - This is a array of integers with the variable a String s [] - This is a array of strings with the variable s

Creation Once you declare an array of any data type, you should create the same with the help of the new keyword and the same is done like this a = new int [10]; s = new String [5]; The above example shows that the array with the variable a will store integers up to 10 values and the second example creates that the s (String variable) will store Strings up to 5 values.

Remember: The array length starts from 0 The creation of array only reserves the space in memory for 10 integers and 5 strings, but nothing is inside it.

Initialization Once we have the memory reserved, we can put values into each of the individual spaces like this: a[0] = 10; This puts 10 as the first value of the array a[1] = 20; This puts 20 as the second value of the array and so on. Similarly we can put strings into the 5 spaces as under; s[0] = “Gurukul” and so on.

Direct Declaration and Creation The above 1 and 2 steps can be do simultaneous like this int a [] = new int [10]; It is important to note that the [] box can be put before or after the array variable. This is also correct. int [] a = new int[10];

Direct Initialization Since the above process is cumbersome, we can initialize an array with your own values when you declare it and at the same time determine how many elements it will have. This is done as below:

int a [] = { 1,25,30,55} This creates an array with variable name as a and with values as put into the {} and with 4 elements.

Accessing Array Values You can refer to an element of an array by using the array variable followed by the element’s index value enclosed between square brackets. For Example Existing Array: int a [] = { 1,25,30,55} If we have to access the 2nd element of the array, we will do it like this int a[1], here we use 1 because, as said earlier, the array indexing begins with 1. Important: Any attempt to access array indexes beyond the length of the array causes runtime error. For example: If we try to access the 5th element, it will give a runtime error, because there is no 5th element in the array. The exception thrown would be called as ArrayIndexOutOfBoundsException. We will cover the topic of runtime error and the different types of exceptions thrown in the other modules. Code class Test22 { public static void main(String[] args) { int a [] = new int[10]; System.out.println(a[10]); } } Output java.lang.ArrayIndexOutOfBoundsException at Test22.main(Test22.java:6) Exception in thread "main"

Array Bounds In the java programming language, all array subscripts begin at zero. The number of elements in an array is stored as part of the array object, as the length attribute. This value is used to perform bounds checking of all runtime accesses. If an out-bounds access occurs, then a runtime error occurs. Use the length attribute to iterate on an array as follows: int list[] = new list [10]; for (int I = 0 ; I < list.length ; I++) { System.out.println[i];

) Using the length attribute makes the program maintenance easier

Array resizing Once created, an array cannot be resized. However you can use the same reference variable to refer to an entirely new array. Since an array cannot be resized, this is the biggest limitation of arrays. int d[] = new int [6]; d = new int [10]; In this case, the first array is effectively lost unless another reference to it is retained elsewhere.

Array Copying The java language provides a special method in the System class arraycopy () to copy arrays. The syntax for copying array is: System.arraycopy ( original array, 0 (index to start with), new array, 0 (index of new array from where copying has to start), original array.length (or number of references to be copied); The above method can be proved with the help of this example. // original array. int a[] = {1,2,3,4,5,6}; // new larger array. int d[] = {10,9,8,7,6,5,4,3,2,1}; System.arraycopy{a,0,d,0,a.length); After this, the array d will have the following content: 1,2,3,4,5,6,4,3,2,1} Note: The method System.arraycopy() copies, references, not objects, when dealing with array of objects. The objects themselves do not change. Code class Test23 { public static void main(String[] args) { int a[] = {1,2,3,4,5}; int b[] = {10,20,30,40,50,60,70,80}; System.arraycopy(a,2,b,3,2); for (int i = 0; i<b.length;i++) { System.out.println(b[i]+" "); } }

} Output

10 20 30 3 4 60 70 80 Multi-Dimensional Arrays We have only worked with one-dimensional arrays up to now, that is arrays that use a single index.

Why would you ever need the complications of using more indexes to access the elements of an array? Suppose that you have a fanatical interest in the weather and you are intent on recording the temperature each day at 10 separate geographical locations throughout the year 1999. Once you have sorted out the logistics of actually collecting this information, you can use an array of 10 elements corresponding to the number of locations, where each of these elements is an array of 365 elements to store the temperate values. You would declare this array with the statement float temperature [] [] = new float [10] [365]; There are 10 arrays each having 365 elements. In referring to an element, the first square brackets enclose the index for a particular array, and second pair of square brackets encloses the index value for an element within that array. So to refer to the temperate for day 100 for the sixth location, you would use temperature [5] [99]. In java, multidimensional arrays are actually array of arrays. To declare a multidimensional array a variable, specify each additional index using another set of square brackets. For example, the following declares a two-dimensional array variable called D. int D [] [] = new int [2] [4] The above array creates and allocated a 2 by 4 array. Internally this acts like a matrix in which the first square bracket is for the number of rows and the second bracket is for the number of columns. Remember: Note that you can have an array with 0 columns but not with 0 rows. For example int D[] [] = new int [2] [0] - Ok int D[] [] = new int [0] [2] - Not Ok.

Java Operators Java provides a fully featured set of operators, most of which are taken fairly directly from C and C++. However Java’s operators differ in some important aspects from their counterparts in these other languages and you need to understand clearly how java’s operators function. The Java Operators can be classified into 8 Groups as under:

a) Unary Operators b) Arithmetic Operators c) Comparison Operators d) Bitwise Operators e) Short-Circuit Operators f) Ternary Operators g) Assignment Operators

The Unary operators can be classified further into :

1) Increment and Decrement Operators; ++ -- 2) Unary plus and minus Operators; + - 3) The boolean complement operators; ! 4) The Cast operator; ()

Increment and Decrement Operators These operators modify the value of an expression by adding or subtracting 1. So for example, if an int variable x contains 10, then ++x results in 11 and --x give you 9. This is the case because the increment and decrement is done on x and the value is stored in x only To understand how the position of these operators’ ++x and x++ affect their operation, you must understand the different between the values stored by these operations and the result value they give. For example, you could say y = x++; then the value assigned to y will be the original value of x and if you say y = ++x, then the value assigned to y will be 1 more than the original value of x. It is important to note here that in both these cases the value of x will be increment by 1. The following table shows the value of x and y, before and after particular assignment using these operators: Initial value of x Expression Final Value of y Final value of x 10 y = x++ 10 11 10 y = ++x 11 11 10 y = --x 9 9 10 y = x-- 10 9 The Unary + and – operators The unary + and – operators are distinct from the more common binary + and – operators which are usually referred to as + and – (add and subtract).

The unary + has no effect beyond emphasizing the positive nature of a numeric literal. Unary – negates an expression. So one might make a block of assignment just like this: x = -3; y = +3; z = -(y+6); The Boolean Complement Operator ! This operator inverts the value of a boolean expression so !true gives false and !false would give true. This operator is usually used in the body of if() and else() to be swapped. The Cast Operator Casting is used for explicit conversion of the type of an expression. This is only possible for plausible target types. The compiler and runtime system check for conformance with typing rules and incase they do not match, then casting might be required. Casts can be applied to change the type of primitive values, for example forcing a double value into an int value like this: int c = 10; double b = 15.50; int d = (int) (c x b);

Arithmetic Operators The next highest in precedence, after the unary operators are the arithmetic operators. The Arithmetic Operators are divided into two further sub groups, the first group having the *, / and % operators. The second group have the lower precedence + and – operators. Multiplication and Division Operators The above operators can be used on all primitive numeric types and char. Integer division can generate an ArithmeticException from a division by zero. The multiplication and division works as it works in simple math examples which we learnt in school. The important point to note here is that, whether you multiply or divide two integers, the result will be calculated using the integer arithmetic in either int or long representation and u will have to store the same in the wider of the types to ensure that precision is maintained. Modulo Operator % The modulo Operator gives a value which is related to the remainder of a division. It is generally applied to two integers, although it can be applied to floating point numbers also. For example when you say int a = 7 int b = 3 int c = a % b the result would be 1. The Addition and Subtraction Operators

The + and – operators perform addition and subtraction and they apply to operands of any numeric type, but uniquely, the + operator is also permitted when either of the operand is a String object. When either of the operands of a + expression is a String object, the meaning of the operator is changed from numeric addition to concatenation of text. In order to achieve this, both operators must be handled as a text. If both operators are in fact String objects, this simple, however if one of the operands is not a String object, then the non string operand is converted to a String object before the concatenation is taken place. How operands are converted into String Objects?? It is very useful in practice to know a little about how + converts operands into String objects. For object types, conversion to a String object is performed simply by invoking the toString () of that object. The toString () is defined in the java.lang.Object class which is the root of the class hierarchy and therefore all objects have a toString () method. Conversion of an operand of primitive type to a String is typically achieved by this, indirectly using the conversion utility method in the wrapper classes. For example, the following code explains the situation. Code class Test11 { public static void main(String[] args) { int a = 10; String s = "Hello"; System.out.println(a+s); } } Output The output would be 10Hello. But how did it convert the primitive data type of int to a String, so that it can be concatenated with s. This is properly explained in the following code. Code class Test11 { public static void main(String[] args) { int a = 10; String s = "Hello"; Integer i = new Integer(a); String s1 = i.toString(); System.out.println(s1+s); } } Output The output would be the same as 10Hello, but we have properly explained the procedure over here. First of all the primitive int is converted into an Object via the use of Wrapper classes (set of classes provided for each primitive data type for conversion into an object). Please note

that there is no class specifically called as Wrapper class, all the classes together are called as Wrapper classes, since the purpose of these classes is to wrap the primitive into an object. IMP: The rule for the + operator is that if both sides are primitives it would perform arithmetic calculation and incase one side is a String, it would convert the other side to a String and then do concatenation. The process would be from left to right.

Code class Test12 { public static void main(String[] args) { String s = 10 + 10 + "Hello"; String s1 = "Hello"+10+10; System.out.println(s); System.out.println(s1); } } Output : The output would be 20Hello and Hello1010. The first output is 20 because for the first + operator both the sides are numeric and hence it performed arithmetic calculation and then concatenated the result with the String because the second + operator had a String on one of its side.

The Comparison Operators The comparison operators all return a boolean value. There are three types of comparison:

a) Ordinal - Which tests the relative value of the numeric operands b) Object Type - Which tests if the runtime type of an object is of a

particular type or subclass of that particular type

c) Equality - Which test if two values are the same and may be applied to values of non-numeric types also.

Ordinal Comparison operators are of the following type: Operator Meaning Example < Less than x < 3 > Greater than x > 3 <= Less than or equal to x <= 3 >= Greater than or equal to x >= 3 Object Type comparison is done with the help of the instanceof Operator This is the operator, which tests the class of an object at runtime. The left-hand argument can be any object reference expression, usually a variable, while the right hand operand must be a class, interface or array type. You cannot use a java.lang.Class object or its string name as the right hand operands.

The instanceof operator returns true if the class of a left hand argument is the same or is some subclass of the class specified by the right hand operand. The right hand operand may equally well be an interface. In such a case, the test determines if the object at the left hand argument implements the specified interface. Note: If the left hand argument is a null type, the instanceof test simply returns false – it does not cause an exception. Code class Test13 { public static void main(String[] args) { A x = new A(); B y = new B(); C z = new C(); boolean k = x instanceof B; boolean l = y instanceof A; // boolean m = z instanceof B; System.out.println(k); System.out.println(l); } } class A { }; class B extends A { }; class C extends A { }; Output: It would be false and true. Over here we have class A which has 2 subclasses. Now we have introduced a new keyword called extends. It is this keyword which makes possible inheritance possible in Java. Then we create 3 instances of each of the classes. Since all comparison operators return a boolean value, we are capturing the same in a boolean variable. First we check whether x is a instanceof B and it return false because a superclass instance cannot be a instance of the subclass. Then we check whether y is a instance of A and it returns true because a subclass variable is a instance of the subclass and also of the super class since the subclass extends the super class.

incase we remove the comment and printout the variable m also, it would result into a compilation error because there cannot be a relationship between two unrelated classes. It will not give false also, but a compilation error. Equality comparison operators: == and != and equals() The Equality comparison can be on two grounds:

a) Checking the Memory location equality (whether both the variables being checked belong to the same memory location or not).

b) The content Equality. (checking the contents of the String)

The operators == and != test for equality and inequality, respectively returning a boolean value. For primitive type, the concept of equality is quite straightforward and is subject to promotion rules so that for example a float value of 10.0 is considered equal to a byte value of 10. For variables of object type, the “value” is taken as the reference to the object; typically this is the memory address. You should not use these operators to compare the contents of objects, such as Strings because they will return true if two reference refer to the same object, rather than if the two objects have an equivalent meaning. Code class Test14 { public static void main(String[] args) { String s = "Hello"; String s1 = "Hello"; String s2 = new String ("Hello"); String s3 = new String ("Hello"); boolean a = s == s1; boolean b = s1 == s2; boolean c = s2 == s3; System.out.println(a); System.out.println(b); System.out.println(c); } } Output: It would be true, false and false. Now before we go to the result, we need to understand what do one mean by memory location. There are two parts of a computer memory, a stack and a heap. In the earlier programming languages, String was a primitive data type, but in java, they wanted it to be an object and also as a data type and hence String is the only class which can be created without the new keyword. When String is initialized without the new keyword it is taken as a primitive data type and when it is initialized with the new keyword it is taken as a proper object. Hence we cannot call the methods of a String object on the primitive data type.

The rules for Stack and Heap are as under:-

a) primitive data types are always stored in the stack. b) The rule in the stack is that, once we have a particular value, a memory location is

allotted to it and when another variable is initialized to the same value, a different memory location is not created, but the same memory location now points to both the variables.

c) Objects are always stored in the heap.

d) Whenever a object is created with a new keyword a new memory location is created

irrespective of the contents of the Object. Now based on the above rules, we can analyze the above code as under:-

a) Both the String values of s and s1 would be stored in the stack. b) Since both the values of s and s1 are the same, it would have the same memory

location and hence s == s1 returns true.

c) Now s2 and s3 are created with the new keyword and hence they would be allotted separate memory locations, in the help although they have the same contents.

d) Hence s2 == s3 would return false.

e) s1 == s2 would definitely give false, because they are in separated areas of memory.

To achieve a in-depth comparison, so that two different String objects containing the text “Hello” are considered equal, you must see the equals() rather than the == method. IMP: We have a equals method in the Object class, which is similar to the == method which checks for the equality on the basis of the memory location. However in the String class the equals method have been overridden to check for the equality on the basis of contents. Check the following code Code class Test15 { public static void main(String[] args) { String s = new String ("Hello"); String s1 = new String ("Hello"); StringBuffer sb1 = new StringBuffer("Hello"); StringBuffer sb2 = new StringBuffer("Hello"); boolean a = s.equals(s1); boolean b = sb1.equals(sb2); System.out.println(a); System.out.println(b); }

} Output The answer would be true and false. This is because as said earlier, the equals method have been overridden in the String class to check for the contents whereas in the StringBuffer class the same have not been overridden and hence it checks like the normal equals method which is the memory location and since both are object created with the new keyword, they would have different memory locations and hence false.

Bitwise Operators The Bitwise Operators &, ^ and | provide AND, Exclusive-OR (XOR) and OR Operations respectively. They are applicable to internal types. The bitwise operations calculate each bit of their results by comparing the corresponding bits of the two operands on the basis of these 3 rules:

a) For AND Operations, 1 and 1 produces 1 and any other combination produces 0 b) For XOR Operations, 1 XOR 0 produces 1 as does 0 XOR 1 and any other combination

produces 0

c) For OR Operation 0 OR 0 produces 0 and any other combination produces 1 The names AND, XOR and OR are intended to be mnemonic for these operations. You get 1 result from an AND operation if both the first operand and second operand are 1. An XOR gives 1 result if one or the other operand, but not both (the exclusivity part) is 1. In the OR Operation, you get 1 result if either the first operand or the second operand (or both) is 1 Code class Test16 { public static void main(String[] args) { int a = 10; int b = 15; int c = a & b; int d = a | b; int e = a ^ b; System.out.println(c); System.out.println(d); System.out.println(e); } } Output The answer would be 10, 15 and 5 To check this let us first take a scientific calculator and out the bit pattern of 10 and 15. The bit pattern of 10 is = 1010 The bit pattern of 15 is = 1111

(please remember that int is of 32 bits and since there are zeros in the beginning it is not coming the calculator, but for calculation purpose we need to work out the 28 initial zeros also. Now each bit in the first value will be calculated with the first bit of the second value and similarly all the 32 bits are calculated and then finally whatever bit number comes it is converted in to a integer comes and that is how the values of 10, 15 and 5 came in the above example. Bitwise on Boolean Operations The &, ^ and | operators behave in fundamental the same way when applied to arguments of boolean rather than integral types. However instead of calculating the result on a bit by bit basis the boolean values are treated as single bits, with true corresponding to a 1 bit and false to a 0 bit. The general rules discussed in the previous section may be modified like this when applied to boolean values

a) For AND Operations, true AND true produces true and any other combination produces false.

b) For XOR Operations, true XOR false produces true or false XOR true produces true and

any other combination produces false. For OR Operation, false OR false produces false and for any other combination produces true. Operator Meaning ~ Bitwise complement <<= Left shift assignment (x = x << y) >>= Right shift assignment (x = x >> y) >>>= Zero fill right shift assignment (x = x >>> y) x&=y AND assignment (x = x & y) x|=y OR assignment (x = x | y) x^=y XOR assignment (x = x ^ y)

Short Circuit Logical Operators The short circuit logical operators && and || provides logical AND and OR operations on boolean types. Note that there is no XOR operation provided. Superficially this is similar to the & and | operators with the limitation of only being applicable to boolean values and not integral types. However the && and || operators have a valuable additional feature: the ability to short-circuit a calculation if the result is definitely known. This feature makes these operators central to a popular null-reference-handling idiom in java programming. The main difference between the & and && and the | and || operators is that the right hand side operand might not be evaluated at all. This behavior is based on two mathematical rules that define conditions under which the result of a boolean AND or OR operations is entirely determined by one operand without regard for the value of the other:

a) For a AND operation, if the Left Hand operand is false, the result is false, without regard to the other operand.

b) For an OR operation, if the Left Hand is true, the result is true, without regard to the other

operand.

Given these rules, if the left hand operand of a boolean AND operation is false, the result is definitely false whatever the right hand operand may be. It is therefore unnecessary to evaluate the right hand operand. Similarly, if the left hand operand of a boolean OR operation is true, the result is true and the right hand operand need not be evaluated. For Example if ((s != null) && (s.length() > 20)) { System.out.println(s); } Now here if the String reference is null, then calling the s.length() method would raise a NullPointerException. If we use the short-circuit && then that situation would not arise, because if (s != null) returns false, then the whole test expression is guaranteed to be false. Where the first operand is false then in && the second operand is not evaluated at all and the s.length () is not evaluated at all. The Ternary Operator:

The ternary operator provides a way to code simple situations (if/else) into a single expression. The syntax for a ternary operator is (boolean condition) ? true : false. Here the boolean condition is evaluated and if the result is true then the value of the expression after the ? is evaluated (here true) otherwise it is the value after the colon will be evaluated ( here false). The sub expressions (true and false) on either side of the colon must have the same type. Example: int a = 10; int b = 20; inc c = (a>b)?40:50. This will give the value of c as 50, since (a>b) returns false and hence the right hand side of the colon will be evaluated.

Assignment Operators The assignment operators set the value of a variable or expression to a new value. Simple assignment uses =. Besides simple assignments, compound “calculate and assign” is provided by operators such as += and *=. These operators do the calculation and then assigns. The point to be noted here with the right hand operand must be a type that is assignment compatible with the left hand operand. Expression Meaning x += y x = x + y x -= y x = x - y x *= y x = x * y x /= y x = x / y

Loops in Java The Flow Controls in java is broken in to 3 modules which are as under:

b) Loops c) Selection statements d) Jump statements

The loops in java are

a) The for loop b) The while loop c) The do-while loop

The for Loop A common requirement in programming is to perform a loop so that a single variable is incremented over a range of values between two limits. This is frequently provided for by a loop that uses the keyword for. The primary purpose of the for loop is to execute a block of statements a given number of time. The for loop syntax is for (initialization ; loop condition ; increment expression) { body of the loop; } The control for the for loop appears in parentheses followed by the keyword for. It has three parts separated by semi-colons.

1. The first part, initialization is executed before the execution of the loop starts. This is typically used to initialize a counter for the number of loop iterations, for example i = 0. With a loop controlled by a counter, you can count up or doing using a integer or a floating point variable. It is only used to set up a starting conditions.

2. The second part is the loop condition, which means the execution of the loop continues

as long as the condition you have specified in this is true. That means the loop conditions should be a boolean conditions which will either return a true or false. This loop conditions is checked at the beginning of each loop iteration and when it is false the execution stops and the program continues with the statement after the loop. A simple example of loop conditions is i < 10, which would mean that the loop would execute as long as the variable has a value less than 10 and the moment it increases the value of 10, the loop conditions will retune false the loop stops.

3. The third part the increment expression, is executed immediately after the body of the

loop, just before the test is performed again. Commonly this is used to increment the loop counted. This could be i++, which will increment the loop counter by one. Of course you might want to increment the loop counter in steps other than one and in that case you can write i +=2, in which case the loop counter gets increment by 2.

Example for (int i = 0 ; i<5 ; i++)

{ System.out.println(“The value is now “ + i); } System.out.println(Out of the loop now); The above code prints The value is now 0 till The value is now 5 and then Out of the loop now. The execution is done in the following way

a) First of all the loop is initialized to 0, then it check whether the boolean condition is true and in this case it is true since 0 is less then 5, then it goes into the body and the statement” The value is now 0 is printed..

b) Then it goes to the Iteration statement and this increments the value of the loop counter

to 1

c) Then it again check the boolean condition and this continues till the boolean condition is false and once it is false, it comes out of the loop.

d) Then the statements after the loop are executed.

Note: The for () loop allows the use of comma operators in a special way. For example for (int i = 0, j = 0 ; j <10 ; i++, j++) { } The above code initialize int i and int j to 0, the checks the boolean condition or conditions and then increments both the variables. IMP: The loop condition should always return a boolean value, otherwise the compiler will throw an error.

The while Loop The while loop executes as long as the given logical expression in the parentheses is true and stop when the conditions becomes false. The syntax for the while loop is; while (boolean condition) { Statement; } It is important to note here that the condition is checked at the beginning of the loop and hence if the condition is false initially, then the loop will not execute at all. Note here that in java the conditions can only be a boolean condition, while in C and C++ it can be a variety of types. The statement or statements will be executed again and again until the boolean condition becomes false. If the condition will never become false, then it will be a infinite loop. Code class While

{ public static void main(String[] args) { int a = 0; while (a < 10) { System.out.println(a); a++; } } }

The do – while Loop The do – while loop is similar to the while loop and the only difference is that the boolean condition is after the body of the loop, which means that even if the condition is false, the loop will be executed atleast one. In programming, this loop is very important where we want a particular statement to execute atleast once. The syntax for the do loop is; do { statement; } while (boolean condition) Each iteration of the loop first executes the body and then evaluates the conditional expression. If this expression is true, then it will execute the body again and then checks for the condition and this goes on till the condition becomes false. IMP: In general programming all of the above loops is used together and all the above loops can be nested also. The main difference between the while and do-while loop is that incase the condition is false, the do-while loop will be executed atleast once, whereas the while loop will not be executed at all. Code class DoWhile { public static void main(String[] args) { do { System.out.println("Hello"); } while (false); } } Output Hello

Selection statements in Java Java supports if – else and switch as its selection statements and we will discuss both of them in this section if Statement The if statement is used to route programs execution to different paths depending on a particular condition and the syntax for the same is; if (condition) { Statement; } else { Statement; } As in the earlier cases, the condition checking the flow of control is a boolean condition and if the condition is true, then the if part body will be executed or the else part of the body will be executed.

Example int a ; int b ; if (a>b) { int c = a; } else { int c = b; } In the above example we want the value of int c to be the higher value amount a and b and this we do not know and hence we will use the if loop and if (a>b) then the value of int c will be the value of a and if int b is higher then the value of int c will be the value of int b as stated in the else part of the body.

Nested ifs A nested if is an if statement that is the target of another if or else. Nested ifs are very common in programming and when you nest a if, the important point to remember is that an else statement always refer to the nearest if statement that is within the same block as the else.

It is very important that you use block of codes, when using the nested ifs or otherwise you will find a result other than what you were expecting. if-else-if ladder The if-else-if ladder syntax looks like this if (condition) { Statement; } else if (condition) { Statement; } else if (condition) { Statement; } else { Statement; } The if condition in the first if will be considered and like the normal if-else will not go to the else part, but it will check the else if condition and like this it goes down the ladder. After the last else if is encountered and then also the condition is not true then the else statement at the end of the ladder will be executed. Remember, if the last else statement is not there and if all the else if condition returns false then nothing will be executed. switch Statement If you need to make a choice between multiple alternative execution paths and the choice can be based on a non-boolean value, then you should use the switch () construct as we cannot use the if-else loop. The syntax is as under: switch (expression) { case value1: { Statement; } case value2: { Statement; } case value3: {

Statement; } default: { Statement; } IMP: It is very important to note here that the expression must be of type byte, short, int or char and each of the values in the cases (e.g. case value1 ....) must be type compatible with the expression and each case should be a unique (e.g. it should not be a constant or a variable). Duplicate case values are also not allowed. IMP: There is a fundamental difference between the switch in C++ and java wherein we need to mandatorily use the break statement to jump out once the case have been matched, otherwise the control will enter all the cases and then reach the end of the loop. To understand the meaning of the above statement, please have a look at the following code. Code class Test17 { public static void main(String[] args) { for (int i = 0;i<3 ;i++ ) { switch (i) { case 0: { System.out.println("Zero"); } case 1: { System.out.println("One"); } case 2: { System.out.println("Two"); } default: { System.out.println("Default"); } } // end of switch cases } // end of for loop } // end of main method. } Output : Zero One Two Default One Two

Default Two Default The above output is because of the lack of break statements after the cases and hence once the case is matched, the code enters all the subsequent cases and printout out the same (including the default). To ensure only one case is matched and the code to exit the switch block, we will see the following code where there is a break statement after the cases. Code class Test17 { public static void main(String[] args) { for (int i = 0;i<3 ;i++ ) { switch (i) { case 0: { System.out.println("Zero"); } break; case 1: { System.out.println("One"); } break; case 2: { System.out.println("Two"); } break; default: { System.out.println("Default"); } } // end of switch cases } // end of for loop } // end of main method. } Output: Zero One Two We will see later on what is the significance of the break keyword. The switch starts off with a expression and the value is compared with each of the literal values in the case statements and if a match is found then the body of that case value is executed and if none of the case values are matched the default block is always executed. The default is optional here and if no matching case if found and there is no default then nothing will be executed.

One can use the break statement inside a switch to terminate a statement sequence. When a break statement is encountered, the execution branches to the first line of code that follows the entire switch statement. The switch statement differs from the other loops in that the switch can only test for equality, where as the other loops test for boolean condition. That is the switch looks only for a match between the value of the expression and one in its case and has nothing to do with the boolean conditions.

Jump statements in Java The three jump statements in java is the break statement, the continue statement and the return statement. The java’s jump statements help in transferring control to another part of the program.

Using break statements Break can be used for 3 reasons

a) breaking out of the switch statements b) breaking out of a loop c) Labeled break to enable transfer to a particular point in the code.

We have seen how to break out of a switch statement in the earlier code.

Using Break to exit out of a loop We can use break to force immediate termination of a loop and thereby bypassing the conditional expression and any remaining code in the body of the loop. When break statement is encountered inside a loop, the loop is terminated and the program control resumes at the next statement following the loop. Let’s see a example Code class Test { public static void main(String args[]) { for (int i=0 ; i<100 ; i++) { if (i==10) { break; } System.out.println(“The value of loop is “ + i); } System.out.println(“ The loop is complete”); } }

Output: The above program is to print the numbers from one to hundred, but we are having a if condition which states that if i is equal to 10, then it should break out of the loop and then it will print the statement that loop is complete. The above program generates numbers till “The value of i is 9” and then will exit out of the loop and then the next statement that “The loop is complete” will be printed out. The following points are also important regarding the break statement:

a) The break statement is used to exit out of infinite loops. b) When used inside nested loops, the break statement will come out of the innermost loop

and the execution of the outer loops will continue.

Using Labeled Break Java also makes a labeled break available to you, by which you can exit out of any block with the respective block name. It is not necessary that it have to be a loop or switch. The labeled break enables you to break out to the statement following an enclosing block that has a label regardless of how many levels there are. You might have nested blocks and you can exit out of any nested block or blocks by using the respective block name (label) and the only important point here is that you will have to name the block with the name. For Example Block 1 { Block 2 { Block 3 {

if (true) { break Block 2 (here i can break out of any block, either 3,2 or 1) } } } The break statement inside block 3, tells to break out of block 2 and hence the point of execution will be switched here and any statement after the break will not be executed. } Code class Test19 { public static void main(String[] args) { one:{ Two:{ Three:{ System.out.println("Before Break"); if (true) { break Two; } System.out.println("After Break"); } System.out.println("After Three");

} System.out.println("After Two"); } System.out.println("After One"); } // end of main } // end of class Output: The output would be Before Break After Two After One This is because; any statement after the break within a block of codes is never executed and we are specifically telling the compiler to break out of the block named as Two and the cursor would be positioned outside the block Two and then all the statements would be executed. Points to remember

a) Whenever we are having labeled block of codes, and we want to break outside, we always need to give the block name from which to break and a simple break statement would not work. Let us remove the block Two from the break and it would throw the following exception.

Test19.java:11: break outside switch or loop break ; ^ 1 error

b) We need to put the break inside the if (true) block or otherwise the following error would be generated. (comment the if block and just give break Two; inside the block Three)

Test19.java:13: unreachable statement System.out.println("After Break"); ^ 1 error

Continue Statement Sometimes it is useful to force an early iteration of a loop. That is, you might want to continue running the loop, but stop processing the remainder of the code in its body for this particular iteration. For example, Incase we need to print out the values from 1 to 10 in a for loop but print only the odd numbers, we will be using the continue statement. Code class Test20 { public static void main(String[] args) { for(int i =1 ; i <= 10 ; i++)

{ if (i % 2 == 0 ) { continue; } System.out.println(i); } } } Output 1 3 5 7 9 In the above example we are checking in the if loop incase the remainder is equal to 0 to go to the next iteration and not complete the block of the for loop. This will ensure that it does not print out the System.out.println() statement. The continue statement can appear anywhere within a block of loop statements.

New Keyword We have already seen the use of the new keyword earlier, when we created a instance of a class and also we used the same in arrays. Now let us see in depth what does the new keyword means and what it does. If we have to create an object for a particular class, the same can be done with the help of a new keyword. For example class Test { int a; int b; double c; } The above class is just a template for any object creation and a new object is created with the help of the following syntax: Test a = new Test(); Here a is just a handle for the Test and is an instance of Test. When you create an object of class Test, it will have its own copy of the instance variables defined by the class. Thus every Test object will have its own copies of int a, int b and double c. Over here it is important to note that a is a variable that refer to an object. The following examples create new instances of the classes String, Random and store those new instances in variables of the appropriate types: String str = new String ();

Random r = new Random(); The parentheses are important; don't leave them off. The parentheses can be empty (as in these examples), in which case the most simple, basic object is created; or the parentheses can contain arguments that determine the initial values of instance variables or other initial qualities of that object: Date dt = new Date (90, 4, 1, 4, 30); Point pt = new Point (0,0); The number and type of arguments you can use inside the parentheses with new are defined by the class itself using a special method called a constructor (you'll learn more about constructors later). If you try and create a new instance of a class with the wrong number or type of arguments (or if you give it no arguments and it needs some), then you'll get an error when you try to compile your Java program.

Memory allocation and layout When variables of any primitive type - that is boolean, int, etc - are declared, the memory space is allocated as part of the operation. The declaration of a variable using a non-primitive type – that is an object does not allocate space for the object. It is the new keyword that implies allocation and initialization of storage. Getting Values To get to the value of an instance variable, you use an expression in what's called dot notation. With dot notation, the reference to an instance or class variable has two parts: the object on the left side of the dot and the variable on the right side of the dot. IMP: Dot notation is an expression used to get at instance variables and methods inside a given object For example, if you have an object assigned to the variable myObject, and that object has a variable called var, you refer to that variable's value like this: myObject.var; This form for accessing variables is an expression (it returns a value), and both sides of the dot can also be expressions. This means that you can nest instance variable access. If that var instance variable itself holds an object and that object has its own instance variable called state, you could refer to it like this: myObject.var.state; Dot expressions are evaluated left to right, so you start with myObject's variable var, which points to another object with the variable state. You end up with the value of that state variable after the entire expression is done evaluating.

Changing Values Assigning a value to that variable is equally easy-just tack an assignment operator on the right side of the expression: myObject.var.state = true;

Constructor As already stated the new keyword dynamically allocated memory for an object. We can create an object of a class with the new keyword and the class name is followed by parentheses specifies the constructor for the class. Constructor’s basic purpose is to initialize the class variables of a class when an object of the class is created. Most of the real world classes define their own constructors and incase there is no explicit constructor defined in a class, java provided its own constructor. A constructor always has the same name as the class in which it is defined, has no return type specified, and must not include a return statement. You can always specify a constructor with any parameters as the arguments and anything in the body, which will be guaranteed to be initialized when we use the new keyword. A default constructor has nothing in its body and has no arguments in it. The constructor is an unusual type of method because it has no return value. This is distinctly different from a void return value, in which the method returns nothing but you still have the option to make it return something else. Constructors return nothing and you don’t have an option. If there were a return value, and if you could select your own, the compiler would somehow need to know what to do with that return value.

Example using constructor:

class Test { int a,b,c; Test() { System.out.println(“This is inside the constructor”); a = 10; b = 5; c = 5; } int met1() { return int d = a x b x c; } public static void main (String arg[])

{ Test t = new Test(); Test s = new Test(); int z = t.met1(); int y = s.met1(); System.out.println(z); System.out.println(y); } }

Result: The result will be

This is inside the constructor

This is inside the constructor

250

250

As you will see both the object variables z and y were initialized with the constructor Test, when they were created. Since the constructor gives all the object the same dimensions, the volumes with both the object are 250.

With the new keyword a constructor is called, if available and if not a default constructor is called. The default constructor initializes all instance variables to zero. But it is important to note that once you define your own constructor, the default constructor will not be called. Points to note:

1) Constructor is like a method but without a return type, whereas the methods always need a return type.

2) The basic purpose of the constructor is to initialize the class variables.

3) Constructor of a class is classed dynamically when a instance of a class is created,

whereas needs need to be explicitly called.

4) Constructor of a class should have the same name as the class name, whereas the method can have any name.

Constructors make like easy for us and we will now consider two examples to prove this point further. Now consider we have two class variables a and b which should take different values for calculation and a method met1() which multiplies the class variables and give the output. Code class Test25 { int a,b; public static void main(String[] args) { Test25 x = new Test25(); x.a = 10; x.b = 20; x.met1(); Test25 y = new Test25(); y.a = 40; y.b = 50; y.met1(); } void met1() { int c = a * b; System.out.println(c); } } Output 200 2000 Without a constructor we need to mandatorily create instance of the class and then with the class instance initialize the class variables. For separate set of values for the class variables, we need separate instances. They with the instances we call the method met1(). Code class Test26 { int a, b; Test26(int x, int y) { a = x; b = y; } public static void main(String[] args) { Test26 x = new Test26(10,20); x.met1(); Test26 y = new Test26(40,50); y.met1();

} void met1() { int c = a * b; System.out.println(c); } } Output 200 2000 The output would be the same, but we saw how life is made easier for us with the use of the constructor to initialize the class variables and we pass values to the parameters of the constructors. Parameter: This specifies what values can be passed inside a method or a constructor. for example Test26 (int x, int y), we specify that the constructor should take two int values. Arguments: This is the actual values passed in to the parameter of a method or a constructor. for example Test26 (10,20), over here we pass the values of 10 and 20 which will call the constructor and the values of 10 will be passed to int x and 20 will be passed to int y and inside the constructor we initialize the class variables with the two values passed in the constructor. Default Constructor: Until now we have created instances, without knowing the concept of constructors at all. This would mean incase we do not have a constructor within our class then the JVM will provide us with a default constructor which is a constructor with no parameters. Incase we define our own parameterized constructor, then the system will no longer provide us with the default constructor and we need to specifically create a no parameter constructor ourselves. Code class Test27 { int x; public static void main(String[] args) { Test27 x = new Test27(); } Test27(int a) { x = a; System.out.println("class variable initialised"); } } Output Test27.java:6: cannot resolve symbol symbol : constructor Test27 () location: class Test27

Test27 x = new Test27(); ^ 1 error This above code would prove our point. Now to ensure that our code functions, create a default constructor (constructor with no parameter) and our code will function properly.

Determining the class of an Object Want to find out the class of an object? Here's the way to do it for an object assigned to the variable obj: String name = obj.getClass().getName(); What does this do? The getClass() method is defined in the Object class, and as such is available for all objects. The result of that method is a Class object (where Class is itself a class), which has a method called getName(). getName() returns a string representing the name of the class. Now over here we would like to bring to your notice that the superclass of all objects in java is the class Object which is there in the java.lang package. As said earlier the java.lang package is imported by default and incase we need to use any other class which is not there in the lang package we would need to import the package specifically otherwise the compiler will cry. IMP: All classes by default extend the Object package. Code class Test24 { public static void main(String[] args) { Test24 x = new Test24(); Class c = x.getClass(); String s = c.getName(); System.out.println(s); } } Output Test24 Whenever we need to find out the class name of an object we would be using the getClass() and the getName() methods.

this keyword Every instance method has a variable with the name, this which refers to the current object for which the method is being called. This is used implicitly when your method refers to an instance variable of the class.

In the body of a method definition, you may want to refer to the current object-the object in which the method is contained in the first place-to refer to that object's instance variables or to pass the current object as an argument to another method. To refer to the current object in these cases, you can use the this keyword. this keyword can be used anywhere the current object might appear-in dot notation to refer to the object's instance variables, as an argument to a method, as the return value for the current method, and so on. In many cases you may be able to omit the this keyword entirely. You can refer to both instance variables and method calls defined in the current class simply by name; the this is implicit in those references. Note Omitting the ‘this’ keyword for instance variables depends on whether there are no variables of the same name declared in the local scope. Keep in mind that because this is a reference to the current instance of a class, you should only use it inside the body of an instance method definition. IMP: Class methods-that is, methods declared with the static keyword-cannot use this. Code class Test28 { int x, y; public static void main(String[] args) { Test28 z = new Test28(10,20); z.met1(); } Test28(int x, int y) { this.x = x; this.y = y; } void met1() { System.out.println("The value of x is = "+x+" The value of y is = "+y); } }

Output The value of x is = 10 The value of y is = 20 In the above example, we have a parameter x and a class variable whose name is also x. So we cannot say x = x. So over here we need to tell the compiler that the parameterized x should be passed into the class variable x and for this we do this.x = x, where this.x refers to the class variable. Remember that incase there is a name conflict (a class variable has the same name and the local variable has the same name) when we just the variable, we are calling the local variable, because the local variable hides the class variable inside the method. The second use of this is to call another constructor of the same class within a constructor as in this example. This concept is explained in the topic “Overloaded Constructors”.

Introducing Methods We have already seen what a method is and how it functions etc in our examples till now. We know that all methods need to have a mandatory return type and incase the method is not returning anything then void keyword should be prefixed to the method name. Methods that you define for a class provide the actions that can be carried out using the variables specified in the class definition. Method is a self-contained block of code that has a name and has some property that it is reusable – the same method can be executed from as many different points in a program as you require. A method is executed by calling the method using its name, as will see and a method may or may not return a value, but the return type is mandatory before the method name. The general form of a method is: <modifier> <any other key word> turn-type> <name> (<argument list>) throws <exception (if any)> { block of code; } There are 6 parts of the method and they should appear in the following order from left to right.

a) Access Modifier (public, private, protected or nothing which amounts to default). This determines the accessibility of the method. We will at a later stage go into each of the different modifiers

b) Any other keyword (like static, final, abstract) and within this it can appear in any

order.

c) Return type of the method.

d) Name of the method. The name is the name of the method, by which it will be referenced later on in the source codes

e) Parameters of the method. The argument list allows argument values to be passed into a method. Elements of the list are separated by a comma, while each element consists of a type and an identifier.

f) throws statement, incase a method throws any exception (this will be dealt with in the

next module). The throws (exception) clause cause a runtime error (exception) to be reported to the calling method so as to handle it in a suitable manner

Incase a method returns anything, then the respective data type of the return should be prefixed before the method name and there should be a mandatory return statement as the last line in the method. What the method return type is declared in the signature of the method (the data type the method is declaring that it will return) should be within the conversion rules of primitive data types. If the method returns anything it must be specified before the modifiers name and if not so the compiler will give a compile time error. Java is very particular about what the method returns. If we write that the method returns int and incase it returns any other data type, the compiler again will complain. Use the return command within a method to pass back a value. For example, incase a method declares in the signature that it would return a int data type, then the actual return type can be byte, short or int, but not any other data type which is larger than int (more than 32 bits). Code class Test30 { public static void main(String[] args) { Test30 x = new Test30(); x.met1(); } int met1() { System.out.println("Inside met1"); } } Output Test30.java:10: missing return statement { ^ 1 error The compiler will cry here. So to make the above code run, we should have a mandatory return statement at the end of the method like return 0 (zero). The following points are just revision to the points that we have already mentioned earlier.

a) Similar to the variables, there are also two methods known as instance methods and class or static methods.

b) One can execute class methods without any object of the class also, whereas for instance methods, an object of the class should be there. Since the class methods are declared using the static keyword, they are also called as static methods.

c) Since class methods are executed when there are no objects in existence, they cannot refer to instance variables. This is quite sensible – if you think about it - trying to operate with variables that might not exist would be bound to cause trouble. Java will not allow you to try and will give a compile time error.

d) The best example of a class / static method is the main method and you declare the same with the keyword static. This is because the main() is the method from where the execution starts in an application and before an application can start no objects will exist and hence the main() will have to be declared as static.

Accessing Variables and methods In many circumstance, you would want to refer to a constant or a variable or a method of a particular class in another class. There are two rules for it

a) A static member of a class can be accessed using the class name, followed by a period, followed by the member name. With a class method, you also need to supply the parentheses enclosing any arguments to the method after the method name. The period here is called the dot operator. So if you want to calculate the square root of PI you could access the class method sqrt() and class variable PI that is defined in the Math class as follows: double a = Math.sqrt (Math.PI);

b) Instance variables and method can only be called using an object reference, as by

definition they relate to a particular object. The syntax is exactly the same as we have outlined for static members.

Overloading of Methods

As already discussed earlier overloading is the important concept in OOPs which allows the feature of polymorphism in java. Overloading of methods means having the same method name, but different type and order or parameters and depending on the values passed, the program would know to call which method. Code class Test31 { public static void main(String[] args) { Test31 x = new Test31();

x.met1(10); x.met1("Hello",20); } void met1(int a) { System.out.println("Method with one parameter"); } void met1(String s, int a) { System.out.println("Method with two parameters"); } } Output Method with one parameter Method with two parameters So here we can conclude that the program knows how to call a method inspite of having the same name on the basis of the parameters passed into the method. IMP: Overloading cannot be done on the basis of different return types. Return Type itself is not sufficient for overloading of methods. It can only be done on the basis of different type and order of parameters. To explain the above point, have a look at the following code. Code class Test32 { public static void main(String[] args) { Test32 x = new Test32(); x.met1(10); x.met1(20); } int met1(int a) { System.out.println("Method with return type as int"); } void met1(int a) { System.out.println("Method with return type as void"); } } Output Test32.java:15: met1(int) is already defined in Test32 void met1(int a) ^

1 error Since overloading cannot be done on the basis of the return type and also the parameters are the same, the compiler is complaining that we already have a method with the same name, as we cannot have the same identifier used twice.

Overloaded Constructors Overloading is the basic feature of OOPs wherein you have the same method / constructor name but different type and order of parameters. Let us take the example of a website where in you need the users to input their name and salary. There are 4 possibilities in this case

a) User inputs his name but not his salary b) User inputs his salary but his name c) User input both salary and name d) User inputs neither salary nor name.

Now let us see how to we code this. We also want the above data to be there in the table wherein incase there is no name, “unknown” should be there and where no salary is there, 0 should be the amount value. Code public class Test29 { String name; int salary; public Test29 (String n, int s) { name = n; salary = s; System.out.println("The name entered is = "+name+" and the salary is = "+salary); } public Test29(String n) { this(n,0); } public Test29(int s) { this("unknown",0); } public Test29() { this ("unknown"); } public static void main(String arg[]) { Test29 a = new Test29("ABC"); // user inputting only name Test29 b = new Test29(1000); // user inputting only salary Test29 c = new Test29("XYZ",20000); // user both name and salary Test29 d = new Test29(); // user inputting neither name nor salary

} } Output The name entered is = ABC and the salary is = 0 The name entered is = unknown and the salary is = 0 The name entered is = XYZ and the salary is = 20000 The name entered is = unknown and the salary is = 0 IMP: Any call to this, if present, must be the first statement in any constructor.

How argument values are passed. This is one of the most important and the most confusing part of java fundamentals. The fundamental rule for understanding how argument values are passed is:-

a) Primitive Data Types are always passed by value b) Objects are always passed by reference.

Now what do one mean by how values are passed? This would mean when we declare something in the parameter of a method and when actual argument is given to that method, depending on the whether the argument value is a primitive or a object, the values are actually passed in the method. In java, all arguments values that belong to one of the basic primitive types are transferred to a method using what is called the pass-by-value mechanism. All this means is that for each argument value that you pass to a method, a copy is made and it is the copy that is passed and referenced through the parameter name and not the original value. This implies that if you use a variable of any of the basic primitive types as an argument, the method cannot modify the value of the main variable in the calling program. For example; Code class Test33 { public static void main (String arg[]) { int i = 10; Test33 t = new Test33(); int z = t.met1(i); System.out.println("The value of the variable captured from the method is "+z); System.out.println("The value of the actual method variable is " + i); } int met1(int a) {

++a; return a; } } Output The value of the variable captured from the method is 11 The value of the actual method variable is 10 So we can finalize the concept over here that whenever we pass a primitive data type as the argument to the method, it would always be passed by value and the original value remains unchanged. In the above example, what is passed as an argument to the met1() is a copy (value) of i and not the actual i and hence what is returned is 11, caught by int z, while the value of i remains contact at 10. Passing objects to a method. Until now we have seen that only simple types are parameters to methods. However it is very common and correct to pass objects to methods. One of the most common use of object parameters involves constructors. Frequently you will want to construct a new object so that it is initially the same as some existing object. To do this, you must define a constructor that takes an object of its class as a parameter. Passing objects to the parameter is known as call-by-reference. In this method, a reference to an argument (and not the value of the argument) is passed to the parameter. Inside the method, this reference is used to access the actual argument specified in the call. This means that changes made to the parameter will affect the argument used to call. Code class TestTemp { int a,b; TestTemp (int i, int j) { a = i; b = j; } void met1( TestTemp o) { o.a *= 2; o.b /= 2; } } class Test34 { public static void main (String arg[]) { TestTemp z = new TestTemp(15,20); System.out.println("Value before call " + z.a+ " " + z.b); z.met1(z); System.out.println("Value after first call " + z.a+ " " + z.b); z.met1(z);

System.out.println("Value after second call " + z.a+ " " + z.b); } } So we see here that when we pass an object as an argument to a method, then it is passed by reference, which means what is passed is the memory location of the address and any changes made in the method also gets reflected in the original also.

Access Modifiers We have already studied about encapsulation, which links data with the code that manipulates it. Encapsulation also provides another important feature and that is Access Control. It is through encapsulation that you can control what parts of the code (that is variables and methods) can be accessed by members of other classes which call upon code from your class. There are 4 types of access control modifiers which can be used to control the visibility of the methods and class variables.

a) public b) private c) default (when we do not write any modifier also called as friendly) d) protected

We will explain over here the first two modifiers and the other two modifiers are associated with the concept of packages and hence we will be covering the same in the other sub-module.

Public Access Modifier When a member of a class is having a public access modifier then that member can be accessed by any other code in your program. Remember our original program whether we had used public access modifier in our main (). This is done so to enable the code outside the program – that is the Java run-time system to call it.

Private Access Modifier There are many situations when we want some data members or methods which access those data members to be accessed by that class and not to be accessed by any other class either by way of inheritance or by way of creation of objects. This can be done by prefixing the members of the class with the keyword private. The variables / methods prefixed with the private access modifier can be used only within that particular class. Other classes, which extend this class, also cannot access these variables. This keyword provides the maximum security. For Example

class Test { public static void main (String arg[]) { int i = 10 private int j = 10 } } class Test1 extends Test { public static void main (String arg []) { System.out.println (j); // it is not possible to access j since it is private. } } With the help of the above code we can generalize that the private keyword class variable is accessible only with the class in which it was created and not even in the sub-class of that method. Protected Access Modifier If a variable or a method is prefixed with this modifier then it will be accessible to all classes in the same package as well as in another class in another package provided the following two conditions are met:-

a) The class in the other package extends the original class b) An instance of sub class is created.

Default Access Modifier If a class or a method or a variable do not have any access modifier, then it is called as default or friendly access modifier. The visibility of this modifier is in all classes in the same package, either by creating an instance or by virtue of inheritance. Example: Now we are going to create two packages and two classes in each of the packages and show the usage of all the above modifiers. package one; public class Pack1 { static private int x=10; static int y; static protected int z=30; } package one; public class Pack2 extends Pack1 { public static void main(String[] args)

{ System.out.println(y); System.out.println(z); } } package one; public class Pack3 { public static void main(String[] args) { Pack1 p=new Pack1(); //System.out.println(p.x); System.out.println(p.y); System.out.println(p.z); } } package two; import one.*; public class Pack4 extends Pack1 { public static void main(String[] args) { Pack4 a=new Pack4(); System.out.println(a.z); Pack1 x = new Pack1()// will give an error System.out.println(x.z); // will give an error } } Note: For further explanation, you need to call Prof. Venkat Krishnan on 98214-22745

static Initializing block As we already know a block is a code which is enclosed in a set of braces so that it is executed together. A initialization block is a block of code between braces that is executed before an object of the class is created. This is normally used with the static keyword and this block is executed once when the class is loaded.

The main purpose of the static initialization block is:

a) To initialize static data members of the class.

b) To load the library files of other languages so that the same can be used within the java using native keyword. (this is not a part of the java certification).

All the other methods are initialized after the static initialization block. If you want your variables to be started with a particular values, then you can put the same in the static initialization block and can then use the variables in the other methods.

Incase there are multiple static initializing block, then they are executed in the order of their appearance and the static class variables take the value as present in the last block. Code class Test35 { static int a; static { a = 10; } public static void main(String[] args) { System.out.println(a); } static { a = 50; } } Output 50 This would be 50 because, initially in the first static block it got initialized to 10 and then it again got initialized to 50 before entering the main block. Pls remember that all static blocks would be executed before entering the main method. Please remember that inside the static blocks do not again declare the variable and incase you do that, then it would be taken as another variable and not the class variable. See the following code for this purpose. Code class Test35 { static int a; static { a = 10; } public static void main(String[] args) { System.out.println(a); } static { int a = 50; } } Output 10 The output is 10 because in the second static block we are again saying int a = 10 and this a and the class variable a are two different entities.

How Constructors are called When there is multi level hierarchy, in what order are constructors called. The constructors are called in the order of derivation from superclass to subclass. It is important to note here that this order is followed irrespective of whether super () is used or not. If super () is not used, then the default or parameter less constructor is used. ( we will study about the super keyword in the next sub-module). Code class Test36 { public static void main(String[] args) { Three x = new Three(); } } class One { One() { System.out.println("Constructor in One class"); } }; class Two extends One { Two() { System.out.println("Constructor in Two class"); } }; class Three extends Two { Three() { System.out.println("Constructor in Three class"); } }; Output Constructor in One class Constructor in Two class Constructor in Three class This would prove that the original constructor of the super most class is loaded first and then it goes down the hierarchy. This is logical since the methods of the super class can be called with the sub class instance variable and hence the super class should be loaded in the memory. By calling the constructor of the super class that class is loaded in the memory.

Please note that the sub-most class would call its super class default constructor which in turn will call the constructor of its super class and this process will go on till the super most classes’ constructor is loaded. Now incase if there is no default constructor anywhere in the hierarchy then the loading of the classes would stop and a compilation error would be generated. This is why we had insisted earlier that when we define our own constructors, it is our duty to also provide for a default constructor also. Code class Test36 { public static void main(String[] args) { Three x = new Three(); } } class One { One() { System.out.println("Constructor in One class"); } }; class Two extends One { Two(int a) { System.out.println("Constructor in Two class"); } }; class Three extends Two { Three() { System.out.println("Constructor in Three class"); } }; Output Test36.java:28: cannot resolve symbol symbol : constructor Two () location: class Two { ^ 1 error What the compiler is trying to tell us by the above error is that it cannot find a default constructor in class Two. We can make the code compile properly by provide for a default constructor.

is - a and has - a relationship In programming language, one often creates a model of something (for example, an employee) and then need a more specialized version of that original model. For example, you might want a model for a manager, which only has more features but is still an employee. The Is-a relationship in java is done with the help of extends keyword which creates a new class from an existing class, by sub-classing it. For Example: class Employee { String name; int salary; Date hiredate; } class Manager extends Employee { String department; } In the above example, when we sub-class the class Manager, the Manager class will have all the variable and methods that an Employee has. All these variables and methods are inherited from the definition of the parent class. The class Manager then adds additional functionality to itself by defining its own variables and methods. The has-a relationship comes when a particular variable or method is inside a particular class. For example in the above class Employee, we can safely say class Employee has a name. So we can safely finalize by saying that is-a relationship is for sub-class and super-class relationship and is for variable inside the class.

super keyword The super keyword refers to the superclass of the class in which the keyword is used. It only refers to the immediate super class and not up the hierarchy. The super keyword has two general forms:

a) The super keyword is also used to invoke the parent class’s constructor from the child class’s constructor. For this one should use the super keyword in the first line of the child class’s constructor.

IMP: If one uses the super with no argument in the child’s class’s constructor, then this will call the default parent class constructor and if such a constructor is not available in the parent class, then a compile error results. For Example: class Employee

{ String name; pubic Employee (String s) { name = s; } } class Manager extends Employee { String department; public Manager (String s, string d) { super(); // this will cause a compile error, because there is no default

//constructor in Employee. super(s) // this will work department = d; } } When a subclass calls super, it is calling the constructor of its immediate superclass and which constructor to call would depend on the parameters being passed in the super keyword argument. IMP: We had seen earlier in the order in which constructors are called, the sub class automatically calls the super class default constructor and this is possible because there is a implicit super in the sub class which calls the super classes’ default constructor every time. Code class Test38 extends TestTem { int d; public static void main(String[] args) { Test38 l = new Test38(10,20,30); l.area(); l.volume(); } Test38( int x, int y, int z) { super(x,y); d = z; } void volume() { int e = a*b*d; System.out.println("The volume is = "+e); } }

class TestTem { int a, b; TestTem( int x, int y) { a = x; b = y; } void area() { int c = a*b; System.out.println("The area is = "+c); } };// end of class Output The area is = 200 The volume is = 6000 In the above code, we have two variables in one class and another variable in the sub-class. The sub class constructor initializes all the 3 variables, by providing the values and the sub class constructor call the super class constructor which will initialize the two variable in that class and then calls the area and volume methods. We can call the area method also, because the Test38 class extends TestTem class. The main purpose of the super keyword is to ensure that there is no duplication of efforts and more over when we need to specifically call a super class constructor from inside the child classes’ constructor IMP: The super keyword incase is there in the constructor should be the first line in the sub classes’ constructor or else the compiler would throw an error. IMP: The super and this keyword cannot be accessed from inside a static method.

b) The second use of super is to refer to the member variables or methods of the superclass that is hidden by the subclass.

This is also like this, except that it always refers to the superclass of the subclass in which it is used. The syntax for the same is: super.member. (Here the member can either be a variable or a method) It is used more in those cases when the variable name of a subclass hides the members by the same name of the superclass. For Example: class First { int i; } class Second extends First {

int i; Second (int a, int b)// constructor { super.i = a; i = b; } void method() { System.out.println( “ This is superclass i “ +super.i); System.out.println( “ This is superclass i “ +i); } class Super { public static void main (String args []) { Second s = new Second(10,25); s.method() } } This example shows how to use the super keyword in the second context.

Method overriding Overriding is one of the basic features of the Object Oriented Programming. If a method is defined in a subclass that has the same name and return type exactly as that of the superclass (or parent class), then the new method is said to override the old one. When an overridden method is called from within a subclass, then it will always refer to the version of that method defined by the subclass. Note: Remember that methods with the same name, but with different argument lists that are in the same class are simply overloaded and not overridden. Overriding is fundamental to the OOPs principals because it allows for the subclasses through the inheritance to add more specialized features which inheriting the generalized features of the sub class.

For Example: The Source Code file name should be Tes.java class One { void show() { int i = 10; int j = 20; System.out.println(" The value of i and j are " + i+""+j); }

} class Two extends One { void show() { int a = 50; int b = 60; System.out.println(" The value of a and b are " + a+""+b); } } class Tes { public static void main(String arg[]) { Two t = new Two(); t.show(); } } This will print out the show () of the object, which is created. If one has to use the show () of the superclass then we can use the same as super.show (), which will use the show () of the super class.

Rules about overriding methods The following rules are mandatory and apply to overridden methods:

a) The return type of overriding method must be identical to the method it overrides. This would mean that even if the arguments are the same, but return type is different, then it would be neither overloading nor overriding and infact the compiler will think that one is trying to over ride the method and give an error.

Code class Test39 extends Temp { public static void main(String[] args) { Test39 x = new Test39(); x.met1(); } int met1() { System.out.println("Inside Test39 class"); } } class Temp { void met1() {

System.out.println("Inside Temp class"); } }; Output Test39.java:9: met1() in Test39 cannot override met1() in Temp; attempting to use incompatible return type found : int required: void int met1() ^ 1 error

b) An Overriding method cannot be less accessible that the method it overrides. This would

mean that if a method has a particular access modifier then the overriding method couldn’t have a modifier, which makes it less accessible.

Now the accessibility from the least accessible to the most accessible is in the following order: private - default - protected - public (we will cover protected and default later on, but just remember that this is the order). Code class Test40 extends Temp { public static void main(String[] args) { Test40 x = new Test40(); x.met1(); } void met1() { System.out.println("Inside Test40 class"); } } class Temp { public void met1() { System.out.println("Inside Temp class"); } }; Output Test40.java:9: met1() in Test40 cannot override met1() in Temp; attempting to assign weaker access privileges; was public void met1() ^ 1 error

The compiler is trying to tell us the overriding method (met1() in Test40) cannot be less accessible that the method which it is trying to override (met1() in Temp). So to make the code compile we need to have the access modifier of the overriding method in Test40 to have atleast the same level of accessibility or more. This can be done by making the method met1() as public in Test40.

c) An overriding method cannot throw higher class types of exception that the method it overrides. It need not throw any exception or can throw subclasses of the exceptions throws by the super class but not anything higher that already thrown by the superclass.

Code The hierarchy in the following code is Throwable class is the superclass and Exception class is the sub class. class Test41 extends Temp { public static void main(String[] args) { Test41 x = new Test41(); x.met1(); } public void met1() throws Throwable { System.out.println("Inside Test41 class"); } } class Temp { public void met1() throws Exception { System.out.println("Inside Temp class"); } }; Output Test41.java:9: met1() in Test41 cannot override met1() in Temp; overridden method does not throw java.lang.Throwable public void met1() throws Throwable ^ 1 error The compiler is trying to tell us that the overridden method is not throwing Throwable and hence the overriding method cannot throw that kind of exception. This is important because Throwable is the superclass of Exception. We can check the same code in the following two ways:

a) Let the overriding method (met1() in Test40 class) not to throw any exception. The code will compile finely because the rule is that the overriding method cannot throw any superclass of the exceptions that what is already thrown by the superclass.

b) Let the overriding method (met1() in Test40 class) throw RuntimeException which the subclass of Exception. Again the code would compile finely.

Why Overriding? Overriding of methods allows java to support polymorphism, which allows a general class to specify methods that will be common to all of its subclasses, while allowing each of the sub classes to define the specific implementation of some or all of those methods.

Virtual Method Invocation / Dynamic Binding / Runtime Polymorphism / Late Binding To understand the topic of Virtual Method Invocation or also called as Runtime Polymorphism, we should understand when an object of a superclass is allowed to be assigned to the subclass and vice versa. It is possible to automatically allow a sub class instance to be assigned to a super class instance, because the sub class would know all the methods that are there in the super class (because of inheritance). Code class Test42 { public static void main(String[] args) { T1 x = new T1(); T y = new T(); y = x; // subclass variable casted to super class automatically y.met1(); // y.met2(); } } class T { void met1() { System.out.println("Inside met1 in class T"); }

void met3() {

System.out.println("Inside met3 in class T"); }

}; class T1 extends T { void met2() { System.out.println("Inside met2 in class T1");

} void met1() { System.out.println("Inside met1 in class T1"); } }; Output Inside met1 in class T1 The important points to be noted here are:

a) Here in the above code we see that the compiler automatically allows the sub class instance to be assigned to the superclass instance. That means when we go up the hierarchy there is no need for casting, but when we come down the hierarchy there is a explicit need for casting to avoid compile time error.

b) An important point to note here is that after assignment, when we call a method

which is overridden in the sub class through the assigned instance, it would print the overridden method as above. (e.g. y.met1() in the above example)

c) Comment the instance assignment ( y = x) and then when we call y.met1() it would

print

Inside met1 in class T, this is the method of the super class itself

d) When we do assignment ( y = x) and then try to call the specialized method in the subclass (met2()), the compiler will complain, because when we do assignment (y = x), we are explicitly agreeing that through the assigned instance we can all the methods of the super class only and only the overridden methods in the subclass. (Uncomment y.met2() in the above code and see the error).

Code class Test43 { public static void main(String[] args) { T1 x = new T1(); T y = new T(); x = y; } } class T { void met1() { System.out.println("Inside met1 in class T"); } }; class T1 extends T { void met2()

{ System.out.println("Inside met2 in class T1"); } void met1() { System.out.println("Inside met1 in class T1"); } }; Output Test43.java:8: incompatible types found : T required: T1 x = y; ^ 1 error Now let us try by casting y to the subclass by typing x = (T1)y; There would not be any compile time error, but when we execute the code, the output would be as under:- java.lang.ClassCastException: T at Test43.main(Test43.java:8) Exception in thread "main" This exception will be thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance. We are attempting to cast y in to T1 where it is actually an instance of T. Now let us try casting it to the original class to which it belongs by changing the assignment as x = (T)y;. Even then the output would be Test43.java:8: incompatible types found : T required: T1 x = (T)y; ^ 1 error The Virtual Method invocation is a mechanism by which a call to an overridden function is resolved at run time rather than compile time. How does this happen.

a) A superclass variable can access a subclass object. Java uses this fact to resolve calls to overridden methods at runtime.

b) When a overridden method is called through a superclass reference, java determines

which version of that method to execute based upon the type of the object being referred to at the time when the call occurs. Thus this determination is done at runtime.

c) In other words, it is the type of the object being referred to and not the type of the reference variable.

Code class Test44 extends Temp { int a = 20; void met1() { System.out.println("Inside met1 in class Test44"); } public static void main(String[] args) { Temp x = new Test44(); x.met1(); System.out.println(x.a); } } class Temp { int a = 10; void met1() { System.out.println("Inside met1 in class Temp"); } }; Output Inside met1 in class Test44 10 Now when we are creating a instance till now we have been saying Test x = new Test() only, but here were are saying Temp x = new Test44(), which means that through the instance of the super class we are calling the constructor of the sub class. IMP: We will have to understand that there is a variable a in the super class as well as in the sub class. The variable a in the subclass will be hiding the variable a of the super class, as variables in two classes related through inheritance can only be hidden, whereas the methods will be overridden. Now when we create the instance by saying Temp x = new Test44(), we are creating an instance of the class Temp only and not of Test44 at all. Hence when we say x.a, it prints the value as 10 only. Now when we call x.met1(), it will check whether the method met1() is overridden in the subclass and incase it is, it will call the overridden method of the subclass only and incase it is not overridden, it will call the method of the super class since it is an instance of the super class only. Please note that through the instance x we cannot access any method of the subclass at all. See the revised code for this purpose. Code

class Test45 extends Temp { int a = 20;

void met1() { System.out.println("Inside met1 in class Test44"); } void met2(); { System.out.println("Inside met2 in class Test44"); } public static void main(String[] args) { Temp x = new Test44(); x.met1(); System.out.println(x.a); x.met2(); // x.met3(); // will throw a compilation error and hence commented. Uncomment to check } } class Temp { int a = 10; void met1() { System.out.println("Inside met1 in class Temp"); } void met3(); { System.out.println("Inside met3 in class Temp"); } }; Output Inside met1 in class Test44 10 Inside met2 in class Temp Here when we say x.met2(), it checks whether the method is overridden in the subclass and incase not it just prints the super class version.

Abstract class

There are many situations when you want to define a super class that declares the structure of a given abstraction without providing a complete implementation of every method. That is one creates a superclass that only defines a completely general form that will be shares by all of its subclasses leaving it to each of the subclass to fill in the details. For Example, we have a class called Figure which has a method called area () which does nothing, but lets the subclasses like Circle, Triangle, Square to override it and give specific implementation to the same. In this case you should call the area () as abstract. The other example can be a Drawing class. The class contains methods for variety of drawing facilities, but these must be implemented in a platform independent way. You cannot access the video hardware of a machine and still be platform independent. The intention is that the drawing class defines which method should exist, but special platform independent subclasses actually implement that behavior. The syntax of an abstract method is abstract method (); It is important to note here that the abstract method does not have a body. The points to be remember here are:

a) Any class, which has one or more abstract method, should be declared as abstract. To declare a class as abstract, simply use the abstract keyword in front of the class.

b) There can be no objects of the abstract class. That is an abstract class cannot be directly

instantiated with the new keyword. This is so because the class is not complete.

c) Any subclass of an abstract class must override all the abstract methods, or the subclass must also be declared as abstract. That means any subclass must override all of the abstract methods.

d) An abstract class can have a non-abstract method also.

e) An abstract class can have member variables also, which can be used by the subclass

after it overrides the abstract methods.

f) An abstract class need not have any abstract methods, but incase a class has an abstract method, it should mandatorily be declared as abstract class.

Code class Test46 extends Temp { public static void main(String[] args) { Test46 x = new Test46(); x.met1(); x.met2(); x.met3(); } void met1() {

System.out.println("Overridden met1 in Test46"); } void met3() { System.out.println("Overridden met3 in Test46"); } } abstract class Temp { abstract void met1(); void met2() { System.out.println("Hello World!"); } abstract void met3(); }; Output Overridden met1 in Test46 Hello World! Overridden met3 in Test46 Over here, the class Temp should be declared as abstract class since it has abstract methods. ( try to remove the abstract keyword from the class and then compile the same). Any class (Test46) extending the abstract class should override all the abstract methods or else that class should be declared as abstract since it would have a abstract method by way of inheritance and rule 1 is any class having an abstract method should be declared abstract. (Try commenting the whole method met3() from Test46 and then compile). Try creating an instance of Temp class and compile An abstract class can have non abstract methods also, like met2() in Temp class. An abstract class need not have any abstract methods. We would need a class to be declared as abstract and still not have any abstract methods only in the scenario when we do not want any one to create an instance of our class. Code class Test47 extends Temp { public static void main(String[] args) { Test47 x = new Test47(); x.met1(); } } abstract class Temp

{ void met1() { System.out.println("Hello World!"); } }; Output Hello World! See in the above class although we are extending the abstract class, since there is no abstract method, we need not override any method and can directly call any other non-abstract methods.

final Keyword The final keyword can be used for a class, variable or a method.

a) When a class is pre-fixed with a final keyword, then that class cannot be extended further. For example, the java.lang.String is a final class. This is done for security reasons, because it ensures that if a method has a reference to a string, it is definitely a string of class String and not a string of a class that is a modified subclass of String that might have been maliciously changed.

b) When a variable is pre-fixed with the final keyword, then it cannot take any other variable

than the variable with which it was initialized. That would mean that it will act like a constant.

c) When a method is pre-fixed with the final keyword, then it cannot be overridden to

provide any additional functionality. This is also done for security reasons. You should make a method final if the method has a implementation that should not be changed and is critical to the consistent state of the object. The methods declared final are sometimes used for optimization. The compiler can generate code that causes direct call to the method rather than the usual virtual method invocation that involves a runtime lookup.

It is a common coding convention to choose all uppercase identifier for final variables. Variables declared as final do not occupy memory on a per instance basis. Thus the final variable is essentially a constant. Thus final keyword is often used to prevent overriding and also to prevent inheritance. Example of final Keyword for a class Code class Test48 extends String { public static void main(String[] args) { System.out.println("Hello World!"); } } Output

Test48.java:1: cannot inherit from final java.lang.String class Test48 extends String ^ 1 error The above output confirms that we cannot extend classes which are declared as final and all the Wrapper classes and String classes are declared as final in the java API. Examples of final keyword for variables final variables should be initialized when they are declared, which is different from normal class variables which take default value even when they are not initialized. Code class Test50 { final int a; public static void main(String[] args) { Test50 x = new Test50(); x.met1(); } void met1() { System.out.println(a); } } Output Test50.java:1: variable a might not have been initialized class Test50 ^ 1 error This proves the point that final variables should be initialized when they are declared. Code The final variables can be initialized in the constructor of a class also when an instance of the class is created and different instances can take different values of the final variables class Test51 { final int a; Test51(int x) { a = x; } public static void main(String[] args) {

Test51 l = new Test51(10); Test51 k = new Test51(20); System.out.println(l.a); System.out.println(k.a); // l.a = 40; } } Output 10 20 So here we see that a final variable is initialized in the constructor and can take a single value for different instance. Try removing the comment and then the compiler complains that we cannot change the value of a final variable. Example of final keyword for methods Code class Test49 extends Temp1 { public static void main(String[] args) { System.out.println("Hello World!"); } void met1() { System.out.println("Overridden met1"); } } class Temp1 { final void met1() { System.out.println("final met1"); } }; Output Test49.java:8: met1() in Test49 cannot override met1() in Temp1; overridden method is final void met1() ^ 1 error Here the compiler is complaining that the overridden method is final and final methods cannot be overridden

Inner classes

Until now we have seen classes defined so far separate from each other. In previous releases, Java supported only top-level classes, which must be members of packages. In the 1.1 release, the Java 1.1 programmer can now define inner classes as members of other classes, locally within a block of statements, or (anonymously) within an expression.

Here are some of the properties that make inner classes useful:

1. The inner class's name is not usable outside its scope, except perhaps in a qualified name. This helps in structuring the classes within a package.

2. The code of an inner class can use simple names from enclosing scopes, including both

class and instance members of enclosing classes, and local variables of enclosing blocks.

It is possible to define a class within another class and such classes are known as nested classes. The scope of the nested class is within the boundary of the outer class. The nested class can access all the variables, including private (since the inner class is within the boundary of the outer class), but the outer class does not have access to the members of the nested class. There are 3 types of inner classes and they are:-

a) Normal Inner Class b) static Inner Class

c) Inner class inside a method.

Normal Inner Class In this case we simply have an inner class declared before closing the final brace of the outer class. The inner class is declared outside any methods but within the outer class Code class Test52 { int a = 10; private int b = 20; public static void main(String[] args) { Test52 x = new Test52(); Test52.Inner y = x.new Inner(); y.met1(); } class Inner { void met1() { System.out.println(a + " "+b); } };

} Output

10 20 Over here we should remember that to create a instance of the inner class, we mandatorily require an instance of the outer class and then create a instance of the inner class referenced with the outclass class Once the instance of the outer class is created, then we simply call the inner class method. Static Inner Class Inner classes cannot have static declarations of any sort, neither static class variables nor static methods. Code class Test52 { int a = 10; private int b = 20; public static void main(String[] args) { Test52 x = new Test52(); Test52.Inner y = x.new Inner(); y.met1(); } class Inner { static int c = 30; void met1() { System.out.println(a + " "+b+" "+c); } }; } Output Test52.java:14: inner classes cannot have static declarations static int c = 30; ^ 1 error We just changed the code to include a static class variable of the inner class and the compiler complains. To ensure that the inner class shall have static declarations, the whole inner class shall be declared as a static inner class. Remember only inner classes can be static and not outer classes. A major limitation of the static inner classes is that it cannot refer to non-static variables of the outer class

Code class Test52 { int a = 10; private int b = 20; public static void main(String[] args) { Test52 x = new Test52(); Test52.Inner y = x.new Inner(); y.met1(); } static class Inner { static int c = 30; void met1() { System.out.println(a + " "+b+" "+c); } }; } Output Test52.java:17: non-static variable a cannot be referenced from a static context System.out.println(a + " "+b+" "+c); ^ Test52.java:17: non-static variable b cannot be referenced from a static context System.out.println(a + " "+b+" "+c); ^ 2 errors Hence to compile the above code, either we should remove the variables a and b from the inner class or should declared int a and int b as static in Test52. Another way to create an instance of the inner class is in the following way Test52.Inner y = new Test52().new Inner(); IMP: The class file of Inner will be Test52$Inner.class. Since the system internally uses the $ word, hence we had requested that the $ word to used in a limited way in an identifier. Inner Class inside a method We can also have a inner class inside a method also, but the only condition is that incase the inner class accesses any variable that is inside the method, then that method should be declared as final, or otherwise the compiler will complain. Code class Test53 { public static void main(String[] args) {

Test x = new Test(); x.met1(); } } class Test { int a = 10; void met1() { int b = 20; class Inner { void met2() { System.out.println("Inside met2"+a+" "+b); } }; // end of inner class Inner x = new Inner(); x.met2(); }// end of met1() };// end of main class Output Test53.java:22: local variable b is accessed from within inner class; needs to be declared final System.out.println("Inside met2"+a+" "+b); ^ 1 error To remove the error , we should make the variable int b as final, since it is accessed inside the Inner class. In the above code we see that we have a inner class inside a method and to call a method of the inner class, we should create a instance of the class and call the method, before getting out of the method itself. Also remember in java forward instantiation is not possible. That is we cannot create an instance before declaring the class itself.

Concept of Packages A package is a collection of class and is often used to keep the class name compartmentalized. The package has both a naming and visibility control mechanism. One can define classes inside a package that is not accessible to others outside the package. Essentially a package is a named collection of classes. To use a package, just use package command as the first statement in the source file. Any classes declared within that file will belong to the specified package.

If you omit the package statement, the class names are put into the default package with no name. The syntax for the package statement is: package abc // abc is the name of the package IMP: If you want the classes in a package to be accessible outside the package, you must declare the class using the public keyword. The class definitions that aren’t preceded by the public keyword are only accessible from methods in classes that belong to the same package. More than one file can include the same package statement. The package statement simply specifies to which package the classes defined in a file belong. The package mechanism is for two main purposes:

a) Reduce the problems with name conflicts. b) Control the visibility of classes, interfaces and the methods and data defined within them.

One can also have a hierarchy of packages. To do so, simply separate each package name from the one above it by the use of the period. For Example: package abc.xyz.nmq Java uses file systems directories to store packages. For example, a class file for the above class you declare will be a part of the abc package and in a directory called as abc. Remember java is case-sensitive.

Accessing a package How do you access a package when you are compiling a program that uses the package depends on where you have put it. There are a couple of options here. The first but not the best is to leave the .class file for the classes in the package in the directory with the package name. Let’s look at that before we go into to the second option. With the .class file in the original package directly, either the path to your package must appear in the string set for the CLASSPATH environment variable or you must use the classpath option on the command line when you invoke the compiler or the interpreter. This overrides the CLASSPATH environment variable if it happens to be set. Note that it is up to you to make sure that the classes in your package are in the right directory. Java will not prevent you from saving a file in a directory that is quite different from that appearing the package statement. Of the two options here, using the –classpath option on the command line is preferable because it sets the class paths transiently each time and can’t interfere with anything you do subsequently. This has the advantage that it only applies for the current compilation or execution so you can easily set it to suit each run. The command to compile Test.java defining the class path would be: javac –classpath ,; c:\MySource\Test.java

If you do not set the class path in one of the above two ways or do it incorrectly, then java will not be able to find the classes in any new package you might create. Also we can directly tell the compiler to create a directory with whatever is the package name with the -d option when compiling. This will make the compiler create the directory with the package name and put the .class file inside the created directory. This option is better than manually creating the directory and putting the .class inside the directory as the chances of manual error is there.

The Important java packages are: a) java.applet - Classes for implementing Graphics. b) java.awt - Classes for text, windows and GUIs. c) java.io - Classes for all kinds of input and output d) java.net - Classes for networking. e) java.math - Classes for calculations.

Protected and Default Access Modifiers We had learnt about private and public access modifier and now we will see the other two access modifiers now. Package adds a complete new dimension to access control. Package is a container for classes and other subordinate packages.

Default Modifier A Default Access Modifier means, when we do not specify anything to the class, method or variable it is said to have default access modifier. The default access modifier means it is available to any class inside the package, irrespective of whether it is sub class or not and is not available to any sub class outside the package also. The access modifier from the most restrictive to the least restrictive is private --> default --> protected --> public

Importing packages All of java classes are stored in packages and one would not find a single class just hanging in open air. Since classes within packages must be fully qualified with their package name or names, it would be tedious to type in the long dot-separated package name for every class you want to us. For this java has a special statement called import statements, which will certain class or the entire packages into visibility? The import statement tells the compiler where to find the particular classes.3

Once imported, a class can be referred to directly, using only its name. The import statement is a convenience to the programmer and is not technically needed to write a complete java program. In a normal java source code, the import statement occurs immediately after the package statement. The general form of a import statement is: import package1.package2.*; This would mean that all the classes in package1.package2 would be imported. But remember it would also take for the basic source java file to compile, as all the classes will have to be imported. If one know a file which is to be specifically imported then it should be written as: import package1.package2.Test; All the standard java classes are included in a basic package called java. The basic language functions are stored in a package inside the java package called java.lang. Normally one will have to import every package or class that you want to use, but since java is useless without much of the functionalities in java.lang, the compiler for all programs implicitly imports it.

protected keyword A Protected Access Modifier is actually a misnomer and is often confusing. By general understanding of the term is seems to be more restrictive that private, but is not actually so. When we declare a member of a class as protected, and then it is available to all members inside the package and also to classes, which is a subclass in a different package. Remember that the protected modifier can be for variables and method only and we cannot declare the class as protected. Now as already learnt there are the two ways in which any variable in one class be accessed in another class

a) by creating an instance and calling the variable with the instance b) by way of inheritance. (the sub class automatically gets all the variables other than

the private one’s) Recap of Access Modifiers

a) private keyword variables and methods are accessible only in the class in which they are declared and not even in the subclasses.

b) default keyword is accessible in the package in which they are declared either by way

of inheritance (in subclass) or (in any other class) by way of creating an instance of the class in which the variable is there.

c) protected modifier is accessible in the package in which they are declared like the

default modifier (by way of inheritance or by creating instance of the class) and also in another package in a class which is a subclass of the class which contains the protected keyword.

Remember protected keywords are accessible in another packages only in the subclasses, by creating an instance of the subclass and not by creating an instance of the class which contains the protected keyword. Also protected keywords cannot be accessible in other classes in another package by creating an instance of the class in which the protected keyword is there. Also the class which contains the protected keyword should be declared as public.

d) The public keyword variables / methods are accessible everywhere by creating of the

class which contains the public keyword items Now let us have two classes which we will store in two different packages and also try out the protected keyword Code package one; public class Test54 { protected int a = 10; } Now to compile this code we should use the -d option so that the compiler will automatically create a directory by the name of the package (i.e. one) and put Test54.class inside that. Assuming Test54.java is there in c:\java directory, we will go to that directory and type the following command javac -d c:\java Test54.java Over here c:\java specifies that the new directory called as one will be created below c:\java directory. Now to check whether the compiler has done the job we can go the c:\java\one directory and type dir to check the contents of the directory. Now we will create another source code file in another package to access this class variable a. Code package two; import one.*; class Test55 extends Test54 { public static void main(String arg[]) { Test55 x = new Test55(); System.out.println(x.a); } } We will compile the above code also with the -d option as explained earlier.

Now we need to run the interpreter and we will have to go a directory one above which contains the .class file that is c:\java and type java two.Test55. Output 10 This will print out the value of the class variable in Test54 since Test55 extends Test54.

interfaces We have discussed about the concept of inheritance and have understood that java has simple inheritance only. There are many cases when a particular method will be used by a lot of classes and this can be done by defining them in an interface and all the classes which needs that method will be implementing the interface to provide body to the abstract method. An interface is also like a normal class, but it has only public static and final variable (constants) and public and abstract methods. That would mean that it is similar to abstract classes, but since the interface is by abstract and all the methods are abstract (remember abstract classes can also have non-abstract methods) there is no need to write abstract before the interface. Similarly, all the data members declared in an interface are by default constants, there is no need to explicitly insert a final, static or final modifier before them. But we need to prefix the class name with interface instead of class. For example, the general syntax of an interface is: interface Test { met1(); } implements clause A class declares all of the interfaces it is implementing using the implements clause. The implements clause consists of the keyword implements followed by the list of interfaces separated by commas and it must be put after the extends keyword (if any). This would mean that a class can implement more than one interface. An interface gives the illusion of bending the java technology single inheritance rule, while a class can extend only a single class, it can implement as many interfaces as needed, but it is the duty of that class to mandatorily override all the methods otherwise it should be declared as a abstract class. (since the class has a abstract method which is not overridden). Code interface Temp { int a; void met1(); }

Output Temp.java:3: = expected int a; ^ 1 error This is because final variable need to be initialized when they are declared. Not to properly run the code have the int a initialized to a value of 10. Code class Test56 implements Temp { public static void main(String[] args) { Test56 x = new Test56(); x.met1(); } public void met1() { a = 20; System.out.println("Inside met1"); } } Output Test56.java:10: cannot assign a value to final variable a a = 20; ^ 1 error The above error proves that all the values in the interfaces are final. Now to properly run the code, remove the line a = 10 and insert a System.out.println (Temp.a) line. The output would be Inside met1 10 This would prove that the variable in the method are static also. Now incase we do not override the method in the interface let us see what happens (for this comment the overriding part) and the output would be Test56.java:1: Test56 should be declared abstract; it does not define met1 () in Test56 class Test56 implements Temp ^ 1 error Interfaces are useful for:

a) Declaring methods that one or more classes are expected to implement.

b) Determining an object’s programming interface without revealing the actual body of the class.

c) Capturing the similarities between unrelated classes without forcing a class relationship.

Variables in Interfaces One can also use interfaces to import shared constants into multiple classes by simply declaring an interface that contains variables, which are initialized to the desired values. When you then implement the interface all those variable names will be in scope as constants.

Interfaces can be extended One interface can inherit another with the help of the usual extends keyword. When a class implements an interface that inherits another interface, it must provide implementation for all methods defined within the interface inheritance chain.

Partial Implementation It is very much possible that a class will implement an interface, but does not want to override all the abstract method, but will override some abstract methods and leave the further implementation to its own subclasses. In this case we should declare the class as abstract, because there is some abstract method in the class. Code interface Two extends One { void met2(); } interface One { void met1(); } abstract class PartialImplementation implements Two { public void met2() { System.out.println("This is inside met2()"); } } class FullImplementation extends PartialImplementation { public static void main(String[] args) { System.out.println("Hello World!"); } public void met1() {

System.out.println("This is inside met1"); } } Output class FullImplementation extends PartialImplementation { public static void main(String[] args) { FullImplementation x = new FullImplementation(); x.met1(); x.met2(); } public void met1() { System.out.println("This is inside met1"); } } In the above classes, the PartialImplementation class should be declared as abstract, since it is implementing Interface Two, but does not override all the methods of the interface, that is specifically it does not override met1(). Although met1() is not specifically in Interface Two, it is there in Interface One which Interface Two is extending.

Garbage Collection In the earlier programming languages, it was the duty of the programmer to allocate the memory and also to de-allocate the memory. One of the most frequent reasons for the programs crashes was the lack of the memory, since memory was not released by the objects once their work was finished. In java we do not have that problem at all, since we have a Garbage Collector which always runs in the background when the interpreter is called and automatically re-claims the memory. The only problem is that we cannot force the garage collector nor can we predict at a particular point of time, a object will be definitely garbage collected, since Garbage Collector is a low priority thread. The points to be considered in this sub-module can be summarized as under:-

1. A System Level Thread, which is automatically created by the JVM. 2. Low Priority Thread

3. One cannot predict when the garbage collection of any particular object will be done.

4. One cannot force garbage collection even by using the System.gc() method which will

only request the Garbage Collector to run.

5. By using the finalize() method, there is no guarantee that the object will be immediately collected.

6. Also we can be sure that when a object is garbage collected, it will definitely call the finalize () method before the object is garbage collected.

finalize method We have already learnt about the concept of Garbage Collection, which is done by a system level thread, which will collect an object, which is of no use. But sometimes an object will need to perform some action when it is destroyed. In many cases a particular java object may be holding some non-java resource such as a window character font etc and we must make it sure that these resources are freed before an object is destroyed. To handle such cases, java has a mechanism called finalization. By using finalization, one can define specific actions that will occur, before the garbage collector reclaims the object. To add a finalize to a class, one needs to just define the finalize method. The Java environment calls that method whenever it is about recycle an object of that class. Inside the finalize () method you specify those actions which must be performed before the object is destroyed. The general form of a finalize () is: protected void finalize() { finalization code; } Here the keyword protected is a specifier that prevents access to finalize () by code defined outside its class. It is important to note here that the method is not called when an object goes out-of-scope. The finalize () method is a member of the Object class. Since all classes inherit from the Object class, your classes also contain the default finalize () method. This gives you an opportunity to execute your special cleanup code on each object before the memory is reclaimed.

native Keyword The native keyword is used to declare native code method. Once declared, these methods can be called from inside your java programs just as you do any other java method. After you declare a native method, you must write the native method and follow a rather complex series of steps to link it with your code. The mechanism used to integrate C code with java programs is called JNI. This methodology was created in 1.1 and then expanded and enhanced in 1.2 The precise steps that you need to follow will vary between different java environments and versions. This also depends on the language that you are using to implement the native method. Native methods seem to offer great promise, because they enable you to gain access to your exiting base of library routines, and they offer the possibility of faster runtime execution. The problems with native methods are:-

a) Potential security risk: Because a native method executes actual machine

code, it can gain access to any part of the hose system. That is native code is not confined to the JVM and this could allow a virus infection. Applets cannot use native methods.

b) Loss of portability: Because the native code is contained in a DLL, it must

be present on the machine that is executing the java program. Further because each native method is CPU and OS dependent, each DLL is inherently non portable. Thus a java application that uses native methods will be able to run only on a machine for which a compatible DLL has been installed.

Thus the use of native methods should be restricted, because they render you java programs non portable and pose significant security risks.

Methods returning Objects As we know the return type of java method should be some primitive data type or should be specifically declared as void. However methods can also returns object, but care should be taken that there is mandatorily a return statement at the end of the method and the object specified and object returns should be the same. The following example returns a String object, which we capture and print in our program. class ObjectReturn { public static void main(String[] args) { ObjectReturn x = new ObjectReturn(); String s = x.met1(); System.out.println(s); } String met1() { return "Hello"; } } The output would be Hello.

String class A String is a series of characters treated as a single unit. A string may include letters, digits and other various special characters like +,-,@, # etc.

A white space has no meaning in a java source code, but if included in a String, it is also taken as a character. String is the only object in Java which can be created with out the new keyword and incase it is done so, it is treated as a primitive data type, however when we create String with the new keyword, then it becomes a proper object. Hence the different ways of creating a String are: String s = “Hello”, in which case it is taken as a primitive and stored in the stack, String s1 = new String (“Hello”);, in which case it is taken as a Object properly initialized with the new keyword and stored in the Heap. The 4 Important Constructors of the String class are:-

a) String (String s) – creates an object of the character item passed in the parameters. b) String () – creates an instance of String with no characters in it.

c) String (char c[]) – creates an object of the char array passed into it

d) String (char c[], int startindex, int numberofchars) – This creates an object of the c

array starting from the position in the 2nd parameter till the number of characters as specified in the 3rd parameter.

Code class String1 { public static void main(String[] args) { String s = new String(); String s1 = new String("Hello friends"); char c [] = {'h','e','l','l','o'}; String s2 = new String (c); String s3 = new String(c,0,4); System.out.println(s); System.out.println(s1); System.out.println(s2); System.out.println(s3); } } Output (This is actually a space) Hello friends hello hell The String objects are immutable - their character contents cannot be changed after they are created. A String reference cannot be used to modify a String object to delete or modify a String object from the memory as in other programming languages such as C or C++.

The Important Methods are:

1. int length () – This returns the number of characters that it contains. 2. char charAt (int index) – To extract a single character at the specified index.

3. boolean equals () – actual contents of the String, which included the case sensitiveness

also. Code class String2 { public static void main(String[] args) { String s = new String("Hello"); String s1 = new String("Hello"); int a = s.length(); char c = s.charAt(1); boolean b = s.equals(s1); System.out.println("The number of characters in s is = "+a); System.out.println("The character at position 1 in s is = "+c); System.out.println("The contents of S and S1 are equal = "+b); } } Output The number of characters in s is = 5 The character at position 1 in s is = e The contents of S and S1 are equal = true

4. boolean equalsIgnoreCase () – checks without the case sensitiveness. 5. boolean startsWith (String s) – Determines if the String starts with the String specified in

the parameter.

6. overloaded version. boolean startsWith (String s, int index) – This allows you to specify a starting point.

Code class String3 { public static void main(String[] args) { String s = new String("hello"); String s1 = new String("HELLO"); boolean a = s.equals(s1);

boolean b = s.equalsIgnoreCase(s1); boolean c = s1.startsWith("H"); boolean d = s.startsWith("ll",2); System.out.println("Whether s and s1 contents are similar = "+a); System.out.println("Whether s and s1 contents are similar ignoring case = "+b); System.out.println("Whether s starts with h = "+c); System.out.println("Whether s starts with ll from position 2 = "+d); } } Output Whether s and s1 contents are similar = false Whether s and s1 contents are similar ignoring case = true Whether s starts with h = true Whether s starts with ll from position 2 = true

7. int indexOf (int c or String s) – checks for the first occurrence of the character or the string.

8. int lastIndexOf(int c or String s) –

9. overloaded version – int indexOf (int c, int position) – This enables u to start searching

from the specified position.

10. String substring(int startindex) – copies all the characters till the end from the start position in this string to another string.

11. String substring (int start, int end (exclusive)) – copies the characters form the start till the

end into another string. Code class String5 { public static void main(String[] args) { String s = new String ("Hello lilly"); int a = s.indexOf('l'); System.out.println("The first occurence of l in String s is = "+a); int b = s.lastIndexOf('l'); System.out.println("The last occurence of l in String s is = "+b); int c = s.indexOf('l',4); System.out.println("The first occurence of l in String s from position 4 is = "+c); String s1 = s.substring(5); System.out.println("The substring of String s from position 5 is = "+s1); String s2 = s.substring(5,9);

System.out.println("The substring of String s from position 5 till 9 is = "+s2); } } Output The first occurence of l in String s is = 2 The last occurence of l in String s is = 9 The first occurence of l in String s from position 4 is = 6 The substring of String s from position 5 is = lilly The substring of String s from position 5 till 9 is = lil

12. String replace (char original, char replacement) – replaces the original character with the replacement character in the whole string and returns a new String.

13. String trim () – removes the white space in the beginning and in the end.

14. String toUpperCase () – converts all the characters to Upper Case

15. String toLowerCase() –

16. static String valueOf (any datatype) – returns the String object of any primitive data type.

Code class String6 { public static void main(String[] args) { String s = new String ("Hello"); String s1 = s.replace('l','m'); System.out.println("The new String s1 is = "+s1); String s2 = s1.toUpperCase(); System.out.println("The new String s2 is = "+s2); s2 = s1.toLowerCase(); System.out.println("The String s2 is now = "+s2); String s3 = String.valueOf(10); System.out.println("The new String s3 is = "+s3); } } Output The new String s1 is = Hemmo The new String s2 is = HEMMO The String s2 is now = hemmo The new String s3 is = 10

17. char [] toCharArray() – To convert all the characters in a String to a character array.

18. boolean regionMatches (int startindex, String 2, int String2start index, int no of characters) – This compares a specific region in a string with another specific region in another String

Code class String7 { public static void main(String[] args) { String s = new String("Gurukul"); char c[] = s.toCharArray(); for (int a = 0;a<c.length;a++ ) { System.out.println(c[a]); } } } Output G u r u k u l Code class String8 { public static void main(String[] args) { String s = new String ("Hello Guys"); String s1 = new String("Girls Hello"); boolean c = s.regionMatches(0,s1,6,4); System.out.println("Whether the position of Hello in s1 and s2 is same = "+c); } } Output Whether the position of Hello in s1 and s2 is same = true Code public class Test83 {

public static void main(String args[]) {

String s1 = new String("Hello");

String s2 = new String("There"); System.out.println(s1); s1=s2; System.out.println(s1);

} } Output Hello There This is because when we say s1 = s2, the earlier value of s1 is lost and now it points to s2 and hence the output.

StringBuffer Class StringBuffer is a class which is the mutable version for string concatenation. All the methods of the String class return a new string object, as once a string object is created, it cannot be changed. However most of the methods of the StringBuffer class return the same object and changes are made in the same memory location. Constructors

a) StringBuffer () – creates space for 16 characters. b) StringBuffer (int size) – creates a SB with the size specified in the parameter.

c) StringBuffer (String s) – creates a SB with the string specified and additional 16

character spaces. Important Methods 1) int length () – This returns the current length of the SB. 2) int capacity () – This returns the total capacity of the SB. Code class SB1 { public static void main(String[] args) { StringBuffer s = new StringBuffer(); System.out.println("The length of s is = "+s.length()); System.out.println("The total capacity of s is = "+s.capacity()); StringBuffer s1 = new StringBuffer("Hello"); System.out.println("The length of s1 is = "+s1.length()); System.out.println("The total capacity of s1 is = "+s1.capacity()); StringBuffer s2 = new StringBuffer(4); System.out.println("The length of s2 is = "+s2.length());

System.out.println("The total capacity of s2 is = "+s2.capacity()); } } Output The length of s is = 0 The total capacity of s is = 16 The length of s1 is = 5 The total capacity of s1 is = 21 The length of s2 is = 0 The total capacity of s2 is = 4 3) StringBuffer append (String s): adds to the end of the String Buffer. Is overloaded. 4) StringBuffer insert (int position, String s) – inserts at the specified int position. 5) StringBuffer reverse () – reverses the contents of the String. Code class SB2 { public static void main(String[] args) { StringBuffer s1 = new StringBuffer("Hello"); s1 = s1.append(" Gurukul"); System.out.println("s1 after appending looks like = "+s1); s1 = s1.insert(5," guys from"); System.out.println("s1 after inserting looks like = "+s1); } } Output s1 after appending looks like = Hello Gurukul s1 after inserting looks like = Hello guys from Gurukul 6) StringBuffer delete ( int start , int end ) – Deletes a range of characters. 7) StringBuffer deleteCharAt(int position) – Deletes the character at the specified position. 8) New - StringBuffer replace( int start, int end, String s) – replaces the set of characters

specified between start and end with the String s. 9) New – String substring (int start) – this returns the substring from the StringBuffer object. Code class SB3 { public static void main(String[] args) {

StringBuffer s1 = new StringBuffer("Hello"); s1.delete(1,3); System.out.println("After deleting characters from 1 to 3 in s1 = "+s1); s1.deleteCharAt(1); System.out.println("After further deleting characters at position 1 in s1 = "+s1); StringBuffer s2 = new StringBuffer("lilly"); s2.replace(1,4,"Hello"); System.out.println("After replacing s2 looks like = "+s2); } } Output After deleting characters from 1 to 3 in s1 = Hlo After further deleting characters at position 1 in s1 = Ho After replacing s2 looks like = lHelloy IMP: Also please note that the equals method is not overridden in the StringBuffer class and hence when we call the equals () method on two String objects, it would return false, although the contents of the same would be true. The same if done with String class would return true, since the equals method is overridden in the String class to check the contents of the String and not the memory location of the objects. Code class Test84 { public static void main(String[] args) { StringBuffer sb = new StringBuffer("One"); StringBuffer sb1= new StringBuffer("One"); boolean a = (sb== sb1); boolean b = sb.equals(sb1); System.out.println(a); System.out.println(b); } } Output false false

What is a Java Exception? Programmers in any language try to always write error and bug free codes, which would execute properly under any circumstances and programs which should never crash. Unfortunately it is not

only difficult but many times impossible for a code to execute under any circumstances. Any program at a given point of time would execute normally under normal circumstances. In real programs, errors or abnormal conditions occur, either because the programmer didn't anticipate every situation your code would get into (or didn't have the time to test the program enough), or because of situations which are out of the programmer's control - bad input data from users, corrupt files that don't have the right data in them, network connections that don't connect, hardware devices that don't respond. In Java, these sorts of strange events that may cause a program to fail are called Exceptions in general. The term exception is shorthand for the phrase "exceptional event". It can be defined as follows: Definition: An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. Many kinds of errors can cause exceptions - problems ranging from serious hardware errors, such as a hard disk crash, to simple programming errors, such as trying to access an out-of-bounds array element. When such an error occurs within a Java method, the method creates an exception object and hands it off to the runtime system. The exception object contains information about the exception, including its type and the state of the program when the error occurred. The runtime system is then responsible for finding some code to handle the error. In Java terminology, creating an exception object and handing it to the runtime system is called throwing an exception. After a method throws an exception, the runtime system checks incase there is so one who can handle that type of exception and incase there is indeed a catch block then the exception is handled properly. The runtime system searches backwards through the call stack, beginning with the method in which the error occurred, until it finds a block that contains an appropriate exception handler or called as the catch block. An exception handler is considered appropriate if the type of the exception thrown is the same as the type of exception handled by the handler. Thus the exception bubbles up (goes up) through the call stack until an appropriate handler is found and one of the calling methods handles the exception. The exception handler chosen is said to catch the exception. If the runtime system exhaustively searches all of the methods on the call stack without finding an appropriate exception handler, the runtime system (and consequently the Java program) terminates. Java defines a number of language features to deal with exceptions, including

1. How to handle exceptions in the code and recover gracefully from potential problems 2. How to tell users of the methods that you're expecting a potential exception

3. How to create an exception if one is necessary.

In other languages that do not support exception handling, errors must be checked and handled manually – typically through the use of error codes and so on.

This approach is as cumbersome as it is troublesome. Java’s exception handling avoids these problems and in the process brings run time error management into the object oriented world. Java exception handling is managed via five keywords: try, catch, throw, throws and finally.

1. The try statement contains the program statements that you want to monitor for exceptions contained within that block

2. The catch statement handles this exception or throws back the same. The System

generated exceptions are automatically thrown by the java run-time environment.

3. To manually throw an exception we should use the keyword throw

4. Any exception that is thrown out of a method must be specified as such by a throws clause

5. Any code that must be executed before a method returns is put in a finally block

Exception Class Hierarchy All exception types are sub classes of the built in class Throwable. Throwable is at the top of the exception class hierarchy. The Throwable class has two subclasses namely Exception and Error.

The logic behind this partition is why such abnormal conditions happen. Error in programs happens normally not due to any error in programming logic but more due to factors which are outside the programmer control.

The Error subclasses are not expected to be caught under normal circumstance by the program. These abnormal conditions are used by the Java runtime system to indicate errors having to do with the run-time environmental, itself. Error class has subclasses which are serious problems which are not normally associated with the code and which the programmer should not try to catch, like for example ClassFormatError (when the .class file has been tampered with). We should let the JVM handle the Error as the way it wants to.

Exception happens more generally due to factors which are within the programmers control and programmer should properly handle the same. Since the Exception class contains exception sub classes which are within the programmer’s control, the programmer should catch the same (but not all sub classes as explained later on).

The Exception class is again classified into two sections called as the Compile Time Exception and Runtime Exception.

It is the programmer’s duty to properly handle the Compile Time Exceptions whereas like Errors they can let the JVM handle the Runtime Exception. The RuntimeException automatically defines for the programs that you will write and include things such as division by zero and invalid array indexing.

The other main branch is topped by Error, which defines exceptions that are not expected to be caught under normal circumstances by your program.

Generating Exceptions Whenever there is an exception, it must be caught by an exception handler and dealt with immediately. But incase the same is not caught, and then it will ultimately be processed by the default handler.

The default handler displays a string describing the exception, prints a stack trace from the point at which the exception occurred and terminates the program. The following is the code which automatically generates an exception and on the basis of the output, we will analyze the code

Code class Test57 { public static void main (String args []) { System.out.println("Before Exception"); int a = 42/0; System.out.println("After Exception"); } } Output Before Exception java.lang.ArithmeticException: / by zero at Test57.main(Test57.java:6) Exception in thread "main" When we compile the above code, it compiles properly, but at runtime it generates the following output, which means that ArithmeticException which is generated is a Runtime Exception.

IMP: Any statement after the exception object in the same block of code will not be printed. When the exception object is raised by the JVM at line number 6 of the above code, it looks for an exception handler immediately and does not find the same and the program crashes. Notice how the class name, Test; the method name, main, the filename, Test.java and the line number 6, are all included in the simple stack trace. Also, notice that the type of the exception thrown is a subclass of Exception called ArithmeticException, which more specifically describes what type of error happened. IMP: The stack trace will always show the sequence of method invocations that led up to the error. Let us see this with the example of a Code Code class Extra3 { public static void main(String[] args) { Extra3 y = new Extra3(); y.met1(); } void met1() { met2(); } void met2() { int a [] = {10,29}; int x = a[3]; System.out.println(x); } } Output java.lang.ArrayIndexOutOfBoundsException at Extra3.met2(Extra3.java:18) at Extra3.met1(Extra3.java:11) at Extra3.main(Extra3.java:6) Exception in thread "main"

try and catch blocks All though the default exception handler provided by the Java runtime system is useful for debugging, you will usually want to handle an exception yourself. Doing so will be advantageous in two ways:-

a) It allows one to fix the error and allows program to continue b) It prevents the program from terminating automatically. Most users would be confused if

the program stopped running and printed a stack trace whenever an error occurred!. They need to be told in a softer manner and in plain words what caused the above abnormal condition.

try is keyword in java and the block that follows the try should have the codes which the programmer feels that might generate an exception. catch is also keyword in java. The catch block will have in its parameter the type of exception which that particular catch block can handle. Incase if any exception is generated in the try block, the program immediately comes out of the try block and looks for the catch block within the method and incase it does not find the same, it will look for it in the method which called the method in which the abnormal condition happened and this continues till it reaches the topmost method. If the program finds a catch block at any position, then it would continue the normal executed of the program, in the method in which the catch block was found and the program would terminate normally. Code class Extra4 { public static void main(String[] args) { Extra4 y = new Extra4(); y.met1(); System.out.println("last Line in main method"); } void met1() { met2(); System.out.println("last Line in met1()"); } void met2() { int a [] = {10,29}; try { int x = a[3]; } catch (ArrayIndexOutOfBoundsException e) { System.out.println("caught in met2 "); } System.out.println("last Line in met2()"); } } Output

caught in met2 last Line in met2() last Line in met1() last Line in main method Now instead of having the catch block at the point of generation of the error, let have the catch block in the main method and now let us see the output. Code class Extra5 { public static void main(String[] args) { Extra5 y = new Extra5(); try { y.met1(); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("caught in met2 "); } System.out.println("last Line in main method"); } void met1() { met2(); System.out.println("last Line in met1()"); } void met2() { int a [] = {10,29}; // try // { int x = a[3]; // } /* catch (ArrayIndexOutOfBoundsException e) { System.out.println("caught in met2 "); }*/ System.out.println("last Line in met2()"); } } Output caught in met2 last Line in main method We saw that incase the exception is not caught, it would not print any line further after the generation of the exception and the program would continue further in the method in which it was caught and hence the last lines in met1 and met2 methods were not printed.

The important points to be noted here is that:

a) Once an exception is thrown, the program control transfers out of the try block into the relevant catch block and any statement after the try block does not execute. We saw that the println statement “In Try Block” did not get executed.

b) Incase a exception is generated in a method, then the program will look for the catch

statement in that method and incase it does not find one, then it will look for the catch statement in the method which called this method and incase again there is no catch block there also, then the program will crash and properly generate the stack records. (We will see this possibility in the next code).

c) Both the try and catch blocks are blocks of code and once the program control shifts out

of the try block, it will not come back into the try block like methods do.

d) A try block must be accompanied by at least one catch statement or finally statement. It is not mandatory that try should always be accompanied with the catch block, it can be with the finally block also, but in that case remember that the exception would not be caught.

e) There can be no intervening statement between the end of a try block and the beginning

of a catch block.

f) A catch statement requires a single formal statement. The argument to a catch statement looks like an argument declaration for a method. The argument type declares the type of exception that the handler can handle and must be the name of a class that inherits from the Throwable class. When a java programs throw an exception they are really just throwing an object and only objects that derive from Throwable can be thrown.

Displaying a Description of an Exception The Throwable class overrides the toString () defined in the object, so that it returns a string containing a description of the exception. You can display this description in a println statement by simply passing the exception as an argument. For Example catch (ArithmeticException e) { System.out.println(“Exception : “ + e); } wherein e gives u the description of the exception that occurred Now there are 4 ways in which to describe an exception in the catch block and they are:-

a) A simple println() method which would say “Exception caught” or some other plain lines, which does not use the exception object e.

b) A printStackTrace () method which uses the exception object and which generated

the complete stack trace as if the exception actually occurred. The printStackTrace() method actually informs us about 5 important things and they are:-

1) The name of the exception. } 2) Message of the exception } Both the above are in the 1st line 3) Method in which exception was generated 4) Source Code file name in which the exception was generated

5) Line Number in which the exception was generated. The last 3 points are there in the 2nd line. and incase there is no exception handler (catch statement) in a method, they it will go up the stack trace and give details of the same also. (as we saw in the earlier code).

c) Simply printout the exception objects (e). This will give the description of the

exception and the message of the exception ( Line No 1 of the printStackTrace() method) only.

d) Incase we need only the message of the exception, we can use the method

getMessage() on the exception object and get only the message of the exception. Remember that e.getMessage() should be in the println() method.

Code class Extra2 { public static void main(String[] args) { try { int a = 10 / 0; } catch (ArithmeticException e) { System.out.println("Exception caught"); System.out.println("----------------------------------------------"); e.printStackTrace(); System.out.println("---------------------------------"); System.out.println(e); System.out.println("---------------------------------"); System.out.println(e.getMessage()); } } } Output Exception caught ---------------------------------------------- java.lang.ArithmeticException: / by zero at Extra2.main(Extra2.java:7) --------------------------------- java.lang.ArithmeticException: / by zero --------------------------------- / by zero

finally keyword When exceptions are throws, execution in a method takes a rather abrupt, nonlinear path that alters the normal flow through the method. Depending on how the method is coded, it is even possible for an exception to cause the method to return prematurely.

This could be a problem in some method. For example, if a method opens a file upon entry and closes it upon exit, then you will not want the code that closes the file to be bypassed by the exception-handling mechanism. The finally block provides the means to clean up at the end of executing a try block. You use a finally block when you need to be sure that some particular code is run before a method returns, no matter what exceptions are thrown within the previous try block. A finally block is always executed, regardless of what happened during the execution of the method. If a file needs to be closed or a critical resource released, you can guarantee that it will be done if the code to do it put in a finally block. If an exception is thrown, the finally block will execute even if no catch statement matches the exception. For a try block, either a catch statement or a finally statement has to be present. Code class Test61 { public static void main(String[] args) { int a = 0; int b = 0; try { a = args.length; b = 10/a; System.out.println("The value of b is ="+b); } catch (ArithmeticException e) { e.printStackTrace(); } finally { System.out.println("Finally block"); } System.out.println("After all execution"); } } Output Possibility One Incase we do pass parameters as we did earlier (assume we passed two parameters) then the output would be The value of b is =5 Finally block After all execution

Possibility Two Incase we do not pass any parameters, then the output would be java.lang.ArithmeticException: / by zero at Test61.main(Test61.java:11) Finally block After all execution In both the possibilities we saw that the finally block was always executed. In the second possibility, we saw that since an exception was generated, it went into the catch block and then into the finally block and the program went on properly. Now let us see what would be the output incase we comment the catch block and the output would be Finally block java.lang.ArithmeticException: / by zero at Test61.main(Test61.java:11) Exception in thread "main" We saw that the finally block gets executed whether the exception is caught or not caught. Over here before the exception stack trace is printed since there is no catch statement, the finally block gets a chance to execute itself and then the error is thrown out. Since there is no catch block, the program gets crashed the final println() statement is not executed.

throws keyword In the previous examples you learned how to deal with methods that might possibly throw exceptions by the Java Run-time system and protecting code (try block) and catching any exceptions that occur. The Java compiler will check to make sure you've somehow dealt with a method's exceptions-but how did it know which exceptions to tell you about in the first place? The answer is that the original method indicated in its signature the exceptions that it might possibly throw. You can use this mechanism in your own methods-in fact; it's good style to do so to make sure that other users of your classes are alerted to the errors your methods may come across. To indicate that a method may possibly throw an exception, you use a special clause in the method definition called throws. The throws Clause To indicate that some code in the body of your method may throw an exception, simply add the throws keyword after the signature for the method (before the opening brace) with the name or names of the exception that your method throws: public boolean myMethod (int x, int y) throws AnException { ... }

If your method may possibly throw multiple kinds of exceptions, you can put all of them in the throws clause, separated by commas: public boolean myOtherMethod (int x, int y) throws AnException, AnotherException, AThirdException { ... } Note that as with catch you must use a superclass of a group of exceptions to indicate that your method may throw any subclass of that exception: public void YetAnotherMethod() throws IOException { ... } Keep in mind that adding a throws method to your method definition simply means that the method might throw an exception if something goes wrong, not that it actually will. The throws clause simply provides extra information to your method definition about potential exceptions and allows Java to make sure that your method is being used correctly by other people. IMP: Pls remember that the exception which will be caught should be equal or higher in the hierarchy than the exception thrown. Incase it is down in the hierarchy the compiler will complain. Code class Test62 { public static void main(String[] args) { Test62 x = new Test62(); try { x.met1(); } catch (Exception e) { System.out.println("Following Exception caught in main method" + e); } System.out.println("After all exceptions in the main method"); } void met1() throws Exception { try { int a = 10 / 0; } catch (ArithmeticException e) { System.out.println(e.getMessage()); } } }

Output / by zero After all exceptions in the main method Points to be noted:

1) We are putting int a = 10/0 in a try block within met1() and hence the exception is caught inside met1() itself and no exception is pending and hence it did not go into the catch block in the main method and also printed out the final println () statement.

2) Try removing the try block in met1() method so that an exception object will be

pending and which will be caught in the main method and then the output would be. Following Exception caught in main method java.lang.ArithmeticException: / by zero After all exceptions in the main method

3) Now in the 1st point, there was no exception, but we still put x.met1() code in the try

block as said earlier. We will see now what happens when we remove the try and catch block in the main method and simply put x.met1() in the main method.

Test62.java:8: unreported exception java.lang.Exception; must be caught or declared to be thrown x.met1(); ^ 1 error So here we saw that irrespective of whether an exception comes out the met1() method or not (over here there is no exception since it is already caught in the met1() method) we still have to put the calling code x.met1() in the calling method in try and catch blocks.

4) Now we will change the exception type in the catch block of the main method from

Exception to Arithmetic exception and also remove the full try and catch blocks from met1() so that an Arithmetic exception definitely gets generated and see what is the output.

Test62.java:8: unreported exception java.lang.Exception; must be caught or declared to be thrown x.met1(); ^ 1 error Again the compiler complains, this is because although Arithmetic Exception is coming out, it is declaring to the world that it throws Exception object and all methods which call this method should mandatorily should catch Exception only.

throw keyword Until now we have been depending on the JVM to generate the system defined exception, but in many situations in our code we would want to generate a exception ourselves depending on some conditions.

Declaring that your method throws an exception is useful only to users of your method and to the Java compiler, which checks to make sure all your exceptions are being dealt with. But the declaration itself doesn't do anything to actually throw that exception should it occur; you have to do that yourself in the body of the method. Remember that exceptions are all instances of some exception class, of which there are many defined in the standard Java class libraries. In order to throw an exception, therefore, you'll need to create a new instance of an exception class. Once you have that instance, use the throw statement to throw it (could this be any easier?). The simplest way to throw an exception is simply like this: throw new ServiceNotAvailableException(); IMP: You can only throw objects that are instances of subclasses of Throwable. This is different from C++ exceptions, which allow you to throw objects of any type. Depending on the exception class you're using, the exception may also have arguments to its constructor that you can use. The most common of these is a string argument, which lets you describe the actual problem in greater detail (which can be very useful for debugging purposes). Here's an example: throw new ServiceNotAvailableException("Exception: service not available, database is offline."); Once an exception is thrown, the method exits immediately, without executing any other code (other than the code inside finally, if that clause exists) and without returning a value. If the calling method does not have a try or catch surrounding the call to your method, the program may very well exit based on the exception you threw. IMP: Whenever a method has a throw keyword inside its body, the signature of the method should mandatorily have the throws keyword. This is but obvious, since throws keyword tell the callers of its method, that a exception might or might not occur from its body and with the throw keyword there is definitely an exception and hence throws is required in the signature of the method. IMP: Like any other case, when an exception object is generated, it would look for the catch block otherwise the program would crash. Also once the exception object is generated, no further statement in the block would be executed. Also the throw keyword can be there in any part of the methods, in the catch block or outside the catch block etc. Code class Test64 { public static void main(String[] args) { Test64 x = new Test64(); try { x.met1(); } catch (Exception e) { System.out.println(e); }

System.out.println("In the main method"); } void met1() throws Exception { try { int a = 10 / 0; } catch (ArithmeticException e) { System.out.println(e); throw new Exception("This is a user generated exception"); } System.out.println("After the throw keyword"); } } Output java.lang.ArithmeticException: / by zero java.lang.Exception: This is a user generated exception In the main method So here we saw that the first line is because of the catch block in the met1() and there again it uses the throw keyword to generate another Exception object and give it a message. Remember that the println() "After the throw keyword" does not print since there is no catch block for this new exception object and it goes back to the caller, where there is a catch block and the programs continues. IMP: The exception object in the throws cause of the method which has a throw keyword should be higher in the hierarchy always. Incase we swap the exceptions that is the throws keyword would have the ArithmeticException e and the catch block in met1() would have the Exception object, then the following error would be generated Test64.java:28: unreported exception java.lang.Exception; must be caught or declared to be thrown throw new Exception("This is a user generated exception"); ^ 1 error

Checked and Unchecked Exceptions

Since exceptional conditions throw objects, objects are instances of classes, and classes may be inherited in Java, a natural hierarchy can be created which causes exceptions to be grouped in logical ways.

1. Checked Exceptions - The checked exceptions are the exceptions which the java compiler will check and incase not properly done would not compile. The checked exceptions are those classes which are sub-classes of the Exception class other than the RuntimeException class.

This would mean that for all these subclasses the compiler would check, which would mean that we have to mandatorily write any methods which throw these types of exceptions in try - catch block or the method should have the throws signature. Unless this is done, the compiler will not allow the code to compile

2. Un-checked exceptions- These types of exception are not checked by the compiler and

hence it is not mandatory to write these methods in try / catch block. However to ensure that the program continues smoothly, we should properly handle these exceptions also, but the compiler does not force us, like in the case of Checked Exceptions.All the subclasses of the RuntimeException and Error classes fall under this category.

Exceptions of all Exception classes and subclasses other than RuntimeException which is a subclass of Exception (approximately seventeen different classes plus any that you may add) are checked by the compiler and will result in compiler errors if they are not either caught or specified. Later, we will learn how you can create your own exception classes. Whether your exception objects become non-checked or checked depends on which class you choose as your superclass in defining your exception class. Code import java.io.*; class Test65 { public static void main(String[] args) { try { FileInputStream fis = new FileInputStream("c:/one.txt"); } catch (IOException e) { System.out.println(e); } System.out.println("Hello World!"); } } Output Hello World! The rule is that all checked exceptions should be mandatorily should be put in an exception handling mechanism whether they throw an exception or not. Now in the above code we have put the FileInputStream which throws a FileNotFoundException which is a subclass of the IOException which is a checked exception. We are trying to open a file called one.txt which is there in the C: root directory. For all IO we should use the system independent way of handling the files that is the “/” slash and not the windows type of “\” slash. Now if the file is not there, it would throw an exception and the output would be java.io.FileNotFoundException: c:/one.txt (The system cannot find the file specified) Hello World! Normal Termination

and if the file is indeed there it would not enter the catch block. Now the argument would be if the file is indeed there then should we put the code in a try - catch block. So let us comment the try and catch statements and directly put the line FileInputStream fis = new FileInputStream("c:/one.txt"); in the main method and the output would be: Test65.java:9: unreported exception java.io.FileNotFoundException; must be caught or declared to be thrown FileInputStream fis = new FileInputStream("c:/one.txt"); ^ 1 error So this confirms that whether in a Checked Exception we should mandatorily put the code in a try - catch block because the compiler checks for the same.

Creating own Exceptions

Exceptions are simply classes, just like any other classes in the Java hierarchy. Although there are a fair number of exceptions in the Java class library that you can use in your own methods, there is a strong possibility that you may want to create your own exceptions to handle different kinds of errors your programs might run into. Fortunately, creating new exceptions is easy. Your new exception should inherit from some other exception in the Java hierarchy. Look for an exception that's close to the one you're creating; for example, an exception for a bad file format would logically be an IOException. If you can't find a closely related exception for your new exception, consider inheriting from Exception, which forms the "top" of the exception hierarchy for explicit exceptions (remember that implicit exceptions, which include subclasses of Error and RuntimeException, inherit from Throwable). Exception classes typically have two constructors: The first takes no arguments and the second takes a single string as an argument. In the latter case you'll want to call super() in that constructor to make sure the string is applied to the right place in the exception. Beyond those three rules, exception classes look just like other classes. You can put them in their own source files and compile them just as you would other classes: IMP: Also the convention is to have the Exception word as the last in the class name of user defined exceptions. Also whether the user defined exception would be a checked exception or unchecked exception would depend on which class we are extending. Code class UserDefinedException1 extends RuntimeException { UserDefinedException1() { } UserDefinedException1(String s) { super(s); } }

class UserDefinedException extends Exception { UserDefinedException() { } UserDefinedException(String s) { super(s); } } class Test66 { public static void main(String[] args) { Test66 x = new Test66(); try { x.met1(); } catch (Exception e) { System.out.println(e); } } // end of main void met1() throws Exception { if (true) { throw new UserDefinedException1("This is Exception"); } else { throw new UserDefinedException1("This is Exception1"); } } // end of met1 } Output UserDefinedException1: This is Exception In the above code we created two user defined exception and simply tried the same in Test66. Change the if condition to false you will fine that it will throw UserDefinedException1 and the output would be UserDefinedException: This is Exception1 The super statement in the String parameter constructor of the user defined constructor is very important as without that whatever message that we print in the throw statement parameter would not go the getMessage() and hence nothing would be printed. To test the same comment the super() statement from both the user defined exceptions and then compile and run Test66. We will find that whatever message we give the throw statement would not be printed.

Structure of the IO Package Java input and output is based on the use of streams.

Streams are sequences of bytes that travel from a source to a destination over a communication path. If your program is writing to a stream, it is the stream's source. If it is reading from a stream, it is the stream's destination.

The communication path is dependent on the type of I/O being performed. It can consist of memory-to-memory transfers, file system, network, and other forms of I/O.

A Stream is an abstract representation of an input or output device that is a source of or destination for data. The java.io package supports two types of streams, Binary Streams, which contain binary data, and character streams, which contain character data.

When you write data to a stream as a series of bytes, that is binary data, it is written to the stream exactly as it appears in memory. No transformation of the data takes place. Numerical values are just written as a series of bytes. Character streams are used for storing and retrieving text. You can also use character streams to read a text file not written by a java program.

All numeric values are converted to a textual representation before written to the stream. This involves formatting the data to generate a character representation of the data value.

All Unicode Characters are automatically converted to the local representation of the characters as used by the host machine and then these are written to the file.

Unicode uses 16 bits to represent each character. If the high-order 9 bits are all zeros, then the encoding is simply standard ASCII, otherwise the bits represents a character that is not represented in 7-bit ASCII. Java’s char datatype uses Unicode Encoding.

Unicode’s 16-bit is sufficient to encode most alphabets but pictographic Asian Languages like Japanese, Vietnamese present a problem. The answer for this is UTF (UCS Transformation format and UCS stands for Universal Character Set).

UTF encoding uses as many bits as needed to encode a character: fewer bits for smaller alphabets and more bits for larger Asian alphabets.

The important classes in the io.package are

a) File – An object of this class represents a pathname either to a file that you will access for input or output or to a directory.

b) RandomAccessFile – Random Access to a File.

c) Output Stream – Base class for Byte Stream output.

d) Input Stream – Base Class for Byte Stream Input.

e) Writer – Base class for Character stream Output.

f) Reader – Base class for Character stream Input. - Streams are powerful because they abstract away the details of the communication path

from input and output operations. This allows all I/O to be performed using a common set of methods.

- Whenever we are using the classes of the java.io package, the package will have to be

imported and all the codes should be put in a try - catch block or the method should have throws signature, because most of the methods in this package throw IOException which is a Checked Exception.

File Class File class represents the name of a file or directory that might exist on the hose machine’s file system. The constructors are

1. File (String file) 2. File(String dir, String subpath)

3. File(File dir, String subpath)

"File" class is a non-stream class because it just has methods to access the information about a file or directory entry in the file system and not the file contents. To get information about a file and perform standard operations on it, we should first have a valid File object. The important methods are:

1. Boolean exists() – Where the file or directory exists or not

2. String getAbsolutePath() – This returns the absolute and not the relative path of file or directory.

3. String getName()

4. String getParent() – This returns the name of the directory that contains the File.

5. Boolean isDirectory()

6. Boolean isFile()

7. String [ ] list() – This returns an array containing the name of files and directories within

the File (which should be a directory).

8. Boolean canRead()

9. Boolean canWrite()

10. long length()

11. Boolean mkdir(File f)

12. boolean renameTo (File newname) Creating a file or directory createNewFile() - Atomically creates a new, empty file if and only if a file with this name does not yet exist. createTempFile(String prefix, String suffix) - Creates an empty file in the default temporary-file directory, using the given prefix and suffix to generate its name. createTempFile(String prefix, String suffix, File directory) - Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name. Creating a File object for a nonexistent file is not an error, so File constructors will not throw any exceptions. You can use the exists() method to find out the file or directory existence. We can create a directory with mkdir() or mkdirs(). mkdir() creates a single directory; mkdirs() creates the directory including any necessary but nonexistent parent directories renaming a file renameTo(File dest) - Renames the file/directory denoted by this abstract pathname. deleting a file or directory delete() to delete a file or directory. Although you can create and delete files and directories, there is no method that allows you to change the current working directory. You have to just create a new "File" object with a different directory for the constructor. IMP: Deleting an instance of the File has no effect on the local file system IMP: Please note that the File class objects created are of a directory present in the system and for checking the same, please change it to a directory present in your system along with the file. Code (Simple methods of the File class) import java.awt.*; import java.awt.event.*; import java.io.*; public class File1 {

File f; public File1() throws IOException { f= new File("C:/Students-March","test.txt"); System.out.println("Chek for the file " +f.exists()); System.out.println("Chek for the file " +f.getName()); System.out.println("Chek for the file " +f.getParent()); System.out.println("Chek for the file " +f.isFile()); System.out.println("Chek for the file" +f.isDirectory()); } public static void main(String args[]) throws IOException { new File1(); } } Code (Example of the list method of the File class) import java.awt.*; import java.io.*; import java.awt.event.*; public class File2 implements ActionListener { File f; Frame f1; TextArea ta; TextField tf; Button b; public File2() { try { f1 = new Frame("F1"); f1.setLayout(new FlowLayout()); ta = new TextArea(10,20); tf = new TextField(20); b = new Button("Ok"); f1.add(tf); f1.add(b); f1.add(ta); tf.addActionListener(this); b.addActionListener(this); f1.setSize(200,200); f1.setVisible(true); } catch(Exception ie) { ie.printStackTrace(); } }

public void actionPerformed(ActionEvent ae) { if(ae.getSource()==b) { String s = tf.getText(); File f = new File(s); if (f.isDirectory()) { String arr[]= f.list(); for( int i=0;i<arr.length;i++) { ta.append(""+arr[i]+"\n"); } } else if(f.isFile()) { ta.append("Please enter directory name"); } } } public static void main(String[] args) { new File2(); } }

RandomAccessFile Class One way to ready or modify a file is to use the RandomAccessFile class. This class represents a model of files that is incompatible with the Stream / Writer classes. With a RandomAccessFile, you can seek a desired position within a file and then read or write a desired amount of data. The RandomAccessFile provides method that support seeking, reading and writing Constructors RandomAccessFile (String file, String mode // which can be ‘r’ or ‘rw’) The rw refers to Read - Write over here. The ‘rw” form of constructor is useful when you want to open some of the methods of the File class before opening a RAF, so that a instance of File is in hand when calling the RAF constructor. Constructing a RAF is similar like constructing an instance of File. After a random Access file is created, you can seek to any byte position within the file and then read or write. Pre java systems have supported this seeing to a position relative to the beginning of the file, end of the file or the current position of the file. The methods

long getFilePointer () throws IOException – This returns the current position within the file, in bytes, Subsequent reading and writing will take place starting at this position. long length() throws – length of file in bytes void seek( long position) thro – This sets the current position within the file in bytes. Subsequent reading and writing will take place at this position. Files start at position 0. The common methods that support reading and writing are: int read() - this returns the next byte from the file or –1 is end of file int read(byte d[]) – attempts to read enough bytes t fill array d[] int read(byte d[], int o, int n) – attempts to read n number of bytes into array d[] starting at o. RandomAccessFile supports reading and writing of all primitive data types. When RAF is no longer needed, it should be closed: void close() throws IOException Code import java.awt.*; import java.io.*; public class Raf1 { RandomAccessFile raf ; public Raf1() { try { raf = new RandomAccessFile("1.txt","rw"); raf.writeBoolean(true); raf.writeChar('a'); raf.writeInt(1234); System.out.println("read1"+raf.length()); raf.seek(1); System.out.println("read1"+raf.readChar()); System.out.println("read1"+raf.readInt()); raf.seek(0); System.out.println("read1"+raf.readBoolean()); } catch(Exception e) { e.printStackTrace(); } } public static void main(String[] args) { new Raf1(); }

}

Stream Classes The superclass of the Stream Classes or called as the byte oriented classes are the abstract class InputStream and OutputStream. We will be discussing each of the important classes relevant from the certification point over here. FileInputStream This class will enable us to create a InputStream with which one can use to read bytes from a file. The common Constructors are as under: FileInputStream (String filename); FileInputStream (File f); Either of this will throw a checked exception and hence will have to be put in a try / catch block or the method will have to throw this FileNotFoundException. Code import java.io.*; public class Fis1 { public static void main(String[] args) { try { File f =new File(args[0]); FileInputStream fis = new FileInputStream(f); int i = fis.available(); for(int j=0;j<i;j++) { System.out.print((char)fis.read()); } } catch(Exception e) { e.printStackTrace(); } } } Code import java.io.*; public class Fis2 { public static void main(String[] args) {

try { File f =new File(args[0]); FileInputStream fis = new FileInputStream(f); int i; while((i = fis.read())!=-1) { System.out.print((char)i); } } catch(Exception e) { e.printStackTrace(); } } } In the earlier two codes, we have seen how to use the while and the for loop for using the read () method and then printing out the contents of the file which we pass as argument to the code. ByteArrayInputStream This is an implementation of an InputStream that uses byte array as the source. The two constructors for this are: ByteArrayInputStream (byte b[]) ByteArrayInputStream (byte b[], int start, int noofbytes) Code import java.io.*; public class BAIS { public static void main(String[] args) { try { String s = "hello is it done?"; byte b[] = s.getBytes(); ByteArrayInputStream bais = new ByteArrayInputStream(b); int i; while((i=bais.read())!=-1) { System.out.print((char)i); } } catch (Exception ie) { ie.printStackTrace(); } } }

SequenceInputStream This class allows us to concatenate two Input Streams. The two constructors for this are: SequenceInputStream (IS one, IS two); Remember it can take only two Input Streams. SequenceInputStream (Enumeration s) In the case of the first constructor, the class reads requests from the first until it runs out and then switches to the other and so on. In the case of Enumeration, it will continue through all the IS until the end of the last one is reached. Code import java.io.*; public class SIS { public static void main(String[] args) { try { FileInputStream fis = new FileInputStream("1.txt"); FileInputStream fis1 = new FileInputStream("2.txt"); SequenceInputStream sis = new SequenceInputStream(fis,fis1); int i; while((i=sis.read())!=-1) { System.out.print((char)i); } } catch (IOException ie) { ie.printStackTrace(); } } } Filter Streams The FilterInputStream and FilterOutputStream classes are subclasses of InputStream and OutputStream that acts just like a regular stream, except that it performs some additional processing on an underlying data stream. Each of the subclasses of FilterInputStream works by wrapping an existing input stream, called the underlying input stream, and providing additional functionality. The methods of FilterInputStream simply override the methods of InputStream with versions that call the corresponding methods of the underlying stream. You won't much use these classes directly. Some of the filtered streams that are:

1. Buffered streams 2. Data streams 3. Print Stream

You connect filter streams to an underlying stream that supplies the actual bytes of data by passing the original stream to the filter stream's constructor. For example, to create a new DataOutputStream from a FileOutputStream, FileOutputStream fos = new FileOutputStream("ln.txt"); DataOutputStream dos = new DataOutputStream(fos); Buffered Streams Buffering is usually used to increase the efficiency of a stream. The BufferedInputStream is "wrapped" around the underlying stream, a FileInputStream. The first time we call read() on the buffered stream, it fills an internal buffer from the underlying FileInputStream. Subsequent calls to read() return data directly from the buffer, which is faster than reading the file again. The BufferedInputStream constructors let you specify whatever buffer size you want. Data Streams The Date Stream a type of filtered streams is for reading and writing primitive types and objects in a portable way. It gives you access to a range of methods such as readDouble, readInt that will work the same on different platforms. In JDK1.0 this was one of the main ways to access Unicode text, but has been superceded by the Reader classes since JDK 1.1. These classes take an instance of a Stream as a constructor These are conveniently named writeInt(), writeDouble(), writeBoolean(), and so forth. Data written with a DataOutputStream can be read using a DataInputStream using the readInt(), readDouble() and readBoolean() etc. These classes read and write primitive Java data types and Strings in a machine-independent way. (Big-endian for integer types, IEEE-754 for floats and doubles, UTF-8 for Unicode) PrintStream The print stream class is implemented by System.out and System.err. It allows very simple printing of primitive values, objects, and string literals. It uses the platform's default character encoding to convert characters into bytes. This class traps all IOException. However you can test the error status with checkError(). This returns true if an error has occurred, false otherwise. public boolean checkError() The main use of the class is the exceptionally overloaded print() and println() methods. They differ in that println() adds an end-of-line character to whatever it prints while print() does not. Code import java.io.*; public class DIS

{ public static void main(String[] args) { try { FileOutputStream fos = new FileOutputStream("3.txt"); DataOutputStream dos = new DataOutputStream(fos); dos.writeInt(10) ; dos.writeDouble(10.10); dos.writeBoolean(true); dos.close(); fos.close(); FileInputStream fis = new FileInputStream("3.txt"); DataInputStream dis = new DataInputStream(fis); System.out.println(""+dis.readInt()); System.out.println(""+dis.readDouble()); System.out.println(""+dis.readBoolean()); } catch (IOException ie) { ie.printStackTrace(); } } } FileOutputStream The FileOutputStream is used to create an OutputStream that u can use to write bytes to a file. The most common used constructors are: FileOutputStream (String s) FileOutputStream (File f) FileOutputStream (String s, boolean append) This class can throw IOException or SecurityException. IMP: Creating of a file is not dependent on whether the file is already existing or not. This will create another file and incase there is a existing file, the same will be overwritten. Code import java.io.*; public class FOS1 { public static void main(String[] args) { try { String s= "appending here"; byte b[] =s.getBytes(); FileOutputStream fos = new FileOutputStream("1.txt",true);

for(int i=0; i<b.length;i++) { fos.write(b[i]); } fos.close(); } catch (IOException ie) { ie.printStackTrace(); } } }

Character Classes The Streams basically was dealing with bytes and hence the Reader and Writer classes was introduced which is also called as Character Oriented Streams. The important Reader Classes from the Certification point of view are

a) File Reader b) BufferedReader

Both the above classes are similar to the byte oriented streams. Code import java.io.*; public class FReader { public static void main(String[] args) { try { FileReader fr= new FileReader("1.txt"); FileWriter fw = new FileWriter("5.txt"); int i; while ((i=fr.read())!=-1) { System.out.print((char)i); } } catch (IOException ie) { ie.printStackTrace(); } } }

Corresponding to the Reader classes, the important classes from the certification point of view are

a) FileWriter b) BufferedWriter

Code import java.io.*; public class FReader { public static void main(String[] args) { try { FileReader fr= new FileReader("1.txt"); FileWriter fw = new FileWriter("5.txt"); int i; while ((i=fr.read())!=-1) { System.out.print((char)i); } } catch (IOException ie) { ie.printStackTrace(); } } } Code import java.io.*; public class ISReader { public static void main(String[] args) { try { System.out.println("Enter the first number "); BufferedReader br= new BufferedReader(new InputStreamReader(System.in)); String s = br.readLine(); int i =Integer.parseInt(s); System.out.println("Enter the second number "); s = br.readLine(); int j =Integer.parseInt(s);

int k = i + j; System.out.println("The total is: "+k); } catch (IOException e) { e.printStackTrace(); } } } The above code is important since we are using the System.in to take the input from the user and for this we always have to wrap System.in in the InputStreamReader class.

Multi Threading This is a concept wherein multiple threads within a single process gets executed. When we start a simple program, the default main is a thread and we can also create threads within it. There are two important methods in any thread, that is the run () in which one will put all the codes that the thread will have to execute and another is the start () method, which makes the thread ready to run. When the thread will start running (execute the run ()) will depend on the Thread Scheduler. What the start () does is that it puts the thread in the ready to run state. There are two types of thread schedulers-

Pre-emptive Scheduler: In this case a thread with will leave the running state in the following three situations.

A thread of higher priority is there in the ready to run state.

A thread yields

A thread sleeps.

In Solaris, the scheduling is pre-emptive, that would mean that any thread should either yield or sleep, or the other threads will never run.

Time Sliced Scheduler: In this scheduler any thread runs for a fixed amount of time and then enter the ready to run state and allows another thread to run, again depending of its priority. This scheduler ensure that all thread will run at some stage anyhow. The dis-advantage of this is that it is non-deterministic – which thread executes at a particular point of time or for how long it will execute.

In Windows 98, threads of equal priority are time sliced.

In java technology, threads are usually preemptive, but not necessarily time sliced (the process of giving each thread an equal amount of CPU time).

The Thread Class and the Runnable Interface

There are two ways how to make a thread execute and that is by extending the Thread Class or by implementing the Runnable Interface. Infact the whole of java’s multithreading system is built upon the Thread class, its methods and its companion interface, Runnable. The main Thread

When a java program starts up, one thread begins running simultaneously. This is usually called the main thread of your program, because it is the one that is executed when your program begins. The main thread is important for two reasons:

It is the thread from which other threads will be spawned. The main thread must be the last thread to finish execution. When the main thread stop, the program stop.

Examples of creating Threads, by extending the Thread Class and by implementing Runnable Interface class Thread1 extends Thread { public static void main(String[] args) { Thread1 x= new Thread1(); x.start(); for (int i=0;i<500;i++) { System.out.println("Main="+i); } } public void run() { for (int j=0;j<500;j++) { System.out.println("Run="+j); } } } class TestThread2 implements Runnable { public static void main(String[] args)

{ TestThread2 x2 = new TestThread2(); Thread t = new Thread(x2); t.start(); for(int i=0;i<10;i++) { System.out.println("Main = "+i); } } public void run() { for(int j=0;j<10;j++) { System.out.println("Run = "+j); } } }