JavaSE 基础语法与面向对象编程复习

JavaSE 基础语法与面向对象编程复习

一、输入输出基础

1. 控制台输出

Java 中最常用的输出方式是通过 System.out。在 main 方法中，我们可以直接调用 println 打印字符串。

public static void main(String[] args) {
    System.out.println("hello");
}

2. 控制台输入

处理用户输入通常使用 Scanner 类，记得导入 java.util.Scanner。创建对象时将其关联到标准输入流 System.in。

import java.util.Scanner;

public class InputDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("name: ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name);
    }
}

二、类和对象

Java 是面向对象的编程语言。类是对事物的抽象描述，而对象则是类的实例化。

1. 类的定义

使用 class 关键字定义类，内部包含成员变量和成员方法。

public class Person {
    String name;
    int age;

    public void action() {
        System.out.println("play");
    }
}

2. 对象的创建和使用

静态变量属于类，所有实例共享；对象创建即实例化过程。

public class Person {
    String name;
    int age;

    public void action() {
        System.out.println("play");
    }

    public static void main(String[] args) {
        // person 变量引用 new Person() 创建的对象
        Person person = new Person();
        person.name = "baby";
        person.age = 20;
        person.action();
    }
}

3. 构造方法

构造方法用于初始化对象，名称必须与类名相同，且没有返回值类型。若未显式定义，编译器会提供默认无参构造；一旦定义了有参构造，默认无参构造将失效。

public class Student {
    String name;
    int age;

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

4. this 关键字

this 代表当前对象的引用。常用于区分成员变量和局部变量，或在构造方法中调用其他构造方法（需放在第一行）。

public class Car {
    String brand; // 品牌
    int price;    // 价格

    public Car(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public Car(String brand) {
        // 调用有参构造方法
        this(brand, 10000);
    }

    public void display() {
        System.out.println(this.brand + " " + this.price);
    }

    public static void main(String[] args) {
        Car car = new Car("宝马");
        car.display();
    }
}

5. 包

Package 用于组织类，防止命名冲突并提高代码可维护性。自定义包时需使用 package 声明，并确保目录结构一致。

6. 封装

封装是面向对象的核心特性之一。通过将属性私有化（private），并提供公共的 getter 和 setter 方法来访问和修改，可以隐藏内部实现细节，提升安全性和可维护性。

public class User {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

三、继承

继承允许子类复用父类的属性和方法，实现代码复用。Java 支持单继承，但支持多层继承。

1. 继承的实现

使用 extends 关键字建立父子关系。

public class Animal {
    String name;

    public void eat() {
        System.out.println(name + " eating");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " 汪汪汪~");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "大黄";
        dog.eat();
        dog.bark();
    }
}

2. 方法重写（Override）

子类可以重写父类方法，要求方法名、参数列表、返回值类型一致（或协变），且访问权限不能更严格。

public class Person {
    public void study() {
        System.out.println("读");
    }
}

public class PersonAdd extends Person {
    @Override
    public void study() {
        System.out.println("写");
    }
}

3. super 关键字

super 用于访问父类的成员。在子类构造方法中，super() 必须位于第一行，用于调用父类构造器。

public class Father {
    String familyName = "张";

    public Father() {
        System.out.println("父类无参构造方法");
    }

    public void showFamilyname() {
        System.out.println("家族姓氏" + familyName);
    }
}

public class Son extends Father {
    public Son() {
        super();
    }

    public void showInfo() {
        super.showFamilyname();
        System.out.println("子类中访问父类姓氏" + super.familyName);
    }
}

四、多态

多态指同一行为有多种表现形式。实现条件包括：继承、方法重写、父类引用指向子类对象。

public class Shape {
    public void draw() {
        System.out.println("绘制图形");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        shape1.draw(); // 输出：绘制圆形
        shape2.draw(); // 输出：绘制矩形
    }
}

核心要点：

• 继承：子类复用父类结构，可扩展或修改行为。
• 方法重写：替换父类实现，实现定制化逻辑。
• 多态：父类引用指向子类对象，运行时根据实际类型执行对应方法，增强代码灵活性。

五、抽象类和接口

1. 抽象类

使用 abstract 修饰，不能实例化。用于定义子类的共同行为和属性，可作为模板。包含抽象方法（无方法体）和普通方法。子类必须实现所有抽象方法。

public abstract class Animal {
    protected String name;

    public abstract void makeSound();

    public void setName(String name) {
        this.name = name;
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println(name + " 汪汪汪~");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.makeSound();
    }
}

2. 接口

使用 interface 定义，JDK 8+ 支持默认方法和静态方法。类通过 implements 实现接口，需实现所有抽象方法。一个类可实现多个接口，接口间也可继承。

interface IFlyable {
    void fly();

    default void land() {
        System.out.println("降落");
    }
}

public class Bird implements IFlyable {
    @Override
    public void fly() {
        System.out.println("飞翔");
    }
}