Coretan Kod Java :)

Sintaks

Pengubahsuai Akses:

Awam
Kelas, kaedah atau pembolehubah yang ditakrifkan sebagai awam, boleh diakses oleh mana-mana kelas atau kaedah.

Dilindungi
Protected boleh diakses oleh kelas pakej yang sama, atau oleh subkelas kelas ini, atau dalam kelas yang sama.
(Nota: Kata kunci ini hanya dibenarkan untuk kelas bersarang)

Persendirian
Kelas persendirian, kaedah atau pembolehubah yang ditakrifkan sebagai persendirian boleh diakses dalam kelas sahaja.

Lalai
Lalai boleh diakses dalam pakej sahaja. Secara lalai, semua kelas, kaedah dan pembolehubah adalah daripada skop lalai.

package com.example;

public class Example {
    private int privateVar = 10;
    int defaultVar = 20;
    protected int protectedVar = 30;
    public int publicVar = 40;

    public static void main(String[] args) {
        Example example = new Example();

        // Accessing all variables within the same class
        System.out.println("Private Var: " + example.privateVar);
        System.out.println("Default Var: " + example.defaultVar);
        System.out.println("Protected Var: " + example.protectedVar);
        System.out.println("Public Var: " + example.publicVar);
    }
}

//Another file
package com.example;

public class Example1 {
    public static void main(String[] args) {
        Example example = new Example();

        // Private variable is inaccessible
        System.out.println("Default Var: " + example.defaultVar);
        System.out.println("Protected Var: " + example.protectedVar);
        System.out.println("Public Var: " + example.publicVar);
    }
}

// File: Different.java
package com.example.subpackage;

import com.example.Example;

public class Different extends Example {
    public static void main(String[] args) {
        Example example = new Example();
        Different subClassExample = new Different();

        // Private variable is inaccessible
        // Default variable is inaccessible
        // Protected variable is inaccessible
        System.out.println("Public Var: " + example.publicVar);

        // Accessing protected variable through inheritance
        System.out.println("Protected Var (through inheritance): " + subClassExample.protectedVar);
    }
}

Jenis data

public class Main {

    // Class to demonstrate structure equivalent
    static class Person {
        String name; // Default value is null
        int age; // Default value is 0
        float salary; // Default value is 0.0f
    }

    // Enumeration to demonstrate enum equivalent
    enum Color { RED, GREEN, BLUE }

    public static void main(String[] args) {

        // Basic data types
        int a = 10; // Default value is 0
        float b = 5.5f; // Default value is 0.0f
        char c = 'A'; // Default value is '\u0000'
        double d = 2.3; // Default value is 0.0d
        long e = 123456789L; // Default value is 0L
        short f = 32000; // Default value is 0
        byte g = 100; // Default value is 0

        // Array
        int[] arr = {1, 2, 3, 4, 5};

        // Structure equivalent
        Person person1 = new Person();
        person1.age = 30;
        person1.salary = 55000.50f;

        // Enumeration
        Color myColor = Color.RED;
    }
}

Berlebihan

Pembebanan Kaedah berlaku apabila berbilang kaedah mempunyai nama yang sama tetapi parameter berbeza dalam kelas yang sama. Ini diselesaikan pada masa penyusunan.

class MathOperations {
    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Method to add three integers
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // Method to add two double values
    public double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperations math = new MathOperations();

        System.out.println(math.add(2, 3));
        System.out.println(math.add(1, 2, 3));
        System.out.println(math.add(2.5, 3.5));
    }
}

Mengatasi

Penggantian Kaedah berlaku apabila subkelas menyediakan pelaksanaan khusus untuk kaedah yang telah ditakrifkan dalam kelas supernya. Ini diselesaikan pada masa jalan

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound(); // Calls method in Animal class

        Dog myDog = new Dog();
        myDog.makeSound(); // Calls overridden method in Dog class
    }
}

Susunan

Tatasusunan dan Objek sentiasa dilalui oleh rujukan bukan sebagai salinan. Jenis data primitif dihantar mengikut nilai.

public class Main {
    public static void main(String[] args) {

        // Integer array
        int[] intArray = new int[5]; // Default values: 0
        int[] intArray2 = {1, 2, 3, 4, 5}; // Initialized with specific values

        // Float array
        float[] floatArray = new float[5]; // Default values: 0.0f
        float[] floatArray2 = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f}; // Initialized with specific values

    }
}

Kata Kunci Lalai

Kaedah lalai ialah kaedah yang ditakrifkan dalam antara muka dengan kata kunci lalai. Ini membolehkan antara muka menyediakan pelaksanaan kaedah tanpa menjejaskan kelas yang melaksanakan antara muka.

