【Java 基础】面相对象核心

╰+攻爆jí腚メ 2024-05-04 08:03 8阅读 0赞

![在这里插入图片描述][c53360fa1df3404b93fac78e42d93d49.png]

> 👉**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
💞 个人主页：[个人主页][Link 2]  
🙉 专栏地址： ✅ [Java 进阶之路][Java]  
🙉八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  一、类和对象的概述
         *  二、方法的使用详情
         *  三、可变参数的使用和注意事项
         *  四、访问修饰符
         *  五、this关键字的应用
         *  六、面向对象三大特性一封装
         *  七、面向对象三大特性一继承
         *  八、面向对象三大特性一多态

#### 一、类和对象的概述 ####

Java是一种面向对象的编程语言，类和对象是Java中最基本的概念。类是一种抽象的概念，用于描述具有相同属性和行为的一组对象。对象是类的实例，它具有类定义的属性和行为。

在Java中，类是创建对象的模板。它定义了对象的属性和方法。属性是对象的状态，用于描述对象的特征。方法是对象的行为，用于描述对象可以执行的操作。

类的定义通常包括以下几个部分：

1.  **类的修饰符**：用于控制类的访问权限，如public、private等。
2.  **类的名称**：用于唯一标识类的名称，按照命名规范应该使用大写字母开头的驼峰命名法。
3.  **类的成员变量**：用于描述类的属性，包括数据类型和变量名。
4.  **类的方法**：用于描述类的行为，包括方法的返回类型、方法名和方法的参数列表。

创建对象时，需要使用关键字"new"来实例化一个类，并调用类的构造方法来初始化对象。通过对象可以访问类的属性和调用类的方法。

类和对象的概念是面向对象编程的核心，它们使得程序可以更加模块化和可重用。通过定义不同的类和创建对象，可以构建复杂的程序，并实现代码的封装和抽象。

#### 二、方法的使用详情 ####

Java中的方法是一段可重复使用的代码块，用于执行特定的任务或操作。方法可以接受参数并返回一个值，也可以不接受参数或不返回值。方法的使用可以使代码更加模块化、可重用和易于维护。

下面是Java方法的一些使用详情：

1.  **方法的定义**：

方法由方法名、参数列表、返回类型和方法体组成。方法名是用于唯一标识方法的名称。参数列表是传递给方法的参数的类型和名称。返回类型是方法执行完后返回的数据类型。方法体是方法的具体实现。

例如，下面是一个简单的方法定义：

public int add(int a, int b) {
        
     	int sum = a + b;
        return sum;
    }

1.  **方法的调用**：

要使用方法，需要通过方法名和参数列表来调用它。调用方法时，传递给方法的参数必须与方法定义中的参数类型和顺序相匹配。方法的返回值可以被存储在变量中，或者直接使用。

例如，调用上面定义的add方法：

int result = add(5, 3);
       System.out.println(result);  // 输出结果为 8

1.  **方法的参数**：

方法可以接受零个或多个参数。参数可以是基本数据类型或对象类型。方法的参数可以在方法体内部使用，用于执行特定的操作。

例如，下面是一个接受两个参数的方法：

public void greet(String name, int age) {
        
      	System.out.println("Hello, " + name + "! You are " + age + " years old.");
    }

1.  **方法的返回值**：

方法可以有一个返回值，也可以没有返回值。返回值的类型必须与方法定义中的返回类型相匹配。如果方法没有返回值，返回类型应该使用关键字 `void` 。

例如，下面是一个返回值为int类型的方法：

public int multiply(int a, int b) {
        
     	int product = a * b;
      	return product;
    }

以上是Java方法的一些基本使用详情。方法的使用可以使代码更加模块化、可读性更高，并且可以提高代码的复用性和可维护性。

#### 三、可变参数的使用和注意事项 ####

Java中的可变参数是一种特殊的参数类型，它可以接受不定数量的参数。在方法定义中，使用三个点(…)来表示可变参数。可变参数必须是方法的最后一个参数，且只能有一个可变参数。

下面是Java可变参数的一些使用和注意事项：

1.  **可变参数的定义**：  
    可变参数是一种数组类型，可以接受任意数量的参数。在方法定义中，使用三个点(…)来表示可变参数。例如，下面是一个接受可变参数的方法定义：

public void printValues(String... values) {
        
      	for (String value : values) {
        
            System.out.println(value);
        }
    }

1.  **可变参数的调用**：

