java面试题基础篇 温故而知新 没事在地铁上多看看

// 使用byte类型存储整数
byte b = 10; // b的值为10,占用一个字节(8位)
System.out.println("b的值为" + b); // 输出结果为b的值为10

// 使用short类型存储整数
short s = 10; // s的值为10,占用两个字节(16位)
System.out.println("s的值为" + s); // 输出结果为s的值为10

// 使用int类型存储整数
int i = 10; // i的值为10,占用四个字节(32位)
System.out.println("i的值为" + i); // 输出结果为i的值为10

// 使用long类型存储整数
long l = 10L; // l的值为10,占用八个字节(64位)
System.out.println("l的值为" + l); // 输出结果为l的值为10

// 使用float类型存储浮点数
float f = 10F; // f的值为10,占用四个字节(32位),其中小数部分占用了三个字节(24位)
System.out.println("f的值为" + f); // 输出结果为f的值为10.000000

// 使用double类型存储浮点数
double d = 10D; // d的值为10,占用八个字节(64位),其中小数部分占用了七个字节(56位)
System.out.println("d的值为" + d); // 输出结果为d的值为10.0000000000000000000000000000000000000000000000000

public class MyClass {
    private int myInt; // 整型变量myInt的命名符合Java标识符的命名规则
    private String myString = "Hello World"; // 字符串变量myString的命名符合Java标识符的命名规则
    public void myMethod() {
        double myDouble = 3.14; // 双精度浮点型变量myDouble的命名符合Java标识符的命名规则
    }
}

public class Animal {

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

public class Dog extends Animal {

    @Override
    public void makeSound() {
        System.out.println("Dog is barking.");
    }
}

public class Main {

    public static void main(String[] args) {
        Animal animal = new Dog(); // 创建一个狗对象
        if (animal instanceof Dog) { // 检查动物对象是否是狗的实例
            System.out.println("The animal is a dog.");
        } else if (animal instanceof Animal) { // 检查动物对象是否是任何动物的实例(包括狗和猫等)
            System.out.println("The animal is an animal.");
        } else { // 如果不是狗或任何动物的实例，则输出错误信息
            System.out.println("The animal is neither a dog nor an animal.");
        }
    }
}

Java自动装箱与拆箱是Java语言中的一个重要特性，它允许程序员在不需要显式声明类型的情况下将基本数据类型转换为对象类型。以下是Java自动装箱与拆箱的示例代码：

自动装箱
int a = 5;
Integer b = a; // 将int类型的a自动装箱成Integer类型
System.out.println(b); // 输出结果为5

自动拆箱
Integer c = new Integer(5);
int d = c; // 将Integer类型c自动拆箱成int类型
System.out.println(d); // 输出结果为5

抛出异常
int e = 0;
try {
int f = (int) "0"; // 将字符串"0"强制转换为int类型，会抛出NumberFormatException异常
} catch (NumberFormatException ex) {
System.out.println(ex.getMessage()); // 输出结果为"Value is not a number"
}

最大值和最小值检查
int g = Integer.MAX_VALUE;
if (g == 10) {
System.out.println("g is equal to 10"); // 输出结果为"g is equal to 10"
} else {
System.out.println("g is not equal to 10"); // 输出结果为"g is not equal to 10"

public class MyClass {

    public void method(int a, int b) {
        System.out.println("Method with two integers: " + a + b);
    }

    public void method(String str) {
        System.out.println("Method with a string: " + str);
    }
}

class Animal {

    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public 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 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);
    }
    
    // toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class HashCodeExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";
        
        int hash1 = str1.hashCode(); // 计算str1的哈希码值
        int hash2 = str2.hashCode(); // 计算str2的哈希码值
        
        System.out.println("str1的哈希码值为：" + hash1);
        System.out.println("str2的哈希码值为：" + hash2);
        
        if (hash1 == hash2) { // 判断两个字符串的哈希码值是否相等
            System.out.println("str1和str2相等");
        } else {
            System.out.println("str1和str2不相等");
        }
    }
}
str1的哈希码值为：504839640
str2的哈希码值为：720774163
str1和str2不相等

String str1 = "Hello, world!";

System.out.println(str1); // 输出： Hello, world!

StringBuffer strBuffer = new StringBuffer("Hello, Java!");

strBuffer.append(", World!"); // 修改字符串内容

System.out.println(strBuffer); // 输出： Hello, Java!, World!

StringBuilder stringBuilder = new StringBuilder("Hello, Java!");