interface Animal {
    void makeSound(); // abstract method

    // Default method
    default void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();

        dog.makeSound(); // Output: Bark
        dog.sleep();     // Output: Sleeping...

    }
}

Kata kunci statik

Ia menunjukkan bahawa ahli (pembolehubah, kaedah atau kelas bersarang) tergolong dalam kelas itu sendiri dan bukannya tika kelas.
(Nota: Kami tidak boleh mengisytiharkan pembolehubah statik dalam kaedah bukan statik)

public class StaticExample {
    // Static variable
    static int staticVariable = 10;

    // Instance variable
    int instanceVariable = 20;

    // Static method
    static void staticMethod() {
        // Can access static variable
        System.out.println(staticVariable);

        // Cannot access instance variable directly
        // System.out.println(instanceVariable);
    }

    // Instance method
    void instanceMethod() {

        // Can access static variable
        System.out.println(staticVariable);

        // Can access instance variable
        System.out.println(instanceVariable);
    }

    // Static nested class
    static class StaticNestedClass {
        void display() {
            System.out.println("Static nested class method called.");
            // Can access static members of the outer class
            System.out.println("Static variable from nested class: " + staticVariable);
        }
    }

    public static void main(String[] args) {
        // Call static method
        StaticExample.staticMethod();

        // Create an instance of the class
        StaticExample example = new StaticExample();
        // Call instance method
        example.instanceMethod();

        // Create an instance of the static nested class
        StaticNestedClass nestedClass = new StaticNestedClass();
        nestedClass.display();
    }
}

Inisialisasi

(Nota: Hanya contoh dan pembolehubah statik diawal dengan nilai lalai)

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
          int num;
          int num1=0;
          System.out.println(num); //Throws error
          System.out.println(num1); // prints 0 
    }
}

Kaedah paparan dan parameter kelasnya

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = LinkedList.class;
        // Get all methods of the class
        Method[] methods = clazz.getDeclaredMethods();
        // Print the names and parameters of all methods
        for (Method method : methods) {
            System.out.print("Method Name: " + method.getName());
            System.out.print(", Parameters: ");
            Parameter[] parameters = method.getParameters();
            for (Parameter parameter : parameters) {
                System.out.print(parameter.getType().getName() + " " + parameter.getName() + ", ");
            }
            System.out.println();
        }
    }
}

Input/Output Asas

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        // Reading integer input
        System.out.print("Enter an integer: ");
        int intValue = scan.nextInt();
        System.out.println("Integer entered: " + intValue);

        // Reading double input
        System.out.print("Enter a double: ");
        double doubleValue = scan.nextDouble();
        System.out.println("Double entered: " + doubleValue);

        // Reading string input (including spaces)
        System.out.print("Enter a string: ");
        scan.nextLine(); // Consume the newline character
        String stringValue = scan.nextLine();
        System.out.println("String entered: " + stringValue);

        // Reading character input
        System.out.print("Enter a character: ");
        char charValue = scan.next().charAt(0);
        System.out.println("Character entered: " + charValue);

        // Reading boolean input
        System.out.print("Enter a boolean (true/false): ");
        boolean booleanValue = scan.nextBoolean();
        System.out.println("Boolean entered: " + booleanValue);

        // Reading input until there is no more input available
        System.out.println("Enter multiple lines of input (Ctrl+D / Ctrl+Z to exit):");
        scan.nextLine(); // Consume the newline character
        while (scan.hasNext()) {
            String line = scan.nextLine();
            System.out.println("Input: " + line);
        }

        scan.close();
    }
}

Untuk Gelung

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; ++i) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

Manakala Gelung

public class Main {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            System.out.print(i + " ");
            ++i;
        }
        System.out.println();
    }
}

Fungsi

public class Main {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(5, 3);
        System.out.println("Sum: " + result);
    }
}

Kelas dan Objek

public class Rectangle {
    private int width, height;

    public Rectangle(int w, int h) {
        this.width = w;
        this.height = h;
    }

    public int area() {
        return width * height;
    }

    public static void main(String[] args) {
        Rectangle rect = new Rectangle(5, 3);
        System.out.println("Area: " + rect.area());
    }
}

Warisan

public class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }

    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw();
    }
}

Kata kunci akhir

Ia dicipta dengan menambah akhir kata kunci

1) Pembolehubah akhir
Pembolehubah ini setelah dimulakan tidak boleh diubah

public class FinalVariableExample {
    public static void main(String[] args) {
        final int x = 10;
        // x = 20; // This will cause a compilation error
        System.out.println(x);// 10
    }
}

