PBO JAVA 1

CATATAN
(NOTE)
Methods

Methods define behavior. A method is a collection of statements that are grouped together to perform an operation. System.out.println() is an
example of a method.
You can define your own methods to perform your desired tasks.
Let's consider the following code:

class MyClass {

static void sayHello() {

System.out.println("Hello World!");
}

public static void main(String[ ] args) {

sayHello();
}
}
// Outputs "Hello World!"

The code above declares a method called "sayHello", which prints a text, and then gets called in main.
To call a method, type its name and then follow the name with a set of parentheses.

Calling Methods

You can call a method as many times as necessary.

When a method runs, the code jumps down to where the method is defined, executes the code inside of it, then goes back and proceeds to the
next line.
Example:

class MyClass {

static void sayHello() {

System.out.println("Hello World!");
}

public static void main(String[ ] args) {

sayHello();
sayHello();
sayHello();
}
}

// Hello World!
// Hello World!
// Hello World!

In cases like the one above, where the same thing is repeated over and over, you can achieve the same result using loops (while or for).

Method Parameters

You can also create a method that takes some data, called parameters, along with it when you call it. Write parameters within the method's
parentheses.
For example, we can modify our sayHello() method to take and output a String parameter.

class MyClass {

static void sayHello(String name) {

System.out.println("Hello " + name);
}

public static void main(String[ ] args) {

sayHello("David");
sayHello("Amy");
}

}
// Hello David
// Hello Amy

The method above takes a String called name as a parameter, which is used in the method's body. Then, when calling the method, we pass the
parameter's value inside the parentheses.
Methods can take multiple, comma-separated parameters.
The advantages of using methods instead of simple statements include the following:
- code reuse: You can write a method once, and use it multiple times, without having to rewrite the code each time.
- parameters: Based on the parameters passed in, methods can perform various actions.

The Return Type

The return keyword can be used in methods to return a value.

For example, we could define a method named sum that returns the sum of its two parameters.static int sum(int val1, int val2) {
return val1 + val2;
}
Notice that in the method definition, we defined the return type before we defined the methodname. For our sum method, it is int, as it takes
two parameters of the type int and returns their sum, which is also an int.
The static keyword will be discussed in a future lesson.
Now, we can use the method in our main.

class MyClass {

static int sum(int val1, int val2) {

return val1 + val2;
}

public static void main(String[ ] args) {

int x = sum(2, 5);
System.out.println(x);
}
}
// Outputs "7"Try It Yourself

As the method returns a value, we can assign it to a variable.

When you do not need to return any value from your method, use the keyword void.
Notice the void keyword in the definition of the main method - this means that main does not return anything.

The Return Type

Take a look at the same code from our previous lesson with explaining comments, so you can better understand how it works:// returns an int
value 5
static int returnFive() {
return 5;
}

// has a parameter
static void sayHelloTo(String name) {
System.out.println("Hello " + name);
}

// simply prints"Hello World!"

static void sayHello() {
System.out.println("Hello World!");
}
Having gained knowledge of method return types and parameters, let's take another look at the definition of the main method. public static void
main(String[ ] args)
This definition indicates that the main method takes an array of Strings as its parameters, and does not return a value.

The Return Type

Let's create a method that takes two parameters of type int and returns the greater one, then call it in main:

public static void main(String[ ] args) {

int res = max(7, 42);
System.out.println(res); //42
}

static int max(int a, int b) {

if(a > b) {
return a;
}
else {
return b;
}
}T

A method can have one type of parameter (or parameters) and return another, different type. For example, it can take two doubles and return
an int.

Creating Classes

In order to create your own custom objects, you must first create the corresponding classes. This is accomplished by right clicking on
the src folder in Eclipse and selecting Create->New->Class.

Now lets create a simple method in our new class.

Animal.javapublic class Animal {
void bark() {
System.out.println("Woof-Woof");
}
}
We declared a bark() method in our Animal class.
Now, in order to use the class and it's methods, we need to declare an object of that class.

