Learn JAVA #15

Posted on by Apostube

Java Classes/Objects

Java is an object-oriented programming language.

Everything in Java is associated with classes and objects, along with its attributes and methods. For example: in real life, a car is an object. The car has attributes, such as weight and color, and methods, such as drive and brake.

A Class is like an object constructor, or a “blueprint” for creating objects.

Create a Class

To create a class, use the keyword class:

Main.java

Create a class named “Main” with a variable x:

public class Main {
  int x = 5;
}

Create an Object

In Java, an object is created from a class. We have already created the class named Main, so now we can use this to create objects.

To create an object of Main, specify the class name, followed by the object name, and use the keyword new:

Example

Create an object called “myObj” and print the value of x:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

Multiple Objects

You can create multiple objects of one class:

Example

Create two objects of Main:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj1 = new Main();  // Object 1
    Main myObj2 = new Main();  // Object 2
    System.out.println(myObj1.x);
    System.out.println(myObj2.x);
  }
}

Using Multiple Classes

You can also create an object of a class and access it in another class. This is often used for better organization of classes (one class has all the attributes and methods, while the other class holds the main() method (code to be executed)).

Remember that the name of the java file should match the class name. In this example, we have created two files in the same directory/folder:

  • Main.java
  • Second.java

Main.java

public class Main {
  int x = 5;
}

Second.java

class Second {
  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

When both files have been compiled:

C:\Users\Your Name>javac Main.java
C:\Users\Your Name>javac Second.java

Run the Second.java file:

C:\Users\Your Name>java Second

And the output will be:

5

Java Class Attributes

In the previous chapter, we used the term “variable” for x in the example (as shown below). It is actually an attribute of the class. Or you could say that class attributes are variables within a class:

Example

Create a class called “Main” with two attributes: x and y:

public class Main {
  int x = 5;
  int y = 3;
}

Another term for class attributes is fields.

Accessing Attributes

You can access attributes by creating an object of the class, and by using the dot syntax (.):

The following example will create an object of the Main class, with the name myObj. We use the x attribute on the object to print its value:

Example

Create an object called “myObj” and print the value of x:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

Modify Attributes

You can also modify attribute values:

Example

Set the value of x to 40:

public class Main {
  int x;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 40;
    System.out.println(myObj.x);
  }
}

Or override existing values:

Example

Change the value of x to 25:

public class Main {
  int x = 10;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 25; // x is now 25
    System.out.println(myObj.x);
  }
}

If you don’t want the ability to override existing values, declare the attribute as final:

Example

public class Main {
  final int x = 10;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 25; // will generate an error: cannot assign a value to a final variable
    System.out.println(myObj.x);
  }
}

The final keyword is useful when you want a variable to always store the same value, like PI (3.14159…).

Multiple Objects

If you create multiple objects of one class, you can change the attribute values in one object, without affecting the attribute values in the other:

Example

Change the value of x to 25 in myObj2, and leave x in myObj1 unchanged:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj1 = new Main();  // Object 1
    Main myObj2 = new Main();  // Object 2
    myObj2.x = 25;
    System.out.println(myObj1.x);  // Outputs 5
    System.out.println(myObj2.x);  // Outputs 25
  }
}

Multiple Attributes

You can specify as many attributes as you want:

Example

public class Main {
  String fname = "John";
  String lname = "Doe";
  int age = 24;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println("Name: " + myObj.fname + " " + myObj.lname);
    System.out.println("Age: " + myObj.age);
  }
}

Java Class Methods

You learned from the Java Methods chapter that methods are declared within a class, and that they are used to perform certain actions:

Example

Create a method named myMethod() in Main:

public class Main {
  static void myMethod() {
    System.out.println("Hello World!");
  }
}

myMethod() prints a text (the action), when it is called. To call a method, write the method’s name followed by two parentheses () and a semicolon;

Example

Inside main, call myMethod():

public class Main {
  static void myMethod() {
    System.out.println("Hello World!");
  }

  public static void main(String[] args) {
    myMethod();
  }
}

// Outputs "Hello World!"

Static vs. Public

You will often see Java programs that have either static or public attributes and methods.

In the example above, we created a static method, which means that it can be accessed without creating an object of the class, unlike public, which can only be accessed by objects:

Example

An example to demonstrate the differences between static and public methods:

public class Main {
  // Static method
  static void myStaticMethod() {
    System.out.println("Static methods can be called without creating objects");
  }

  // Public method
  public void myPublicMethod() {
    System.out.println("Public methods must be called by creating objects");
  }

  // Main method
  public static void main(String[] args) {
    myStaticMethod(); // Call the static method
    // myPublicMethod(); This would compile an error

    Main myObj = new Main(); // Create an object of Main
    myObj.myPublicMethod(); // Call the public method on the object
  }
}

