View source for Basic Java Language

This lesson discusses the basics of the Java language, including variables, primitives, operators, statements and Java writing conventions.
{{ntnes}}
== Touch on Classes ==
Everything in Java is written in classes. A Class in this context is a section of code that can contain data (variables), and instructions for processing that data (methods). Returning to the Hello World example from the [[Introduction to Java]], the class is defined on the first line, and everything within the curly brackets is within that class.

<source lang="java">
public class HelloWorld 
{
     public static void main (String[] args) 
     {
          System.out.println("Hello World!");
     }
}
</source>

The first line is always of the general form:

<pre>
[Protection] class [Name] [Extend/Implements...]
{
     /*Class Code Here*/
}
</pre>

===Protection or Access Levels===
Java provides two types of access levels.
* Class access: ''public'' or package level (no modifier)
* Member access: ''public'', ''protected'', package (no modifier or default), and ''private''

A class with ''public'' modifier is visible by all other classes. Class with no modifier has package level protection. It means that only other classes within the same package can see it. 

Member access levels control visibility of member data or methods from its own class, within package, subclass, or the world. See table below for the summary. 

However, in order to get started without being bogged down by choosing one, just declare all of your classes as <code>public</code>. The idea behind protection is that, if only the class itself can make changes to the data stored within itself, the other parts of the program do not need to know where the data is coming from or how it is stored. This is great for two reasons, firstly, it is easy to rewrite the structure of a class without changing the external application, and secondly it allows the class to make assumptions about the data, and do slightly less exception handling. You should know that if your code tried to break the protection of a class, the java compiler will stop and report an error.

<center>
{| class="wikitable"
|+'''Access Levels'''
|-
|width="70"|'''Modifier'''||width="70"|'''Class'''||width="70"|'''Package'''||width="70"|'''Subclass'''||width="70"|'''World'''
|-
|public||style="background-color:#F0FFF0"|Y||style="background-color:#F0FFF0"|Y||style="background-color:#F0FFF0"|Y||style="background-color:#F0FFF0"|Y
|-
|protected||style="background-color:#F0FFF0"|Y||style="background-color:#F0FFF0"|Y||style="background-color:#F0FFF0"|Y||style="background-color:#FFE4E1"|N
|-
|no modifier||style="background-color:#F0FFF0"|Y||style="background-color:#F0FFF0"|Y||style="background-color:#FFE4E1"|N||style="background-color:#FFE4E1"|N
|-
|private||style="background-color:#F0FFF0"|Y||style="background-color:#FFE4E1"|N||style="background-color:#FFE4E1"|N||style="background-color:#FFE4E1"|N
|}
</center>

===class===
This is the bit that tells the Java compiler we are writing a new class, the only slightly notable thing about it is that it must be written in small letters. It is not <code>Class</code>!
===Name===
This is the name by which you will reference your class when you use it in your code, it can be called almost anything you want, containing numbers, letters and underscores, though it must start and end with a letter. One thing to watch out for, is that, like everything in Java, it is case sensitive. This means that <code>Hello</code> is not the same as <code>hello</code>. You could, if you wanted have two different classes, one called <code>hello</code> and the other called <code>HeLlO</code>, however this might get confusing and so is strongly discouraged. In fact, in order to try and make things less confusing, there is a convention amongst Java programmers that all words in a class name start with a capital letter, and the rest are lower case letters. ''eg.'' <code>public class VeryUseful</code> or <code>public class CompanyDepartment</code>

===Extends/Implements===

Extends/Implements not complete yet. Soon..

== Statements ==
All operations are done in statements. Every statement ends in a semicolon: ;. Statements can set a variable with the '=' operator. This sets the variable you wish to set to another variable or a value. Values can only be used on primitive types.  As you saw in the HelloWorld program, there was one statement: <code>System.out.println("Hello, World")</code>. This is one type of statement called "calling a method". More will be discussed later. Finally, you can declare a variable. If a class has no statements, it would do nothing.

== Comments ==
Comments are short notes that the developer can insert into their code. This allows the developer to keep track of their code and helps when developers are collaborating on a project. It is good to write a summary of the following code at the beginning of your methods, classes, etc. The Java compiler completely ignores comments, so you can say anything in them.

Comments are written using two forward slashes 	 
<source lang="java">// This is a comment</source>
Comments can be written at the end of a line 	 
<source lang="java">System.out.println("I love comments"); // This is also a comment</source>
Comments can also be written on multiple lines by starting with '''/*''' and ending with'''*/'''.

