Java Development

4 min read

Today’s Summary:

Common Data Types:
- Covered: Integer, String, Character, Array
- Not yet covered: List series (lists), Set series (collections), Map series (dictionaries)
Object-Oriented Programming
Packages (Python packages and modules)

About Object #

In Python, every class by default inherits from the Object class (all classes are subclasses of Object).
In Java, all classes also by default inherit from the Object class.
A base class can be used to generally refer to the types of its subclasses.

☕

java

 import java.util.Arrays; // Import the java.util.Arrays class, used for array operations, but not used in this program
 
 public class Hello { // Define a public class named Hello
 
     public static void main(String[] args) { // The main method, entry point of the program
 
         // String first = "Joebiden"; // Define a string variable named first and initialize it to "Joebiden"
         Object first = new String("Joebiden"); // Define an object variable named first, and initialize it with a String object "Joebiden"
         System.out.println(first); // Print the content of the first object, which is the string "Joebiden"
         System.out.println(first.getClass()); // Print the class information of the first object, i.e., class java.lang.String
 
         Object second = 2027; // Define an object variable named second, and initialize it with the integer 2027 (autoboxed to Integer)
         System.out.println(second); // Print the content of the second object, which is the integer 2027
         System.out.println(second.getClass()); // Print the class information of the second object, i.e., class java.lang.Integer
     }
 }

☕

java

 import java.util.Arrays;
 
 public class Hello {
 
     public static void main(String[] args) {
         // Declare an array, elements must be of type int
         int[] functionname1 = new int[3];
 
         // Declare an array, elements must be of type String
         String[] functionname2 = new String[3];
 
         // Declare an array, elements can be of type int or String (any Object type)
         Object[] functionname3 = new Object[3];
         functionname3[0] = 83;
         functionname3[1] = "joebiden";
     }
 }

So, if you want to declare an array with mixed types in the future, you can use Object to achieve this.

☕

java

 import java.util.Arrays;
 
 public class Hello {
 
     public static void main(String[] args) {
         // v1 refers to a String object
         String v1 = new String("ningkong");
         String res = v1.toUpperCase();
         System.out.println(res);
 
         // v2 is essentially a String object, but declared as Object
         Object v2 = new String("ningkong"); 
         String data = (String) v2;  // type casting back to String
     }
 }

☕

java

 import java.util.Arrays;
 
 public class Hello {
 
     public static void func(Object v1) {
         // System.out.println(v1);
         // System.out.println(v1.getClass());
         if (v1 instanceof Integer) {
             System.out.println("Integer type");
         } else if (v1 instanceof String) {
             System.out.println("String type");
         } else {
             System.out.println("Unknown type");
         }
     }
 
     public static void main(String[] args) {
         func(123);
         func("123");
     }
 }

In Java, all classes inherit from Object, and Object represents all types.
Creating Relationships Yourself

📄

java

ArrayList v1 = new ArrayList();
LinkedList v2 = new LinkedList();
 
List v1 = new ArrayList();
List v2 = new LinkedList();
 
Object v1 = new ArrayList();
Object v2 = new LinkedList();

1. Common Data Types ✅ #

1.1 —The List Interface – used to store multiple pieces of data dynamically. #

Similar to a list in Python. ✅

List is an interface, and it has two commonly used implementations (designed to store multiple dynamic data elements).

ArrayList – storage in contiguous memory addresses (with automatic internal resizing). → This corresponds to the characteristics of Python lists.
LinkedList – implemented based on a linked list structure (like a bicycle chain). → This does not correspond to Python lists (since Python lists are array-based).

☕

java

 ArrayList v1 = new ArrayList();
 v1.add("ningkong");
 v1.add("alice");

 LinkedList v1 = new LinkedList();
 v1.add("boob");
 v1.add("ningkong");

In Java, an interface is used to constrain the classes that implement it, requiring them to contain certain members.

☕

