【Java】面向对象核心知识点（一），文章层次分明，内容精益求精，代码简单易懂

目录

一、概述

二、权限修饰符

三、两个关键字

3.1 this关键字

3.2 super关键字

四、封装

4.1 概念

4.2 作用

4.3 代码

五、继承

5.1 概念

5.2 作用

5.3 语法

5.4 情况

5.5 代码

六、多态

6.1 概念

6.2 形式

6.3 代码

---

（原创文章，转载请注明出处）

博主是计算机专业大学生，不定期更新原创优质文章，感兴趣的小伙伴可以关注博主主页支持一下，您的每一个点赞、收藏和关注都是对博主最大的支持！

---

一、概述

• 面向对象是一种软件开发方法，同时也是一种程序设计范型
• 编写对象编程，就是把要处理的数据交给对象，让对象来处理
• 面向对象三大特征：封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）

先了解以下概念

• 类（class）：类是对象的抽象，用于描述一组对象的共同特征和行为
• 对象（object）：对象是类的示例，用于描述现实中的个体，一个类可以对应多个对象
• 成员变量：成员变量是来描述对象的特征，成员变量也被称作对象的属性
• 成员方法：成员方法用于描述对象的行为，成员方法也可简称为方法
• 局部变量：定义在方法中的变量被称为局部变量

下面根据代码深刻理解这几个概念

① 学生类

//类的定义：定义一个学生类
public class Student {
    String name = "张三";  //成员变量

    public void say() {  //成员方法
        int age = 22;   // 局部变量
        System.out.println("我是" + name + "，今年" + age + "岁");
    }
}

② 测试类

public class Test {
    public static void main(String[] args) {
        Student student = new Student(); //实例化学生类的对象
        student.say();  //调用类的成员方法
    }
}

二、权限修饰符

权限修饰符是用来限制类的成员（成员变量、成员方法...）能够被访问的范围

修饰符	同一类中	同一包中的类	不同包的子类	全局范围
private	√
缺省（不写）	√	√
protected	√	√	√
public	√	√	√	√

权限范围：private < 缺省（不写） < protected < public

三、两个关键字

3.1 this关键字

this就是一个变量，用在方法中，可以拿到当前类的对象，使用语法如下

this.成员变量	//访问本类成员变量
this.成员方法	//调用本类成员方法
this()		//调用本类构造方法

（1）访问本类的成员变量和方法

① 例子类

public class Example {
    // 成员变量
    public String name = "我是成员变量";

    // 成员方法
    public String say() {
        return "我是成员方法";
    }

    public void show() {
        System.out.println(this.name);  // 访问本类成员变量
        System.out.println(this.say()); // 调用本类成员方法
    }
}

② 测试类

public class ExampleTest {
    public static void main(String[] args) {
        new Example().show();
        // 输出：
        // 我是成员变量
        // 我是成员方法
    }
}

（2）访问本类的构造方法

① 学生类

public class Student {
    String name;
    int age;

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

    public Student() {
        this("张三", 22);  // 调用本类构造方法
        // this()用于类的构造函数中初始化成员变量，
        // 在本按例中，若没有进行赋值，默认为：name = "张三" age = 22
    }
}

② 测试类

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println("姓名：" + s1.getName() + ",年龄：" + s1.getAge());
        Student s2 = new Student("李四", 21);
        System.out.println("姓名：" + s2.getName() + ",年龄：" + s2.getAge());
        // 输出：
        // 姓名：张三,年龄：22
        // 姓名：李四,年龄：21
    }
}

3.2 super关键字

super关键字可以在子类中调用父类的普通属性、方法以及构造方法，解决了父类方法被重写后，子类对象将无法访问父类被重写的方法的问题

super.成员变量	//访问父类成员变量
super.成员方法	//调用父类成员方法
super()		//调用父类构造方法

（1）访问父类成员变量和方法

① 父类

public class Father {
    // 父类成员变量
    public String name = "父类成员变量";

    // 父类成员方法
    public String say() {
        return "父类成员方法";
    }
}

② 子类

public class Child extends Father {
    // 子类成员变量
    public String name = "子类成员变量";

    // 子类成员方法
    public String say() {
        return "子类成员方法";
    }

    // 访问父类成员变量
    public String showFatherName() {
        return super.name;
    }

    // 调用父类成员方法
    public String showFatherSay() {
        return super.say();
    }
}

③ 测试类

public class SuperTest {
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(child.name);
        System.out.println(child.say());
        System.out.println(child.showFatherName());
        System.out.println(child.showFatherSay());
        // 输出：
        // 子类成员变量
        // 子类成员方法
        // 父类成员变量
        // 父类成员方法
    }
}

（2）调用父类构造方法

① 父类

public class Father {
    String name;

