Difference between C++ and JAVA:-
1. Java has no preprocessor. If you want to use classes in another library, you say Import and the name of the library. There are no preprocessors-like macros.
2. there are no pointers in the sense of C and C++. When you create an object with new, you get back a reference.
3. there are no destructors in Java. There is no “scope” of a variable per seen, to indicate when the object’s lifetime is ended-the lifetime of an object is determined instead by the garbage collection.
4. There is no GOTO statement in JAVA.
5. No INLINE methods. The java compiler might decide it’s own to inline a method, but you don’t have much control over this. You can suggest inlining in java by using FINAL keyword for a method. However , inline functions are only suggestions to the C++ compiler as well.
6. Java has method overloading that works virtually identically to C++ function overloading.
7. Java doesn’t create exe file after the execution of a program.
8.
9. > In Java, the sizes of int, long etc. are rigidly defined in terms of
10. > bits. In C++ they are platform−dependent.
11. >
12. > In Java, the JVM behaves at if it were big endian, even if internally
13. > it is actually little−endian. In C++, the endianness is platform
14. > dependent.
15. >
16. > In Java, garbage collection of unreferenced objects is automatic. In
17. > C++, you manually manage memory.
18. >
19. > In Java, references are constrained to point only to the beginnings of
20. > objects. In C++, you can do arithmetic on pointers and make pointers
21. > point anywhere in the address space.
22. >
23. > In Java you cannot overload operators. In C++, you can.
24. >
25. > In Java, by default methods are virtual (overrideable). In C++, by
26. > default, methods are non−virtual.
27. >
28. > Java object code (class files containing JVM byte codes) will run
29. > unmodified on any platform. C++ object code must be first linked to
30. > produce an executable containing platform−specific machine
31. > instructions. It will run only on one platform.
32. >
33. > Java checks all subscripts that they are in bounds and all casts for
34. > validity. C++ does not.
35. >
36. > Java requires a JVM to execute. C++ programs are usually freestanding.
37. > Java does not use a preprocessor. C++ makes extensive use of a macro
38. > preprocessor.

Constants and Variables
A quantity, which may vary during a program execution, is called a variable.
A quantity whose value cannot be changed is called Constant.
e.g. in expression c = a + b - 5;
In above expression a, b, c are variables and 5 is constant.

Rules for naming variables in JAVA
(i) A variable name is any combination of alphabets digits or underscore ( _ ). Some compilers allow variable names up to 40-characters in length.
(ii) The first character of the variable name must be an alphabet i.e. it must not be a digit.
(iii) There should not be any blank space or comma within variable name.
(iv) No special symbol other than ( _ ) underscore can be used within variable name e.g. ?,*,+,’ etc.
(v) It should not be a keyword.

Keywords:
Keywords are the words whose meaning has already been explained to the JAVA-Compiler. The keyword cannot be used as variable name because doing so will try to assign a new meaning to keyword, which is not allowed by the compiler. e.g. float, if, int, do, for, break, while, else, switch, class, private, public etc.

Tokens : Token is the smallest part of statement, it may be an operator, variable, constant, punctuation mark or keyword. E.g. the statement if ( a >5)
Above statement has 6 tokens as if , ( , a , > , 5 , )

Identifiers : Identifiers refer to the names of variables, functions, arrays, classes etc. created by the programmer. Each language has its own rules for naming identifiers. The rules for naming identifiers in C / C++ has been given above with heading “Rules naming variables in JAVA”

Writing JAVA Program:
Each JAVA program defines a class. The name of class is same as that of name of .java file in which this source program is to be stored. For core java, there must exist a public function named “main”, receiving command-line-arguments as an array of String class. This member method will be executed when java program is executed. As every java program is definition of a class, therefore, during the execution an object of this class is automatically created and executed “main” method on that object. We cannot execute a java program without class which makes it “pure-object-oriented”. In C++, it supported the object-oriented techniques, but itself C++ was not a pure-object-oriented language because C++ used the procedure “main ( )” as startup method/function, which was not a member of any class. Therefore, it was a procedural language because the program starts from a procedure, now, objects can be declared and used within that procedure but the still it a procedure that invoked the code. In JAVA, a set of statements are written in a method of class, that are executed sequentially to accomplish the task.