java

 interface List {
     public void add(Object data);   // Methods in an interface do not provide implementations; they only serve as constraints.
 }
 class ArrayList implements List {
     public void add(Object data) {
         // Store the data in memory using a contiguous storage approach.
         // ..
     }
 }
 class LinkedList implements List {
     public void add(Object data) {
         // Store the data in memory in the form of a linked list.
         // ..
     }
 }

☕

java

 
List v1 = new ArrayList();
 v1.add("ningkong");
 v1.add("alice");

List v1 = new LinkedList();
 v1.add("ningkong");
 v1.add("alice");

ArrayList Example：

☕

java

 import java.util.ArrayList;
 import java.util.Arrays;
 
 public class Hello {
 
     public static void main(String[] args) {
 
         // By default, ArrayList can store mixed data types if no generic type is specified.
         // However, it is recommended to use generics for type safety.
         // Example:
         // ArrayList <String> data = new ArrayList <String>();
         // ArrayList <Object> data = new ArrayList <Object>();
 
         ArrayList data = new ArrayList();  // Create an ArrayList to store different data types
         data.add("ningkong");  // Add a String
         data.add("alice");     // Add a String
         data.add(2027);        // Add an Integer
         data.add("windows");   // Add a String
 
         // String value1 = data.get(1);  // Trying to get the second element (compile error without casting)
         // String value2 = (String) data.get(2);  // Cast to String (will cause runtime error if type is not String)
         // System.out.println("I'm value1: " + value1);
         // System.out.println("I'm value2: " + value2);
 
         Object temp = data.get(1);   // Get the second element
         String value = (String) temp; // Cast to String (safe in this case)
         System.out.println(value);
 
         int xo = (int) data.get(2);  // Get the third element and cast to int
         System.out.println(xo);
 
         data.set(0, "hello");  // Modify the first element
         System.out.println(data);
 
         data.remove("bush");   // Try to remove element "bush" (no effect, since it doesn’t exist)
         data.remove(0);        // Remove the first element
         System.out.println("After attempting to remove \"bush\" and removing the first element: " + data);
 
         int size = data.size();  // Get the size of the ArrayList
         System.out.println(size);
 
         boolean exists = data.contains("Ningkong");  // Check if a specific element exists (case-sensitive)
         System.out.println(exists);
 
         for (Object item : data) {  // Iterate over the ArrayList and print each element
             System.out.println("Item: " + item);
         }
 
         for (int i = 0; i < data.size(); i++) {  // Iterate using index
             Object item = data.get(i);
             System.out.println("Index " + i + " --> " + item);
         }
     }
 }

LinkedList Example：

☕

java

 import java.util.LinkedList;
 
 public class Hello {
 
     public static void main(String[] args) {
         // Create a LinkedList to store integers
         LinkedList<Integer> v1 = new LinkedList<Integer>();
         v1.add(2045);  // Add element 2045 to v1
         v1.add(2046);  // Add element 2046 to v1
 
         // Create a LinkedList to store objects of any data type
         LinkedList<Object> v2 = new LinkedList<Object>();
         v2.add("United States");  // Add a string to v2
         v2.add("North America");  // Add a string to v2
         v2.add(2009);             // Add an integer to v2
         v2.add(2025);             // Add an integer to v2
 
         // v2.remove(1);  // Try to remove the element at index 1
         // v2.remove("North America");  // Try to remove the element "North America"
 
         v2.set(2, "Google");    // Replace the third element
         v2.push("Microsoft");   // Add an element to the beginning
 
         // Iterate over the LinkedList and print each element
         for (int i = 0; i < v2.size(); i++) {
             Object item = v2.get(i);
             System.out.println(item);
         }
 
         // Iterate over the LinkedList using an enhanced for loop
         for (Object item : v2) {
             System.out.println(item);
         }
     }
 }

about iterator：

☕