    public Father() {  // 空参构造
        System.out.println("父类空参构造");
    }

    public Father(String name) {  // 含参构造
        this.name = name;
        System.out.println("父类" + this.name + "构造");
    }
}

② 子类

public class Child extends Father {
    public Child() {
        super();  // 调用父类空参构造
    }

    public Child(String name) {
        super(name); // 调用父类含参构造
    }
}

③ 测试类

import org.junit.Test;

public class SuperTest {
    @Test
    public void test() {
        new Child();
        new Child("含参");
        // 输出：
        // 父类空参构造
        // 父类含参构造
    }
}

四、封装

4.1 概念

封装是将对象的状态（属性）和行为（方法）结合在一起，作为一个单独的实体（类）来处理。通过将属性声明为私有（private󠁪），并提供公共（public）的getter和setter方法（或称为访问器和修改器方法），控制对这些属性的访问和修改。

4.2 作用

封装的主要目的是隐藏对象的内部实现细节，只对外提供有限的操作接口。这样可以确保数据安全，防止外界直接操作对象内部状态导致逻辑混乱或异常，同时也方便在未来更改内部实现而不影响依赖于它的外部代码。

4.3 代码

① 学生类

public class Student {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

② 测试类

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(22);
        System.out.println("姓名：" + student.getName() + "，年龄：" + student.getAge());
        // 输出：姓名：张三，年龄：22
    }
}

五、继承

5.1 概念

• 在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系（Object类是所有类的间接或直接父类）
• 继承是一种层次结构的概念，允许一个类（子类）从另一个类（父类）继承已有的属性和方法。

5.2 作用

• 子类不仅可以拥有父类的所有非私有属性和方法，还可以添加新的属性和方法，或者覆盖（重写）父类的方法，从而扩展和定制功能。
• 继承有助于减少代码冗余，促进代码复用，并且可以构建一个更丰富的类体系结构。

5.3 语法

class 父类{ …… }
class 子类 extends 父类{ …… }

5.4 情况

（1）可以多个子类继承一个父类

class A{ }
class B extends A{ }
class C extends A{ }
// B和C同时继承A

（2）在Java中也可是是多层继承

class A{ }
class B extends A{ }
class C extends B{ }
// B继承A，C继承B

5.5 代码

① 父类

public class Father {
    // 父类成员变量
    public String name = "父类成员变量";

    // 父类成员方法
    public String say() {
        return "父类成员方法";
    }
}

② 子类

public class Child extends Father { }

③ 测试类

public class ExtendsTest {
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(child.name);
        System.out.println(child.say());
        // 输出：
        // 父类成员变量
        // 父类成员方法
    }
}

六、多态

6.1 概念

• 在Java中，多态是指不同对象在调用同一个方法时表现出的多种不同行为。
• 多态意味着一个接口可以有多种不同的实现，或者说一个方法可以有多种形式。
• 多态允许程序员编写更加通用的代码，能够处理多种不同类型对象的行为，增强了程序的灵活性和扩展性。

6.2 形式

• 在Java中，多态主要表现为两种形式：方法重载（Overloading）和方法重写（Overriding）。
• 方法重载是在一个类中定义多个同名方法，但参数列表不同（参数类型、数量或顺序不同），编译器根据传入的参数类型和数量决定调用哪个方法。
• 方法重写是子类重新定义父类中的某个方法，当父类引用指向子类对象时，调用该方法时执行的是子类的重写版本。

6.3 代码

（1）方法重载

① 例子类

public class Example {
    public int sum(int a, int b) {
        return a + b;
    }
    // 参数数量不同
    public int sum(int a, int b, int c) {
        return a + b + c;
    }
    // 参数类型不同
    public int sum(int a, float b) {
        return (int) (a + b);
    }
    // 参数类型顺序不同
    public int sum(float a, int b) {
        return (int) (a + b);
    }
}

② 测试类

public class OverloadingTest {
    public static void main(String[] args) {
        Example e = new Example();
        System.out.println("两数之和：" + e.sum(35, 65));
        System.out.println("三数之和：" + e.sum(35, 20, 45));
        System.out.println("整数+浮点数：" + e.sum(35, (int) 65.5));
        System.out.println("浮点数+整数：" + e.sum((int) 35.5, 65));
        // 输出：
        // 两数之和：100
        // 三数之和：100
        // 整数+浮点数：100
        // 浮点数+整数：100
    }
}

（2）方法重写

① 父类

public class Father {
    public String say() {
        return "我是父类方法";
    }
}

② 子类

public class Child extends Father {
    public String say() {
        return "我是子类方法";
    }
}

③ 测试类

public class OverridingTest {
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(child.say());
        // 输出：我是子类方法
    }
}

若有不妥之处，恳请读者批评指正