Java基础语法与面向对象

时游大约 8 分钟

一、Java 基础概念

1.1 Java 特点

跨平台：一次编写，到处运行（JVM 屏蔽操作系统差异）。
面向对象：万物皆对象，支持封装、继承、多态。
内存自动管理：通过 GC（垃圾回收）自动回收不用的对象。
丰富标准库：集合、IO、并发、网络等都有成熟封装。

1.2 Java 程序结构（HelloWorld 拆解）

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java");
    }
}

逐行解释：

public class HelloWorld { ... }
- class：声明一个类。
- HelloWorld：类名。
- 源文件名必须与这个 public class 名一致：这里文件名必须是 HelloWorld.java。
public static void main(String[] args) { ... }
- 这是 Java 程序的入口方法，固定写法。
- public：任何地方都能调用。
- static：属于类本身，不需要创建对象就能被调用。
- void：方法没有返回值。
- String[] args：命令行参数，初学可以先不管。
System.out.println("Hello, Java");
- System.out：标准输出（控制台）。
- println：打印一行并换行。

二、基本数据类型与变量

2.1 基本数据类型（记住常用的就行）

整数型
- int：最常用，范围大概是 (-2^{31}) 到 (2^{31}-1)。
- long：更大的整数，字面量一般写成 100L。
- byte、short：用得少，主要在特殊场景（比如网络、二进制协议）中用。
浮点型
- double：默认的小数类型，精度比 float 高。
- float：较小的浮点类型，字面量需写成 1.0F。
字符型
- char：表示单个字符，例如 char c = 'A';。
布尔型
- boolean：只有 true / false 两个取值。

对应的包装类型（用于集合、可以为 null）：

int ↔ Integer，double ↔ Double，boolean ↔ Boolean，……
自动装箱：Integer x = 1;（编译器自动帮你做 Integer.valueOf(1)）。
自动拆箱：int y = x;（编译器自动帮你做 x.intValue()）。

2.2 变量、常量与作用域

变量声明

int a = 10;       // 局部变量
String name = "张三";

局部变量：写在方法里面，只能在当前方法中使用；使用前必须显式赋值。
成员变量：写在类里面、方法外面，对整个类都可见；如果不赋值，会有默认值（0、false、null 等）。

常量

使用 final 修饰：值一旦赋值就不能再改。

final int MAX = 100;
public static final double PI = 3.14159;

常量命名习惯：全大写 + 下划线，例如：MAX_VALUE、DEFAULT_SIZE。

作用域（变量能被看见的范围）

{} 块作用域：在大括号内部定义的变量，只能在这个大括号里用。
方法作用域：方法中的变量，只在方法内可见。
类作用域：成员变量，对整个类可见。

同名变量就近原则：如果内层和外层有同名变量，会优先使用内层的。

三、运算符与控制语句

3.1 常见运算符（写一点小例子）

算术运算符：+ - * / %

int a = 7;
int b = 3;
int c1 = a + b;  // 10
int c2 = a / b;  // 2（整数相除，结果还是整数，小数部分直接丢掉）
int c3 = a % b;  // 1（取模/求余）

关系运算符：> < >= <= == !=（结果是 boolean 类型）

int x = 5;
boolean r1 = x > 3;   // true
boolean r2 = x == 5;  // true
boolean r3 = x != 1;  // true

逻辑运算符：&& || !

boolean a1 = true && false;  // false
boolean a2 = true || false;  // true
boolean a3 = !true;          // false

三元运算符：条件 ? 值1 : 值2

int score = 80;
String result = score >= 60 ? "及格" : "不及格";

注意：== 比较的是值是否相等；以后学到对象时要记住，比较字符串内容要用 equals。

3.2 条件与分支（if / switch）

if / else if / else 适合写各种判断逻辑：

int score = 75;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

switch：当某个变量只在几个固定值之间选择时，代码更清晰：

switch (day) {
    case "Mon":
        System.out.println("星期一");
        break;
    case "Tue":
        System.out.println("星期二");
        break;
    default:
        System.out.println("其它");
}

break 用来阻止「贯穿」到后面的 case；如果故意省略 break，会从匹配的 case 一直执行到下一个 break 或 switch 结束。

switch (day) {
    case "Mon":
        System.out.println("星期一");
        break;
    case "Tue":
        System.out.println("星期二");
        break;
    default:
        System.out.println("其它");
}

3.3 循环（for / while）

for 循环：

for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

执行顺序：初始化 int i = 0 → 判断条件 i < 5 → 执行循环体 → i++ → 再判断条件……

while 循环：

int i = 0;
while (i < 5) {
    System.out.println("i = " + i);
    i++;
}

do-while 循环：至少执行一次：

int x = 10;
do {
    System.out.println("会先执行一次");
    x++;
} while (x < 5);

增强 for：用来遍历数组或集合，更简洁：

String[] names = {"张三", "李四", "王五"};
for (String name : names) {
    System.out.println(name);
}

跳转语句：
- break：立即退出当前循环。
- continue：结束本次循环，直接进入下一次判断。
- return：结束整个方法（不只是循环）。

四、面向对象基础

4.1 类与对象（把现实世界映射到代码里）

public class Person {
    // 成员变量（字段）
    private String name;
    private int age;

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

    // 成员方法
    public void sayHello() {
        System.out.println("Hi, I'm " + name);
    }
}

对象创建

Person p = new Person("Tom", 18);
p.sayHello();