java

 import java.util.*;
 
 public class Hello {
 
     public static void main(String[] args) {
 
         ArrayList s1 = new ArrayList(); // Create an ArrayList called s1
         s1.add("Facebook");  // Add "Facebook" to the list
         s1.add("Qualcomm");  // Add "Qualcomm" to the list
         s1.add("Cisco");     // Add "Cisco" to the list
 
         Iterator it = s1.iterator(); // Create an iterator for the list
         while (it.hasNext()) {       // While there are more elements
             String item = (String) it.next(); // Get the next element as a string
             System.out.println(item);         // Print the element
         }
     }
 }

1.2 — Set Interface — Multi-Element Collection #

Set is an interface in Java. Two common classes that implement this interface are used to represent collections of elements without duplicates.

HashSet – removes duplicates, does not preserve order.
TreeSet – removes duplicates and maintains sorted order (by ASCII or Unicode). [Note: Different data types cannot be directly compared in a TreeSet.]

☕

java

 
 import java.util.*;
 
 public class Hello {
 
     public static void main(String[] args) {
         // Different ways to declare a Set:
         // HashSet s1 = new HashSet();
         // Set s1 = new HashSet();
         // HashSet <String> s1 = new HashSet <String>();
         
         HashSet s1 = new HashSet();
         s1.add("north");
         s1.add("south");
         s1.add("north"); // duplicate ignored
         s1.add("east");
         s1.add(2025);    // allowed, since HashSet accepts mixed types
         System.out.println(s1); // Output example: [north, south, east, 2025]
         
         // Initialize HashSet with elements directly
         HashSet s2 = new HashSet() {{
             add("california");
             add("newyork");
             add("canada");
         }};
         System.out.println(s2);
 
 
 
         // Different ways to declare a TreeSet:
         // Set s3 = new TreeSet();
         // TreeSet <String> s3 = new TreeSet <String>();
 
         TreeSet s3 = new TreeSet();
         s3.add("north");
         s3.add("south");
         s3.add("north"); // duplicate ignored
         s3.add("east");
         // s3.add(2027); // Not allowed, since TreeSet requires comparable elements of the same type
 
         System.out.println(s3); // Output: [east, north, south]
 
         // Initialize TreeSet with elements directly
         TreeSet s4 = new TreeSet() {{
             add("Britsh");  // (probably meant "British")
             add("French");
             add("Germany");
             add("French");  // duplicate ignored
         }};
         System.out.println(s4); // Output: [Britsh, French, Germany]
     }
 }

On Union, Intersection, and Difference:

☕

java

 import java.util.*;
 
 public class Hello {
 
     public static void main(String[] args) {
         // Set s1 = new HashSet();
         HashSet s1 = new HashSet();
         s1.add("push");
         s1.add("pop");
         s1.add("arm64");
         s1.remove("pop");
         System.out.println(s1); // [push, arm64]
 
         boolean exists = s1.contains("");
         System.out.println(exists);
 
         HashSet s2 = new HashSet();
         s2.add(2025);
         s2.add(2026);
 
         HashSet v1 = new HashSet(); // initially empty
         v1.addAll(s1);
         v1.retainAll(s2); // intersection (s1 ∩ s2)
         System.out.println(v1);
 
         HashSet v2 = new HashSet();
         v2.addAll(s1);
         v2.addAll(s2); // union (s1 ∪ s2)
         System.out.println(v2);
 
         HashSet v3 = new HashSet();
         v3.addAll(s1);
         v3.removeAll(s2); // difference (s1 - s2)
         System.out.println(v3);
 
         HashSet v4 = new HashSet();
         v4.addAll(s2);
         v4.removeAll(s1); // difference (s2 - s1)
         System.out.println(v4);
     }
 }

About TreeSet:

☕

java

 import java.util.*;
 
 public class Hello {
 
     public static void main(String[] args) {
 
         TreeSet s1 = new TreeSet();
         s1.add("billgates");
         s1.add("stevejobs");
         s1.add("elonmusk");
 
         for (Object item : s1) {
             System.out.println(item);
         }
     }
 }

About Iterators:

☕

