【零碎小知识点 】（二）Java基础与常用API编码实践

Java基础与常用API编码实践

下面我将根据你提到的Java基础知识点，提供相应的代码示例和练习，帮助你提高编码能力。

1. 核心语法与面向对象编程

基本数据类型与流程控制

public class BasicSyntax {
    public static void main(String[] args) {
        // 1. 数据类型与变量
        byte aByte = 127;                    // 8位
        short aShort = 32767;                // 16位
        int anInt = 2147483647;              // 32位
        long aLong = 9223372036854775807L;   // 64位
        float aFloat = 3.14f;                // 32位浮点
        double aDouble = 3.1415926535;       // 64位浮点
        char aChar = 'A';                    // 16位Unicode
        boolean aBoolean = true;             // 真值
        
        // 2. 流程控制
        // if-else
        if (anInt > 1000) {
            System.out.println("大于1000");
        } else if (anInt > 500) {
            System.out.println("大于500但小于等于1000");
        } else {
            System.out.println("小于等于500");
        }
        
        // switch (Java 12+更强大的switch表达式)
        int day = 3;
        String dayType = switch (day) {
            case 1, 2, 3, 4, 5 -> "工作日";
            case 6, 7 -> "周末";
            default -> "无效日期";
        };
        System.out.println("日期类型: " + dayType);
        
        // 循环
        // for循环
        for (int i = 0; i < 5; i++) {
            System.out.println("For循环: " + i);
        }
        
        // while循环
        int count = 0;
        while (count < 3) {
            System.out.println("While循环: " + count);
            count++;
        }
        
        // do-while循环
        int num = 5;
        do {
            System.out.println("Do-While循环: " + num);
            num--;
        } while (num > 0);
    }
}

面向对象编程实践

// 封装示例
class BankAccount {
    private String accountNumber;
    private double balance;
    
    // 构造方法
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    // 封装的方法
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，当前余额: " + balance);
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("取款成功，当前余额: " + balance);
        } else {
            System.out.println("取款失败，余额不足");
        }
    }
    
    // getter方法
    public double getBalance() {
        return balance;
    }
    
    public String getAccountNumber() {
        return accountNumber;
    }
}

// 继承与多态示例
class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void makeSound() {
        System.out.println("动物发出声音");
    }
    
    public String getName() {
        return name;
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类构造方法
    }
    
    @Override
    public void makeSound() {
        System.out.println(getName() + "汪汪叫");
    }
    
    // super关键字使用示例
    public void superMakeSound() {
        super.makeSound(); // 调用父类方法
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(getName() + "喵喵叫");
    }
}

// 抽象类与接口
abstract class Shape {
    protected String color;
    
    public Shape(String color) {
        this.color = color;
    }
    
    // 抽象方法
    public abstract double area();
    
    // 具体方法
    public String getColor() {
        return color;
    }
}

interface Drawable {
    void draw(); // 接口方法默认public
    default void display() { // 默认方法
        System.out.println("展示图形");
    }
    static void printInfo() { // 静态方法
        System.out.println("这是一个可绘制接口");
    }
}

class Circle extends Shape implements Drawable {
    private double radius;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void draw() {
        System.out.println("绘制一个" + color + "的圆形，半径: " + radius);
    }
}

// 内部类示例
class OuterClass {
    private int outerField = 10;
    
    // 成员内部类
    class InnerClass {
        void display() {
            System.out.println("访问外部类字段: " + outerField);
        }
    }
    
    // 静态内部类
    static class StaticNestedClass {
        void display() {
            System.out.println("静态内部类");
        }
    }
    
    // 方法内部类
    void methodWithClass() {
        class LocalClass {
            void display() {
                System.out.println("方法内部类");
            }
        }
        
        LocalClass local = new LocalClass();
        local.display();
    }
}

public class OOPPractice {
    public static void main(String[] args) {
        // 封装测试
        BankAccount account = new BankAccount("123456", 1000);
        account.deposit(500);
        account.withdraw(200);
        System.out.println("最终余额: " + account.getBalance());
        
        // 继承与多态测试
        Animal myDog = new Dog("Buddy");
        Animal myCat = new Cat("Whiskers");
        
        myDog.makeSound(); // 多态：运行时调用Dog的方法
        myCat.makeSound(); // 多态：运行时调用Cat的方法
        
        // 抽象类与接口测试
        Circle circle = new Circle("红色", 5.0);
        System.out.println("圆形面积: " + circle.area());
        circle.draw();
        circle.display();
        Drawable.printInfo(); // 调用接口静态方法
        
        // 内部类测试
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
        
        OuterClass.StaticNestedClass staticNested = new OuterClass.StaticNestedClass();
        staticNested.display();
        
        outer.methodWithClass();
    }
}

2. 常用API实践

String和Object类

import java.util.Arrays;

