- Java Programming Basics
- Java Tutorial
- Java Overview
- Java Environment Setup
- Java Program Structure
- Java Basic Syntax
- Java First Program
- Java Constants
- Java Separators
- Java Keywords
- Java Data Types
- Java Data Types
- Java Integers
- Java Floating Point
- Java Characters
- Java Booleans
- Java Numbers
- Java Programming Variables
- Java Variables
- Java Variable Types
- Java Variable Scope
- Java Type Conversion
- Java Type Casting
- Java Auto Type Promotion
- Java Type Promotion Rules
- Java Programming Arrays
- Java Arrays
- Java One Dimensional Array
- Java Multidimensional Array
- Java Programming Operators
- Java Operators
- Java Arithmetic Operators
- Java Increment Decrement
- Java Bitwise Operators
- Java Left Shift
- Java Right Shift
- Java Relational Operators
- Java Boolean Logical Operators
- Java Ternary(?) Operator
- Java Operator Precedence
- Java Control Statements
- Java Decision Making
- Java if if-else if-else-if
- Java switch Statement
- Java Loops
- Java while Loop
- Java do-while Loop
- Java for Loop
- Java for-each Loop
- Java Nested Loops
- Java break Statement
- Java continue Statement
- Java Class Object Method
- Java Classes and Objects
- Java Class
- Java Object
- Java new Operator
- Java Methods
- Java Constructors
- Java this Keyword
- Java Stack
- Java Overloading Recursion
- Java Method Overloading
- Java Constructor Overloading
- Java Object as Parameter
- Java Call by Value Reference
- Java Returning Objects
- Java Recursion
- Java Modifier Types
- Java Encapsulate Poly String
- Java Encapsulation
- Java Polymorphism
- Java Nested Inner Class
- Java Strings
- Java Command Line Arguments
- Java Variable Length Arguments
- Java Inheritance Abstraction
- Java Inheritance
- Java super Superclass
- Java Multilevel Hierarchy
- Java Method Overriding
- Java Abstraction
- Java Packages Interfaces
- Java Packages
- Java Access Protection
- Java Import Statement
- Java Interfaces
- Java Programming Exceptions
- Java Exception Handling
- Java try catch
- Java throw throws
- Java finally Block
- Java Built In Exceptions
- Java Exception Subclasses
- Java Chained Exceptions
- Java Multithreading
- Java Multithreading
- Java Thread Model
- Java Main Thread
- Java Create Thread
- Java Thread Priorities
- Java Synchronization
- Java Inter Thread Communication
- Java Suspend Resume Stop Thread
- Java Get Thread State
- Java Enum Autobox Annotation
- Java Enumerations
- Java Type Wrappers
- Java Autoboxing
- Java Annotation
- Java Marker Annotations
- Java Single Member Annotation
- Java Built In Annotations
- Java Type Annotations
- Java Repeating Annotations
- Java Data File Handling
- Java Files I/O
- Java Streams
- Java Read Console Input
- Java Write Console Output
- Java PrintWriter Class
- Java Read Write Files
- Java Automatically Close File
- Java Programming Advance
- Java Date and Time
- Java Regular Expressions
- Java Collections Framework
- Java Generics
- Java Data Structures
- Java Network Programming
- Java Serialization
- Java Send Email
- Java Applet Basics
- Java Documentation
- Java Programming Examples
- Java Programming Examples
Java Class
The most important thing to understand about class is that it defines a new data type. Once defined, this new type can be used to create objects of that type. Therefore, a class is a template for an object, and an object is an instance of the class because an object is an instance of a class, you will often see the two words, object and instance used interchangeably.
When you define a class in Java, you declare its exact form and nature. You do this by specifying the data that it contains and the code that works on that data. While very simple classes may contain only code or only data, most real-world classes have both. As you will see, a class code defines the interface to its data.
Java class Keyword
A class is declared by the use of the class keyword.
The classes that have been used up to this point are actually very limited illustrations of its complete form. Classes can (and usually do) get much more complex.
A simplified form of a class definition is shown below :
class classname { type instance-variable1; type instance-variable2; //... type instance-variableN; type methodname1(parameter-list) { // body of the method } type methodname2(parameter-list) { // body of the method } //... type methodnameN(parameter-list) { // body of the method } }
The data, or the variables defined within a class are called instance variables.
The code is obtained within the methods. Collectively, the methods and the variables defined inside a class are called members of the class.
In most classes, the instance variables are acted upon and accessed through the methods defined for that class. Thus, as a general rule, it is methods that determine how a class data can be used.
Java Instance Variables
Variables defined within a class are called instance variables because all instance of the class (i.e., all object of the class) contains its own copy of these variables. Therefore, the data for one object is unique and separate from the data for another.
All methods have same general form as main(), which we have been using so far. Nevertheless, most methods will not be specified a static or public.
Notice that the common form of a class does not specify a main() method. Java classes do not need to have a main() method. You only define one if that class is the starting point for your program. Further, some kinds of Java applications, such as applets, don't require a main() method at all.
Simple Java Class
Now let's start our study of a class with a simple example. Here is a class called Box that defines these three instance variables:
- width
- height
- depth
Currently, Box does not have any methods (but some will be added soon).
class Box { double width; double height; double depth; }
As stated, a class defines a new data type called Box in this case. You will use this name to declare objects of type Box.
It is significant to remember that a class declaration only creates a template, it does not create an actual object. Therefore, the preceding code does not cause any objects of type Box to come into existence.
To actually create a Box object, you will use a statement as shown here:
Box mybox = new Box(); // creates a Box object called mybox
After above statement executes, mybox will be an instance of Box. Thus, it will have "physical" reality. For the moment, don't worry about the details of above statement.
As discussed earlier, each time you create an instance of a class, you are creating an object which contains its own copy of each instance variable defined by the class. Therefore, every Box object will also contain its own copies of the instance variables width, height, and depth. You will use the dot operator (.) to access these variables.
The dot operator (.) links the name of the object with the name of an instance variable. For instance, to assign the width variable of mybox, the value 100, you would use the following statement :
mybox.width = 100;
Above statement tells the compiler to assign the copy of width that is contained within the mybox object the value of 100.
In common, you use the dot operator to access both the instance variables and the methods within an object. One another point: Even though commonly referred to as the dot operator, the formal specification for Java categorizes the . as a separator. Nevertheless, as the use of the term "dot operator" is widespread.
Java class Example
Following is a complete program that uses Box class :
/* Java Program Example - Java Classes * Call this file BoxDemo.java */ class Box { double width; double height; double depth; } /* class that declares an object of type Box */ class BoxDemo { public static void main(String args[]) { Box mybox = new Box(); double vol; /* assign the values to the mybox's instance variables */ mybox.width = 100; mybox.height = 200; mybox.depth = 150; /* now compute the volume of the box */ vol = mybox.width * mybox.height * mybox.depth; System.out.println("Volume is " + vol); } }
You should call the file that contains this program BoxDemo.java, since the main() method is in the class called BoxDemo, not the class called Box.
When you compile this program, you will find that the two .class files have been created, one for the Box and one for the BoxDemo class. The Java compiler automatically places each class into its own .class file. It is not necessary for both Box and BoxDemo to actually exist in the same source file. You could put each class in its own file, named Box.java and BoxDemo.java, respectively.
To run above program, you must execute BoxDemo.class. When you do this, you will see the following output:
As told earlier, each object has its own copies of the instance variables. This means that if you have two Box objects, each having its own copy of , and height, width, and depth.
It is important to understand that changes to the instance variables of one object have none effect on the instance variables of another. For instance, the following program declares the two Box objects :
/* Java Program Example - Java Classes * This program declares two Box objects */ class Box { double width; double height; double depth; } class BoxDemo { public static void main(String args[]) { Box mybox1 = new Box(); Box mybox2 = new Box(); double vol; /* assign the values to the mybox1's instance variables */ mybox1.width = 100; mybox1.height = 200; mybox1.depth = 150; /* assign different values to the mybox2's instance variables */ mybox2.width = 30; mybox2.height = 60; mybox2.depth = 90; /* compute the volume of the first box */ vol = mybox1.width * mybox1.height * mybox1.depth; /* print the volume of the first box */ System.out.println("Volume of first box is " + vol); /* compute the volume of the second box */ vol = mybox2.width * mybox2.height * mybox2.depth; /* print the volume of the second box */ System.out.println("Volume of second box is " + vol); } }
When the above Java program is compile and executed, it will produce the following output:
As you can see, from the above output, mybox1's data is completely separate from the data contained in mybox2.
« Previous Tutorial Next Tutorial »