Creating Objects

Let's head over to our main and create a new object of our class.
MyClass.java

class MyClass {
public static void main(String[ ] args) {
Animal dog = new Animal();
dog.bark();
}
}
// Outputs "Woof-Woof"Try It Yourself

Now, dog is an object of type Animal. Thus we can call its bark() method, using the name of the object and a dot.
The dot notation is used to access the object's attributes and methods.
You have just created your first object!

Defining Attributes

A class has attributes and methods. The attributes are basically variables within a class.
Let's create a class called Vehicle, with its corresponding attributes and methods.public class Vehicle {
int maxSpeed;
int wheels;
String color;
double fuelCapacity;

void horn() {
System.out.println("Beep!");
}
}
maxSpeed, wheels, color, and fuelCapacity are the attributes of our Vehicle class, and horn() is the only method.
You can define as many attributes and methods as necessary.

Creating Objects

Next, we can create multiple objects of our Vehicle class, and use the dot syntax to access their attributes and methods.

class MyClass {
public static void main(String[ ] args) {
Vehicle v1 = new Vehicle();
Vehicle v2 = new Vehicle();
v1.color = "red";
v2.horn();
}
}Try It Yourself

Tap Try It Yourself to play around with the code!

Access Modifiers

Now let's discuss the public keyword in front of the main method.public static void main(String[ ] args)
public is an access modifier, meaning that it is used to set the level of access. You can use access modifiers for classes, attributes, and methods.

For classes, the available modifiers are public or default (left blank), as described below:
public: The class is accessible by any other class.
default: The class is accessible only by classes in the same package.

The following choices are available for attributes and methods:

default: A variable or method declared with no access control modifier is available to any other class in the same package.
public: Accessible from any other class.
protected: Provides the same access as the default access modifier, with the addition that subclasses can access protected methods and
variables of the superclass (Subclasses and superclasses are covered in upcoming lessons).
private: Accessible only within the declared class itself.

Example:public class Vehicle {

private int maxSpeed;
private int wheels;
private String color;
private double fuelCapacity;

public void horn() {

System.out.println("Beep!");
}
}
It's a best practice to keep the variables within a class private. The variables are accessible and modified using Getters and Setters.
Tap Continue to learn about Getters and Setters.

Getters & Setters

Getters and Setters are used to effectively protect your data, particularly when creating classes. For each variable, the get method returns its
value, while the set method sets the value.

Getters start with get, followed by the variable name, with the first letter of the variable name capitalized.
Setters start with set, followed by the variable name, with the first letter of the variable name capitalized.

Example:public class Vehicle {

private String color;

// Getter
public String getColor() {
return color;
}
// Setter
public void setColor(String c) {
this.color = c;
}
}
The getter method returns the value of the attribute.
The setter method takes a parameter and assigns it to the attribute.
The keyword this is used to refer to the current object. Basically, this.color is the color attribute of the current object.

Getters & Setters

Once our getter and setter have been defined, we can use it in our main:

public static void main(String[ ] args) {

Vehicle v1 = new Vehicle();
v1.setColor("Red");
System.out.println(v1.getColor());
}

//Outputs "Red"Try It Yourself

Getters and setters allow us to have control over the values. You may, for example, validate the given value in the setter before actually setting
the value.
Getters and setters are fundamental building blocks for encapsulation, which will be covered in the next module.

Constructors

Constructors are special methods invoked when an object is created and are used to initialize them.
A constructor can be used to provide initial values for object attributes.

- A constructor name must be same as its class name.

- A constructor must have no explicit return type.

Example of a constructor:public class Vehicle {

private String color;
Vehicle() {
color = "Red";
}
}
The Vehicle() method is the constructor of our class, so whenever an object of that class is created, the color attribute will be set to "Red".
A constructor can also take parameters to initialize attributes.public class Vehicle {
private String color;
Vehicle(String c) {
color = c;
}
}
You can think of constructors as methods that will set up your class by default, so you don’t need to repeat the same code every time.

