Java编程基础与面向对象核心概念

Java编程基础与面向对象核心概念

一、Java编程基础

1. Java语言特性与运行机制

Java是跨平台、面向对象、强类型的高级编程语言，核心特性包括：

• 一次编译，多处运行：源码经javac编译为字节码（.class文件），由不同平台的Java虚拟机（JVM）解释执行，实现跨平台兼容性。

• 自动内存管理：通过垃圾回收（GC）机制自动回收无用对象内存，无需手动释放，降低内存泄漏风险。

• 强类型规范：变量必须声明类型，编译期检查类型匹配，提升代码稳定性。

• 面向对象核心：以"对象"为核心组织代码，支持封装、继承、多态三大核心特性。

运行流程：编写.java源码 → 编译生成.class字节码 → JVM加载字节码 → 解释/即时编译（JIT）执行。

2. 基础语法核心

（1）数据类型

Java数据类型分为基本数据类型和引用数据类型，是变量存储的基础：

• 基本数据类型（8种，存储具体值，存于栈内存）：

数值型：byte（1字节）、short（2字节）、int（4字节，默认整数）、long（8字节，后缀L）；

浮点型：float（4字节，后缀F）、double（8字节，默认浮点数）；

字符型：char（2字节，存储Unicode字符，单引号' '）；

布尔型：boolean（1位，仅true/false）。

• 引用数据类型（存储对象地址，存于堆内存）：类、接口、数组、枚举等，默认值为null。

（2）变量与常量

• 变量：程序运行中可修改的存储单元，声明格式：数据类型 变量名 = 初始值;，需遵循"先声明后使用、先赋值后访问"。

• 常量：运行中不可修改的量，用final修饰，声明格式：final 数据类型 常量名 = 值;，常量名建议全大写（如final int MAX_NUM = 100;）。

（3）运算符

Java支持多种运算符，按功能分类：

• 算术运算符：+、-、*、/、%（取余）、++（自增）、--（自减）；

• 关系运算符：==（等于）、!=（不等于）、>、<、>=、<=，结果为boolean；

• 逻辑运算符：&&（短路与）、||（短路或）、!（非），用于布尔逻辑判断；

• 赋值运算符：=、+=、-=、*=、/=等，简化赋值操作；

• 位运算符：&、|、^、~、<<、>>、>>>，针对二进制位操作。

（4）流程控制

流程控制决定代码执行顺序，核心分为三类：

• 顺序结构：代码按书写顺序从上到下依次执行，是默认执行方式。

• 分支结构：根据条件选择执行路径，包括：

if-else：单分支、双分支、多分支条件判断；

switch-case：匹配固定值分支，支持byte、short、int、char、String、枚举类型，需搭配break避免穿透。

• 循环结构：重复执行代码块，包括：

for循环：适合已知循环次数（如for(int i=0; i<10; i++){}）；

while循环：先判断条件再执行，适合未知循环次数；

do-while循环：先执行一次再判断条件，至少执行一次；

循环控制：break（跳出当前循环）、continue（跳过本次循环，进入下一次）。

（5）数组

数组是相同类型数据的有序集合，属于引用数据类型，特点：长度固定、下标从0开始、内存连续存储。

• 声明与初始化：

静态初始化：int[] arr = {1,2,3};（直接赋值）；

动态初始化：int[] arr = new int[5];（指定长度，默认值为0）。

• 常用操作：通过下标访问元素（arr[0]）、遍历数组（for/增强for循环）、获取长度（arr.length）。

3. 方法（函数）基础

方法是完成特定功能的代码块，实现代码复用，是Java程序的基本执行单元。

（1）方法定义格式

修饰符 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2...) {

// 方法体：具体功能代码

return 返回值; // 无返回值时用void，省略return

}

（2）核心概念

• 修饰符：常用public（公共访问）、private（私有访问）、static（静态方法，属于类）；

