Java’s Memory Management for Objects
In Java, when an object is created, it is stored in a memory location called the Heap. All objects, no matter when, where, or how they are constructed, exist on the heap. Java allocates heap memory space based on how much a specific object requires. When an object is no longer in use, it qualifies for garbage collection when the JVM “sees” that it will never be used again. At this point, the garbage collector will activate, clear the area of any unreachable objects, and free up space so that it can be used again. The Java heap is known as the Garbage-Collectible Heap, and it’s not just any ordinary memory heap. Memory management is handled by Java, and as a programmer, you don’t need to worry about it. This feature of Java helps to prevent memory leaks and simplifies memory management, making Java a popular choice among programmers.
How does Java manage memory for objects?
When an object is created in Java, it is stored in a memory location called The Heap. No matter when, where, or how they are constructed, all objects exist on the heap. The Java heap is known as the Garbage-Collectible Heap, and it’s not just any ordinary memory heap. Java allocates heap memory space when you create an object based on how much that specific object requires. A hypothetical object with 15 instance variables will likely require more space than a hypothetical object with just two instance variables. But what happens if you have to take that space back? When you’re finished with an object, how do you remove it from the heap? That memory is handled by Java for you! An object qualifies for garbage collection when the JVM “sees” that it will never be used again. Additionally, if you run out of memory, the garbage collector will activate, clear the area of any unreachable object, and free up space so that it can be used again. You’ll learn more about how this works in upcoming tutorials.
Global Methods and Variables in Java
In Java, there is no concept of “global” methods and variables. However, there are situations where a method or constant needs to be accessible to all code running in a program. To achieve this, you can declare a method or variable as public and static. This will make it behave similarly to a global method or variable, as it can be accessed by any code in any class. If a variable is declared as public, static, and final, it becomes a globally accessible constant. It’s important to keep in mind that in Java, static elements are the exception rather than the norm, and they are used to represent unique situations where there aren’t any further instances or objects. Overall, the use of public and static methods and variables can make it easier to access important functionality and constants throughout a program without having to pass them around as parameters.
What if I need global variables and methods? If everything has to be done in a class, how can I achieve that?
In a Java OO program, there is no concept of “global” variables and methods. However, in actual use, there are times when you want a method (or a constant) to be accessible to all code running across your program. Consider the random() method in the Tic-Tac-Toe game; it can be called from any location. Another option is a constant like pi. In a future tutorial, you’ll discover that making a method public and static causes it to act very similarly to a “global.” A public static method in your application can be accessed by any code in any class.
Additionally, if a variable is declared public, static, and final, it effectively becomes a globally accessible constant.
Object-Oriented Programming and Static Elements in Java
In Java, everything is contained in a class, making it an object-oriented programming (OOP) language. OOP emphasizes the creation of objects, which are instances of classes that encapsulate data and behavior. While Java doesn’t support global variables or functions, it has static elements, such as static methods and static variables. Static elements are like global functions and data, but they are accessed using a class name instead of an object reference. Static elements don’t belong to any particular object and can be used by any code running in the program. However, they are typically used sparingly because they don’t adhere to the principles of OOP, which prioritize encapsulation and data hiding.
Then how is this object-oriented if you can still make global functions and global data?
To begin with, everything in Java is contained in a class. As a result, even though they are both static and public, the random() function and the constant pi are specified in the Math class. Additionally, you must keep in mind that in Java, static (global-like) elements are exceptions. They illustrate a particularly unique situation in which there aren’t any further instances or objects.
Delivering a Java Program
To deliver a Java program, you need to provide the necessary class files to the end user. If the end user already has a Java Virtual Machine (JVM) installed on their computer, they can simply run the program by executing the main class file. However, if they do not have a JVM installed, you will need to provide a JVM with your application’s classes so they can run the program. One way to package your classes and JVM is to create a Java Archive (.jar) file, which is a compressed file format based on the pkzip format. You can also include a manifest file within the jar file that specifies which class has the main method to be executed. This makes it easier to distribute and run the program on different platforms. Additionally, you can use installation applications to bundle the jar file and JVM together and provide an installer for the end user.
What is a Java program? What do you actually deliver?
A Java program is a pile of classes (or at least one class). One of the classes in a Java application needs to contain a main() method, which is used to launch the application. As a result, you create one or more classes as a programmer.
You deliver those classes, after all. You’ll also need to include a JVM with your application’s classes if the end user doesn’t have a JVM so they can run your program. You can package your classes with a variety of JVMs (for example, for different platforms) and put everything on a CD-ROM using a number of installation applications. If they don’t already have it on their computer, the end user can then install the correct version of the JVM. Do not worry if you do not understand some terms used here. We will explain to them as we go further.
Bundling Multiple Classes into a Java Archive (JAR) File
What if I have a hundred classes? Or a thousand Isn’t that a big pain to deliver all those individual files? Can I bundle them into one Application Thing?
Yes, it would be a major hassle to send your end users a great number of separate files, but you won’t have to. Your entire application can be contained in a Java Archive (.jar file), which is based on the pkzip format.
A simple text file formatted as something called a manifest can be included in the jar file to specify which class in the jar has the main() method that should be run.
Key Points of Object-Oriented Programming in Java
- With object-oriented programming, you may add new functionality to an existing program without changing the previously tested, functioning code.
- All code in java is defined in a class.
- A class outlines the creation process for an object of that class type. A class is comparable to a blueprint.
- An object can take care of itself; you don’t need to know or give a damn how it does it.
- An object knows things and does things.
- Instance variables are things that an object knows about itself. They represent an object’s state.
- Methods are the actions that an object takes. They represent an object’s behavior.
- When you create a class, you should also create a separate test class that you will use to create objects of your new class type.
- Instance variables and methods can be inherited by a class from a more abstract superclass.
- A Java program is nothing more than objects “talking” to one another during runtime.
