What are Fields in Java?
Defining Fields in Java
In Java, a field is a variable that is defined within a class. A field is a data member of a class, which means it is a variable that belongs to the class and can be accessed by other classes. In Java, a field is declared with the public, private, or protected access modifier, and can be either static or non-static. For example, let’s define a simple Person class with two fields: name and age.
public class Person {
private String name;
private int age;
// Constructor
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter method
public String getName() {
return name;
}
// Setter method
public void setName(String name) {
this.name = name;
}
// Getter method
public int getAge() {
return age;
}
// Setter method
public void setAge(int age) {
this.age = age;
}
}Creating a Field with Initial Value
When a field is declared, it can have an initial value, which means a value is assigned to the field when it is first created. For example, let’s create a Person class with a name field that has an initial value of "John Doe".
public class Person {
private String name = "John Doe";
// Constructor
public Person(String name) {
this.name = name;
}
// Getter method
public String getName() {
return name;
}
}Creating a Field without an Initial Value
If a field is declared without an initial value, it will be null when it is first created. For example, let’s create a Person class with a name field that is null when it is first created.
public class Person {
// Field declaration
private String name;
// Constructor
public Person() {
this.name = null;
}
// Getter method
public String getName() {
return name;
}
}Creating a Static Field
A static field is a field that belongs to the class, rather than an instance of the class. For example, let’s create a Math class with a PI field that is a static field.
public class Math {
// Static field
public static double PI = 3.14159;
// Method
public static void main(String[] args) {
System.out.println(Math.PI);
}
}Creating a Non-Static Field
A non-static field is a field that belongs to an instance of the class. For example, let’s create a Person class with a name field that is a non-static field.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Getter method
public String getName() {
return name;
}
}Creating a Static Method
A static method is a method that belongs to a class, rather than an instance of the class. For example, let’s create a Math class with a getPrimeNumbers method that is a static method.
public class Math {
// Static method
public static void getPrimeNumbers(int n) {
for (int i = 2; i <= n; i++) {
System.out.println(i);
}
}
}Creating an Instance Method
An instance method is a method that belongs to an instance of the class. For example, let’s create a Person class with a calcAge method that is an instance method.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Instance method
public void calcAge() {
int age = this.age;
System.out.println("Your age is " + age);
}
}Method Parameters
When a method is declared, it can take one or more parameters, which are variables passed to the method from outside the method. For example, let’s create a calcAge method that takes an int parameter.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Instance method
public void calcAge(int age) {
int ageInYears = age;
System.out.println("Your age is " + ageInYears + " years");
}
}Method Return Type
When a method is declared, it can return one or more values, which are the results of the method execution. For example, let’s create a calcAge method that returns an int value.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Instance method
public int calcAge() {
int age = this.age;
return age;
}
}Method Overloading
Method overloading is a feature of Java that allows a method to have multiple definitions with different parameters. For example, let’s create a calcAge method that takes an int parameter.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Instance method
public void calcAge(int age) {
int ageInYears = age;
System.out.println("Your age is " + ageInYears + " years");
}
// Instance method
public void calcAge(String surname) {
String surnameIn Capitals = surname.toUpperCase();
System.out.println("Your surname is " + surnameIn Capitals);
}
}Exception Handling
Exception handling is a feature of Java that allows a method to handle runtime errors. For example, let’s create a calcAge method that throws an IntegerException if the age is negative.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Instance method
public void calcAge(int age) {
if (age < 0) {
throw new IntegerException("Age cannot be negative");
}
int ageInYears = age;
System.out.println("Your age is " + ageInYears + " years");
}
}Lambda Expressions
Lambda expressions are a feature of Java that allows a method to be defined with a single expression. For example, let’s create a calcAge method that takes an int parameter and returns a String value.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Instance method
public void calcAge(int age) {
String ageInYears = Integer.toString(age);
System.out.println("Your age is " + ageInYears + " years");
}
}Functional Programming
Functional programming is a paradigm of programming that emphasizes the use of pure functions, immutability, and first-class functions. For example, let’s create a calcAge method that returns a String value.
public class Person {
private String name;
// Constructor
public Person(String name) {
this.name = name;
}
// Instance method
public String calcAge() {
return Integer.toString(this.age);
}
}Value Type vs Reference Type
Java has two types of variables: value type and reference type. Value type variables store values, while reference type variables store pointers to values. For example, let’s create a Person class with two value type fields: name and age.
public class Person {
private String name;
private int age;
// Constructor
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter method
public String getName() {
return name;
}
// Setter method
public void setName(String name) {
this.name = name;
}
// Getter method
public int getAge() {
return age;
}
// Setter method
public void setAge(int age) {
this.age = age;
}
}Abstract Classes and Interfaces
Abstract classes and interfaces are two types of classes in Java. Abstract classes cannot be instantiated and are used to define the interface for other classes. For example, let’s create an Animal abstract class with a sound method.
public abstract class Animal {
public abstract void sound();
public abstract void eat();
}public class Dog extends Animal {
public void sound() {
System.out.println("Woof!");
}
public void eat() {
System.out.println("Eating dog food");
}
}public class Cat extends Animal {
public void sound() {
System.out.println("Meow!");
}
public void eat() {
System.out.println("Eating cat food");
}
}Override and Implement
Override and Implement are keywords in Java that are used to override methods in a superclass or implement an interface.
public class Person {
public void sayHello() {
System.out.println("Hello!");
}
}
public class Child extends Person {
@Override
public void sayHello() {
System.out.println("Hi!");
}
public static void main(String[] args) {
Child child = new Child();
child.sayHello();
}
}I hope this article has helped you understand what fields in Java are and how they work.