stringBuilder.append(", World!"); // 修改字符串内容

System.out.println(stringBuilder); // 输出： Hello, Java!, World!

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建ArrayList对象
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        System.out.println("ArrayList: " + list1);
        
        // 创建LinkedList对象
        LinkedList<Integer> list2 = new LinkedList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(5);
        System.out.println("LinkedList: " + list2);
        
        // 添加元素到ArrayList中
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            int num = random.nextInt(10);
            if (list1.contains(num)) {
                continue;
            } else {
                list1.add(num);
            }
        }
        System.out.println("ArrayList: " + list1);
        
        // 添加元素到LinkedList中
        for (int i = 0; i < 10; i++) {
            int num = random.nextInt(10);
            if (list2.contains(num)) {
                continue;
            } else {
                list2.add(num);
            }
        }
        System.out.println("LinkedList: " + list2);
    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class MapExample {
    public static void main(String[] args) {
        // 创建HashMap对象
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1, "one");
        map1.put(2, "two");
        map1.put(3, "three");
        System.out.println("HashMap: " + map1);

        // 创建HashTable对象
        HashSet<Integer> set1 = new HashSet<>();
        set1.add(1);
        set1.add(2);
        set1.add(3);
        System.out.println("HashTable: " + set1);
    }
}

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

public class Example {
    public static void main(String[] args) {
        // 创建一个List集合对象
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        
        // 输出List集合中的元素数量
        System.out.println("List集合中的元素数量：" + list.size());
        
        // 将List集合转换为字符串并输出
        System.out.println("List集合转换为字符串：" + list);
    }
}

// 创建一个对象并使用Strong Reference引用它
Object obj = new Object();
ReferenceType objRef = new ReferenceType(obj);
System.out.println("obj的值为：" + obj.toString());
System.out.println("objRef的值为：" + objRef.get());

// 将objRef设置为null,表示不再使用Strong Reference引用它
objRef = null;
System.gc(); // 执行一次垃圾回收
System.out.println("obj的值为：" + obj.toString());

public class GenericClass<T> {

    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

public class Main {

    public static void main(String[] args) {
        GenericClass<Integer> integerClass = new GenericClass<>();
        integerClass.setValue(10);
        System.out.println("Value of integerClass: " + integerClass.getValue()); // Output: Value of integerClass: 10

        GenericClass<String> stringClass = new GenericClass<>();
        stringClass.setValue("Hello, World!");
        System.out.println("Value of stringClass: " + stringClass.getValue()); // Output: Value of stringClass: Hello, World!
    }
}

        java复制代码Person person = new Person("张三", 20);

        java复制代码Class<?> clazz = Class.forName("com.example.Person");
Object obj = clazz.newInstance();

        java复制代码// 定义一个工厂类，用于创建Person对象
public class PersonFactory {
    public static Person createPerson(String name, int age) {
        Person person = new Person(name, age);
        return person;
    }
}

// 在其他地方调用工厂类创建Person对象
Person person = PersonFactory.createPerson("张三", 20);

        java复制代码
public class UnequalHashCodeExample {

    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";
        
        int hashCode1 = str1.hashCode();
        int hashCode2 = str2.hashCode();
        
        System.out.println("str1 hash code: " + hashCode1);
        System.out.println("str2 hash code: " + hashCode2);        if (hashCode1 == hashCode2) {
            System.out.println("The two strings have the same hash code!");
        } else {
            System.out.println("The two strings do not have the same hash code!");
        }
    }
}

 
public class ShallowCopyExample {

    public static void main(String[] args) {
        List<Integer> originalList = new ArrayList<>(Arrays.asList(1, 2, 3));
        List<Integer> shallowCopyList = new ArrayList<>(originalList); // 浅拷贝
        originalList.add(4); // 在原始列表中添加元素4
        System.out.println("Original list: " + originalList); // [1, 2, 3, 4]
        System.out.println("Shallow copy list: " + shallowCopyList); // [1, 2, 3, 4]
    }
}

import java.util.ArrayList;

import java.util.List;

public class DeepCopyExample {

    public static void main(String[] args) {
        List<Integer> originalList = new ArrayList<>(Arrays.asList(1, 2, 3));
        List<Integer> deepCopyList = new ArrayList<>(originalList); // 深拷贝
        originalList.add(4); // 在原始列表中添加元素4
        System.out.println("Original list: " + originalList); // [1, 2, 3, 4]
        System.out.println("Deep copy list: " + deepCopyList); // [1, 2, 3, 4]
    }
}