Learn Ms office online CIT student notes

Java has been designed with security and portability in mind. The features of the language make writing distributed applications much easier.

Java is a truly Object Oriented language. Object-oriented design is very powerful because it facilitates the clean definition of interfaces and makes it possible to provide reusable code.

Java source code is compiled into byte codes for the Java Virtual Machine specification...

Java was based on C++, and the syntax is very similar, so programmers who know C++ will have little difficulty adopting Java. But Java is much simpler than C++; the best way to describe the simplicity of Java is to talk about some of the things that were omitted. Sun believed that a lot of the features of C++ were more of a preventing to programmers than they were a benefit. These features were omitted from the language design without a loss of functionality. The most important features of C++ that are absent from Java are operator overloading and pointer arithmetic. There is no direct manipulation of pointers in Java. The language handles garbage collection for you. To sum up on the simplicity issue, Java is a full-service language without the endless special cases and exceptions plaguing C++.

A software design method that models the characteristics of abstract or real objects using classes and objects.

In the Java language, a type that defines the implementation of a particular kind of object. A class definition defines instance and class variables and methods, as well as specifying the interfaces the class implements and the immediate superclass of the class.

A class is a reference name or label of a plan that consist of different objects.

A class is the plan or design for an object, Similar in concept to the blueprints for a car.

A method that creates an object. In the Java language, constructors are instance methods with the same name as their class. Java constructors are invoked using the new keyword.

An object of a particular class. In Java programs, an instance of a class is created using the new operator followed by the class name.

In the Java language, a group of methods that can be implemented by several classes, regardless of where the classes are in the class hierarchy.

The principle building blocks of object-oriented programs. Each object is a programming unit consisting of data (instance variables) and functionality (instance methods). See also class.

In the Java language, a group of classes. Packages are declared with the package keyword.

Any method that can be invoked using the name of a particular class. Class methods affect the class as a whole, not a particular instance of the class. Class methods are defined in class definitions. See also instance method.

A data item associated with a particular class as a whole--not with particular instances of the class. Class variables are defined in class definitions.

Using one identifier to refer to multiple items in the same scope. In the Java language, you can overload methods but not variables or operators.

Machine-independent code generated by the Java compiler and executed by the Java interpreter.

Command	Description	Syntax/Examples
class	Use to declare a class	class identifier-name { statements }
public	A Supporting command that used with class and with other commands use to specify that the related class code is globally accessible.	1). public class identifier { statements } 2). public static void main(String [] args) { statements }
static	Use to specify that the related function/code/parameters is remains same when program executes.	public static void main(String [] args)
import	Use to include built-in Java packages (consist of classes/methods definition) with program.	import java.lang; import java.io.; import java.awt.;
main()	A built-in method in Java that must use when you want to develop a Java Application program.	public static void main(String[] args)
system.out.print	A built-in method in Java that is use to display your identifiers values on console/monitor, not perform line feed + carriage return operation.	System.out.print("Hello"); System.out.print("====");
system.out.println	A built-in method in Java that is use to display your identifiers values on console/monitor, perform line feed + carriage return operation.	System.out.println("Hello World!"); System.out.println("====");
if	If is use to specify a condition in Java program. The if statement checks the expression value (which returns a boolean) and if the expression value is true, it executes the statement block otherwise the execution block is skipped.	int a=0,b=10; If (a<b) { System.out.print("Variable A is less than B");} Else System.out.print("Variable B is less than A");} /***syntax*/ if(expression) { statements;} else {statements;}
for	Iterative controls structure in Java Language that is use to specify a loop in Java program. In for method first argument is use to assign a value to counter; 2^nd argument is use to specify a condition; and third argument is is use to define the increment/decrement in counter.	for (int I=0;I<=10;I++) { System.out.print(a);} /*** OR*********/ for (int I=0;I<=10;) { System.out.print(a); I++;}
While	Iterative controls structure in Java Language that is use to specify a conditional loop in Java program.	i=10; while ( i>0) { System.out.print(i);i--;}