调用可变参数的方法时，可以传递任意数量的参数。在方法内部，可变参数被视为一个数组类型。例如，下面是一个调用可变参数方法的示例：

printValues("Hello", "World", "Java");

1.  **可变参数的注意事项**：
    
     *  可变参数必须是方法的最后一个参数。
     *  可变参数只能有一个。
     *  可变参数的类型必须与数组元素的类型相同。
     *  如果方法定义中没有参数，则可变参数可以为空。
     *  如果同时存在固定参数和可变参数，则固定参数必须在可变参数之前。
     *  如果调用可变参数的方法时不传递任何参数，则可变参数会被初始化为空数组。
     *  如果调用可变参数的方法时传递的参数数量超过了可变参数的长度，则会抛出ArrayIndexOutOfBoundsException异常。
     *  如果调用可变参数的方法时传递的参数类型与可变参数的类型不匹配，则会抛出ArrayStoreException异常。

例如，下面是一个使用可变参数的方法定义，其中包含固定参数和可变参数：

public void printValues(String prefix, String... values) {
        
        System.out.println(prefix);
        for (String value : values) {
        
            System.out.println(value);
        }
    }

调用该方法时，可以传递任意数量的参数，例如：

printValues("Values:", "Hello", "World", "Java");

输出结果为：

Values:
    Hello
    World
    Java

#### 四、访问修饰符 ####

Java中的访问修饰符用于控制类、方法、变量和构造函数的访问权限。Java中有四种访问修饰符：

1.  **public**：公共访问修饰符，可以在任何地方被访问。被public修饰的类、方法、变量和构造函数可以被同一个包内的其他类、不同包的类以及不同包的子类访问。
2.  **private**：私有访问修饰符，只能在定义它的类内部访问。被private修饰的方法、变量和构造函数只能在同一个类内部被访问和调用。
3.  **protected**：受保护的访问修饰符，可以在同一个包内的其他类以及不同包的子类中访问。被protected修饰的方法、变量和构造函数可以在同一个包内的其他类中被访问，也可以在不同包的子类中被访问。
4.  **默认（没有显式修饰符）**：默认访问修饰符，也称为包级访问修饰符。如果没有指定访问修饰符，则默认为包级访问修饰符。被默认修饰符修饰的类、方法、变量和构造函数可以在同一个包内被访问，但不能在不同包中被访问。

访问修饰符的使用可以根据需要来控制类、方法、变量和构造函数的可见性和访问权限，以实现封装和隐藏内部实现细节的目的。

#### 五、this关键字的应用 ####

Java中的"this"关键字用于引用当前对象，它可以在类的方法中使用。下面是"this"关键字的一些应用：

1.  **引用当前对象的成员变量**：

当类的成员变量和方法参数名字相同时，可以使用"this"关键字来引用当前对象的成员变量。例如：

public class Person {
        
      	 private String name;
         public void setName(String name) {
        
            this.name = name;
        }
    }

在上面的例子中，使用"this.name"来引用当前对象的成员变量"name"。

1.  **调用当前对象的其他方法**：

在类的方法中，可以使用"this"关键字来调用当前对象的其他方法。例如：

public class Person {
        
         public void sayHello() {
        
            System.out.println("Hello");
         }
         
         public void greet() {
        
            this.sayHello();
        }
    }

在上面的例子中，使用"this.sayHello()“来调用当前对象的方法"sayHello()”。

1.  **在构造函数中调用其他构造函数**：

当类有多个构造函数时，可以使用"this"关键字在一个构造函数中调用另一个构造函数。这种方式称为构造函数的重载。例如：

public class Person {
        
        private String name;
        private int age;
        public Person() {
        
            this("John Doe", 30); // 调用另一个构造函数
        }
        
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    }

在上面的例子中，无参构造函数使用"this(“John Doe”, 30)"来调用有参构造函数。

1.  **返回当前对象**：

在方法中，可以使用"return this"语句来返回当前对象的引用。这样可以实现方法的链式调用。例如：

public class Person {
        
         private String name;
         public Person setName(String name) {
        
             this.name = name;
             return this;
         }
         
         public void sayHello() {
        
             System.out.println("Hello, " + this.name);
         }
    }

在上面的例子中，方法"setName()"返回当前对象的引用，从而实现了方法的链式调用。

"this"关键字在Java中的应用有很多，它可以帮助我们引用当前对象、调用其他方法和构造函数，以及实现方法的链式调用。

#### 六、面向对象三大特性一封装 ####