Following rules are applicable on all JAVA statements
(i) Blank spaces may be inserted between two words/keywords to improve the readability of the statement. However no blank spaces are allowed within variable, constant or keywords.
(ii) Writing statements in Java language is case sensitive.
(iii) Any Java-Statement always ends with a semicolon
(iv) Remarks can be written using double backslashes ( // ) on the same line
Where ever // appears, whole line after that is ignored by the compiler If we want to add multi line remarks then we use /* ---------- */ to write remarks in between them e.g. /*………………………………………………… ………………………………………………… ………………………………………………… */

Types of Statements/instructions in JAVA
Now, let us see how constants, variables and expressions are combined together to form instructions
There are basically 4-types of instructions:
1. Type Declaration Instructions
2. Input / Output Instructions
3. Arithmetic and logical instructions (Expressions)
4. Control Instructions

Data Types One of the fundamental concepts of any programming language is that of data types. Data types define the storage methods available for representing information, along with how the information is interpreted. Data types are linked tightly to the storage of variables in memory because the data type of a variable determines how the compiler interprets the contents of the memory. You already have received a little taste of data types in the discussion of literal types. To create a variable in memory, you must declare it by providing the type of the variable as well as an identifier that uniquely identifies the variable. The syntax of the Java declaration statement for variables follows: Type Identifier [, Identifier];

The declaration statement tells the compiler to set aside memory for a variable of type Type with the name Identifier. The optional bracketed Identifier indicates that you can make multiple declarations of the same type by separating them with commas. Finally, as in all Java statements, the declaration statement ends with a semicolon. Java data types can be divided into two categories: simple and composite. Simple data types are core types that are not derived from any other types. Integer, floating-point, Boolean, and character types are all simple types. Composite types, on the other hand, are based on simple types, and include strings, arrays, and both classes and interfaces in general. You’ll learn about arrays later in this chapter. Classes and interfaces are covered in Chapter 14, “Classes, Packages, and Interfaces.”
In C++, Data Types are further divided into categories :
(i) Built-in (basic) data types : int, float, char, long int etc.
(ii) use defined data types : class, interface
(iii) derived data types : array, function

Integer Data Types Integer data types are used to represent signed integer numbers. There are four integer types: byte, short, int, and long. Each of these types takes up a different amount of space in memory, as shown in Table 12.4. Table 12.4. Java integer types. * *Type *Size

byte 1 byte short 2 byte int 4 byte long 8 byte To declare variables using the integer types, use the declaration syntax mentioned previously with the desired type. The following are some examples of declaring integer variables: int i; short rocketFuel; long angle, magnitude; byte red, green, blue;

Floating-Point Data Types Floating-point data types are used to represent numbers with fractional parts. There are two floating-point types: float and double. The float type reserves storage for a 32-bit single-precision number and the double type reserves storage for a 64-bit double-precision number. Declaring floating-point variables is very similar to declaring integer variables. The following are some examples of floating-point variable declarations: float temperature; double windSpeed, barometricPressure;

*Type *Size

single 4 bytes Double 8 bytes boolean Data Type The boolean data type is used to store values with one of two states: true or false. You can think of the boolean type as a 1-bit integer value, because 1 bit can have only two possible values: 1 or 0. However, instead of using 1 and 0, you use the Java keywords true and false. true and false aren’t just conveniences in Java; they are actually the only legal Boolean values. This means that you can’t interchangeably use Booleans and integers like in C/C++. To declare a Boolean value, just use the boolean type declaration: boolean gameOver;

Character Data Type The character data type is used to store single Unicode characters. Because the Unicode character set is composed of 16-bit values, the char data type is stored as a 16-bit unsigned integer. You create variables of type char as follows: char firstInitial, lastInitial;

Remember that the char type is useful only for storing single characters. If you come from a C/C++ background, you might be tempted to try to fashion a string by creating an array of chars. In Java this isn’t necessary because the String class takes care of handling strings. This doesn’t mean that you should never create arrays of characters, it just means that you shouldn’t use a character array when you really want a string. C and C++ do not distinguish between character arrays and strings, but Java does.