Using Constructors

The constructor is called when you create an object using the new keyword.
Example:public class MyClass {
public static void main(String[ ] args) {
Vehicle v = new Vehicle("Blue");
}
}
This will call the constructor, which will set the color attribute to "Blue".

Constructors

A single class can have multiple constructors with different numbers of parameters.
The setter methods inside the constructors can be used to set the attribute values.
Example:public class Vehicle {
private String color;

Vehicle() {
this.setColor("Red");
}
Vehicle(String c) {
this.setColor(c);
}

// Setter
public void setColor(String c) {
this.color = c;
}
}
The class above has two constructors, one without any parameters setting the color attribute to a default value of "Red", and
another constructor that accepts a parameter and assigns it to the attribute.

Now, we can use the constructors to create objects of our class.

//color will be "Red"

Vehicle v1 = new Vehicle();

//color will be "Green"

Vehicle v2 = new Vehicle("Green"); Try It Yourself

Java automatically provides a default constructor, so all classes have a constructor, whether one is specifically defined or not.

Value Types

Value types are the basic types, and include byte, short, int, long, float, double, boolean, and char.
These data types store the values assigned to them in the corresponding memory locations.
So, when you pass them to a method, you basically operate on the variable's value, rather than on the variable itself.
Example:

public class MyClass {

public static void main(String[ ] args) {
int x = 5;
addOneTo(x);
System.out.println(x);
}
static void addOneTo(int num) {
num = num + 1;
}
}
// Outputs "5"Try It Yourself

The method from the example above takes the value of its parameter, which is why the original variable is not affected and 5 remains as its
value.

Reference Types

A reference type stores a reference (or address) to the memory location where the corresponding data is stored.
When you create an object using the constructor, you create a reference variable.
For example, consider having a Person class defined:

public class MyClass {

public static void main(String[ ] args) {
Person j;
j = new Person("John");
j.setAge(20);
celebrateBirthday(j);
System.out.println(j.getAge());
}
static void celebrateBirthday(Person p) {
p.setAge(p.getAge() + 1);
}
}
//Outputs "21"Try It Yourself

The method celebrateBirthday takes a Person object as its parameter, and increments its attribute.
Because j is a reference type, the method affects the object itself, and is able to change the actual value of its attribute.
Arrays and Strings are also reference data types.

The Math Class

The JDK defines a number of useful classes, one of them being the Math class, which provides predefined methods for mathematical operations.
You do not need to create an object of the Math class to use it. To access it, just type in Math.and the corresponding method.

Math.abs() returns the absolute value of its parameter.

int a = Math.abs(10); // 10
int b = Math.abs(-20); // 20Try It Yourself

Math.ceil() rounds a floating point value up to the nearest integer value. The rounded value is returned as a double.

double c = Math.ceil(7.342); // 8.0Try It Yourself

Similarly, Math.floor() rounds a floating point value down to the nearest integer value.

double f = Math.floor(7.343); // 7.0Try It Yourself

Math.max() returns the largest of its parameters.

int m = Math.max(10, 20); // 20Try It Yourself

Conversely, Math.min() returns the smallest parameter.

int m = Math.min(10, 20); // 10Try It Yourself

Math.pow() takes two parameters and returns the first parameter raised to the power of the second parameter.

double p = Math.pow(2, 3); // 8.0Try It Yourself

There are a number of other methods available in the Math class, including:
sqrt() for square root, sin() for sine, cos() for cosine, and others.

Static

When you declare a variable or a method as static, it belongs to the class, rather than to a specific instance. This means that only one instance of
a static member exists, even if you create multiple objects of the class, or if you don't create any. It will be shared by all objects.
Example:public class Counter {
public static int COUNT=0;
Counter() {
COUNT++;
}
}
The COUNT variable will be shared by all objects of that class.
Now, we can create objects of our Counter class in main, and access the static variable.