2) Kaedah akhir
Kaedah ini tidak boleh diganti

class Parent {
    final void show() {
        System.out.println("This is a final method.");
    }
}

class Child extends Parent {
    // void show() { // This will cause a compilation error
    //    System.out.println("Trying to override.");
    // }
}

public class FinalMethodExample {
    public static void main(String[] args) {
        Child c = new Child();
        c.show(); // Output: This is a final method.
    }
}

Kata kunci super

Kata kunci super dalam Java digunakan untuk merujuk kepada kelas induk terdekat bagi objek semasa. Ia menyediakan cara untuk mengakses ahli (kaedah dan pembolehubah) kelas induk dari dalam kelas anak.

class Parent {
    int x = 10;

    void display() {
        System.out.println("Parent's display method");
    }

    Parent() {
        System.out.println("Parent's constructor");
    }
}

class Child extends Parent {
    int x = 20;

    void display() {
        super.display(); // Calls the display method of Parent class
        System.out.println("Child's display method");
    }

    Child() {
        super(); // Calls the constructor of Parent class
        System.out.println("Child's constructor");
    }
}

public class Test {
    public static void main(String[] args) {
        Child obj = new Child();
        System.out.println("Value of x in Child: " + obj.x);
        obj.display();
    }
}

Abstrak

Kata kunci abstrak dalam Java digunakan untuk menentukan kelas abstrak dan kaedah abstrak. Kelas abstrak tidak boleh digunakan secara langsung dan dimaksudkan untuk disubkelaskan. Kaedah abstrak tidak mempunyai badan dan mesti dilaksanakan oleh subkelas.
Ia mengandungi kaedah abstrak dan konkrit

abstract class Animal {
    // Abstract method (does not have a body)
    abstract void makeSound();

    // Regular method
    void eat() {
        System.out.println("This animal is eating.");
    }
}

class Dog extends Animal {
    // The body of the abstract method is provided here
    void makeSound() {
        System.out.println("Woof");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSound();  // Output: Woof
        myDog.eat();        // Output: This animal is eating.
    }
}

Apabila satu antara muka mahu mewarisi kaedah daripada antara muka lain, ia menggunakan kata kunci lanjutan.

Kelas abstrak boleh melaksanakan antara muka. Ini bermakna kelas abstrak menyediakan pelaksanaan separa antara muka menggunakan kata kunci implements.

Kelas abstrak boleh melanjutkan kelas abstrak lain menggunakan kata kunci lanjutan

Antara muka

Ia adalah jenis rujukan yang serupa dengan kelas yang mengandungi hanya pemalar, kaedah lalai, kaedah statik dan tandatangan kaedah
(Nota: Hanya definisi kaedah lalai yang terdapat dalam antara muka)
(Nota: Pemalar yang diisytiharkan di dalam antara muka ialah awam, statik dan akhir)

interface Animal {
    void makeSound(); // abstract method
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // Output: Bark
        cat.makeSound(); // Output: Meow
    }
}

Mengatasi Masalah Berlian (warisan berganda):

interface A {
    void display();
}

interface B extends A {
    default void display() {
        System.out.println("Display from B");
    }
}

interface C extends A {
    default void display() {
        System.out.println("Display from C");
    }
}

class D implements B, C {

    @Override
    public void display() {
        B.super.display();
        C.super.display();
        System.out.println("Display from D");
    }
}

public class Main {
    public static void main(String[] args) {
        D d = new D();
        d.display();

        //Output
        //Display from B
        //Display from C
        //Display from D
    }
}

Senaraikan

import java.util.LinkedList;
import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {

        // Declare list as LinkedList
        List<Character> list = new LinkedList<>();

        // Add elements
        list.add('A');
        list.add('B');
        list.add('C');

        // Change implementation to ArrayList
        list = new ArrayList<>(list);

        // Add more elements
        list.add('D');
        list.add('E');

        // Change implementation to Vector
        list = new Vector<>(list);

        // Add more elements
        list.add('F');
        list.add('G');
    }
}

Beratur

Antara muka Queue di Java ialah sebahagian daripada Rangka Kerja Koleksi Java dan mewakili koleksi yang direka untuk memegang elemen sebelum diproses. Ia biasanya memesan elemen dalam cara FIFO (masuk-dahulu-keluar), tetapi pesanan lain boleh dilakukan, seperti LIFO (masuk-dahulu-keluar terakhir) dalam kes pelaksanaan Deque.

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Deque;

