搜索

首页  >  文章  >  Java  >  Java 代码片段:)

Java 代码片段:)

PHPz
PHPz原创
2024-08-07 01:15:33880浏览

Java Code Snippets:)

句法

访问修饰符：

公共
定义为公共的类、方法或变量可以被任何类或方法访问。

受保护
protected 可以被同一个包的类访问，也可以被该类的子类访问，也可以在同一个类内访问。
(注意：此关键字仅允许用于嵌套类)

私人
定义为 private 的私有类、方法或变量只能在类内部访问。

默认
默认值只能在包内访问。默认情况下，所有类、方法和变量都具有默认范围。

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);
    }
}

数据类型 

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;
    }
}

超载

当同一个类中多个方法具有相同名称但参数不同时，就会发生方法重载。这在编译时就解决了。

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));
    }
}

压倒一切

当子类为其超类中已定义的方法提供特定实现时，就会发生方法重写。这在运行时解决

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
    }
}

大批

数组和对象始终通过引用传递，而不是复制。原始数据类型按值传递。

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

    }
}

默认关键字

默认方法是在接口中使用 default 关键字定义的方法。这允许接口提供方法实现，而不影响实现该接口的类。

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...

    }
}

静态关键字

它表示成员（变量、方法或嵌套类）属于类本身而不是类的实例。
(注意：我们不能在非静态方法中声明静态变量)

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();
    }
}

初始化

（注意：只有实例变量和静态变量会使用默认值进行初始化）

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 
    }
}

显示类的方法及其参数 

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();
        }
    }
}

基本输入/输出 

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();
    }
}

For循环 

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

While 循环 

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

功能 

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);
    }
}

类和对象 

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());
    }
}

遗产 

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();
    }
}

最终关键词

它是通过添加final关键字

创建的

1) 最终变量
该变量一旦初始化就无法更改

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）最终方法
这些方法不能被重写

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.
    }
}

超级关键词

Java中的super关键字用于引用当前对象的直接父类。它提供了一种从子类中访问父类的成员（方法和变量）的方法。

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();
    }
}

抽象的

Java中的abstract关键字用于定义抽象类和抽象方法。抽象类不能直接实例化，只能进行子类化。抽象方法没有主体，必须由子类实现。
它包含抽象方法和具体方法

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.
    }
}

当一个接口想要继承另一个接口的方法时，可以使用extends关键字。

抽象类可以实现接口。这意味着抽象类使用implements关键字提供了接口的部分实现。

抽象类可以使用 extends 关键字扩展另一个抽象类

界面

它是类似于类的引用类型，仅包含常量、默认方法、静态方法和方法签名
(注意：接口中仅存在默认方法的定义)
（注意：接口内声明的常量为 public、static 和 final）

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
    }
}

克服钻石问题（多重继承）：

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
    }
}

列表 

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');
    }
}

队列

Java 中的 Queue 接口是 Java 集合框架的一部分，代表一个设计用于在处理之前保存元素的集合。它通常以 FIFO（先进先出）方式对元素进行排序，但其他排序也是可能的，例如 Deque 实现中的 LIFO（后进先出）。

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++");
    }
}

收藏

数组列表

1.动态调整大小
2.实现列表接口

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!
    }
}

以上是Java 代码片段:)的详细内容。更多信息请关注PHP中文网其他相关文章！

Java Static String Array Object define switch for while Lambda using class public private protected Interface Collection copy default this display input Access
声明：
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
上一篇：Introduction to Java in Machine Learning: A Beginner&#s Perspective下一篇：Advanced Testing with JUnit 5

相关文章

查看更多