public class MyClass {

public static void main(String[ ] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.COUNT);
}
}
//Outputs "2"Try It Yourself
The output is 2, because the COUNT variable is static and gets incremented by one each time a new object of the Counter class is created. In the
code above, we created 2 objects.
You can also access the static variable using any object of that class, such as c1.COUNT.
It’s a common practice to use upper case when naming a static variable, although not mandatory.

Static

The same concept applies to static methods.public class Vehicle {

public static void horn() {
System.out.println("Beep");
}
}
Now, the horn method can be called without creating an object:

public class MyClass {

public static void main(String[ ] args) {
Vehicle.horn();
}
}Try It Yourself

Another example of static methods are those of the Math class, which is why you can call them without creating a Math object.
Also, the main method must always be static.

final

Use the final keyword to mark a variable constant, so that it can be assigned only once.
Example:

class MyClass {
public static final double PI = 3.14;
public static void main(String[ ] args) {
System.out.println(PI);
}
}Try It Yourself

PI is now a constant. Any attempt to assign it a value will cause an error.

Methods and classes can also be marked final. This serves to restrict methods so that they can't be overridden and classes so that they can't be
subclassed.
These concepts will be covered in the next module.

Packages

Packages are used to avoid name conflicts and to control access to classes.
A package can be defined as a group made up of similar types of classes, along with sub-packages.
Creating a package in Java is quite easy. Simply right click on your src directory and click New->Package. Give your package a name and
click Finish.
You will notice that the new package appears in the project directory. Now you can move and create classes inside that package. We have
moved our Vehicle, Counter and Animal classes to the package samples.
When you move/create a class in your package, the following code will appear at the top of the list of files.package samples;
This indicates the package to which the class belongs.
Now, we need to import the classes that are inside a package in our main to be able to use them.
The following example shows how to use the Vehicle class of the samples package.import samples.Vehicle;

class MyClass {
public static void main(String[ ] args) {
Vehicle v1 = new Vehicle();
v1.horn();
}
}
Two major results occur when a class is placed in a package. First, the name of the packagebecomes a part of the name of the class. Second, the
name of the package must match the directory structure where the corresponding class file resides.
Use a wildcard to import all classes in a package.
For example, import samples.* will import all classes in the samples package.

Encapsulation

There are 4 core concepts in OOP: encapsulation, inheritance, polymorphism, and abstraction.

The idea behind encapsulation is to ensure that implementation details are not visible to users. The variables of one class will be hidden from
the other classes, accessible only through the methods of the current class. This is called data hiding.
To achieve encapsulation in Java, declare the class' variables as private and provide public setterand getter methods to modify and view the
variables' values.

For example:class BankAccount {

private double balance=0;
public void deposit(double x) {
if(x > 0) {
balance += x;
}
}
}
This implementation hides the balance variable, enabling access to it only through the deposit method, which validates the amount to be
deposited before modifying the variable.
In summary, encapsulation provides the following benefits:
- Control of the way data is accessed or modified
- More flexible and easily changed code
- Ability to change one part of the code without affecting other parts

Inheritance

Inheritance is the process that enables one class to acquire the properties (methods and variables) of another. With inheritance, the information
is placed in a more manageable, hierarchical order.

The class inheriting the properties of another is the subclass (also called derived class, or child class); the class whose properties are inherited is
the superclass (base class, or parent class).

To inherit from a class, use the extends keyword.

This example shows how to have the class Dog to inherit from the class Animal.class Dog extends Animal {
// some code
}
Here, Dog is the subclass, and Animal is the superclass.

Inheritance

When one class is inherited from another class, it inherits all of the superclass' non-privatevariables and methods.
Example:class Animal {
protected int legs;
public void eat() {
System.out.println("Animal eats");
}
}