java

 import java.util.*;
 
 public class Hello {
 
     public static void main(String[] args) {
 
         TreeSet s1 = new TreeSet();
         s1.add("north");
         s1.add("south");
         s1.add("west");
 
 
         Iterator it = s1.iterator();
         while (it.hasNext()) {
             String item = (String) it.next();
             System.out.println(item);
         }
 
     }
 }

1.3 — The Map Interface — Storing Key-Value Pairs #

Map is an interface, and there are two common classes that implement this interface, used to store key-value pairs:

HashMap: unordered.
TreeMap: ordered by key by default (commonly used). # In Python, you need to handle the problem of key sorting yourself.

☕

java

 v4 = {
     "aid":2024,
     "cid":2025,
     "wid":2046
 }
 
 # 1. Sort by key
 # data = ["{}={}".format(key, v4[key]) for key in sorted(v4.keys())]
 
 # 2. Then concatenate
 # result = "&".join(data)
 
 result = "&".join(["{}={}".format(key, v4[key]) for key in sorted(v4.keys())])
 print(result)

☕

java

 /**
  * @author calleng
  * @version 1.0
  * @date 2024/07/05 18:44
  * @desc Demonstrates different ways to create and use HashMaps in Java
  */
 
 import java.util.HashMap;
 
 public class LookUp {
 
     public static void main(String[] args) {
         // Example 1: Raw HashMap without generics
         HashMap h1 = new HashMap();
         h1.put("name","bob");
         h1.put("age",39);
         h1.put("gender","male");
         System.out.println(h1); // {gender = male, name = bob, age = 39}
 
         // Example 2: HashMap with generics (String, String)
         HashMap<String,String> h2 = new HashMap<String,String>();
         h2.put("name","alice");
         h2.put("age","18");
         h2.put("gender","female");
         System.out.println(h2); // {gender = female, name = alice, age = 18} ✅ corrected comment
 
         // Example 3: Anonymous inner class with initializer block
         HashMap<String,String> h3 = new HashMap<String,String>(){
             {
                 put("name","charles");
                 put("age","42");
                 put("gender","male");
             }
         };
         System.out.println(h3); // {gender = male, name = charles, age = 42}
     }
 }

☕

java

 /**
  * @author calleng
  * @version 1.0
  * @date 2024/07/05 18:44
  * @desc Example of using HashMap and Map in Java
  */
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class LookUp {
 
     public static void main(String[] args) {
         // Raw HashMap without generics
         HashMap h1 = new HashMap();
         h1.put("name","timcook");
         h1.put("age",64);
         h1.put("gender","male");
         System.out.println(h1); // {gender = male, name = timcook, age = 64}
 
         // HashMap with <String, String>
         HashMap<String,String> h2 = new HashMap<String,String>();
         h2.put("name","masayoshison");
         h2.put("age","68");
         h2.put("gender","male");
         System.out.println(h2); // {gender = male, name = masayoshison, age = 68}
 
         // ❌ Problem here:
         // You declared Map <String, Integer>, but tried to put String values ("jackma", "male").
         // This will cause a compilation error, because "jackma" and "male" are not Integers.
         // Correct approach should be <String, String> if you want to store string values.
 
         /*
         Map <String,Integer> h3 = new HashMap <String,Integer>(){
             {
                 put("name", "jackma");   // ERROR: "jackma" is not Integer
                 put("age",60);          // OK
                 put("gender", "male");   // ERROR: "male" is not Integer
             }
         };
         System.out.println("Direct map usage -> " + h3);
         */
 
         // ❌ Same problem: declared HashMap <String, Integer> but storing Strings
         /*
         HashMap <String,Integer> h4 = new HashMap <String,Integer>(){
             {
                 put("name", "samaltman");   // ERROR
                 put("age",40);             // OK
                 put("gender", "male");      // ERROR
             }
         };
         System.out.println("String, Integer type -> " + h4);
         */
     }
 }

Common Operations:

☕