public class CommonAPIPractice {
    public static void main(String[] args) {
        // String类实践
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = new String("Hello");
        String str4 = "World";
        
        // == 和 equals 区别
        System.out.println("str1 == str2: " + (str1 == str2)); // true，字符串常量池同一对象
        System.out.println("str1 == str3: " + (str1 == str3)); // false，不同对象
        System.out.println("str1.equals(str3): " + str1.equals(str3)); // true，内容相同
        
        // String不可变性演示
        String original = "Hello";
        String modified = original.concat(" World");
        System.out.println("Original: " + original); // 不变
        System.out.println("Modified: " + modified); // 新对象
        
        // StringBuffer vs StringBuilder
        // StringBuffer是线程安全的，StringBuilder不是但更快
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("Hello").append(" ").append("World");
        System.out.println("StringBuffer: " + stringBuffer.toString());
        
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Hello").append(" ").append("World");
        System.out.println("StringBuilder: " + stringBuilder.toString());
        
        // Object类方法实践
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Alice", 25);
        Person person3 = new Person("Bob", 30);
        
        System.out.println("person1.equals(person2): " + person1.equals(person2));
        System.out.println("person1.equals(person3): " + person1.equals(person3));
        
        System.out.println("person1 hashCode: " + person1.hashCode());
        System.out.println("person2 hashCode: " + person2.hashCode());
        System.out.println("person3 hashCode: " + person3.hashCode());
        
        System.out.println("person1 toString: " + person1.toString());
        System.out.println("person1 class: " + person1.getClass().getName());
        
        // Arrays类实践
        int[] numbers = {3, 1, 4, 1, 5, 9, 2, 6};
        System.out.println("Original array: " + Arrays.toString(numbers));
        
        // 排序
        Arrays.sort(numbers);
        System.out.println("Sorted array: " + Arrays.toString(numbers));
        
        // 二分查找
        int index = Arrays.binarySearch(numbers, 5);
        System.out.println("Index of 5: " + index);
        
        // 填充
        int[] filledArray = new int[5];
        Arrays.fill(filledArray, 7);
        System.out.println("Filled array: " + Arrays.toString(filledArray));
        
        // 比较
        int[] array1 = {1, 2, 3};
        int[] array2 = {1, 2, 3};
        int[] array3 = {1, 2, 4};
        System.out.println("array1 equals array2: " + Arrays.equals(array1, array2));
        System.out.println("array1 equals array3: " + Arrays.equals(array1, array3));
        
        // Math类实践
        System.out.println("Math.abs(-5): " + Math.abs(-5));
        System.out.println("Math.sqrt(25): " + Math.sqrt(25));
        System.out.println("Math.pow(2, 3): " + Math.pow(2, 3));
        System.out.println("Math.max(10, 20): " + Math.max(10, 20));
        System.out.println("Math.min(10, 20): " + Math.min(10, 20));
        System.out.println("Math.random(): " + Math.random()); // 0.0到1.0之间的随机数
        
        // 生成特定范围的随机数
        int min = 10, max = 20;
        int randomNum = min + (int)(Math.random() * ((max - min) + 1));
        System.out.println("Random between " + min + " and " + max + ": " + randomNum);
        
        // Date和Calendar实践
        // 旧版Date（已不推荐用于日期操作）
        java.util.Date oldDate = new java.util.Date();
        System.out.println("Old Date: " + oldDate);
        
        // Calendar类
        java.util.Calendar calendar = java.util.Calendar.getInstance();
        System.out.println("Current time: " + calendar.getTime());
        System.out.println("Year: " + calendar.get(java.util.Calendar.YEAR));
        System.out.println("Month: " + (calendar.get(java.util.Calendar.MONTH) + 1)); // 月份从0开始
        System.out.println("Day: " + calendar.get(java.util.Calendar.DAY_OF_MONTH));
        
        // 添加时间
        calendar.add(java.util.Calendar.DAY_OF_MONTH, 7);
        System.out.println("Date after 7 days: " + calendar.getTime());
        
        // 新版Java时间API (Java 8+)
        java.time.LocalDate localDate = java.time.LocalDate.now();
        System.out.println("LocalDate: " + localDate);
        
        java.time.LocalDateTime localDateTime = java.time.LocalDateTime.now();
        System.out.println("LocalDateTime: " + localDateTime);
        
        java.time.format.DateTimeFormatter formatter = java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println("Formatted: " + localDateTime.format(formatter));
    }
}

// 用于演示equals和hashCode的类
class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 重写equals方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
    
    // 重写hashCode方法
    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        return result;
    }
    
    // 重写toString方法
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

3. 练习题目

基础练习

1. 编写一个程序，找出100以内的所有素数
2. 实现一个简单的计算器，支持加减乘除运算
3. 编写一个程序，反转一个字符串（不要使用内置的reverse方法）

面向对象练习

1. 设计一个简单的图书馆管理系统，包含Book、Library和Member类
2. 创建一个图形继承体系，包含Shape、Circle、Rectangle和Triangle类
3. 实现一个简单的银行账户系统，支持存款、取款和转账功能

API使用练习

1. 编写一个程序，统计一篇文章中每个单词出现的次数
2. 实现一个日期工具类，提供日期格式化、计算日期差等功能
3. 创建一个学生管理系统，使用Arrays或Collections对学生进行排序和搜索

4. 编码风格建议

1. 命名规范：

   • 类名使用大驼峰：MyClass
   • 方法和变量使用小驼峰：myMethod, myVariable
   • 常量全大写：MAX_VALUE

2. 注释：

   • 使用Javadoc注释类和方法
   • 复杂逻辑添加行内注释

3. 代码组织：

   • 一个类一个文件
   • 使用包组织相关类
   • 保持方法简短，单一职责

4. 异常处理：

   • 使用try-catch处理可能出现的异常
   • 不要捕获异常后什么都不做

这些代码示例和练习题目涵盖了Java基础和常用API的主要知识点。通过实际编写和运行这些代码，你可以更好地理解和掌握这些概念。记得不仅要写代码，还要思考为什么这样设计，以及如何改进代码的质量和效率。