Java 8 基础核心知识梳理：从运算符到面向对象

4、逻辑运算符

主要包括与 &&、或 || 以及取反 !。

5、三元运算符

格式：数据类型 变量名 = 布尔表达式 ? 结果 1 : 结果 2

若表达式为 true，返回结果 1；否则返回结果 2。常用于简单的条件判断替代 if-else。

// 获取三个整数中的最大值
int a = 10, b = 20, c = 30;
int temp = (a > b) ? a : b;
int max = (temp > c) ? temp : c;
System.out.println("max = " + max);

6、移位运算符

仅用于整数类型。

• 左移 <<：低位补 0。
• 右移 >>：正数高位补 0，负数高位补 1（符号位扩展）。

第二章：控制流

Java 控制流涉及 if-else、循环语句及 switch 等关键字。

1、if-else

最基本的流程控制形式，else 可选。

int a = 2, b = 1, result = 0;
if (a > b) {
    result = 1;
} else {
    result = 0;
}

2、while 循环

当布尔表达式为 false 时停止。适合不确定次数的循环。

public class Demo {
    public static void main(String[] args) {
        int i = 1, sum = 0;
        while (i <= 5) {
            sum += i;
            i++;
        }
        System.out.println(sum); // 结果为 15
    }
}

3、for 循环

最常用迭代形式，包含初始化、条件判断和步进。

public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        System.out.println("偶数之和：" + sum);
    }
}

4、嵌套循环

外循环一次，内循环多次。常用于矩阵打印等场景。

public class Demo {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

第三章：继承

1、为什么要继承？

将多个类的相同属性和行为抽取到单独类中，子类直接继承即可复用，无需重复定义。

2、继承定义

子类继承父类的属性和行为，可直接访问父类非私有成员。

3、继承好处

• 提高代码复用性
• 建立类间关联，是多态的前提

4、继承后的特点

4.1 成员变量影响

• 不重名：互不影响，可直接访问。
• 重名：子类优先访问自身变量。如需访问父类同名变量，使用 super.变量名。
• 封装原则：父类私有变量无法直接访问，需通过公共 getter/setter 方法。

4.2 成员方法影响

• 不重名：正常调用。
• 重名（重写 Override）：子类方法覆盖父类方法。要求返回值类型、方法名、参数列表完全一致。

4.3 重载与重写区别

• 重载（Overload）：同一类中，方法名相同但参数列表不同。
• 重写（Override）：子类覆盖父类方法，实现特定行为。

4.4 构造方法

子类无法继承父类构造方法。子类构造器默认隐含 super() 调用父类构造器以完成初始化。

5、小结

• 覆盖方法权限必须大于等于父类。
• 返回值类型、函数名、参数列表需完全一致。

6、super 和 this

• super：代表父类存储空间标识。
• this：代表当前对象引用。

注：Java 只支持单继承，不支持多继承，但可实现任意多个接口。

第四章：封装

封装隐藏数据操作细节，保障安全性并方便调用。即便封装后，仍可通过反射访问私有属性或方法。

第五章：多态

1、概述

多态消除类型耦合，改善代码组织，提升可读性与扩展性。

2、必要条件

1. 有继承
2. 有重写
3. 父类引用指向子类对象

3、好处

• 可替换性：对已存在代码具有替换能力。
• 可扩展性：新增子类不影响现有功能。
• 接口性：超类提供共同接口。
• 灵活性：体现多样操作，提高效率。
• 简化性：简化代码编写与维护。

第六章：接口

1、接口创建 (Java 8 之前)

使用 interface 关键字创建完全抽象的类，只能描述方法签名，无法提供实现体。

2、接口创建 (Java 8 中)

Java 8 引入 default 关键字，允许在接口中提供默认实现，避免新增方法导致实现类报错。

interface AnInterface {
    void firstMethod();
    default void newMethod() {
        System.out.println("newMethod");
    }
}

public class AnImplementation implements AnInterface {
    public void firstMethod() {
        System.out.println("firstMethod");
    }
}

第七章：内部类

定义在另一个类中的类称为内部类，有助于组织相关逻辑并控制可见性。

1、创建内部类

public class Person {
    private boolean live = true;

    class Heart {
        public void jump() {
            if (live) {
                System.out.println("心脏在跳动");
            } else {
                System.out.println("心脏不跳了");
            }
        }
    }

    public boolean isLive() { return live; }
    public void setLive(boolean live) { this.live = live; }
}

public class InnerDemo {
    public static void main(String[] args) {
        Person p = new Person();
        Person.Heart heart = p.new Heart();
        heart.jump();
        p.setLive(false);
        heart.jump();
    }
}

2、使用场景

当一个事物内部还包含其他事物时，适合使用内部类结构。

3、访问特点

• 内部类可直接访问外部类成员（含私有）。
• 外部类访问内部类成员需建立内部类对象。

第八章：匿名内部类

必须继承父类或实现接口，适合仅需使用一次的类。

interface Product {
    double getPrice();
    String getName();
}

public class AnonymousTest {
    public void test(Product p) {
        System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
    }

    public static void main(String[] args) {
        AnonymousTest ta = new AnonymousTest();
        ta.test(new Product() {
            public double getPrice() {
                return 567.8;
            }
            public String getName() {
                return "AGP 显卡";
            }
        });
    }
}