public class QueueExample {
    public static void main(String[] args) {
        // Using LinkedList as a Queue
        Queue<String> queue = new LinkedList<>();
        queue.add("Java");
        queue.add("Python");
        queue.add("C++");

        // Reassigning to PriorityQueue
        queue = new PriorityQueue<>();
        queue.add("Java");
        queue.add("Python");
        queue.add("C++");

        // Reassigning to ArrayDeque
        queue = new ArrayDeque<>();
        queue.add("Java");
        queue.add("Python");
        queue.add("C++");
    }
}

Koleksi

ArrayList

1.Saiz semula dinamik
2.Melaksanakan antara muka Senarai

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        for (int num : list) {
            System.out.print(num + " ");
        }
        System.out.println();

        // Inserting an element
        list.add(2, "Ruby");

        // Accessing elements
        System.out.println("Element at index 3: + list.get(3));

        // Removing an element 
        list.remove(1);

        // Size of the list 
        System.out.println(list.size());

        // Check if list is empty 
        System.out.println("Is list empty? + list.isEmpty());

        // Check if list contains an element 
        System.out.println(list.contains("Java"));

        // Index of an element 
        System.out.println(list.indexOf("JavaScript"));

        // Last index of an element 
        System.out.println(list.lastIndexOf("Ruby"));

        // Clear the list
        list.clear()
    }
}

Stack

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {

        // Create a stack
        Stack<String> stack = new Stack<>();

        // Push elements onto the stack
        stack.push("Java");
        stack.push("Python");
        stack.push("C++");

        // Print the stack after pushes
        System.out.println("Stack after pushes: " + stack);

        // Get the size of the stack
        int size = stack.size();
        System.out.println("Size of stack: " + size);

        // Peek at the top element without removing it
        String topElement = stack.peek();
        System.out.println("Top element (peek): " + topElement);

        // Pop an element from the stack
        String poppedElement = stack.pop();
        System.out.println("Popped element: " + poppedElement);

        // Print the stack after pop
        System.out.println("Stack after pop: " + stack);

        // Check if the stack is empty
        boolean isEmpty = stack.isEmpty();
        System.out.println("Is stack empty? " + isEmpty);

        // Get the size of the stack after pop
        size = stack.size();
        System.out.println("Size of stack after pop: " + size);

        // Search for an element
        int position = stack.search("Java");
        System.out.println("Position of element 'Java': " + position);
    }
}

LinkedList

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // Create a new LinkedList
        LinkedList<String> linkedList = new LinkedList<>();

        // Add elements to the LinkedList
        linkedList.add("Java");
        linkedList.add("Python");
        linkedList.add("C++");
        System.out.println("Initial LinkedList: " + linkedList);

        // Add element at specific index
        linkedList.add(1, "JavaScript");
        System.out.println("After add(1, 'JavaScript'): " + linkedList);

        // Add element at the beginning
        linkedList.addFirst("HTML");
        System.out.println("After addFirst('HTML'): " + linkedList);

        // Add element at the end
        linkedList.addLast("CSS");
        System.out.println("After addLast('CSS'): " + linkedList);

        // Get elements
        System.out.println("First element: " + linkedList.getFirst());
        System.out.println("Last element: " + linkedList.getLast());
        System.out.println("Element at index 2: " + linkedList.get(2));

        // Remove elements
        linkedList.remove(); // removes the first element
        System.out.println("After remove(): " + linkedList);

        linkedList.remove(2); // removes the element at index 2
        System.out.println("After remove(2): " + linkedList);

        linkedList.removeFirst(); // removes the first element
        System.out.println("After removeFirst(): " + linkedList);

        linkedList.removeLast(); // removes the last element
        System.out.println("After removeLast(): " + linkedList);

        // Check if the list contains a specific element
        System.out.println("Contains 'Python': " + linkedList.contains("Python"));

        // Get the size of the list
        System.out.println("Size of LinkedList: " + linkedList.size());

        // Clear the list
        linkedList.clear();
        System.out.println("After clear(): " + linkedList);

        // Check if the list is empty
        System.out.println("Is LinkedList empty? " + linkedList.isEmpty());
    }
}

HashMap

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Alice", 90);
        map.put("Bob", 85);

        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
    }
}

String