java

 import java.util.*;
 
 public class Hello {
 
     public static void main(String[] args) {
         TreeMap h1 = new TreeMap(); // Changed to TreeMap
         h1.put("name", "alex");
         h1.put("age", "18");
         h1.put("hobby", "openai");
         h1.put("academy", "sandford");
 
         h1.remove("age");
         int size = h1.size();
 
         Object value = h1.get("name"); // If the key does not exist, returns null
         System.out.println(value);
 
         boolean existsKey = h1.containsKey("age");
         boolean existsValue = h1.containsValue("alex");
 
         h1.replace("name", "timecook");
         System.out.println(h1);
 
         // Loop: Example 1
         // { ("name", "samaltman"), ("age", "40") }
         Set<Map.Entry<String, String>> s1 = h1.entrySet();
         Iterator it1 = s1.iterator();
         while (it1.hasNext()) {
             // ("name", "samaltman")
             Map.Entry<String, String> entry = (Map.Entry<String, String>) it1.next();
             String k = (String) entry.getKey();
             String v = (String) entry.getValue();
         }
 
         // Loop: Example 2
         Set s2 = h1.entrySet();
         Iterator it2 = s2.iterator();
         while (it2.hasNext()) {
             Map.Entry entry = (Map.Entry) it2.next();
             String k = (String) entry.getKey();
             String v = (String) entry.getValue();
         }
 
         // Loop: Example 3
         TreeMap<String, String> h2 = new TreeMap<String, String>(); // Changed to TreeMap
         h2.put("name", "billgates");
         h2.put("age", "69");
         for (Map.Entry<String, String> entry : h2.entrySet()) {
             String k = entry.getKey();
             String v = entry.getValue();
         }
 
         // Loop: Example 4
         TreeMap h3 = new TreeMap(); // Changed to TreeMap
         h3.put("name", "joebiden");
         h3.put("age", 82);
         
         for (Object entry : h3.entrySet()) {
             Map.Entry<String, Object> entryMap = (Map.Entry<String, Object>) entry;
             String k = entryMap.getKey();
             Object v = entryMap.getValue(); 
             
             if (v instanceof Integer) {
                 System.out.println("Number: " + Integer.toString((Integer) v));
             } else if (v instanceof String) {
                 System.out.println("String: " + (String) v);
             } else {
                 System.out.println("Unknown type: " + v.toString());
             }
         }
     }
 }

2. Object-Oriented Programming #

Python: Supports both functional and object-oriented programming.
Java: Purely object-oriented.

2.1 Classes and Objects #

☕

java

 class Person {
     // Instance variables
     public String name;
     public Integer age;
 
     // Constructor 1
     public Person() {
         this.name = "Donald Trump";
         this.age = 79;
     }
 }
 
 Person obj = new Person();

☕

java

 class Person:
     
     # Initialization method: 
     # 1. __new__ method: constructor method that creates an empty object 
     # 2. __init__ method: initializer
     def __init__(self):
         self.name = "obama"
         self.age = 64
         
 obj = Person()

☕

java

 class Person {
 
     // Instance variables
     public String name;
     public Integer age;
     public String email;
 
     // Constructor 1
     public Person() {
         this.name = "Obama";
         this.age = 64;
     }
 
     // Constructor 2
     public Person(String name, Integer age) {
         this.name = name;
         this.age = age;
         this.email = "google@yahoo.com";
     }
 
     // Constructor 3
     public Person(String name, String email) {
         this.name = name;
         this.age = 83;
         this.email = email;
     }
 }
 
 Person obj1 = new Person("donald trump", 79);
 Person obj2 = new Person();

☕