• 返回值类型：方法执行后返回的数据类型，无返回值用void；

• 参数：方法调用时传入的数据，分为形参（定义时的参数）、实参（调用时的具体值）；

• 方法重载：同一类中，方法名相同、参数列表（个数/类型/顺序）不同，与返回值无关（如int add(int a,int b)和double add(double a,double b)）。

（3）方法调用

• 静态方法调用：类名.方法名(实参)（如Arrays.sort(arr)）；

• 非静态方法调用：需先创建对象，对象名.方法名(实参)。

二、面向对象（OOP）核心概念

面向对象是Java的核心编程思想，以"对象"为核心，将数据与操作数据的方法封装为整体，模拟现实世界的事物与关系，核心包括四大特性：封装、继承、多态、抽象。

1. 类与对象：面向对象的基础

（1）类（Class）

类是对象的模板/抽象描述，定义对象的属性（特征）和行为（功能），是Java代码的基本组织单元。

• 类的结构：

public class 类名 {

// 1. 属性（成员变量）：描述对象特征

数据类型 属性名;

// 2. 构造方法：创建对象时初始化属性

public 类名(参数列表) {}

// 3. 成员方法：描述对象行为

修饰符 返回值类型 方法名(参数列表) {}

}

• 示例：定义Student类，描述学生的属性（姓名、年龄）和行为（学习）。

（2）对象（Object）

对象是类的实例，是类的具体体现，通过new关键字创建，拥有类定义的属性和行为。

• 对象创建与使用：

// 1. 创建对象：类名 对象名 = new 类名(实参);

Student stu = new Student("张三", 18);

// 2. 访问属性：对象名.属性名（需权限修饰符支持）

stu.name;

// 3. 调用方法：对象名.方法名(实参)

stu.study();

• 内存机制：对象通过new在堆内存分配空间，栈内存存储对象的引用地址，多个引用可指向同一对象。

2. 封装（Encapsulation）

封装是将对象的属性和方法隐藏，仅对外暴露必要访问接口的特性，核心目的是保护数据安全、简化使用、降低耦合。

（1）封装实现步骤

• 私有化属性：用private修饰成员变量，禁止外部直接访问；

• 提供公共访问方法：通过public修饰的getXxx()（获取属性）和setXxx()（设置属性）方法，在方法中添加数据校验逻辑；

• 封装方法：将复杂功能封装为方法，外部仅需调用方法，无需关注内部实现。

（2）示例

public class Student {

// 私有化属性

private String name;

private int age;

// 构造方法初始化

public Student(String name, int age) {

this.name = name;

this.age = age;

}

// 公共get/set方法，添加数据校验

public String getName() {

return name;

}

public void setAge(int age) {

if(age > 0 && age < 150) { // 年龄合法性校验

this.age = age;

} else {

System.out.println("年龄输入不合法");

}

}

}

（3）封装优势

• 数据安全：避免外部随意修改属性，通过方法控制数据合法性；

• 代码复用：将通用功能封装为方法，多处调用；

• 降低耦合：外部无需关注内部实现，仅通过接口交互，便于维护。

3. 继承（Inheritance）

继承是子类复用父类属性和方法，并可扩展新功能的特性，实现代码复用与层级化设计，体现"is-a"关系（如"狗是动物"）。

（1）继承基础语法

• 关键字：extends，格式：子类 extends 父类；

• 规则：Java仅支持单继承（一个子类只能继承一个父类），支持多层继承（子类→父类→祖父类），Object类是所有类的根父类。

（2）核心概念

• 父类（超类/基类）：被继承的类，包含通用属性和方法；

• 子类（派生类）：继承父类的类，可复用父类非私有成员，新增自身属性和方法；

• 方法重写（Override）：子类重新定义父类的同名、同参数列表方法，覆盖父类实现，需满足：方法名、参数列表、返回值类型（子类可返回父类返回值的子类）一致，访问权限不低于父类，用@Override注解标识。