Access Methods With an Object

Example

Create a Car object named myCar. Call the fullThrottle() and speed() methods on the myCar object, and run the program:

// Create a Main class
public class Main {
 
  // Create a fullThrottle() method
  public void fullThrottle() {
    System.out.println("The car is going as fast as it can!");
  }

  // Create a speed() method and add a parameter
  public void speed(int maxSpeed) {
    System.out.println("Max speed is: " + maxSpeed);
  }

  // Inside main, call the methods on the myCar object
  public static void main(String[] args) {
    Main myCar = new Main();   // Create a myCar object
    myCar.fullThrottle();      // Call the fullThrottle() method
    myCar.speed(200);          // Call the speed() method
  }
}

// The car is going as fast as it can!
// Max speed is: 200

Example explained

1) We created a custom Main class with the class keyword.

2) We created the fullThrottle() and speed() methods in the Main class.

3) The fullThrottle() method and the speed() method will print out some text, when they are called.

4) The speed() method accepts an int parameter called maxSpeed – we will use this in 8).

5) In order to use the Main class and its methods, we need to create an object of the Main Class.

6) Then, go to the main() method, which you know by now is a built-in Java method that runs your program (any code inside main is executed).

7) By using the new keyword we created an object with the name myCar.

8) Then, we call the fullThrottle() and speed() methods on the myCar object, and run the program using the name of the object (myCar), followed by a dot (.), followed by the name of the method (fullThrottle(); and speed(200);). Notice that we add an int parameter of 200 inside the speed() method.

Remember that..

The dot (.) is used to access the object’s attributes and methods.

To call a method in Java, write the method name followed by a set of parentheses (), followed by a semicolon (;).

A class must have a matching filename (Main and Main.java).

Using Multiple Classes

Remember that the name of the java file should match the class name. In this example, we have created two files in the same directory:

  • Main.java
  • Second.java

Main.java

public class Main {
  public void fullThrottle() {
    System.out.println("The car is going as fast as it can!");
  }

  public void speed(int maxSpeed) {
    System.out.println("Max speed is: " + maxSpeed);
  }
}

Second.java

class Second {
  public static void main(String[] args) {
    Main myCar = new Main();     // Create a myCar object
    myCar.fullThrottle();      // Call the fullThrottle() method
    myCar.speed(200);          // Call the speed() method
  }
}

When both files have been compiled:

C:\Users\Your Name>javac Main.java
C:\Users\Your Name>javac Second.java

Run the Second.java file:

C:\Users\Your Name>java Second

And the output will be:

The car is going as fast as it can!
Max speed is: 200

Java Constructors

A constructor in Java is a special method that is used to initialize objects. The constructor is called when an object of a class is created. It can be used to set initial values for object attributes:

Example

Create a constructor:

// Create a Main class
public class Main {
  int x;  // Create a class attribute

  // Create a class constructor for the Main class
  public Main() {
    x = 5;  // Set the initial value for the class attribute x
  }

  public static void main(String[] args) {
    Main myObj = new Main(); // Create an object of class Main (This will call the constructor)
    System.out.println(myObj.x); // Print the value of x
  }
}

// Outputs 5

Modifiers

By now, you are quite familiar with the public keyword that appears in almost all of our examples:

public class Main

The public keyword is an access modifier, meaning that it is used to set the access level for classes, attributes, methods and constructors.

We divide modifiers into two groups:

  • Access Modifiers – controls the access level
  • Non-Access Modifiers – do not control access level, but provides other functionality

If you don’t want the ability to override existing attribute values, declare attributes as final:

Example

public class Main {
  final int x = 10;
  final double PI = 3.14;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 50; // will generate an error: cannot assign a value to a final variable
    myObj.PI = 25; // will generate an error: cannot assign a value to a final variable
    System.out.println(myObj.x);
  }
}

Static

A static method means that it can be accessed without creating an object of the class, unlike public:

Example

An example to demonstrate the differences between static and public methods:

public class Main {
  // Static method
  static void myStaticMethod() {
    System.out.println("Static methods can be called without creating objects");
  }

  // Public method
  public void myPublicMethod() {
    System.out.println("Public methods must be called by creating objects");
  }

  // Main method
  public static void main(String[ ] args) {
    myStaticMethod(); // Call the static method
    // myPublicMethod(); This would output an error

    Main myObj = new Main(); // Create an object of Main
    myObj.myPublicMethod(); // Call the public method
  }
}

Abstract

An abstract method belongs to an abstract class, and it does not have a body. The body is provided by the subclass:

Example

// Code from filename: Main.java
// abstract class
abstract class Main {
  public String fname = "John";
  public int age = 24;
  public abstract void study(); // abstract method
}

// Subclass (inherit from Main)
class Student extends Main {
  public int graduationYear = 2018;
  public void study() { // the body of the abstract method is provided here
    System.out.println("Studying all day long");
  }
}
// End code from filename: Main.java

