Declaring constants in java

Declaring Constants in Java: A Guide

The Java program below demonstrates the use of two objects to print the value of a final variable. Even though the value of the variable is the same for both instances, different objects were used for each, resulting in copies of the actual variable being printed. Example: Java Program Live Demo Output

Can a final keyword alone be used to define a constant in Java?

A variable that is constant has a fixed value and is unique in the program. If you assign a value to a constant variable, it cannot be altered for the duration of the program.

Java does not provide direct support for constants as compared to other languages. However, it is possible to create a constant by declaring a variable as both static and final.

Declaring a variable as static results in it being loaded into memory during compile time. This means that only one copy of the variable is available.

Declaring a variable as final means that its value cannot be modified afterwards.

To create a constant in Java, simply declare the instance variable as both static and final.

Example

class Data < static final int integerConstant = 20; >public class ConstantsExample < public static void main(String args[]) < System.out.println("value of integerConstant: "+Data.integerConstant); >>

Output

value of integerConstant: 20 value of stringConstant: hello value of floatConstant: 1654.22 value of characterConstant: C

Constants without static keyword

When you declare a final variable without the static keyword, a new instance of the variable is created each time an object is created, even though its value cannot be modified.

Example

Take into account this Java program as an illustration.

class Data < final int integerConstant = 20; >public class ConstantExample < public static void main(String args[]) < Data obj1 = new Data(); System.out.println("value of integerConstant: "+obj1.integerConstant); Data obj2 = new Data(); System.out.println("value of integerConstant: "+obj2.integerConstant); >>

Output

value of integerConstant: 20 value of integerConstant: 20

We have instantiated a final variable and attempted to display its value using two distinct objects. Despite the fact that the value of the variable is identical in both cases, the objects are replicas of the original variable since a distinct object was employed for each.

The constant is defined as requiring the variable to have only one instance throughout the program (class).

To ensure a consistent definition of a constant, it is necessary to declare it as both static and final.

Declaring constant with no value, You can initialise it later in the code. You just have to initialise it before it can be used. It is not write once memory and reads won’t

Constants in Java

Java Programming: Constants in Java ProgrammingTopics discussed:1. Constants in Java.2 Duration: 5:25

Java Programming: 14

In this tutorial I explain how to make constants in Java by using the final modifier on variables Duration: 6:13

Constants in Java — how to declare a constant: const or final?

Java Programming in 60 seconds. How to create constants. What is the ‘const’ keyword? And Duration: 1:01

Difference between constants and final variables in Java?

Constant in Java

In programming, a constant variable is a value that remains fixed and is unique in the program. Once a constant variable is declared and assigned a value, it cannot be altered for the rest of the program’s execution.

Java does not support constants like C language does. However, you can achieve the same effect by declaring a variable as both static and final.

• Once you declare a variable static they will be loaded in to the memory at the compile time i.e. only one copy of them is available.
• once you declare a variable final you cannot modify its value again.

Example

class Data < static final int integerConstant = 20; >public class ConstantsExample < public static void main(String args[]) < System.out.println("value of integerConstant: "+Data.integerConstant); >>

Output

value of integerConstant: 20

Final variable in Java

If you make a variable final, its value cannot be altered and attempting to do so will result in a compile time error.

Example

public class FinalExample < public static void main(String args[]) < final int num = 200; num = 2544; >>

Output

FinalExample.java:4: error: cannot assign a value to final variable num num = 2544; ^ 1 error

In Java programming, the dissimilarity between a final variable and a constant (static and final) lies in the fact that a final variable, when created without the static keyword, generates a distinct copy of the variable every time a new object is formed, even though its value cannot be changed. On the other hand, a constant is an unmodifiable entity that remains constant throughout the program and only has one copy. To illustrate, let us consider the subsequent Java program.

Example

class Data < final int integerConstant = 20; >public class ConstantExample < public static void main(String args[]) < Data obj1 = new Data(); System.out.println("value of integerConstant: "+obj1.integerConstant); Data obj2 = new Data(); System.out.println("value of integerConstant: "+obj2.integerConstant); >>

Output

value of integerConstant: 20 value of integerConstant: 20

We declared a final variable and attempted to display its value using two objects. Despite having the same value, the objects are copies of the original variable since we used different objects for each instance.

The constant’s definition requires that the variable must be present only once within the program (class).

To establish a constant value in programming, it is necessary to specify it as both static and final.

Declare a Constant String in Java, A constant string is declared when it is required to be immutable, which means once any data is defined as constant, it cannot be changed.

What’s the proper way of declaring project constants in Java?

There are numerous approaches to accomplish a task. However, it is imprudent to declare them repeatedly as it seems absurd.

In Java, all entities must be organized into classes. Therefore, there are two possibilities:

1. Choose a primary category for your project such as «FTPServerApp» to house these classes.
2. Develop a class named «Util» which encompasses all of the mentioned functions.

Declare all of them in this manner once you determine their appropriate placement.

public static final [type] [NAME_IN_ALL_CAPS] = [value]; 

• Share public with your entire project, enabling its access from anywhere within the code.
• The value is unique and present in all instances of the class, with only a single copy ( static ).
• It is impossible to alter them, as indicated by final .

In Java, it is customary to use underscores to separate the ALL_CAPS_FOR_CONSTANT_NAMES convention.

Assuming a declaration in a class named FTPServerAPP , a possible formulation involving a constant named SERVICE_PORT would be:

public class FTPServerApp

. and it can be accessed from any class using the following syntax.