Java面向对象的三大特性是封装、继承和多态。在这里我们讨论封装。

封装是指将数据和对数据的操作封装在一个类中，通过访问修饰符来控制外部对数据的访问权限。封装的目的是隐藏类的内部实现细节，只暴露必要的接口供外部使用。这样可以提高代码的安全性和可维护性。

在Java中，可以使用访问修饰符（如private、public、protected和默认访问修饰符）来控制类的成员变量和方法的访问权限。一般情况下，我们将成员变量设置为私有(private)，并提供公共(public)的方法来访问和修改这些成员变量。这样外部代码就无法直接访问和修改类的内部数据，而是通过公共方法来进行操作。

封装的好处有：

1.  **数据隐藏**：封装可以隐藏类的内部实现细节，只暴露必要的接口，防止外部代码直接访问和修改类的内部数据，提高了代码的安全性。
2.  **提高代码可维护性**：封装将类的实现细节和外部代码分离开来，当类的内部实现发生变化时，只需要修改类的内部代码，而不影响外部代码的使用。
3.  **代码复用**：封装可以将类的内部实现封装成一个模块，可以被其他类复用，提高了代码的重用性。

总之，封装是面向对象编程中的重要概念，通过封装可以实现数据的隐藏和保护，提高代码的安全性和可维护性。

假设我们有一个名为"Person"的类，它有两个私有成员变量：“name"和"age”。我们希望外部代码无法直接修改这些成员变量，而是通过公共方法来访问和修改它们。

public class Person {
        
        private String name;
        private int age;
        
        public String getName() {
        
            return name;
        }
        
        public void setName(String name) {
        
            this.name = name;
        }
        
        public int getAge() {
        
            return age;
        }
        
        public void setAge(int age) {
        
            this.age = age;
        }
    }

在上面的例子中，我们将成员变量"name"和"age"设置为私有(private)，这样外部代码无法直接访问它们。然后我们提供了公共的方法"getName()"和"setName()"来访问和修改"name"成员变量，以及"getAge()"和"setAge()"来访问和修改"age"成员变量。

现在，外部代码可以通过这些公共方法来访问和修改Person对象的"name"和"age"。例如：

public class Main {
        
        public static void main(String[] args) {
        
            Person person = new Person();
            person.setName("John");
            person.setAge(30);
             System.out.println("Name: " + person.getName());
            System.out.println("Age: " + person.getAge());
        }
    }

在上面的例子中，我们创建了一个Person对象，并通过公共方法"setName()"和"setAge()“来设置对象的"name"和"age”。然后通过公共方法"getName()"和"getAge()“来获取对象的"name"和"age”，并打印输出。

通过封装，我们可以控制外部代码对类的成员变量的访问权限，保护数据的安全性，并提供统一的接口来操作数据。这样可以提高代码的可维护性和安全性。

#### 七、面向对象三大特性一继承 ####

继承是面向对象编程中的一个重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。通过继承，子类可以获得父类的特性，并且可以在此基础上进行扩展或修改。

继承的主要目的是实现代码的重用和扩展。当一个类与另一个类有相似的属性和方法时，我们可以将这些共同的部分放在一个父类中，然后让多个子类继承这个父类。子类可以直接使用父类中的属性和方法，而无需重新编写相同的代码。这样可以减少代码的重复，提高代码的可维护性和可扩展性。

在继承关系中，子类可以继承父类的公有和受保护的成员（属性和方法），但不能继承私有成员。子类可以通过继承来获得父类的属性和方法，并且可以在子类中添加新的属性和方法，或者重写父类的方法来实现自己的特定行为。

继承关系中还涉及到一些重要的概念，例如单继承和多继承。在Java中，一个类只能直接继承一个父类，这被称为单继承。但是，一个类可以间接继承多个父类，通过继承链的方式，这被称为多层继承。另外，Java中还有接口的概念，它允许一个类实现多个接口，实现了类似于多继承的效果。

总结来说，继承是面向对象编程中的一个重要概念，它允许子类继承父类的属性和方法，实现代码的重用和扩展。通过继承，子类可以直接使用父类的特性，并且可以在此基础上进行修改和扩展。继承是面向对象编程的核心概念之一，它提供了代码的灵活性和可维护性。

让我们以一个简单的例子来说明继承的概念。假设我们有一个父类叫做"Animal"，它有一个属性"age"和一个方法"eat()“。我们想要创建一个子类叫做"Dog”，它继承自"Animal"类，并且具有自己的属性和方法。

