当前位置： 首页 > news >正文

JAVA 关键词

news 来源：原创 2025/5/27 11:13:34

1. interface

Java中的interface关键字用于定义接口，它是一种引用类型，用于指定类必须实现的方法集合。接口在Java中扮演着定义契约的角色，确保实现类遵循特定的行为规范。以下是关于interface的详细介绍，包括其特性、用法和实际应用场景：

一、接口的基本特性

  1. 抽象方法：

    • 接口中的方法默认是public abstract的（无需显式声明）。
    • 实现类必须覆盖所有抽象方法。
    public interface Animal {void eat();  // 抽象方法void sleep();
}

  2. 常量：

    • 接口中的变量默认是public static final的（即常量）。
    • 必须在声明时初始化。
    public interface Constants {int MAX_AGE = 100;         // 常量String DEFAULT_NAME = "Unknown";
}

  3. 默认方法（Java 8+）：

    • 使用default关键字定义，提供默认实现。
    • 实现类可选择覆盖或直接使用默认方法。
    public interface Vehicle {void start();default void stop() {      // 默认方法System.out.println("Vehicle stopped");}
}

  4. 静态方法（Java 8+）：

    • 使用static关键字定义，通过接口名直接调用。
    public interface MathUtils {static int add(int a, int b) {  // 静态方法return a + b;}
}
// 调用：MathUtils.add(3, 5);

  5. 私有方法（Java 9+）：

    • 使用private定义，仅在接口内部复用代码。
    public interface Logger {default void logInfo(String message) {log("INFO: " + message);}private void log(String message) {  // 私有方法System.out.println(message);}
}

二、接口的继承与实现

  1. 类实现接口：

    • 使用implements关键字。
    • 必须实现所有抽象方法（除非是抽象类）。
    public class Dog implements Animal {public void eat() { System.out.println("Dog eats"); }public void sleep() { System.out.println("Dog sleeps"); }
}

  2. 接口继承接口：

    • 使用extends关键字，支持多继承。
    public interface A { void methodA(); }
public interface B { void methodB(); }
public interface C extends A, B {  // 多继承void methodC();
}

  3. 多接口实现：

    • 一个类可以实现多个接口。
    public class Smartphone implements Camera, Phone, Computer {// 实现所有接口的方法
}

三、接口与抽象类的区别

特性接口 (interface)抽象类 (abstract class)
方法类型抽象方法、默认方法、静态方法、私有方法抽象方法、具体方法
变量只能是常量 (public static final)任意类型变量（非final）
构造方法无有
实现/继承类可implements多个接口类只能extends一个抽象类
多继承支持接口可extends多个其他接口不支持多继承

四、示例代码

// 定义接口
public interface Animal {void eat();default void sleep() { System.out.println("Sleeping..."); }
}// 实现接口
public class Dog implements Animal {public void eat() { System.out.println("Dog eats"); }
}// 使用接口
public class Main {public static void main(String[] args) {Animal dog = new Dog();dog.eat();       // 输出：Dog eatsdog.sleep();      // 输出：Sleeping...}
}

2.final

Java 的 final 和 C++ 的 const 都用于定义某种形式的“不可变性”，但它们在语义、用途和实现机制上有显著区别。以下是两者的详细对比：

一、核心概念对比

场景Java finalC++ const
常量变量final int x = 10;
x 不可重新赋值		const int x = 10;
x 不可修改
引用不可变final MyClass obj = new MyClass();
obj 不能指向新对象，但对象内容可修改		MyClass const* ptr = new MyClass();
ptr 可指向新对象，但对象内容不可修改
const MyClass* const ptr = ...;
ptr 和对象内容均不可修改
方法不可重写public final void print() { ... }
子类不能重写该方法		无直接等价，需通过设计模式（如非虚接口模式）实现
类不可继承final class MyClass { ... }
MyClass 不能被继承		class MyClass final { ... }
（C++11 起支持）
常量成员变量在构造函数中初始化：
public final int x;
public MyClass(int x) { this.x = x; }		必须在类内声明并在初始化列表中初始化：
class MyClass { const int x; }
MyClass::MyClass(int x) : x(x) {}
常量引用参数public void method(final MyClass obj) { ... }
obj 不能重新赋值		void method(const MyClass& obj) { ... }
obj 内容不可修改
常量成员函数无直接等价，需通过约定不修改成员变量int getValue() const { ... }
保证不修改对象状态

二、变量修饰对比

1. Java final 变量
  • 基本类型：值不可变
    final int x = 10;
// x = 20; // 编译错误
  • 对象引用：引用不可变，但对象内部状态可变
    final List<String> list = new ArrayList<>();
list.add("Java"); // 允许修改对象内容
// list = new LinkedList<>(); // 编译错误（引用不可变）
2. C++ const 变量
  • 基本类型：值不可变，需初始化
    const int x = 10;
// x = 20; // 编译错误
  • 指针/引用：
    int a = 10, b = 20;
const int* ptr1 = &a;  // 指向的内容不可变
ptr1 = &b;  // 允许修改指针指向
// *ptr1 = 30; // 编译错误（内容不可变）int* const ptr2 = &a;  // 指针本身不可变
*ptr2 = 30;  // 允许修改内容
// ptr2 = &b; // 编译错误（指针不可变）const int* const ptr3 = &a; // 指针和内容均不可变

三、方法与函数修饰对比

1. Java final 方法
  • 禁止子类重写该方法
    class Parent {public final void show() {System.out.println("Parent");}
}
class Child extends Parent {// @Override public void show() { ... } // 编译错误
}
2. C++ const 成员函数
  • 表示该函数不会修改对象状态（只能调用其他 const 成员函数）
    class MyClass {
public:int getValue() const { // const成员函数return value;}void setValue(int v) { // 非const成员函数value = v;}
private:int value;
};const MyClass obj;
obj.getValue();    // 允许
// obj.setValue(5); // 编译错误（const对象只能调用const成员函数）

四、类修饰对比

1. Java final 类
  • 禁止继承该类
    final class ImmutableClass { ... }
// class SubClass extends ImmutableClass { ... } // 编译错误
2. C++ const 类对象
  • C++ 中没有直接对应的 final class，但可以通过构造函数私有化等方式模拟不可继承性。
  • 对象的 const 修饰表示对象不可修改：
    class MyClass {
public:void modify() { ... }void read() const { ... }
};const MyClass obj;
obj.read();      // 允许
// obj.modify(); // 编译错误（const对象只能调用const成员函数）

五、代码示例对比

1. 不可变对象

  • Java（使用 final）：

    final class ImmutablePoint {private final int x;private final int y;public ImmutablePoint(int x, int y) {this.x = x;this.y = y;}// 只有getter，没有setter
}

  • C++（使用 const）：

    class ImmutablePoint {
public:ImmutablePoint(int x, int y) : x(x), y(y) {}int getX() const { return x; }  // const成员函数int getY() const { return y; }
private:const int x;  // const成员变量const int y;
};

核心区别：

  • Java 的 final 主要关注引用不可变性和继承控制，而 C++ 的 const 更注重值不可变性和类型系统安全。
  • C++ 的 const 具有更强的类型系统集成能力（如 const 成员函数、const 引用参数），而 Java 的 final 更简单直观。

相关文章：

  • Mac系统-最方便的一键环境部署软件ServBay（支持php,java,python,node,go,mysql等）没有之一，已亲自使用！
  • 【LeetCode】大厂面试算法真题回忆(99)--Linux发行版的数量
  • TCP 的四次挥手
  • PTA刷题笔记（难度预警！！！有详解）
  • 再写数的划分（dfs）
  • 第四章 面向对象（基础）
  • SymAgent：一种用于知识图谱复杂推理的神经符号自学Agent框架
  • Linux Kernel调试：强大的printk（三）
  • Markdown 到 LaTeX：Overleaf 学习笔记
  • 基于javaweb的SpringBoot体检管理系统设计与实现(源码+文档+部署讲解）
  • 【C++】unordered_map、unordered_set 的使用
  • CQF预备知识：Python相关库 -- NumPy 基础知识 - ndarray 索引
  • vue3组件--无限滚动效果
  • Android7 Input（九）View 建立Input Pipeline
  • 15 dart类（get,set,静态，继承，抽象，接口，混入）
  • Gartner报告解读《Technical Professionals Need to Track 5 ImportantLLM Developments》
  • 论文审稿之我对SCI写作的思考
  • CSS之元素定位
  • 批量获取电商商品数据的解决方案|API接口自动化商品采集|item_get 接口详解
  • 动态规划算法：字符串类问题（2）公共串
  • 阿里巴巴是b2b电子商务网站吗/西安网站建设公司十强
  • 门户网站建设厂商名录/网站推广方案模板
  • 网络推广公司诈骗投诉/新乡网站优化公司价格
  • 如何做适合手机访问的网站/黄山网站seo
  • 关于电商网站规划方案/怎么推广软件
  • 网站建设前期规划方案/软文发布系统