<source lang="java">
/*
Comment 1 	 
Comment 2 	 
Comment 3
*/
</source>

A multi-line comment that opens with two asterisks

<source lang="java">
/**
 * Like this
 */
</source>

is called a '''[[Wikipedia:Javadoc |Javadoc comment]]'''.  These comments are used to generate documentation for your code, and they generally appear at the beginning of a class or a method definition.  A special program (also named javadoc) can be used to automatically create documentation from the Javadoc comments, usually in the form of a set of HTML files.  It is generally good practice to fully document your code by using Javadoc comments, but it is not required. We will use comments to document and explain our code from now on.

== Variables ==
Variables are used to store information in a computer's memory. Like its name implies, variables are values that can be changed. There are two main categories of variables: reference variables and primitive variables. Reference variables are place holders for objects (More on objects in Lesson 4, Java Objects and Classes.) Primitive variables are given a value of a primitive data type, a fundamental value. Variables are all given a type when they are declared, such as "int" or "float".

=== Declaring Variables ===
To declare a variable, use this syntax:
<pre>
[protection] [classname] [identifier]
</pre>
This is one type of statement. The class name is the type of variable you want. Currently, you will only use basic primitive variables, but you will learn about objects soon. Here is an example of declaring a variable:
<pre>
public int myInt
</pre>
myInt has protection of public. It is of class int, or Integer (see Primitive Types). int is a class in Java. When you say that, you are basically making a primitive object.

=== Primitive Data Types ===
Primitives are the simplest type of data. The following table shows all the types of primitives.
<center>
{| border=1 cellspacing=0 cellpadding=5
| '''Primitive'''
| '''Description'''
| '''Values'''
|-
| byte
| A brief, 8-bit integer
| Integer numbers -128 through 127
|-
| short
| A short, 16-bit integer
| Integer numbers -32,768 through 32,767
|-
| int
| A 32 bit integer
| Integer numbers -2,147,483,648 through 2,147,483,647
|-
| long
| A long, 64 bit integer
| Integer numbers -9,223,372,036,854,775,808 through 9,223,372,036,854,775,807
|-
| float
| Single-precision floating point (32-bit IEEE 754)
| Smallest positive non-zero: 14e<sup>-45</sup>, Largest positive non-zero: 3.4028234e<sup>38</sup>
|-
| double
| Double-precision floating point (64-bit IEEE 754)
| Smallest positive non-zero: 4.9e<sup>-324</sup>, Largest positive non-zero: 1.797693157e<sup>308</sup>
|-
| char
| A single character
| All Unicode characters
|-
| boolean
| A Boolean value(1-bit)
| '''true''' or '''false'''
|}
</center>


Using what you have learned, you may have guessed how to create these primitives:

<code>long myLong;</code>
<code>double myDouble;</code>

== Operators ==
Operators are the symbols defining a certain operation to be performed.

=== Assignment Operators ===
An assignment operator assigns a value to a certain variable after evaluating the expression to be assigned. 

The assignment operator, "=",  sets the variable on its left equal to the value on its right. This code creates the variable ''a'' and sets it equal to 5
<source lang="java">int a;
a = 5;
</source>
Fairly simple, right? Here is where it can get a slightly more tricky.

<source lang="java">
int a;
int b;
b = 6;
a = b; //a equals 6
</source>

At first glance, you might think that the last statement is setting ''a'' equal to the letter "b", but instead it is setting ''a'' equal to the ''value'' of ''b'', which is 6. Essentially, a holds the value of 6. You can also set a variable and declare it on the same line:

<source lang="java">
int a = 6;
</source>

