JavaSE：初学String、接口与多态，

正文

目录会跟随阅读位置移动。

阅读进度

我是刚入门JavaSE没多久的新手，最近刚啃完String类、接口和多态这三个“入门坎”，深深觉得这三个知识点既是基础，又容易踩坑，所以整理了自己的学习笔记和心得，用最通俗的话分享给和我一样的初学者，希望能帮大家少走点弯路！

先跟大家说句大实话：刚开始学这三个知识点时，我一度陷入“看得懂代码，写不出来，一用就错”的困境，尤其是多态，总觉得抽象又难理解。

一、String类：看似简单，实则暗藏玄机

String类应该是我们接触Java以来用得最多的类了吧？比如打印一句“Hello Java”，定义一个用户名，都离不开它。但就是这个看似简单的类，藏着很多新手容易忽略的细节，我最开始就栽在“不可变性”和“==与equals的区别”上。

1. 核心特性：String是“不可变”的

什么是不可变性？简单来说，就是字符串对象一旦创建，它的值就不能被修改。

举个简单的例子

String str1 = "Java";
str1 += "SE";
System.out.println(str1); // 输出JavaSE

看似str1的值从“Java”变成了“JavaSE”，但实际上，原有的“Java”对象并没有被修改，而是JVM新创建了一个“JavaSE”对象，然后让str1指向了这个新对象，原来的“Java”对象会被垃圾回收机制回收。这就是String的不可变性，底层是因为String类的value数组被private final修饰，无法被修改，所有看似“修改”的操作，本质上都是创建新对象。

2. 新手必避坑：== 与 equals

这应该是String类最常考、最容易用错的点了，我刚开始每次都搞混，后来总结了一句话，记牢就不会错：

== 比较的是地址值（是否是同一个对象），equals 比较的是字符串内容

再看一个案例，对比着理解：

// 方式1：字面量创建，相同内容共享一个对象
String str2 = "abc";
String str3 = "abc";
// 方式2：new关键字创建，每次都会生成新对象，存入堆内存
String str4 = new String("abc");

System.out.println(str2 == str3); // true（地址相同，同一个对象）
System.out.println(str2 == str4); // false（地址不同，不同对象）
System.out.println(str2.equals(str4)); // true（内容相同）

另外，String类还有很多常用方法，比如截取（substring）、替换（replace）、查找（indexOf）、大小写转换（toUpperCase/toLowerCase），这些方法不用死记硬背，用到的时候查API，多练几次自然就记住了。比如截取字符串：String c = "abc".substring(2, 3); 就会得到“c”。

二、接口：定义规范，实现多继承的“桥梁”

学完类和继承后，我们会发现一个问题：Java中一个类只能继承一个父类（单继承），但实际开发中，一个类可能需要具备多种功能，这时候接口就派上用场了。

我对接口的理解很简单：接口就是一种“规范”，它只定义方法的签名（方法名、参数列表、返回值），不提供具体的实现，相当于一份“契约”，要求实现它的类必须按照这个契约去实现所有方法。

1. 接口的基本语法

定义接口用关键字interface，里面的方法默认是public abstract（可以省略不写），不能有具体实现；接口中也不能定义实例字段，只能定义常量（默认public static final）。

举个简单的接口例子：

// 定义接口
interface Runnable {
    // 抽象方法
    void run();
}

// 实现接口，用implements关键字
class Student implements Runnable {
    @Override
    // 必须实现接口中的所有抽象方法
    public void run() {
        System.out.println("学生课间奔跑，锻炼身体～");
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Runnable student = new Student();
        student.run(); // 输出：学生课间奔跑，锻炼身体～
    }
}

2. 接口的核心特点

单继承，多实现：一个类只能继承一个父类，但可以实现多个接口（用逗号分隔），比如class Student implements Runnable, Eatable，这样就解决了Java单继承的局限性。
接口可以继承接口：一个接口可以通过extends关键字继承另一个接口，相当于扩展接口的方法规范。比如interface Person extends Runnable，那么Person接口就包含了run()方法。

这里还要区分一下接口和抽象类：抽象类可以有实例字段、非抽象方法，而接口不能有实例字段，只能有抽象方法和default方法；一个类只能继承一个抽象类，但可以实现多个接口。

三、多态：让代码更灵活

多态是Java面向对象的三大核心特性之一（另外两个是封装、继承），也是我觉得最难理解的一个知识点。但只要抓住“同一行为，不同实现”这个核心，就会豁然开朗。

通俗来讲，多态就是：同一个方法，在不同的对象上调用，会产生不同的结果。比如同样是“吃饭”这个行为，人用筷子吃，狗用嘴巴啃，这就是生活中的多态；对应到Java中，同样是run()方法，学生对象执行“奔跑”，老师对象执行“跑步健身”，这就是Java中的多态。

1. 多态的三个必要条件（缺一不可）

新手一定要记住这三个条件，否则无法实现多态：

有继承关系：子类必须继承父类（或实现接口）；
子类重写父类方法：子类对父类的非private、非final方法进行重写（方法名、参数列表、返回值必须一致）；
父类引用指向子类对象：声明一个父类类型的引用，指向子类的实例（也就是“向上转型”）。

2. 多态的简单案例

结合接口和多态，写一个案例，大家可以直接复制运行，感受一下多态的效果：

// 定义接口（父类规范）
interface Workable {
    void work();
}

// 子类1：学生实现Workable接口，重写work方法
class Student implements Workable {
    @Override
    public void work() {
        System.out.println("学生的工作：学习JavaSE，攻克知识点");
    }
}

// 子类2：老师实现Workable接口，重写work方法
class Teacher implements Workable {
    @Override
    public void work() {
        System.out.println("老师的工作：讲授Java知识，帮助学生成长～");
    }
}

// 测试多态
public class PolymorphismTest {
    public static void main(String[] args) {
        // 父类引用指向子类对象（向上转型）
        Workable student = new Student();
        Workable teacher = new Teacher();
        
        // 调用同一个work方法，产生不同结果
        student.work(); // 输出：学生的工作：学习JavaSE，攻克知识点～
        teacher.work(); // 输出：老师的工作：讲授Java知识，帮助学生成长～
    }
}

运行结果很明显，同样是调用work()方法，因为指向的子类对象不同，执行的结果也不同，它能让我们的代码更灵活、更简洁.

3. 新手易错点：多态中不能调用子类特有方法

父类引用指向子类对象后，只能调用父类（或接口）中定义的方法，不能直接调用子类特有的方法。比如Student类有一个study()方法，teacher类有一个teach()方法，我们不能通过Workable类型的引用去调用这些特有方法，除非进行“向下转型”（但新手暂时不用深入，先掌握向上转型即可）。

四、学习心得: 理解这三个知识点？

先理解核心，再记语法：不要一上来就死记硬背代码，先搞懂String的不可变性、接口的规范作用、多态的核心逻辑，理解之后，语法自然就记住了。
多写案例，多踩坑：一定要动手写代码，把文中的案例都跑一遍，再自己修改代码（比如给String类加不同的方法，给接口新增抽象方法），踩过的坑才会记得更牢。
不要急于求成，循序渐进：这三个知识点不是孤立的，String是基础，接口是多态的重要实现方式，先吃透String，再学接口，最后学多态，一步一步来，不要着急。

其实JavaSE的学习难，但要多思考、多练习，每天进步一点点，慢慢就能攻克这些基础知识点。我目前也还在持续学习中。