java

 class Person {
 
     // Instance variables
     public String fullName;
     public Integer age;
     public String emailAddress;
 
     // Constructor 1 (no arguments)
     public Person() {
         this.fullName = "Eric";
         this.age = 99999;
     }
 
     // Constructor 2 (name + age)
     public Person(String fullName, Integer age) {
         this.fullName = fullName;
         this.age = age;
         this.emailAddress = "example@live.com";
     }
 
     // Constructor 3 (name + email)
     public Person(String fullName, String emailAddress) {
         this.fullName = fullName;
         this.age = 83;
         this.emailAddress = emailAddress;
     }
 
     // Method (overloaded) - no parameters
     public void introduce() {
         System.out.println(this.fullName);
     }
 
     // Method (overloaded) - with prefix
     public void introduce(String prefix) {
         String text = String.format("%s%s", prefix, this.fullName);
         System.out.println(text);
     }
 }
 
 public class Hello {
 
     public static void main(String[] args) {
         
         // When instantiating objects, encapsulation is demonstrated
         Person person1 = new Person();
         Person person2 = new Person("Alex Johnson", 73);
         Person person3 = new Person("Tony Smith", "tony.smith@example.com");
 
         person1.introduce();
         person1.introduce("Hello, ");
 
         person2.introduce();
         person2.introduce("Hello, ");
 
         person3.introduce();
         person3.introduce("Hello, ");
     }
 }

2.3 Static Members — Static Belong to the Class; Non-Static Belong to the Object #

☕

java

 class Person:
     school_name = "Tsinghua University"   # Static variable (belongs to the class, independent of any object)
     
     def __init__(self):
         self.full_name = "Alice"          # Instance variable (belongs to the object)
         
 
 # Access the static variable directly via the class
 print(Person.school_name)
 
 # 1. Create an empty object in memory
 # 2. Automatically call the constructor (__init__)
 student = Person()
 print(student.full_name)   # Access instance variable
 print(student.school_name) # Access static variable (still works through the object)

☕

java

 class Person {
     // Static variable
     public static String city = "New York";
     
     // Instance variables
     public String name;
     public Integer age;
 
     // Constructor 1
     public Person() {
         this.name = "Alice";
         this.age = 30;
     }
     
     // Instance method
     public void showInfo() {
         System.out.println("Name: " + this.name + ", Age: " + this.age + ", City: " + city);
     }
     
     // Static method
     public static void showData() {
         System.out.println("All persons live in " + city);
     }
 }
 
 // Access static variable
 Person.city;
 
 // Call static method
 Person.showData();
 
 // Create object
 Person obj = new Person();
 obj.name;
 obj.age;
 obj.showInfo();

Essence: Static members belong to the class, while non-static members belong to the object.

2.3 Inheritance – A Class Only Supports Single Inheritance #

In Java, inheritance only supports single inheritance.It does not support multiple inheritance, but it does support implementing multiple interfaces.
//Overloading: When a class contains multiple methods with the same method name but with different numbers or types of parameters. //Overriding: When a subclass redefines a method that already exists in its parent class.

☕

java

 class Animal {
     ...
 }
 
 class Vehicle {
     ...
 }
 
 // Single inheritance
 class Dog extends Animal {
     ...
 }

☕

java

 interface Addable {
     public void add();
 }
 
 interface Multipliable {
     public void multiply();
 }
 
 class Calculator implements Addable, Multipliable {
     public void add() {
         // implementation
     }
     public void multiply() {
         // implementation
     }
 }

In Python, multiple inheritance is supported:

🐍

python

 class Dog(Animal, Pet):
     pass
 
 class Calculator(Addable, Multipliable):
     pass

☕

java

 class Account {
     public String email;
 
     public Account(String email) {
         this.email = email;
     }
 
     public String getAccountInfo() {
         return String.format("%s", this.email);
     }
 }
 
 // Example usage:
 // Account acc = new Account("test@example.com");
 // acc.email;        // "test@example.com"
 // acc.getAccountInfo();  // "test@example.com"
 
 class Person extends Account {
 
     public String name;
     public Integer age;
 
     public Person(String name, Integer age, String email) {
         super(email); // calls parent constructor
         this.name = name;
         this.age = age;
     }
 
     public String getProfile(String prefix) {
         return String.format("%s-%d-%s", this.name, this.age, this.email);
     }
 }
 
 // Example usage:
 Person president = new Person("Joe Biden", 82, "joebiden@google.com");
 
 // president.name;   // "Joe Biden"
 // president.age;    // 82
 // president.email;  // "joebiden@google.com"
 
 // president.getProfile("prefix");   // "Joe Biden-82-joebiden@google.com"
 // president.getAccountInfo();       // "joebiden@google.com"