class Dog extends Animal {

Dog() {
legs = 4;
}
}
As you can see, the Dog class inherits the legs variable from the Animal class.
We can now declare a Dog object and call the eat method of its superclass:

class MyClass {
public static void main(String[ ] args) {
Dog d = new Dog();
d.eat();
}
}Try It Yourself
Recall the protected access modifier, which makes the members visible only to the subclasses.

Inheritance

Constructors are not member methods, and so are not inherited by subclasses.
However, the constructor of the superclass is called when the subclass is instantiated.
Example:

class A {
public A() {
System.out.println("New A");
}
}
class B extends A {
public B() {
System.out.println("New B");
}
}

class Program {
public static void main(String[ ] args) {
B obj = new B();
}
}

/*Outputs
"New A"
"New B"
*/Try It Yourself

You can access the superclass from the subclass using the super keyword.
For example, super.var accesses the var member of the superclass.

Polymorphism

Polymorphism, which refers to the idea of "having many forms", occurs when there is a hierarchy of classes related to each other
through inheritance.
A call to a member method will cause a different implementation to be executed, depending on the type of the object invoking the method.
Here is an example: Dog and Cat are classes that inherit from the Animal class. Each class has its own implementation of
the makeSound() method.class Animal {
public void makeSound() {
System.out.println("Grr...");
}
}
class Cat extends Animal {
public void makeSound() {
System.out.println("Meow");
}
}
class Dog extends Animal {
public void makeSound() {
System.out.println("Woof");
}
}
As all Cat and Dog objects are Animal objects, we can do the following in main:public static void main(String[ ] args) {
Animal a = new Dog();
Animal b = new Cat();
}
We've created two reference variables of type Animal, and pointed them to the Cat and Dog objects.
Now, we can call the makeSound() methods.

a.makeSound();
//Outputs "Woof"
b.makeSound();
//Outputs "Meow"Try It Yourself

As the reference variable a contains a Dog object, the makeSound() method of the Dog class will be called.
The same applies to the b variable.
This demonstrates that you can use the Animal variable without actually knowing that it contains an object of the subclass.
This is very useful when you have multiple subclasses of the superclass.

Method Overriding

As we saw in the previous lesson, a subclass can define a behavior that's specific to the subclass type, meaning that a subclass can implement a
parent class method based on its requirement.
This feature is known as method overriding.
Example:

class Animal {
public void makeSound() {
System.out.println("Grr...");
}
}
class Cat extends Animal {
public void makeSound() {
System.out.println("Meow");
}
}Try It Yourself

In the code above, the Cat class overrides the makeSound() method of its superclass Animal.

Rules for Method Overriding:

- Should have the same return type and arguments
- The access level cannot be more restrictive than the overridden method's access level (Example: If the superclass method is declared public,
the overriding method in the sub class can be neither private nor protected)
- A method declared final or static cannot be overridden
- If a method cannot be inherited, it cannot be overridden
- Constructors cannot be overridden
Method overriding is also known as runtime polymorphism.

Method Overloading

When methods have the same name, but different parameters, it is known as method overloading.
This can be very useful when you need the same method functionality for different types of parameters.
The following example illustrates a method that returns the maximum of its two parameters.int max(int a, int b) {
if(a > b) {
return a;
}
else {
return b;
}
}
The method shown above will only work for parameters of type integer.
However, we might want to use it for doubles, as well. For that, you need to overload the max method:

double max(double a, double b) {

if(a > b) {
return a;
}
else {
return b;
}
}Try It Yourself

Now, our max method will also work with doubles.

An overloaded method must have a different argument list; the parameters should differ in their type, number, or both.
Another name for method overloading is compile-time polymorphism.
Abstraction

Data abstraction provides the outside world with only essential information, in a process of representing essential features without including
implementation details.
A good real-world example is a book. When you hear the term book, you don't know the exact specifics, such as the page count, the color, or the
size, but you understand the idea, or abstraction, of a book.
The concept of abstraction is that we focus on essential qualities, rather than the specific characteristics of one particular example.

