Variables
As you learned in the previous lesson, an object stores its state in fields.
int cadence = 0; int speed = 0; int gear = 1;
The What Is an Object? discussion introduced you to fields, but you probably have still a few questions, such as: What are the rules and conventions for naming a field? Besides int , what other data types are there? Do fields have to be initialized when they are declared? Are fields assigned a default value if they are not explicitly initialized? We’ll explore the answers to such questions in this lesson, but before we do, there are a few technical distinctions you must first become aware of. In the Java programming language, the terms «field» and «variable» are both used; this is a common source of confusion among new developers, since both often seem to refer to the same thing.
The Java programming language defines the following kinds of variables:
- Instance Variables (Non-Static Fields) Technically speaking, objects store their individual states in «non-static fields», that is, fields declared without the static keyword. Non-static fields are also known as instance variables because their values are unique to each instance of a class (to each object, in other words); the currentSpeed of one bicycle is independent from the currentSpeed of another.
- Class Variables (Static Fields) A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. A field defining the number of gears for a particular kind of bicycle could be marked as static since conceptually the same number of gears will apply to all instances. The code static int numGears = 6; would create such a static field. Additionally, the keyword final could be added to indicate that the number of gears will never change.
- Local Variables Similar to how an object stores its state in fields, a method will often store its temporary state in local variables. The syntax for declaring a local variable is similar to declaring a field (for example, int count = 0; ). There is no special keyword designating a variable as local; that determination comes entirely from the location in which the variable is declared which is between the opening and closing braces of a method. As such, local variables are only visible to the methods in which they are declared; they are not accessible from the rest of the class.
- Parameters You’ve already seen examples of parameters, both in the Bicycle class and in the main method of the «Hello World!» application. Recall that the signature for the main method is public static void main(String[] args) . Here, the args variable is the parameter to this method. The important thing to remember is that parameters are always classified as «variables» not «fields». This applies to other parameter-accepting constructs as well (such as constructors and exception handlers) that you’ll learn about later in the tutorial.
Having said that, the remainder of this tutorial uses the following general guidelines when discussing fields and variables. If we are talking about «fields in general» (excluding local variables and parameters), we may simply say «fields». If the discussion applies to «all of the above», we may simply say «variables». If the context calls for a distinction, we will use specific terms (static field, local variables, etc.) as appropriate. You may also occasionally see the term «member» used as well. A type’s fields, methods, and nested types are collectively called its members.
Naming
- Variable names are case-sensitive. A variable’s name can be any legal identifier an unlimited-length sequence of Unicode letters and digits, beginning with a letter, the dollar sign » $ «, or the underscore character » _ «. The convention, however, is to always begin your variable names with a letter, not » $ » or » _ «. Additionally, the dollar sign character, by convention, is never used at all. You may find some situations where auto-generated names will contain the dollar sign, but your variable names should always avoid using it. A similar convention exists for the underscore character; while it’s technically legal to begin your variable’s name with » _ «, this practice is discouraged. White space is not permitted.
- Subsequent characters may be letters, digits, dollar signs, or underscore characters. Conventions (and common sense) apply to this rule as well. When choosing a name for your variables, use full words instead of cryptic abbreviations. Doing so will make your code easier to read and understand. In many cases it will also make your code self-documenting; fields named cadence , speed , and gear , for example, are much more intuitive than abbreviated versions, such as s , c , and g . Also keep in mind that the name you choose must not be a keyword or reserved word.
- If the name you choose consists of only one word, spell that word in all lowercase letters. If it consists of more than one word, capitalize the first letter of each subsequent word. The names gearRatio and currentGear are prime examples of this convention. If your variable stores a constant value, such as static final int NUM_GEARS = 6 , the convention changes slightly, capitalizing every letter and separating subsequent words with the underscore character. By convention, the underscore character is never used elsewhere.
Java: The value of the local variable string is not used
If you see «The value of the local variable string is not used» warning message in your class while using Eclipse IDE, the reason is that you have declared a local variable (a variable inside a method) and you have not used it anywhere in your class. So when the code is compiled by Eclipse for you, it seems that there this particular String variable has no references and is useless — as this may not break your code, just get a friendly warning with yellow highlighting.
The solution is very simple, you need to either use that variable in your code if you think it’s unwanted, simply remove that particular statement.
package sample; public class Sample < public static void main(String[] args) < String output = "Output:"; String sentence = "This is my sentence"; for (int i = 0; i < sentense.length(); i++) < System.out.println(sentense.charAt(i)); >> > As you see I haven't used the output String variable anywhere, to fix this issue I can simply add a System.out.println(output); sentence just after the declaration or remove it completely.- Spring Boot + Redis Cloud Configuration and Setup Tutorial
- Implementing Bubble Sort Algorithm using Java Program
- Generate Maven Project Dependency Tree using MVN Command
- Convert Collection List to Set using Java 8 Stream API
- Java: RabbitMq Create a Queue Example
- List of Java JDK Major Minor Version Numbers
- 9 Ways to Loop Java Map (HashMap) with Code Examples
- [fix] Java Spring Boot JPA SQLSyntaxErrorException: Encountered user at line 1 column 14
- Project JDK is not defined [IntelliJ IDEA]
- Deep Dive: Java Object Class from java.lang Package
- Check if a Java Date String is Valid or Not (Java 8)
- JdbcTemplate Batch Insert Example using Spring Boot
- Convert JSON to Gson with type as ArrayList
- [Fix] Java — Exception in thread main java.lang.IllegalThreadStateException
- [Fix] Spring Boot: java.sql.SQLSyntaxErrorException: Unknown database
- 7 deadly java.lang.OutOfMemoryError in Java Programming
- List of jar files for Jax-ws (SOAP) based Java Web Services
- Java get day of the week as an int using DayOfWeek
- Add two numbers using Java Generics
- Java Program to generate random string
- Spring 5 IoC Example with application Context XML (ClassPathXmlApplicationContext) and Gradle.
- [Java] How to throws Exception using Functional Interface and Lambda code
- Error: Unable to access jarfile jarFileName.jar file [Windows]
- Unhandled exception type InterruptedException : Java Threads
- Fix: SyntaxError: ( was never closed [Python]
Java Variables
In Java, there are different types of variables, for example:
- String — stores text, such as «Hello». String values are surrounded by double quotes
- int — stores integers (whole numbers), without decimals, such as 123 or -123
- float — stores floating point numbers, with decimals, such as 19.99 or -19.99
- char — stores single characters, such as ‘a’ or ‘B’. Char values are surrounded by single quotes
- boolean — stores values with two states: true or false
Declaring (Creating) Variables
To create a variable, you must specify the type and assign it a value:
Syntax
Where type is one of Java’s types (such as int or String ), and variableName is the name of the variable (such as x or name). The equal sign is used to assign values to the variable.
To create a variable that should store text, look at the following example:
Example
Create a variable called name of type String and assign it the value «John«:
String name = "John"; System.out.println(name); To create a variable that should store a number, look at the following example:
Example
Create a variable called myNum of type int and assign it the value 15:
int myNum = 15; System.out.println(myNum); You can also declare a variable without assigning the value, and assign the value later:
Example
int myNum; myNum = 15; System.out.println(myNum); Note that if you assign a new value to an existing variable, it will overwrite the previous value:
Example
Change the value of myNum from 15 to 20 :
int myNum = 15; myNum = 20; // myNum is now 20 System.out.println(myNum); Final Variables
If you don’t want others (or yourself) to overwrite existing values, use the final keyword (this will declare the variable as «final» or «constant», which means unchangeable and read-only):
Example
final int myNum = 15; myNum = 20; // will generate an error: cannot assign a value to a final variable Other Types
A demonstration of how to declare variables of other types:
Example
int myNum = 5; float myFloatNum = 5.99f; char myLetter = 'D'; boolean myBool = true; String myText = "Hello"; You will learn more about data types in the next section.