However, you can't say <code>char myChar = y;</code> to set a character to 'y'. That would set the character variable <code>myChar</code> to the value stored in the character variable <code>y</code>. To set <code>myChar</code> equal to the character <i>y</i>, use a '''character literal''' — a technical term for "a character in single-quotes": <code>char myChar = 'y';</code>. Note that a <code>char</code> primitive can only hold a single character. <code>char myChar = 'Yo';</code> is illegal.

Finally, what's so special about <code>float</code>s and <code>double</code>s? Doubles and floats can have decimals: <code>float myFloat = 5.1;</code>. (The term "float" is short for "floating-point number," referring to the decimal point.)

Now, why would you want to set a variable? You would need to set a variable for further use, i.e., to access at a later time.

=== Addition Operator '+' ===
The addition operator returns the sum of the the values to the left, and the value to the right of it.

If you want to evaluate the expression 23 plus 75, you would type:
<pre>
23+75
</pre>

The addition operator also works with variables:
<pre>
myInt+yourInt
</pre>

Note, this operator is not to be confused with the concatenation operator, which we will discuss later.

=== Subtraction '-', multiplication '*', division '/', and modulus '%' operators ===
Just like the addition operator, the subtraction, multiplication, division, and modulus operators are used as follows:
<source lang="java">
int a = 9;

a-1; // evaluates to 8
a/3; // evaluates to 3
a*2; // evaluates to 18
a%4; // evaluates to 1
</source>

Subtraction, multiplication, and division, you have seen before, but the modulus operator is much less commonly used. Actually, it is commonly used, but it known under a different name, the remainder. Nine divided by four gives a remainder of one, so therefore 9%4 (pronounced "9 mod 4") evaluates to 1.

When more than one of the operators are used in the same statement, for example:
<source lang="java">
int a, b, c, d;
a = a-b/c*d;
</source>

the Java language would use the order-of-operations in this case.

==== Plus-equals ====
The plus-equals operator ("+=") adds the value on the right, to the variable on the left, and then assigns that value back into the variable on the left.

Example:
<source lang="java">
int a = 6; // assigns the value 6 to variable a
a += 5; // adds 5 to a, and assigns that value back into a, now a is 11
</source>

==== Minus-equals, multiply-equals, divide-equals, and mod-equals ====
Minus-equals, multiply-equals, divide-equals, and mod-equals works in the same way as plus-equals, except instead of addition, they do subtraction, multiplication, division, and modulus, respectively.

=== Concatenation operator ===
The concatenation operator (+) looks exactly like the addition operator, however it performs a different operation. The concatenation operator '''concatenates''' or "puts together," for lack of a better term, two <code>Strings</code>.

<pre>
String myString = "Hello, ";
String yourString = "world.";
String ourString = myString + yourString; // evaluates to "Hello, world."
</pre>

== Valid Identifiers ==
There are several rules for the naming of your variables. Identifiers can be named using all the letters from A through Z (capital or lowercase, you choose), numbers 0-9 and underscore _ and the dollar sign $. The first character of the identifier cannot be a number, but it can be a letter, _ or $. Identifiers can be no longer than 32 characters.

You can't create two variables with the same identifier; all identifiers must be unique. You also can't use an identifier that is a Java keyword, listed below. [[Flashcards for Java keywords]] provides some assistance in memorizing the concepts behind specific keywords.

<div align=center>
{| class="wikitable"
 | <code>abstract</code>
 | <code>assert</code>
 | <code>boolean</code>
 | <code>break</code>
 | <code>byte</code>
 | <code>case</code>
 |-
 | <code>catch</code>
 | <code>char</code>
 | <code>class</code>
 | <code>const</code>
 | <code>continue</code>
 | <code>default</code>
 |-
 | <code>else</code>
 | <code>enum</code>
 | <code>extends</code>
 | <code>false</code>
 | <code>final</code>
 | <code>finally</code>
 |-
 | <code>float</code>
 | <code>for</code>
 | <code>goto</code>
 | <code>if</code>
 | <code>implements</code>
 | <code>import</code>
 |-
 | <code>instanceof</code>
 | <code>int</code>
 | <code>interface</code>
 | <code>long</code>
 | <code>native</code>
 | <code>new</code>
 |-
 | <code>null</code>
 | <code>package</code>
 | <code>private</code>
 | <code>protected</code>
 | <code>public</code>
 | <code>return</code>
 |-
 | <code>short</code>
 | <code>static</code>
 | <code>strictfp</code>
 | <code>super</code>
 | <code>switch</code>
 | <code>synchronized</code>
 |-
 | <code>this</code>
 | <code>throw</code>
 | <code>throws</code>
 | <code>transient</code>
 | <code>true</code>
 | <code>try</code>
 |-
 | <code>void</code>
 | <code>volatile</code>
 | <code>while</code>
 | 
 | 
 | 
 |}
</div>

Identifiers should also be meaningful, while maintaining practicality. If calculating the sum of a set of numbers, <code>sum<code> is better than <code>cumulativeTotal</code>, but <code>s</code> might be too short.

== System.out ==
It is often useful (and necessary) to view the output of your program, especially when you are just getting started or when you are debugging.  Java provides a way to do this.  System.out is a static member (don't worry about what this means for right now) which contains various methods which allow programmers to output text to the console. Two commonly used methods are System.out.print() and System.out.println().  The first allows you to print text without a line break, and the second inserts a new line after every call. 

Using System.out.println() is extremely simple, though C/C++ programmers may find it cumbersome to type up compared to simply typing printf(). The method println() takes one parameter, the variable you wish to output, and writes it to the console.

<source lang="java">System.out.println( myInt );</source>

You can also print out multiple variables on the same line:

<source lang="java">System.out.println( false + " " + 54 );</source>

Note that this won't work for two literal numeric values:

<source lang="java">System.out.println( 54 + 32 );</source>. 

The plus sign would be mistaken for the addition operator for adding numeric values. So to print out "5432", you would have to type:

<source lang="java">System.out.println( 54 + "" + 32 );</source>

Now you can do calculations and print the result! For example, say you want to print 6*6*6*6. Here is the code:
<source lang="java">
public class Multiplying
{
  public static void main(String args[])
  {
    int a = 6;
    int b = a*a*a*a;
    System.out.println(b + "");
  }
}
</source>

== Compiling and running your program ==
To compile your program, go to the directory you saved it in. Note that if your class was named NaMe then your file '''must''' be named NaMe.java. Notice that Java is case-sensitive. Anyways, type: <code>javac NaMe.java</code> where NaMe is your class name in a command-line window. To run the program, type <code>java NaMe</code>. Do not forget to include the ".java" extension when compiling the file, and to leave out any extensions when running the program.

If the compiler reports syntax errors with your code, you must look in your source code and fix them. These are usually typos, but can be missing semi-colons or other formatting issues.

If, when running, it reports "invalid class file", the compiler might not have created a file. It should have given an error message at compile time.

== User Input ==

The first way to get user input is from the keyboard without using the swing gui. You must first import the Scanner package first like so. <code>import java.util.Scanner;</code> Once you have done that you will have to create a Scanner object. <code>Scanner scan1 = new Scanner(System.in);</code> Finally after the user has entered the input asked for you retrieve using your Scanner object. For example if we wanted a string as input we could use the following code. 
<source lang="java">
import java.util.Scanner;
Public class GettingStringInput
{
   Public static void main(String[]args)
   {
       String yourinput = new String;
       Scanner scan1 = new Scanner(System.in);
       System.out.print("Please enter a string: ");
       yourinput = scan1.nextLine();
   }
}
</source>

''In order for the following to work properly, you must place the following code on the first line of your .java file. Importing packages will be explained later.''

<source lang="java">import javax.swing.JOptionPane;</source>

Now, let's go on to asking the user to enter a number and doing calculations on it. Basically: <source lang="java">JOptionPane.showInputDialog( null, "Hello, enter something" );</source>. Try putting that in a class (in the main method, of course) and run it. Currently, we can't do anything with it because the value is deleted.

Because what you enter can consist of letters OR numbers, and any length of them, what is "produced" by that is a String. The following will work: <source lang="java">String mine = JOptionPane.showInputDialog( null, "Now I can set a String!" );</source>. Now lets say that after you get the string you want to print it. Just like regularly, add the following line: <source lang="java">System.out.println( mine );</source>.

Now you probably want to be able to enter a number. Java provides a method of changing a '''String''' to an <code>int</code>. It is <source lang="java">Integer.parseInt( String_Here );</source>. So lets say you want the user to enter a number and you print it. Do:
<source lang="java">
int mine = Integer.parseInt( JOptionPane.showInputDialog( null, "Now I can set an int!" ) );
System.out.println( mine );
</source>

And now, of course, you can do whatever you want with that...

== Exercises ==
{{Activity
| Printing variables
| Create a program that stores a String with the value "ABC". Then print the value using System.out.println(StringIdentifierHere). Don't use System.out.println("ABC"), as we are focusing on creating variables.
}}

{{Activity
| Printing number variables
| Do the above with a long set to 10000. Note that you have to say System.out.println(LongIdentifier).
}}
<br><br><hr>
<!--[[Java|Back to Java Main Page]] | [[Introduction_to_Java|Previous Lesson]] | [[Java_Decision_Structures|Next Lesson]]-->
{{1lvlnav|[[Java|Java]]|[[Introduction to Java]]|[[Java Decision Structures]]}}

[[Category:Java]]
[[Category:Learning activities]]
[[Category:Basics]]