In Java, abstraction is achieved using abstract classes and interfaces.

An abstract class is defined using the abstract keyword.
- If a class is declared abstract it cannot be instantiated (you cannot create objects of that type).
- To use an abstract class, you have to inherit it from another class.
- Any class that contains an abstract method should be defined as abstract.
An abstract method is a method that is declared without an implementation (without braces, and followed by a semicolon): abstract void walk();

Abstract Class

For example, we can define our Animal class as abstract:abstract class Animal {
int legs = 0;
abstract void makeSound();
}
The makeSound method is also abstract, as it has no implementation in the superclass.
We can inherit from the Animal class and define the makeSound() method for the subclass:

class Cat extends Animal {

public void makeSound() {
System.out.println("Meow");
}
}Try It Yourself

Every Animal makes a sound, but each has a different way to do it. That's why we define an abstract class Animal, and leave the implementation
of how they make sounds to the subclasses.
This is used when there is no meaningful definition for the method in the superclass.

Interfaces

An interface is a completely abstract class that contains only abstract methods.

Some specifications for interfaces:
- Defined using the interface keyword.
- May contain only static final variables.
- Cannot contain a constructor because interfaces cannot be instantiated.
- Interfaces can extend other interfaces.
- A class can implement any number of interfaces.

An example of a simple interface:interface Animal {

public void eat();
public void makeSound();
}
Interfaces have the following properties:
- An interface is implicitly abstract. You do not need to use the abstract keyword while declaring an interface.
- Each method in an interface is also implicitly abstract, so the abstract keyword is not needed.
- Methods in an interface are implicitly public.
A class can inherit from just one superclass, but can implement multiple interfaces!

Interfaces

Use the implements keyword to use an interface with your class.

interface Animal {
public void eat();
public void makeSound();
}
class Cat implements Animal {
public void makeSound() {
System.out.println("Meow");
}
public void eat() {
System.out.println("omnomnom");
}
}Try It Yourself

When you implement an interface, you need to override all of its methods.

Type Casting

Assigning a value of one type to a variable of another type is known as Type Casting.

To cast a value to a specific type, place the type in parentheses and position it in front of the value.
Example:

int a = (int) 3.14;

System.out.println(a);
//Outputs 3

The code above is casting the value 3.14 to an integer, with 3 as the resulting value.
Another example:

double a = 42.571;
int b = (int) a;
System.out.println(b);
//Outputs 42

Java supports automatic type casting of integers to floating points, since there is no loss of precision.
On the other hand, type casting is mandatory when assigning floating point values to integer variables.

Type Casting

For classes, there are two types of casting.

Upcasting

You can cast an instance of a subclass to its superclass.

Consider the following example, assuming that Cat is a subclass of Animal.Animal a = new Cat();
Java automatically upcasted the Cat type variable to the Animal type.

Downcasting

Casting an object of a superclass to its subclass is called downcasting.

Example:Animal a = new Cat();
((Cat)a).makeSound();
This will try to cast the variable a to the Cat type and call its makeSound() method.
Why is upcasting automatic, downcasting manual? Well, upcasting can never fail. But if you have a group of different Animals and want to
downcast them all to a Cat, then there's a chance that some of these Animals are actually Dogs, so the process fails.

Anonymous Classes

Anonymous classes are a way to extend the existing classes on the fly.
For example, consider having a class Machine:class Machine {
public void start() {
System.out.println("Starting...");
}
}
When creating the Machine object, we can change the start method on the fly.

public static void main(String[ ] args) {

Machine m = new Machine() {
@Override public void start() {
System.out.println("Wooooo");
}
};
m.start();
}
//Outputs "Wooooo";Try It Yourself

After the constructor call, we have opened the curly braces and have overridden the start method's implementation on the fly.
The @Override annotation is used to make your code easier to understand, because it makes it more obvious when methods are overridden.

Anonymous Classes