构造器特点
- 构造器名字必须与类名相同。
- 没有返回类型（连 void 也不能写）。
- 如果你没写任何构造器，编译器会自动给你加一个「无参构造器」。
- 可以重载：写多个参数不同的构造器，方便用不同方式创建对象。

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

    // 无参构造
    public Person() {}

    // 带参数构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

4.2 封装与访问控制（把细节藏起来）

访问修饰符：
- public：任何地方可见。
- protected：同包 + 子类可见。
- default（不写）：同包可见。
- private：仅本类内部可见。

封装的常见写法：字段 private，提供 public 的 getter/setter。

public class User {
    private String username;

    public String getUsername() {
        return username;
    }

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

4.3 this 关键字

指向当前对象实例。
区分成员变量和形参重名：

public Person(String name, int age) {
    this.name = name; // 左边是字段，右边是参数
    this.age = age;
}

在构造器中调用本类其他构造器：this(参数...)，必须写在第一行。

五、继承与多态

5.1 继承（extends）（「是一个」的关系）

public class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
}

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

Java 只支持单继承，一个类只能有一个直接父类。
子类会继承父类的非 private 成员。
构造调用顺序：子类构造器第一行会隐式或显式调用 super(...)。

「是一个」的关系示例：

狗是一个动物 → Dog extends Animal
学生是一个人 → Student extends Person

5.2 多态（polymorphism）（同一个方法，多种形态）

Animal a = new Dog(); // 向上转型
a.eat();              // 调用的是 Dog 中重写后的方法（若有）

多态的三个前提：

有继承关系。
子类重写了父类的方法。
父类引用指向子类对象。

表现：编译看引用类型（Animal），运行看实际对象类型（Dog），最终调用的是 Dog 的实现（动态绑定）。

5.3 方法重载与重写

重载（overload）
- 发生在同一个类中。
- 方法名相同，参数列表不同（数量、类型或顺序）。
- 与返回值类型无关。

public int add(int a, int b) { return a + b; }
public double add(double a, double b) { return a + b; }

重写（override）
- 发生在父子类之间。
- 方法名 + 参数列表完全相同。
- 访问修饰符不能比父类更严格，可以更宽。
- 一般加 @Override 注解防止书写错误。

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃狗粮");
    }
}

六、抽象类与接口

6.1 抽象类（abstract）（有「模板」，但不完整）

使用 abstract 修饰类或方法。
抽象类不能直接 new，即抽象类不能被实例化，只能被继承。
可以包含：抽象方法 + 普通方法 + 成员变量。

public abstract class Shape {
    public abstract double area();

    public void printArea() {
        System.out.println("面积是：" + area());
    }
}

public class Circle extends Shape {
    private double r;

    public Circle(double r) {
        this.r = r;
    }

    @Override
    public double area() {
        return Math.PI * r * r;
    }
}

6.2 接口（interface）

接口是一种「规范」，规定类必须具备哪些行为。
一个类可以实现多个接口：class A implements X, Y {}
Java 8 之后接口可以有：
- 抽象方法（默认）
- default 方法（带方法体，可以在接口中提供默认实现）
- static 方法

public interface Flyable {
    void fly();

    default void printSpeed() {
        System.out.println("默认飞行速度");
    }
}

public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("小鸟在飞");
    }
}

抽象类 vs 接口（怎么区分用哪个？）：

抽象类更偏向「是一种……」的父类，共享某些实现。
接口更偏向「能做什么」，表示一种能力或规范。
一个类只能继承一个抽象类，但可以实现多个接口。
初学时可以简单记：
- 有一部分公共实现要复用 → 考虑抽象类；
- 只是想定义「一组能力/行为」 → 考虑接口。

七、常用关键字：static / final / super

7.1 static

属于类而不是对象，所有实例共享一份。
常见用法：
- 静态变量（类变量）：static int count;
- 静态方法：工具类常用，例如 Math.random()。
- 静态代码块：类加载时执行一次，用于初始化静态资源。
静态方法中不能访问非静态成员，因为静态方法执行时可能还没有实例。

7.2 final

修饰变量：值不能被修改。
修饰方法：方法不能被重写。
修饰类：类不能被继承（如 String, Integer）。

7.3 super

访问父类被子类隐藏的成员：super.xxx。
调用父类构造器：super(参数...)，必须在构造器第一行。

注意：this(...) 和 super(...) 都必须写在构造器第一行，因此不能同时出现。

Java基础语法与面向对象

# 一、Java 基础概念

# 1.1 Java 特点

# 1.2 Java 程序结构（HelloWorld 拆解）

# 二、基本数据类型与变量

# 2.1 基本数据类型（记住常用的就行）

# 2.2 变量、常量与作用域

# 变量声明

# 常量

# 作用域（变量能被看见的范围）

# 三、运算符与控制语句

# 3.1 常见运算符（写一点小例子）

# 3.2 条件与分支（if / switch）

# 3.3 循环（for / while）

# 四、面向对象基础

# 4.1 类与对象（把现实世界映射到代码里）

# 4.2 封装与访问控制（把细节藏起来）

# 4.3 this 关键字

# 五、继承与多态

# 5.1 继承（extends）（「是一个」的关系）

# 5.2 多态（polymorphism）（同一个方法，多种形态）

# 5.3 方法重载与重写

# 六、抽象类与接口

# 6.1 抽象类（abstract）（有「模板」，但不完整）

# 6.2 接口（interface）

# 七、常用关键字：static / final / super

# 7.1 static

# 7.2 final

# 7.3 super