（3）super关键字

• 作用：子类中访问父类成员，解决子类与父类成员重名问题；

• 用法：super.属性名（访问父类属性）、super.方法名()（调用父类方法）、super(参数)（调用父类构造方法，必须放在子类构造方法第一行）。

（4）示例

// 父类：Animal

public class Animal {

protected String name; // protected：子类可访问

public void eat() {

System.out.println(name + "在进食");

}

}

// 子类：Dog继承Animal

public class Dog extends Animal {

// 新增子类属性

private String breed;

// 方法重写

@Override

public void eat() {

System.out.println(name + "（" + breed + "）在吃狗粮");

}

// 子类新增方法

public void bark() {

System.out.println(name + "在汪汪叫");

}

}

（5）继承优势

• 代码复用：子类直接复用父类属性和方法，减少重复代码；

• 层级扩展：通过多层继承实现功能分层，便于系统设计与维护。

4. 多态（Polymorphism）

多态是同一行为，不同对象表现出不同形态的特性，是面向对象的核心优势，基于继承和方法重写实现，核心体现为"父类引用指向子类对象"。

（1）多态实现条件

• 存在继承/实现关系；

• 子类重写父类方法；

• 父类引用指向子类对象（向上转型）。

（2）向上转型与向下转型

• 向上转型（自动转型）：父类引用指向子类对象，格式：父类类型 引用名 = new 子类类型();，可调用父类所有成员、子类重写的方法，无法调用子类特有成员；

• 向下转型（强制转型）：将父类引用转回子类类型，格式：子类类型 引用名 = (子类类型) 父类引用;，需先通过instanceof判断类型，避免ClassCastException异常。

（3）多态示例

// 父类引用指向子类对象（向上转型）

Animal animal = new Dog();

// 调用子类重写的方法，表现多态

animal.eat(); // 执行Dog类的eat方法

// 向下转型，调用子类特有方法

if(animal instanceof Dog) {

Dog dog = (Dog) animal;

dog.bark();

}

（4）多态优势

• 代码灵活：统一父类接口，适配不同子类实现，便于扩展；

• 降低耦合：无需关注具体子类类型，通过父类引用交互，提升代码可维护性。

5. 抽象（Abstraction）

抽象是提取事物共性特征，忽略非核心细节，形成抽象模型的特性，通过抽象类和接口实现，是封装、继承、多态的基础。

（1）抽象类

• 关键字：abstract，格式：abstract class 类名{}；

• 特点：可包含抽象方法（无方法体，abstract 返回值类型 方法名();）和普通方法、属性；不能直接实例化，需子类继承并实现所有抽象方法；

• 作用：定义通用模板，强制子类实现特定功能。

（2）接口（Interface）

• 关键字：interface，格式：interface 接口名{}；

• 特点：仅包含抽象方法（JDK8+支持默认方法、静态方法）、常量（public static final修饰）；无构造方法，不能实例化，需类通过implements实现所有抽象方法；支持多实现（一个类可实现多个接口）；

• 作用：定义行为规范，实现"行为抽象"，解耦功能与实现。

（3）抽象类与接口区别

特性 抽象类 接口

继承/实现 子类extends继承 类implements实现

成员类型 可含属性、普通方法、抽象方法 仅含常量、抽象方法（JDK8+支持默认/静态方法）

构造方法 有构造方法 无构造方法

继承限制 单继承 多实现

核心作用 模板抽象（属性+行为） 行为规范（仅行为）

三、面向对象核心总结

1. 核心逻辑：以类为模板创建对象，通过封装保护数据、继承复用代码、多态灵活扩展、抽象简化设计；

2. 设计原则：高内聚（类内部功能紧密）、低耦合（类之间依赖少），符合现实世界事物关系；

3. 应用价值：相比面向过程，面向对象更适合大型项目开发，代码可复用、可扩展、可维护性更强，是Java企业级开发的核心思想。