Java Virtual Machine: The Java virtual machine(JVM) is the heart of Java. The JVM is a virtual computer that resides in memory and enables a Java program to be executed on a variety of platforms.

For a Java program to run an application, it must have at least one public class that contains a public static method called main() that takes exactly one parameter, an array of string objects. The main() method must be public so that the Java virtual machine can find it. If the method is not public, its name is not included in the compiler’s output. The system does not create any objects prior to the start of the application’s main() method must be static because it cannot be associated with an object.

If an application has a graphical user interface, then it typically creates a java.awt.Frame object in main(). The Frame object acts as the top level window for the application.

Identifier: An identifier is generally used as the name for any thing in a program. A few identifiers are reserved by Java for special uses, these are called Keywords.

Memory Variable: A variable is a named piece of memory that you use to store information in your Java program.

Variable Names: The name that you choose for a variable, or indeed the name of that you choose for anything in Java is called an identifier. An identifier can be any length, but it must start with a letter, an underscore a dollar sign($). The rest of an identifier can include any characters except those used as operators in Java (such as +,-,or *).

Java is case sensitive so the names NAME and Name are not the same. You must not include blanks or tabs in the middle of a name. You cannot be anything like keywords in Java as a name of same thing. A name can’t be 1234 or 37.5 constant can also be alphabetic, such as true and false for example.

Each variable that you declare can store values of a type determined by the data type of that variable. You specify the type of a particular variable by using a type name in the variable declaration.

There are eight basic data types, defined with in the Java language. These fundamentals types, also called primitives, allow you to define variables for storing data that falls into one of three categories:

Integer Data Types: There are four types of variables that you can use to store integer data. All of these are signed. That is they can store both negative and positive value. The four integer differ in the range of value they can store. So the choice of type for a variable depends on the range of data values you are likely to need. The four integer types in Java are:

byte Variables of this type can have value form –128 to +127 and occupy 1 byte(8

Array: - Arrays are List of similar data items OR list of homogeneous data items.

Java uses arrays in a much different manner than other languages. Instead of being a structure that holds variables, arrays in Java are actually objects that can be treated just like any other Java object. The powerful thing to realize here is that because arrays are objects that are derived from a class, they have methods you can call or manipulate the array. The current version of the Java language only supports the length method, but you can expect that more methods will be added as the language evolves. One of the drawbacks to the way Java implements arrays is that they are only one-dimensional. In most other languages, you can create a two-dimensional array by just adding a comma and a second array size. In Java, this does not work.

Since arrays are actually instances of classes (objects) , we need to use constructors to create our arrays much like we did with strings. First , we need to pick a variable name and declare it as an array object and also specify which data type the array will hold. Note that an array can only hold a single data type. You can’t mix strings and integers within a single array. Here are a few examples of how array variables are declared:

As you can see, those look very similar to standard variable declarations, except for the brackets after the variable name, you could also put the brackets after data type if you think this approach makes your declarations more readable:

There are three ways to set the size of arrays. Two of them require the use of the new operator. Using the new operator initializes all of the array elements to a default value. The third method involves filling in the array elements with values as you declare.

The first method involves taking a previously declared variable and setting the size of the array. Here are a few examples:

Now that you know how to initialize arrays, you’ll need to learn how to fill them with data and then access the array elements to retrieve the data. We showed you a very simple way to add data to arrays when you initialize them, but often this just is not flexible enough for real-world programming tasks. To access an array value, you simply need to know its location. The indexing system used to access array elements is zero-based, which means that the first value is always located at position 0. Let’s look at a little program that first fills in an array then prints it out:

So, how does the program work? We first create our array of integer values and assign it to the intarray variable. Next, we begin a loop that foes from zero to intarraylength-1; by calling the length method of our array, we find the number of indexes in the array. Then , we start another loop that does the calculation aand stores the result in the index specified by he I variable from our initial loop. Now that we have filled in all the values for our array, we need to step back through them and print out the result. We could have just put the print statement in the initial loop, but the approach we used gives us a chance to use another loop that references our array. Here is the structure of an index call:

Pretty simple. If you try and use an index that is outside the boundaries of the array, a run time error occurs. If we change the program to count to an index of 20 instead of 20-1=19, we would end up getting an error message like this:

System.out.println("---------------------------------------------------------------");

Command line arguments are only used with Java applications. They provide a mechanism so that the user of an application can pass in information to be used by the program. command line arguments are common with languages like C and C++, which were originally designed to work with command-line operating system like Unix/some time DOS.

The advantages of using command line arguments is that they are passed to a program when the program first starts, which keeps the program from having to query the user for more information. Command-line arguments are great for passing custom initialization data.

The syntax of passing arguments are extremely simple. Just start your programs as you usually would and add any number of arguments to the end of the line with each one separated by a space. Here is a sample call to a program named "myapp":

In this case, we are calling the Java run-time interpreter and telling it to run the class file "myapp". We then are passing in three arguments: "open", "640",and "480" if you wanted to pass in a longer string with spaces as a argument, you could, in this case, you enclose the string in quotation marks and Java will treat it as a single argument. Here is an example

Once again the name of the program is "myapp". However, this time we are only sending it two arguments: "Nice Program!" and "640x480". Note that the quotes themselves are not passed , just the string between the quotes.

In traditional structured programming languages like C or pascal , everything revolves aroud the concepts of algorithms and data structures. The algorithms are kept seprate from the data structures , and they operate on the data to perform actions and results. To help divide programming tasks into separate units, components like functions and procedures are defined. The problem with this programming paradigm is that it doesn’t allow you to easily create code that can be reused and expanded to create other code.

To solve this problem, object-oriented programming languages like small-talk and C++ were created. These languages introduced powerful components called classes so that programmers could combine functions (operations) and data under one roof. This is a technique called encapsulation in the world of object-oriented programming. Every language that uses classes defines them in a slightly different way; however, the basics concepts for using them remain the same. The main advantages of classes are:

Of course , keep in mind that you won’t always use all of the clauses , such as Doc Comments, Modifier , extends , and so on. For example, here’s an example of a very small class definition:

This class has an identifier , atom_ant, and a body, int a=1; of course , don’t try to compile this at home as is because it will only result in an error. Why ? well , even though it is a valid class , it is not capable of standing on its own. ( you would need to set it up as an applet or a main program to make it work.) A class declaration provides all of the information about a class including its internal data (variables) and functions (methods) to be interpreted by the Java compiler. In addition, class declarations provide:

The abstract modifier is used to declare classes that serve as shell or placeholder for implementing methods and variables. When you construct a hierarchy of classes, your top most class will contain the more general data definitions and method implementations that represent your program’s features. As you work your way down the class hierarchy , your classes will start to implement more specific data components and operations. As you build your hierarchy, you may need to create more general classes and defer the actual implementation to later stages in the class hierarchy. This is where the abstract class comes in. This approach allows you to reference the operation that you need to include without having to restructure your entire hierarchy . the technique of using abstract classes in java is commonly referred to as single inheritance by c++ programmers.( By the way limited multiple inheritance techniques can also be implemented in java by using interfaces.)

The main class, Bug, creates an instance of the Atom_ant class- the a object. Then it uses the object to access the data member, a, which is assigned a value in the Atom-ant class. Notice that the the dot operator(.) is used to access a member of class.

The public modifier is used to define a class that can have the greatest amount of access by other classes. By declaring a class as public, you allow all other classes and packages to access its variables, methods, and subclasses. However, only one public class is allowed in any single java applet as serving the role that the main() function does in a c/C++ program.