Using a parent class to refer to all of its subclasses.

☕

java

 // Base class
 class Base {
     public void show() {
         System.out.println("This is Base class");
     }
 }
 
 // Subclass Person extends Base
 class Person extends Base {
     @Override
     public void show() {
         System.out.println("This is Person class");
     }
 }
 
 public class Hello {
     public static void main(String[] args) {
         Person personObj = new Person();
         personObj.show(); // Output: This is Person class
 
         Base baseObj = new Base();
         baseObj.show(); // Output: This is Base class
 
         Base polymorphicObj = new Person();
         polymorphicObj.show(); // Output: This is Person class (polymorphism)
     }
 }

Example with Constructor and Fields

☕

java

// Base class
 class Base {
     public String email;
 
     public Base(String email) {
         this.email = email;
     }
 
     public void getSubInfo() {
         System.out.println("Base Info: " + email);
     }
 }
 
 // Person class inherits from Base
 class Person extends Base {
     public String name;
     public int age;
 
     public Person(String name, int age, String email) {
         super(email); // call parent constructor
         this.name = name;
         this.age = age;
     }
 
     @Override
     public void getSubInfo() {
         System.out.println("Person Info: " + name + ", " + age + ", " + email);
     }
 }
 
 public class Hello {
     public static void handler(Base obj) {
         obj.getSubInfo(); // Demonstrates polymorphism
     }
 
     public static void main(String[] args) {
         Person person1 = new Person("Alice", 30, "alice@example.com");
         handler(person1); // Output: Person Info: Alice, 30, alice@example.com
 
         Base base1 = new Base("contact@example.com");
         handler(base1); // Output: Base Info: contact@example.com
 
         Base person2AsBase = new Person("Bob", 25, "bob@example.com");
         handler(person2AsBase); // Output: Person Info: Bob, 25, bob@example.com
     }
 }

2.4 Interfaces — A Class Can Implement Multiple Interfaces #

Constrains the implementing class by requiring it to include specific members
Generally refers to the objects created by the implementing class
Contains no implementation itself
A single class can implement multiple interfaces

☕

java

 interface MessageService {
     public void send();
 }
 
 // The WeChat class "implements" the MessageService interface
 class WeChat implements MessageService {
     public void send() {
         System.out.println("Sending a message via WeChat");
     }
 }
 
 class DingTalk implements MessageService {
     public void send() {
         System.out.println("Sending a message via DingTalk");
     }
 }
 
 class SMS implements MessageService {
     public void send() {
         System.out.println("Sending a text message via SMS");
     }
 }
 
 // Example usage
 WeChat wechatService = new WeChat();
 MessageService messageService = new WeChat();

☕

java

 public class Hello {
 
     // Polymorphism -> multiple forms of IMessage
     public static void handleMessage(IMessage message) {
         message.send();
     }
 
     // Main function
     public static void main(String[] args) {
         Sms smsMessage = new Sms();
         handleMessage(smsMessage);
     }
 }

In Java: multiple class inheritance is not supported; implementing multiple interfaces is supported.

☕

