15道大厂Java高频面试题（二）

import java.io.*;

// 定义一个可序列化的类
class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class SerializationExample {
    public static void main(String[] args) {
        // 创建Person对象
        Person person = new Person("John", 30);

        // 序列化对象到文件
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            out.writeObject(person);
            System.out.println("Person object has been serialized");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 从文件反序列化对象
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person deserializedPerson = (Person) in.readObject();
            System.out.println("Deserialized Person: " + deserializedPerson.name + ", " + deserializedPerson.age);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

// 定义一个类
class Animal {
    // 属性
    String name;

    // 构造方法
    public Animal(String name) {
        this.name = name;
    }

    // 方法
    public void makeSound() {
        System.out.println(name + " makes a sound");
    }
}

// 继承Animal类
class Dog extends Animal {
    // 构造方法
    public Dog(String name) {
        super(name); // 调用父类的构造方法
    }

    // 重写makeSound方法
    @Override
    public void makeSound() {
        System.out.println("Woof woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Animal myAnimal = new Animal("Generic Animal");
        Dog myDog = new Dog("Rex");

        // 多态的体现
        makeAnimalSound(myAnimal);
        makeAnimalSound(myDog);
    }

    // 该方法接受Animal类型的对象，体现了多态
    public static void makeAnimalSound(Animal animal) {
        animal.makeSound();
    }
}

package com.example.myapp;

public class MyClass {
    // 类的实现
}

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> myList = new java.util.ArrayList<>();
        // 使用myList
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> myList = new ArrayList<>();
        // 使用myList
    }
}

/**
 * 这个类表示一个简单的计算器，提供加法和减法功能。
 */
public class Calculator {

    /**
     * 计算两个数的和。
     * @param a 第一个加数
     * @param b 第二个加数
     * @return 两个数的和
     */
    public int add(int a, int b) {
        return a + b;
    }

    /**
     * 计算两个数的差。
     * @param a 被减数
     * @param b 减数
     * @return 两个数的差
     * @throws IllegalArgumentException 如果b大于a
     */
    public int subtract(int a, int b) {
        if (b > a) {
            throw new IllegalArgumentException("b不能大于a");
        }
        return a - b;
    }
}

/**
 * 一个简单的例子，展示如何实现一个高内聚、低耦合的类。
 */
public class EmailService {
    private final MailProvider mailProvider;

    public EmailService(MailProvider mailProvider) {
        this.mailProvider = mailProvider;
    }

    /**
     * 发送电子邮件。
     * @param to 收件人地址
     * @param subject 邮件主题
     * @param body 邮件正文
     */
    public void sendEmail(String to, String subject, String body) {
        // 使用组合的mailProvider发送邮件
        mailProvider.deliver(to, subject, body);
    }
}

/**
 * 邮件提供者接口，用于发送邮件。
 */
interface MailProvider {
    void deliver(String to, String subject, String body);
}

public class ObjectMemoryExample {
    public static void main(String[] args) {
        // 在栈上创建对象引用
        ObjectMemoryExample obj = new ObjectMemoryExample();
        // obj引用指向堆上的对象
        System.out.println("对象已创建，引用存储在栈上，对象存储在堆上。");
    }
}

public class StringStorageExample {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        
        // 字符串常量池中的内容
        String s3 = s1 + s2;
        System.out.println(s3); // 输出 "helloworld"
        
        // 使用String.intern()方法
        String s4 = new String("hello").interned();
        System.out.println(s4); // 输出 "hello"
        
        // 检查s1和s4是否在字符串常量池中相同
        System.out.println(s1 == s4); // 输出 true
    }
}

public class StringImplementation {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
        // 获取String对象的字符数组
        char[] charArray = str.toCharArray();
        
        // 输出字符数组的内容
        for (char c : charArray) {
            System.out.print(c);
        }
        // 输出: Hello, World!
    }
}

public class StringMethodsExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
        // 字符串拼接
        String concatStr = str.concat(" Java");
        System.out.println(concatStr); // 输出: Hello, World! Java
        
        // 字符串比较
        boolean isEqual = str.equals("Hello, World!");
        System.out.println(isEqual); // 输出: true
        
        // 字符串查找
        int index = str.indexOf('W');
        System.out.println(index); // 输出: 7
        
        // 子字符串
        String substring = str.substring(7, 12);
        System.out.println(substring); // 输出: World
        
        // 字符串替换
        String replaceStr = str.replace('W', 'w');
        System.out.println(replaceStr); // 输出: Hello, world!
        
        // 字符串修剪
        String trimStr = "  " + str + "  ".trim();
        System.out.println(trimStr); // 输出: Hello, World!
        
        // 字符串转换
        String upperStr = str.toUpperCase();
        System.out.println(upperStr); // 输出: HELLO, WORLD!
        
        // 字符串格式化
        String formatStr = String.format("Name: %s, Age: %d", "Kimi", 30);
        System.out.println(formatStr); // 输出: Name: Kimi, Age: 30
    }
}

public class StringPoolExample {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello").interned();
        
        // 由于字符串常量池中已经存在"hello"，所以s1和s2引用的是同一个对象
        System.out.println(s1 == s2); // 输出: true
        
        // s3通过intern()方法添加到字符串常量池，也引用了常量池中的"hello"
        System.out.println(s1 == s3); // 输出: true
    }
}

public class ObjectExample {
    public static void main(String[] args) {
        Object obj = new Object();

        // 检查对象是否等于它自己
        System.out.println(obj.equals(obj)); // 输出: true

        // 获取对象的哈希码
        System.out.println(obj.hashCode());

        // 获取对象的字符串表示
        System.out.println(obj.toString());

        // 获取对象的运行时类信息
        System.out.println(obj.getClass());
    }
}

public class ComparisonExample {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");

        // 使用==比较引用
        System.out.println(s1 == s2); // 输出: true，因为s1和s2指向字符串常量池中的同一个对象
        System.out.println(s1 == s3); // 输出: false，因为s1指向字符串常量池中的对象，而s3指向堆中新创建的对象

        // 使用equals()比较内容
        System.out.println(s1.equals(s2)); // 输出: true，因为"hello"和"hello"的内容相同
        System.out.println(s1.equals(s3)); // 输出: true，因为s1和s3的内容相同
    }
}

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
               Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public static void main(String[] args) {
        Person p1 = new Person("John", 30);
        Person p2 = new Person("John", 30);
        
        System.out.println(p1.equals(p2)); // 输出: true
        System.out.println(p1.hashCode() == p2.hashCode()); // 输出: true
    }
}

import java.util.Objects;

public class CustomObject {
    private int id;
    private String data;

    public CustomObject(int id, String data) {
        this.id = id;
        this.data = data;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CustomObject that = (CustomObject) o;
        return id == that.id &&
               Objects.equals(data, that.data);
    }

    @Override
    public int hashCode() {
        // 使用Objects.hash()生成哈希码，基于id和data
        return Objects.hash(id, data);
    }

    public static void main(String[] args) {
        CustomObject obj1 = new CustomObject(1, "data");
        CustomObject obj2 = new CustomObject(1, "data");
        
        System.out.println(obj1.hashCode()); // 输出哈希码
        System.out.println(obj2.hashCode()); // 输出哈希码，应该与obj1相同
    }
}