// Code from filename: Second.java
class Second {
  public static void main(String[] args) {
    // create an object of the Student class (which inherits attributes and methods from Main)
    Student myObj = new Student();

    System.out.println("Name: " + myObj.fname);
    System.out.println("Age: " + myObj.age);
    System.out.println("Graduation Year: " + myObj.graduationYear);
    myObj.study(); // call abstract method
  }
}

Encapsulation

The meaning of Encapsulation, is to make sure that “sensitive” data is hidden from users. To achieve this, you must:

  • declare class variables/attributes as private
  • provide public get and set methods to access and update the value of a private variable

Get and Set

You learned from the previous chapter that private variables can only be accessed within the same class (an outside class has no access to it). However, it is possible to access them if we provide public get and set methods.

The get method returns the variable value, and the set method sets the value.

Syntax for both is that they start with either get or set, followed by the name of the variable, with the first letter in upper case:

Example

public class Person {
  private String name; // private = restricted access

  // Getter
  public String getName() {
    return name;
  }

  // Setter
  public void setName(String newName) {
    this.name = newName;
  }
}

Example explained

The get method returns the value of the variable name.

The set method takes a parameter (newName) and assigns it to the name variable. The this keyword is used to refer to the current object.

However, as the name variable is declared as private, we cannot access it from outside this class:

Example

public class Main {
  public static void main(String[] args) {
    Person myObj = new Person();
    myObj.name = "John";  // error
    System.out.println(myObj.name); // error 
  }
}

Java Inner Classes

In Java, it is also possible to nest classes (a class within a class). The purpose of nested classes is to group classes that belong together, which makes your code more readable and maintainable.

To access the inner class, create an object of the outer class, and then create an object of the inner class:

Example

class OuterClass {
  int x = 10;

  class InnerClass {
    int y = 5;
  }
}

public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}

// Outputs 15 (5 + 10)

Private Inner Class

Unlike a “regular” class, an inner class can be private or protected. If you don’t want outside objects to access the inner class, declare the class as private:

Example

class OuterClass {
  int x = 10;

  private class InnerClass {
    int y = 5;
  }
}

public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}




Abstract Classes and Methods


Data abstraction is the process of hiding certain details and showing only essential information to the user.

Abstraction can be achieved with either abstract classes or interfaces (which you will learn more about in the next chapter).


The abstract keyword is a non-access modifier, used for classes and methods:


    

  • 

      

    • Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).
      • 

    

    • 





    

  • Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from).
    • 



An abstract class can have both abstract and regular methods:




abstract class Animal {
  public abstract void animalSound();
  public void sleep() {
    System.out.println("Zzz");
  }
}




From the example above, it is not possible to create an object of the Animal class:




Animal myObj = new Animal(); // will generate an error






Example


// Abstract class
abstract class Animal {
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
}

// Subclass (inherit from Animal)
class Pig extends Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}








Interfaces


Another way to achieve abstraction in Java, is with interfaces.


An interface is a completely “abstract class” that is used to group related methods with empty bodies:




Example


// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}






To access the interface methods, the interface must be “implemented” (kinda like inherited) by another class with the implements keyword (instead of extends). The body of the interface method is provided by the “implement” class:




Example


// Interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}










Notes on Interfaces:


    

  • Like abstract classes, interfaces cannot be used to create objects (in the example above, it is not possible to create an “Animal” object in the MyMainClass)
    • 

  • Interface methods do not have a body – the body is provided by the “implement” class
    • 

  • On implementation of an interface, you must override all of its methods
    • 

  • Interface methods are by default abstract and public
    • 

  • Interface attributes are by default public, static and final
    • 

  • An interface cannot contain a constructor (as it cannot be used to create objects)
    • 



Why And When To Use Interfaces?


1) To achieve security – hide certain details and only show the important details of an object (interface).


2) Java does not support “multiple inheritance” (a class can only inherit from one superclass). However, it can be achieved with interfaces, because the class can implement multiple interfaces. Note: To implement multiple interfaces, separate them with a comma (see example below).






Multiple Interfaces


To implement multiple interfaces, separate them with a comma:




Example


interface FirstInterface {
  public void myMethod(); // interface method
}

interface SecondInterface {
  public void myOtherMethod(); // interface method
}

class DemoClass implements FirstInterface, SecondInterface {
  public void myMethod() {
    System.out.println("Some text..");
  }
  public void myOtherMethod() {
    System.out.println("Some other text...");
  }
}

class Main {
  public static void main(String[] args) {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}






 

            

                            
                    
                                        
        


            

                
            

            

                

                    Apostube
                


                
                

                                    

                

                    

                        See author's posts
                    

                

                                    
    
                                                    
                                
