筑基期

1. Java 的基本语法规则是什么？有哪些常见的 Java 基本数据类型？

Java 是一种强类型语言，必须声明变量的类型。

常见的基本数据类型分为四类：

整型：
- byte（1字节）、short（2字节）、int（4字节）、long（8字节）。
浮点型：
- float（4字节）、double（8字节）。
字符型：
- char，占用 2 字节，用于表示 Unicode 字符。
布尔型：
- boolean，只有两个值：true 和 false。

public class DataTypesExample {
    public static void main(String[] args) {
        // 整型
        int age = 30;
        long population = 7800000000L; // long 类型的值必须加 'L'

        // 浮点型
        float price = 19.99f; // float 类型的值必须加 'f'
        double pi = 3.14159;

        // 字符型
        char grade = 'A';

        // 布尔型
        boolean isJavaFun = true;

        System.out.println("Age: " + age);
        System.out.println("Population: " + population);
        System.out.println("Price: " + price);
        System.out.println("Pi: " + pi);
        System.out.println("Grade: " + grade);
        System.out.println("Is Java Fun: " + isJavaFun);
    }
}

2. Java 中有哪些 OOP 的核心概念？

Java 是一种面向对象的编程语言，OOP 的四大核心概念是：

封装：通过隐藏对象的内部状态，只暴露必要的接口。
继承：子类可以继承父类的属性和方法，实现代码重用。
多态：允许父类引用指向子类对象，方法的调用在运行时确定。
抽象：通过接口和抽象类定义通用行为，具体的实现由子类提供。

// 示例：封装和继承
class Animal {
    private String name; // 封装

    public Animal(String name) {
        this.name = name;
    }

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

class Dog extends Animal { // 继承
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() { // 多态
        System.out.println("Dog barks");
    }
}

public class OOPExample {
    public static void main(String[] args) {
        Animal animal = new Dog("Buddy");
        animal.makeSound(); // 多态：运行时决定调用 Dog 的 makeSound
    }
}

3. 如何在 Java 中创建和使用类与对象？

Java 中，类是对象的蓝图，通过类定义属性和行为。

对象是类的实例，使用 new 关键字创建。

// 定义类
class Car {
    String brand;
    int speed;

    // 方法
    void accelerate() {
        speed += 10;
        System.out.println(brand + " accelerates. Speed: " + speed);
    }
}

public class CarExample {
    public static void main(String[] args) {
        // 创建对象
        Car myCar = new Car();
        myCar.brand = "Toyota"; // 设置属性
        myCar.speed = 50;

        myCar.accelerate(); // 调用方法
    }
}

4. 什么是构造方法？如何在 Java 中定义和使用构造方法？

构造方法 是在创建对象时调用的特殊方法，常用于初始化对象。它与类同名，没有返回类型。

// 定义类和构造方法
class Person {
    String name;
    int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class ConstructorExample {
    public static void main(String[] args) {
        // 创建对象并调用构造方法
        Person person = new Person("John", 25);
        person.displayInfo();
    }
}

5. 什么是继承？如何在 Java 中实现类的继承？

继承是 OOP 的重要特性，允许子类继承父类的属性和方法。使用 extends 关键字定义继承关系。

// 父类
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 子类继承父类
class Cat extends Animal {
    void meow() {
        System.out.println("Cat says meow");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Cat myCat = new Cat(); // 创建子类对象
        myCat.eat(); // 调用父类方法
        myCat.meow(); // 调用子类方法
    }
}

6. 什么是多态？Java 中的多态是如何实现的？

多态是同一个行为具有不同表现形式的能力。Java 通过方法重写和父类引用指向子类对象来实现多态。

// 父类
class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类重写父类方法
class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 父类引用指向子类对象
        myAnimal.sound(); // 调用子类重写的方法
    }
}

7. 什么是接口（interface）和抽象类（abstract class）？它们之间有什么区别？

接口是一组方法的声明，没有具体实现，使用 interface 定义，类通过 implements 实现接口。

抽象类 是不能直接实例化的类，可以包含抽象方法（没有实现）和普通方法，使用 abstract 定义。

接口只能包含抽象方法（Java 8 之后可以有默认方法和静态方法），抽象类可以包含普通方法。

一个类可以实现多个接口，但只能继承一个抽象类。

// 定义接口
interface Movable {
    void move();
}

// 定义抽象类
abstract class Vehicle {
    abstract void startEngine(); // 抽象方法

    void stopEngine() {
        System.out.println("Engine stopped.");
    }
}

// 实现接口和继承抽象类
class Car extends Vehicle implements Movable {
    @Override
    void startEngine() {
        System.out.println("Car engine started");
    }

    @Override
    public void move() {
        System.out.println("Car is moving");
    }
}

public class InterfaceAndAbstractExample {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.startEngine();
        myCar.move();
        myCar.stopEngine();
    }
}

筑基期

筑基期