java

 interface PersonActions {
     void speak();
 
     void speak(int age);
 
     void describe(String details);
 }
 
 interface UserActions {
     String generateUserId(int id);
 }
 
 class User {
     public String fullName;
     public Integer age;
     public String email;
 
     public User(String fullName, Integer age, String email) {
         this.fullName = fullName;
         this.age = age;
         this.email = email;
     }
 
     public String getContactInfo() {
         return String.format("Email: %s", this.email);
     }
 }
 
 class Person extends User implements UserActions, PersonActions {
 
     public Person(String fullName, Integer age, String email) {
         super(fullName, age, email);
     }
 
     public String getProfile() {
         return String.format("Name: %s | Age: %d | Email: %s", this.fullName, this.age, this.email);
     }
 
     @Override
     public void speak() {
         System.out.println("Speaking with no parameters.");
     }
 
     @Override
     public void speak(int age) {
         System.out.println("Speaking with age parameter: " + age);
     }
 
     @Override
     public void describe(String details) {
         System.out.println("Description: " + details);
     }
 
     @Override
     public String generateUserId(int id) {
         return "USER-" + id;
     }
 }
 
 public class HelloWorld {
 
     public static void main(String[] args) {
         Person person = new Person("Donald Trump", 79, "donaldtrump@live.com");
         person.speak();
         person.speak(79);
         person.describe("Former U.S. President");
         System.out.println(person.getProfile());
         System.out.println("Generated ID: " + person.generateUserId(2026));
     }
 }

Suppose I am doing reverse engineering and have obtained an APK. I search for a keyword, such as printInfo, and locate an interface:

☕

java

 interface Person {
     public void showName();
 
     public void showAge(int age);
 
     public void printInfo(String details);
 }

The next step is to check which classes implement the Person interface.

If only one class implements Person, then that class is the target.
If multiple classes implement the Person interface, you need to filter and determine which specific class is the one of interest.

2.5 Abstraction — (Inheritance + Interfaces) ) #

☕

java

 // Abstract class
 abstract class MediaPlayer {
 
     // Abstract method (forces subclasses to implement this method)
     public abstract void play(String trackName);
 
     // Normal method
     public void stop() {
         System.out.println("Stop");
     }
 }
 
 // Subclass
 class AudioPlayer extends MediaPlayer {
     @Override
     public void play(String trackName) {
         System.out.println("Playing: " + trackName);
     }
 }
 
 public class Main {
     public static void main(String[] args) {
         AudioPlayer player = new AudioPlayer();
         player.stop();
         player.play("Song A");
 
         // Base class reference can also point to a subclass
         MediaPlayer genericPlayer = new AudioPlayer();
         genericPlayer.play("Song B");
     }
 }

Note: A base class reference can also generally refer to its subclasses.

3.Package Concept #

☕

java

 src
 ├── MainApp.java
 └── utils
     └── MessageUtils.java

☕

java

 // MainApp.java
 
 import utils.MessageUtils;
 
 public class MainApp {
 
     public static void main(String[] args) {
         String message = MessageUtils.getMessage();
         System.out.println(message);
     }
 }

☕

java

 // MessageUtils.java
 
 package utils;
 
 public class MessageUtils {
     public static String getMessage() {
         return "Joe Biden";
     }
 }

Class Modifiers

public – Public, can be accessed by anyone from any package.
default – No modifier; can only be accessed within the same package.

Class Member Modifiers

public – Public, accessible to all classes that can access the class itself.
private – Private, accessible only within the same class.
protected – Accessible within the same package, or by subclasses (even if they are in a different package).
default – No modifier; accessible only within the same package.

Purpose: Using modifiers makes the calling and access relationships clearer. (However, in many projects, these modifiers are not always used in a very strict or “textbook” way.)

What are your Feelings

Still stuck? How can we help?

Updated on September 6, 2025

Java Basic Knowledge

C Lang

Java Development

About Object #

1. Common Data Types ✅ #

1.1 —The List Interface – used to store multiple pieces of data dynamically. #

1.2 — Set Interface — Multi-Element Collection #

1.3 — The Map Interface — Storing Key-Value Pairs #

2. Object-Oriented Programming #

2.1 Classes and Objects #

2.3 Static Members — Static Belong to the Class; Non-Static Belong to the Object #

2.3 Inheritance – A Class Only Supports Single Inheritance #

2.4 Interfaces — A Class Can Implement Multiple Interfaces #

2.5 Abstraction — (Inheritance + Interfaces) ) #

3.Package Concept #

What are your Feelings

Leave a Reply Cancel reply