Consider exploring enumeration types, which can be found in the link (http://download.oracle.com/javase/tutorial/java/javaOO/enum.html). These types are designed to offer a means of supplying constants without the need for defining a concrete class. Alternatively, some people choose to use an Interface to achieve the same outcome.

Another useful approach, which is comparable to the FTPServerApp illustration mentioned earlier, involves establishing a Context for each subsystem, component, or other entity. This Context not only contains the constants required by components in that system, but also any state that you want to make more visible or avoid individual components from holding. Although I believe this is similar to one of the GoF patterns, it has been quite a while since I have consulted that book, and I am presently too indolent to search for it!

Java Variables, type variableName = value;. Where type is one of Java’s types (such as int or String ), and variableName is the name of

Источник

Константы в Java на примерах

«Constant (константа)» – слово в английском языке, относящееся в основном к «ситуации, которая не меняется». Это одна из фундаментальных концепций программирования в Java, и у нее нет каких-либо специальных предпосылок или концепций, которые необходимо знать перед изучением, кроме базовых навыков программирования.

Константы в Java используются, когда необходимо реализовать «статическое» или постоянное значение для переменной. Язык программирования напрямую не поддерживает константы. Чтобы сделать любую переменную ею, мы должны использовать модификаторы static и final.

Синтаксис

static final datatype identifier_name = constant;

• Модификатор static делает переменную доступной без загрузки экземпляра ее определяющего класса.
• Последний модификатор делает переменную неизменной.

Причина, по которой мы должны использовать как статические, так и конечные модификаторы, заключается в том, что:

• Когда мы объявим переменную «var» только как статическую, все объекты одного класса смогут получить доступ к этому ‘var’ и изменить его значения.
• Когда мы объявляем переменную только как final, для каждого отдельного объекта будет создано несколько экземпляров одного и того же значения константы, и это неэффективно / нежелательно.
• Когда мы используем как static, так и final, тогда «var» остается статичным и может быть инициализирован только один раз, что делает его надлежащей константой, которая имеет общую ячейку памяти для всех объектов своего содержащего класса.

Пример

static final int MIN_AGE = 18;

Допустим, нам нужно определить, кто имеет право на получение постоянных водительских прав в группе людей. Мы уже знаем, что минимальный возраст для получения постоянных водительских прав составляет 18 лет.

Поэтому вместо того, чтобы просить пользователя ввести минимальный возраст для сравнения, мы объявляем идентификатор MIN_AGE как постоянное целое число со значением 18.

import java.util.*; public class DrivingLicense < public static void main(String [] args)< Scanner sc = new Scanner(System.in); static final int MIN_AGE = 18; //Minimum age requirement int[] list = new int[5]; System.out.println("Enter the age of people:"); for(int i=0;i<5;i++)< list[i] = sc.nextInt(); >System.out.println("Result for eligibility:"); for(int i=0;i<5;i++) < if(list[i] >= MIN_AGE) System.out.println(i + " is Eligible"); else System.out.println(i + " is Not Eligible"); > > >

Зачем нужны?

Константы делают вашу программу более легкой для чтения и понимания, когда ее читают другие. Использование их также повышает производительность, поскольку константы кэшируются как JVM, так и вашим приложением.

Статические и окончательные модификаторы

• Статический модификатор в основном используется для управления памятью.
• Это также позволяет переменной быть доступной без загрузки какого-либо экземпляра класса, в котором она определена.
• Последний модификатор означает, что значение переменной не может измениться. Как только значение назначено переменной, другое значение не может быть переназначено той же переменной.

С помощью модификатора final типы данных Primitive, такие как int, float, char, byte, long, short, double, Boolean, можно сделать неизменяемыми / неизменяемыми. Вместе, как мы поняли ранее, эти модификаторы создают постоянную переменную.

Общий синтаксис

public static final int MAX_VALUE = 1000;

Это соглашение использовать заглавную букву имени переменной, которую мы хотим объявить как константу. Если мы сохраним спецификатор доступа для постоянной переменной как частный, то его значения не могут быть изменены в этом классе.

Если мы оставим спецификатор доступа общедоступным для постоянной переменной, то его значения можно изменить в любом месте программы.

Пример 1

В этом примере мы использовали перечисление как enum Apple . Идентификаторы Jonathan, GoldenDel, RedDel, Winesap и Cortland называются константами перечисления.

Каждый из них неявно объявлен как публичный статический финальный член Apple. Переменная перечисления может быть создана как другая примитивная переменная. Он не использует «новый» для создания объекта.

‘ap’ имеет тип Apple, единственные значения, которые могут быть назначены (или могут содержать), являются значениями, определенными перечислением.

Все перечисления имеют два предопределенных метода: values() и valueOf(). Синтаксис этих встроенных методов:

public static enum-type [] .values() public static enum-type.valueOf (String str)

Метод values() дает массив, который состоит из списка констант перечисления. Метод valueOf() дает константу перечисления, значение которой соответствует строке, переданной в str.

Пример 2

enum Season < WINTER, SPRING, SUMMER, FALL; >class EnumExample < public static void main(String[] args) < for (Season s : Season.values()) System.out.println(s);//will display all the enum constants of Season Season s = Season.valueOf("WINTER"); System.out.println("S contains " + s);//output: S contains WINTER >>

В приведенном выше примере мы использовали два встроенных метода перечисления.

Источник

Declaring constants in java

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA

Javatpoint Services

JavaTpoint offers too many high quality services. Mail us on h[email protected], to get more information about given services.

• Website Designing
• Website Development
• Java Development
• PHP Development
• WordPress
• Graphic Designing
• Logo
• Digital Marketing
• On Page and Off Page SEO
• PPC
• Content Development
• Corporate Training
• Classroom and Online Training
• Data Entry

Training For College Campus

JavaTpoint offers college campus training on Core Java, Advance Java, .Net, Android, Hadoop, PHP, Web Technology and Python. Please mail your requirement at [email protected].
Duration: 1 week to 2 week

Like/Subscribe us for latest updates or newsletter

Источник