public class StringExamples {
    public static void main(String[] args) {
        // Creating an empty string
        String emptyString = new String();
        System.out.println("Empty String: \"" + emptyString + "\"");

        // Creating a string from another string
        String original = "Hello, World!";
        String copy = new String(original);
        System.out.println("Copy of original: " + copy);

        // Creating a string from a character array
        char[] charArray = {'J', 'a', 'v', 'a'};
        String fromCharArray = new String(charArray);
        System.out.println("String from char array: " + fromCharArray);

        // Length of the string
        int length = original.length();
        System.out.println("Length of original string: " + length);

        //Check if two strings are equal
        String str1 = "Java";
        String str2 = "Java";

        System.out.println(str1.equals(str2)); // true


        // Check if the string is empty
        boolean isEmpty = original.isEmpty();
        System.out.println("Is original string empty? " + isEmpty);

        // Character at a specific index
        char charAt2 = original.charAt(2);
        System.out.println("Character at index 2 in original string: " + charAt2);

        // Convert to uppercase
        String upperCaseStr = original.toUpperCase();
        System.out.println("Uppercase: " + upperCaseStr);

        // Convert to lowercase
        String lowerCaseStr = original.toLowerCase();
        System.out.println("Lowercase: " + lowerCaseStr);

        // Character methods
        char ch1 = 'A';
        char ch2 = 'a';
        char ch3 = '1';
        char ch4 = ' ';
        char ch5 = '\u2603'; // Unicode character for snowman

        System.out.println("isDigit('1'): " + Character.isDigit(ch3)); // true
        System.out.println("isLetter('A'): " + Character.isLetter(ch1)); // true
        System.out.println("isLetterOrDigit('a'): " + Character.isLetterOrDigit(ch2)); // true
        System.out.println("isLowerCase('a'): " + Character.isLowerCase(ch2)); // true
        System.out.println("isUpperCase('A'): " + Character.isUpperCase(ch1)); // true
        System.out.println("isWhitespace(' '): " + Character.isWhitespace(ch4)); // true
        System.out.println("toLowerCase('A'): " + Character.toLowerCase(ch1)); // 'a'
        System.out.println("toUpperCase('a'): " + Character.toUpperCase(ch2)); // 'A'

        // Reverse a string using StringBuilder
        String reversedStr = reverseUsingStringBuilder(original);
        System.out.println("Reversed string: " + reversedStr);
    }

    public static String reverseUsingStringBuilder(String str) {
        StringBuilder stringBuilder = new StringBuilder(str);
        stringBuilder.reverse();
        return stringBuilder.toString();
    }
}

File I/O

import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        // Write to file
        try (FileWriter writer = new FileWriter("example.txt")) {
            writer.write("Hello, file I/O!\n");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Read from file
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Exception Handling

(Note: When catching exceptions the more specific exceptions must be listed before the more general)

public class Main {
    public static int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero");
        }
        return a / b;
    }

    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Inner Classes

An inner class is a class defined within another class.

1. Member Inner Class A member inner class is associated with an instance of the outer class. It has access to the outer class's instance variables and methods.

public class OuterClass {
    private String outerField = "Outer Field";

    class InnerClass {
        void display() {
            System.out.println("Accessing outer field: " + outerField);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}

1. Static Nested Class A static nested class is a static class defined within another class. It does not have access to the instance members of the outer class but can access its static members.

public class OuterClass {
    private static String staticField = "Static Field";

    static class StaticNestedClass {
        void display() {
            System.out.println("Accessing static field: " + staticField);
        }
    }

    public static void main(String[] args) {
        OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
        nested.display();
    }
}

1. Local Inner Class A local inner class is defined within a block or method and can access local variables (which must be final or effectively final) and the outer class's members.

public class OuterClass {
    void method() {
        final String localVariable = "Local Variable";

        class LocalInnerClass {
            void display() {
                System.out.println("Accessing local variable: " + localVariable);
            }
        }

        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.method();
    }
}

1. Anonymous Inner Class An anonymous inner class is a type of inner class without a name. It can extend exactly one class or implement exactly one interface

class BaseClass {
    void display() {
        System.out.println("BaseClass display()");
    }
}

public class Main {
    public static void main(String[] args) {
        BaseClass obj = new BaseClass() {
            @Override
            void display() {
                System.out.println("Anonymous inner class display()");
            }
        };

        obj.display();
    }
}

Lambda Expressions

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);
        nums.add(5);

        nums.replaceAll(n -> n * 2);

        for (int num : nums) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

Switch Statement

public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day");
                break;
        }
    }
}

Normal Pointers

Java does not use explicit pointers as C++ does;

Lower and Upper case:

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello, World!";
        String str2= "HELLO, WORLD!";

        String lowerStr = str2.toLowerCase();
        String upperStr = str1.toUpperCase();

        System.out.println(lowerStr);  // Output: hello, world!
        System.out.println(upperStr);  // Output: HELLO, WORLD!
    }
}

Atas ialah kandungan terperinci Coretan Kod Java :). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!