  • 
                                    
                                
    • 
                                                                                                                                                                                        

                            

        


                                            

	

	



					

										
Related Posts

										

													

								

									

										
		

					


		
									

									

										

																					

										
Learn JAVA #15
										
										

											
Java Classes/Objects Java is an object-oriented programming language. Everything in Java is associated with classes and objects, along with its […]

										

									

								

							

														

								

									

										
		

					


		
									

									

										

																					

										
Learn JAVA #14
										
										

											
Java Methods A method is a block of code which only runs when it is called. You can pass data, known as parameters, […]

										

									

								

							

														

								

									

										
		

					


		
									

									

										

																					

										
Learn JAVA #13
										
										

											
Java Switch Statements Instead of writing many if..else statements, you can use the switch statement. The switch statement selects one of many code blocks to be executed: […]

										

									

								

							

												

				

				



			

			89 thoughts on “Learn JAVA #15”		


		
		
    
					
  1. 
			
		
    2. 
		
  2. 
			
		
    3. 
		
  3. 
			
		
    4. 
		
  4. 
			
		
    5. 
		
  5. 
			
		
    6. 
		
  6. 
			
		
    7. 
		
  7. 
			
		
    8. 
		
  8. 
			
		
    9. 
		
  9. 
			
		
    10. 
		
  10. 
			
		
    11. 
		
  11. 
			
		
    12. 
		
  12. 
			
		
    13. 
		
  13. 
			
		
    14. 
		
  14. 
			
		
    15. 
		
  15. 
			
		
    16. 
		
  16. 
			
		
    17. 
		
  17. 
			
		
    18. 
		
  18. 
			
		
    19. 
		
  19. 
			
		
    20. 
		
  20. 
			
		
    21. 
		
  21. 
			
		
    22. 
		
  22. 
			
		
    23. 
		
  23. 
			
		
    24. 
		
  24. 
			
		
    25. 
		
  25. 
			
		
    26. 
		
  26. 
			
		
    27. 
		
  27. 
			
		
    28. 
		
  28. 
			
		
    29. 
		
  29. 
			
		
    30. 
		
  30. 
			
		
    31. 
		
  31. 
			
		
    32. 
		
  32. 
			
		
    33. 
		
  33. 
			
		
    34. 
		
  34. 
			
		
    35. 
		
  35. 
			
		
    36. 
		
  36. 
			
		
    37. 
		
  37. 
			
		
    38. 
		
  38. 
			
		
    39. 
		
  39. 
			
		
    40. 
		
  40. 
			
		
    41. 
		
  41. 
			
		
    42. 
		
  42. 
			
		
    43. 
		
  43. 
			
		
    44. 
		
  44. 
			
		
    45. 
		
  45. 
			
		
    46. 
		
  46. 
			
		
    47. 
		
  47. 
			
		
    48. 
		
  48. 
			
		
    49. 
		
  49. 
			
		
    50. 
		
  50. 
			
		
    51. 
		
  51. 
			
		
    52. 
		
  52. 
			
		
    53. 
		
  53. 
			
		
    54. 
		
  54. 
			
		
    55. 
		
  55. 
			
		
    56. 
		
  56. 
			
		
    57. 
		
  57. 
			
		
    58. 
		
  58. 
			
		
    59. 
		
  59. 
			
		
    60. 
		
  60. 
			
		
    61. 
		
  61. 
			
		
    62. 
		
  62. 
			
		
    63. 
		
  63. 
			
		
    64. 
		
  64. 
			
		
    65. 
		
  65. 
			
		
    66. 
		
  66. 
			
		
    67. 
		
  67. 
			
		
    68. 
		
  68. 
			
		
    69. 
		
  69. 
			
		
    70. 
		
  70. 
			
		
    71. 
		
  71. 
			
		
    72. 
		
  72. 
			
		
    73. 
		
  73. 
			
		
    74. 
		
  74. 
			
		
    75. 
		
  75. 
			
		
    76. 
		
  76. 
			
		
    77. 
		
  77. 
			
		
    78. 
		
  78. 
			
		
    79. 
		
  79. 
			
		
    80. 
		
  80. 
			
    
				

				
    
					
    Read information now. Everything what you want to know about pills.
    
generic ivermectin
    
safe and effective drugs are available. Some are medicines that help people when doctors prescribe.
    
				
    

				
    Reply
    			
    
		
    81. 
		
  81. 
			
		
    82. 
		
  82. 
			
		
    83. 
		
  83. 
			
		
    84. 
		
  84. 
			
		
    85. 
		
  85. 
			
		
    86. 
		
  86. 
			
		
    87. 
		
  87. 
			
		
    88. 
		
  88. 
			
		
    89. 
		
  89. 
			
		
    90. 
		


			

		
Leave a Reply 
Your email address will not be published. Required fields are marked *