public class Animal {
        
        private int age;
        
        public int getAge() {
        
            return age;
        }
        
        public void setAge(int age) {
        
            this.age = age;
        }
        
        public void eat() {
        
            System.out.println("Animal is eating");
        }
    }
    
    public class Dog extends Animal {
        
        public void bark() {
        
            System.out.println("Dog is barking");
        }
    }

在上面的例子中，我们定义了一个"Animal"类，它有一个私有属性"age"和一个公共方法"eat()“。然后我们创建了一个"Dog"类，它继承自"Animal"类，并且新增了一个公共方法"bark()”。

现在我们可以创建一个"Dog"对象，并且调用继承自父类的方法或属性，以及子类自己的方法。

public class Main {
        
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            dog.setAge(3);
            System.out.println("Dog's age: " + dog.getAge());
            dog.eat();
            dog.bark();
        }
    }

在上面的例子中，我们创建了一个"Dog"对象，并使用继承自父类的方法"setAge()"和"getAge()"来设置和获取"age"属性。然后我们调用了继承自父类的方法"eat()“和子类自己的方法"bark()”。

继承允许我们在不重复编写代码的情况下扩展已有的类，并且可以实现代码的重用性和可维护性。

#### 八、面向对象三大特性一多态 ####

多态是面向对象编程中的一个概念，它指的是同一个方法在不同的对象上具有不同的行为。简单来说，多态允许我们使用父类的引用来引用子类的对象，并且根据实际的对象类型来调用相应的方法。

在面向对象的程序设计中，我们通常会定义一个父类，然后创建多个子类来继承父类。子类可以重写父类的方法，实现自己特定的行为。当我们使用父类的引用来引用子类的对象时，我们可以根据实际对象的类型来调用相应的方法。

通过多态，我们可以在不修改代码的情况下，通过改变对象的具体类型来改变方法的行为。这使得代码更加灵活和可扩展，同时也提高了代码的重用性和可维护性。

多态的一个重要特点是动态绑定，也称为运行时绑定。在运行时，系统会根据实际对象的类型来确定调用哪个方法。这使得我们可以在运行时根据具体情况来决定调用哪个方法，而不是在编译时就确定。

总结来说，多态是面向对象编程中的一个重要特性，它允许我们使用父类的引用来引用子类的对象，并且根据实际对象的类型来调用相应的方法，从而实现灵活、可扩展和可维护的代码。

让我们用一个例子来说明多态的概念。假设我们有一个父类叫做"动物"，它有一个方法"发出声音()"。我们创建了两个子类，一个是"狗"类，一个是"猫"类，它们分别重写了父类的"发出声音()"方法。

public class Animal {
        
        public void 发出声音() {
        
            System.out.println("动物正在发出声音");
        }
    }
    
    public class Dog extends Animal {
        
        @Override
        public void 发出声音() {
        
            System.out.println("狗在汪汪叫");
        }
    }
    
    public class Cat extends Animal {
        
        @Override
        public void 发出声音() {
        
            System.out.println("猫在喵喵叫");
        }
    }

在上面的例子中，我们定义了一个"动物"类和两个子类"狗"和"猫"。它们都重写了父类的"发出声音()"方法，分别输出不同的声音。

现在我们可以创建一个数组，将不同的动物对象存储在其中，并且调用它们的"发出声音()"方法。

public class Main {
        
        public static void main(String[] args) {
        
            Animal[] animals = new Animal[2];
            animals[0] = new Dog();
            animals[1] = new Cat();
             for (Animal animal : animals) {
        
                animal.发出声音();
            }
        }
    }

在上面的例子中，我们创建了一个包含两个动物对象的数组。其中一个对象是狗，另一个对象是猫。通过循环遍历数组，我们调用每个动物对象的"发出声音()"方法。由于多态的存在，即使我们使用的是父类的引用，实际上调用的是子类的方法，输出的声音也会根据实际对象的类型而不同。

多态使得我们的代码更加灵活和可扩展。通过使用父类的引用来操作子类的对象，我们可以实现代码的重用性和可维护性。同时，多态也提供了一种简洁的方式来处理不同类型的对象，使得代码更加清晰和易于理解。

>  精彩专栏推荐订阅：在下方专栏👇🏻  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> 💕💕 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[c53360fa1df3404b93fac78e42d93d49.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/f816afd15ead4d6ba2fc1f88b5095560.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center