Each programming language has its own means of manipulating elements in memory.
Are you manipulating the element directly, or are you dealing with some kind of indirect representation (a pointer in C or C++) that must be treated with a special syntax?
Although you treat everything as an object, the identifier you manipulate is actually a “reference” to an object.
Have a reference doesn’t mean there’s necessarily an object connected to it.
You must create all the objects
The keyword new says, “Make me a new one of these objects.”
Where storage lives
There are five different places to store data:
1.Registers: registers are allocated as they are needed.
2.The Stack: The Java system must know, while it is creating the program, the exact lifetime of all the items that are stored on the stack. Java objects themselves are not placed on the stack.
3.The heap: The compiler doesn’t need to know how long that storage must stay on the heap. Whenever you need an object, you simply write the code to create it by using new, and the storage is allocated on the heap when that code is executed.
4.Constant storage: Constant values are often placed directly in the program code.
5.Non-RAM storage:If data lives completely outside a program, it can exist while the program is not running, outside the control of the program. The two primary examples of this are Streamed Objects and Persistent Objects.
Special case: primitive types
Instead of creating the variable by using new, an “automatic” variable is created that is not a reference.
These sizes don’t change from one machine architecture to another as they do in most languages.
All numeric types are signed.
The “wrapper” classes for the primitive data types allow you to make a non-primitive object on the heap to represent that primitive type.
Java includes two classes for performing high-precision arithmetic: BigInteger and BigDecimal. Neither one has a primitive analogue.
You can do anything with a BigInteger or BigDecimal that you can with an int or float, it’s just that you must use method calls instead of operators.
Arrays in Java
If a program accesses the array outside of its memory block or uses the memory before initialization, there will be unpredictable results.
A Java array is guaranteed to be initialized and cannot be accessed outside of its range.
When you create an array of objects, you are really creating an array of references, and each of those references is automatically initialized to a special value with its own keyword: null.
You never need to destroy an object
Scoping
A variable defined within a scope is available only to the end of that scope.
The C and C++ ability to “hide” a variable in a larger scope is not allowed in Java.
Scope of Objects
The reference s vanishes at the end of the scope. However, the String object that s was pointing to is still occupying memory.
Java has a garbage collector, which looks at all the objects that were created with new and figures out which ones are not being referenced anymore.
Creating new data types: class
Fields and methods
You can put two types of elements in your class: fields ( data members), and methods(member functions).
A field is an object of any type that you can talk to via its reference, or a primitive type.
If it is a reference to an object, you must initialize that reference to connect it to an actual object.
Default values for primitive members
The default values are only what Java guarantees when the variable is used as a member of a class.
This ensures that member variables of primitive types will always be initialized.
Methods, arguments, and return values
Methods in Java determine the messages an object can receive.
The method name and argument list ( the signature of the method) uniquely identify that method.
This act of calling a method is commonly referred to as sending a message to an object.
What you must specify in the argument list are the types of the objects to pass in and the name to use for each one.
As in any situation in Java where you seem to be handing objects around, you are actually passing references.
A program is just a bunch of objects with methods that take other objects as arguments and send messages to those other objects.
Building a Java program
Name visibility
To produce an unambiguous name for a library, the Java creators want you to use your Internet domain name in reverse since domain names are guaranteed to be unique.
This mechanism means that all of your files automatically live in their own namespaces, and each class within a file must have a unique identifier.
Using other components
import tells the compiler to bring in a package, which is a library of classes.
The static keywords
You want to have only a single piece of storage for a particular field, or you need a method that isn’t associated with any particular object of this class.
When you say something is static, it means that particular field or method is not tied to any particular object instance of that class.
Class Data and Class Methods, meaning that the data and methods exist only for the class as a whole, and not for any particular objects of the class.
Since static methods don’t need any objects to be created before they are used, they cannot directly access non-static members or methods by simply calling those other members without referring to a named object.
An important use of static for methods is to allow you to call that method without creating an object.
Your first Java program
When you’re creating a standalone program such as this one, one of the classes in the file must have the same name as the file.That class must contain a method called main( ).
The args won’t be used in this program, but the Java compiler insists that they be there because they hold the arguments from the command line.
Comments and embedded documentation.
Comment documentation
Because of Javadoc, you have a straightforward standard for creating documentation, so you can expect or even demand documentation with all Java libraries.
Syntax
Javadoc will process comment documentation for only public and protected members.
Embedded HTML
Javadoc passes HTML commands through to the generated HTML document.