The modification is applicable only to the current object, and not the class itself. So if we create another object of that class, the start method's
implementation will be the one defined in the class.

class Machine {
public void start() {
System.out.println("Starting...");
}
}
public static void main(String[ ] args) {
Machine m1 = new Machine() {
@Override public void start() {
System.out.println("Wooooo");
}
};
Machine m2 = new Machine();
m2.start();
}
//Outputs "Starting..."

Inner Classes

Java supports nesting classes; a class can be a member of another class.

Creating an inner class is quite simple. Just write a class within a class. Unlike a class, an inner class can be private. Once you declare an inner
class private, it cannot be accessed from an object outside the class.
Example:

class Robot {
int id;
Robot(int i) {
id = i;
Brain b = new Brain();
b.think();
}

private class Brain {

public void think() {
System.out.println(id + " is thinking");
}
}

}Try It Yourself

The class Robot has an inner class Brain. The inner class can access all of the member variables and methods of its outer class, but it cannot be
accessed from any outside class.

Comparing Objects
Remember that when you create objects, the variables store references to the objects.
So, when you compare objects using the equality testing operator (==), it actually compares the references and not the object values.
Example:

class Animal {
String name;
Animal(String n) {
name = n;
}
}

class MyClass {
public static void main(String[ ] args) {
Animal a1 = new Animal("Robby");
Animal a2 = new Animal("Robby");
System.out.println(a1 == a2);
}
}
//Outputs falseTry It Yourself

Despite having two objects with the same name, the equality testing returns false, because we have two different objects (two different
references or memory locations).

equals()

Each object has a predefined equals() method that is used for semantical equality testing.
But, to make it work for our classes, we need to override it and check the conditions we need.
There is a simple and fast way of generating the equals() method, other than writing it manually.
Just right click in your class, go to Source->Generate hashCode() and equals()...
This will automatically create the necessary methods.class Animal {
String name;
Animal(String n) {
name = n;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Animal other = (Animal) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
The automatically generated hashCode() method is used to determine where to store the object internally. Whenever you implement equals,
you MUST also implement hashCode.
We can run the test again, using the equals method:

public static void main(String[ ] args) {

Animal a1 = new Animal("Robby");
Animal a2 = new Animal("Robby");
System.out.println(a1.equals(a2));
}
//Outputs true

You can use the same menu to generate other useful methods, such as getters and setters for your class attributes.

Enums

An Enum is a special type used to define collections of constants.

Here is a simple Enum example:enum Rank {
SOLDIER,
SERGEANT,
CAPTAIN
}
Note that the values are comma-separated.
You can refer to the constants in the enum above with the dot syntax.Rank a = Rank.SOLDIER;
Basically, Enums define variables that represent members of a fixed set.\

Enums

After declaring an Enum, we can check for the corresponding values with, for example, a switch statement.

Rank a = Rank.SOLDIER;

switch(a) {
case SOLDIER:
System.out.println("Soldier says hi!");
break;
case SERGEANT:
System.out.println("Sergeant says Hello!");
break;
case CAPTAIN:
System.out.println("Captain says Welcome!");
break;
}
//Outputs "Soldier says hi!"

Enums

You should always use Enums when a variable (especially a method parameter) can only take one out of a small set of possible values.
If you use Enums instead of integers (or String codes), you increase compile-time checking and avoid errors from passing in invalid constants,
and you document which values are legal to use.
Some sample Enum uses include month names, days of the week, deck of cards, etc.

Java API

The Java API is a collection of classes and interfaces that have been written for you to use.
The Java API Documentation with all of the available APIs can be located on the Oracle website at
http://docs.oracle.com/javase/7/docs/api/
Once you locate the package you want to use, you need to import it into your code.
The package can be imported using the import keyword.
For example:import java.awt.*;
The awt package contains all of the classes for creating user interfaces and for painting graphics and images.
The wildcard character (*) is used to import all of the classes in the package.