Gain insights into Java, a versatile and portable programming language. Delve into similarities with C++ and Python and learn essential Java-specific features with practical coding examples.

Looking to jump into a new programming language? Java is an easy-to-use, highly portable and ubiquitous language that is used for a variety of development purposes such as Android applications,  desktop applications, and website backend systems. Designed for programmers who are already familiar with coding in languages such as C++, Python, or other similar languages, this course articulates any Java-specific details that programmers need to know to get acquainted with the language and also highlights similarities and differences between Java and other languages through multiple coding examples.

The Complete Java Crash Course

We have seen that classes are the organizational unit of a Java program. Source code for methods is always within a class, and we might expect related methods to be in the same class. 

However, classes do much more than this, and are the heart of object-oriented programming in Java:

1) A class is used to define the **custom data structure** that makes up an object.
2) Classes define **methods** that act on those objects.

Here's an example of creating a custom data type, `Circle`, to store information about a circle: 

// include educative's simple graphics library:
import com.educative.graphics.*;

class Circle {
  public int x;
  public int y;
  public int r;
}

class CircleTest {
  public static void main(String[] args) {
    Circle circ;   // declare a variable to store a reference to Circle object
    
    // create a new Circle object in memory, and store a reference to it:
    circ = new Circle(); 
    
    // set values for the instance variables for the circle:
    circ.x = 100;
    circ.y = 100;
    circ.r = 50;
    
    // Create a Canvas object for drawing on the screen:
    Canvas c = new Canvas(200, 200);
    c.fill("yellow");
    c.stroke("black");
    
    // use instance variables of the the circle object when calling
    //  the circle method of the canvas (used to draw the circle)
    c.circle(circ.x, circ.y, circ.r); 
  }

}




Notice that there are two different classes defined in this file. Typically in Java, each class would get its own file, with the name of the file `ClassName.java`. So `Circle` might be defined in a class `Circle.java`. This is a good convention and we should follow it; the classes are in the same file here only because it is easier to read on the web page.

# A class declares what instance variables an object of that class will contain

Just like in Javascript, Python, or C++, an object is a data structure stored on the heap area of memory, containing data elements. These elements are called **instance variables** in Java. A class definition lists out the types and names that each object of that class will have. So each `Circle` object will contain three `int` values: `x`, `y`, and `r.`.

In Python or Javascript, instance variables of an object are created using a special constructor method. Java also has constructors, but in Java, variables must be declared before they can be used or assigned values to -- even the constructor cannot create a new variable that has not been explicitly declared.

In Java, **every instance variable must be declared in the class.** Notice that the declarations for the instance variables occur **outside** of any method in `class Circle`: the class just lists them out. That's because variables declared inside of method definitions are local variables, and are destroyed once the method returns.

Also notice the keyword **public** before each of these instance variables. This indicates that methods of other classes can access these variables. We'll see more later about the difference between public and private variables or methods. 

# Creating an object of a class

Although a class describes the instance variables of an object, no instance variables exist until an object of the class is created. The command `new`, which must be followed by a call to the constructor of a class, creates space on the heap for the object, and returns a reference to that object:

<pre>
<code>
Circle circ;
circ = new Circle(); 
</code>
</pre>

You can think of the reference as the address of the object in memory. So the above code creates a new object on the heap with the code `new Circle()`, and stores a referene to that object in the variable `circ`. Like every other variable in Java, `circ` must have a type. The declaration `Circle circ` creates the variable and indicates that it will store a reference to an object of type `Circle`.

You might notice that there is no definition for a function or method `Circle()` anywhere in the code. Java creates a *default constructor* function for you automatically, with the same name as the name of the class.









A class is used to define the custom data structure that makes up an object of that class.

Hello, Java!

Variables and expressions

Flow of control: loops and conditionals

Classes, objects, and methods

Challenge project: tetrominos

Classes define objects

A class declares what instance variables an object of that class will contain