理解Java中的面向对象

标签：Java name People age lihua introduce 面向对象理解 public

文章目录

前言
1 封装性
2 继承性
3 多态性
- 3.1 方法重写
- 3.2 方法重载
总结

前言

面向对象与面向过程是当今编程世界的两种编程思想，面向过程编程则侧重于以过程为导向，将问题分解为一系列的步骤和函数，通过依次执行这些函数来完成任务。面向对象编程强调以对象为中心，将数据和操作封装在对象中，通过对象之间的交互来实现程序的功能。具体两者的区别可以参考我之前的博客：https://blog.csdn.net/2401_85464956/article/details/142608653?fromshare=blogdetail&sharetype=blogdetail&sharerId=142608653&sharerefer=PC&sharesource=2401_85464956&sharefrom=from_link
本文以Java语言为例，讨论面向对象中的三大特性：封装、继承与多态

1 封装性

1.1 C语言中的封装

在C语言中也存在封装思想，比如说结构体变量。将多个数据类型组装成一个新的数据类型。换言之，我们通过封装，形成了一个新的数据类型。具体语法为：

struct 结构体名 {
    成员类型1 成员名1;
    成员类型2 成员名2;
   ...
    成员类型n 成员名n;
};

举个例子，我们声明一个结构体People，它有两个成员变量，分别为字符串型name(表名字)和整型变量age（表年龄）

# define MAXSIZE 20
struct People {
	char name[MAXSIZE];
	int age;
};

通过结构体变量名和成员运算符（.）来访问结构体的成员。
案例：

#include<stdio.h>
# define MAXSIZE 20
struct People {
	char name[MAXSIZE];
	int age;
};
int main() {
	//声明一个结构体变量，同时进行初始化
	People lihua = { "lihua",18 };
	//通过结构体变量名和成员运算符（.）来访问结构体的成员
	printf("我的名字是%s\n",lihua.name);
	printf("我的年龄是%d\n", lihua.age);
	return 0;
}

运行结果：
在这里插入图片描述

1.2 Java中的封装

1.2.1 基本概念

Java和C语言不同，Java不仅可以将多个数据类型进行封装，还可以将函数与之封装在一起形成一个新的数据类型，我们称之为类。我们将类中的成员变量也称为对象的属性，类中的函数，我们称之为方法体也称为对象的行为。
举个例子，我们定义一个People类，属性有name 、age，行为有greet()、introduce()

public class People {
    String name;
    int age;
    void greet(){
        System.out.println("你好！");
    }
    void introduce(){
        System.out.println("我是"+name+",我今年"+age+"岁了");
    }
}

1.2.2 类的使用方法

1.2.2.1 构造方法

所有的类都默认有一个构造方法，可以通过javap对生成的class文件进行反编译。在类中所有的成员变量都有一个默认的初值，比如0，null等。构造方法可以简单地理解为，在创建对象的同时更改该对象成员变量的初值。添加构造方法的代码如下：

public class People {
    String name;
    int age;
    // 默认的构造方法
    People(){

    }
    // 新定义的构造方法，在创建对象的同时更改初值
    People(String name, int age) {
        this.name = name;
        this.age = age;
    }
    void greet(){
        System.out.println("你好！");
    }
    void introduce(){
        System.out.println("我是"+name+",我今年"+age+"岁了");
    }
}

1.2.2.2 对象的创建与使用

语法：
类名对象名=new 构造方法；
调用方法：
对象+（.）+成员变量或方法

public class Test {
    public static void main(String[] args) {
        //创建对象
        People lihua = new People();
        //查看初值
        System.out.println(lihua.name);
        System.out.println(lihua.age);
        lihua.name = "李华";
        lihua.age = 18;
        lihua.greet();
        lihua.introduce();
        //创建一个新的对象
        People xiaoming = new People("小明",20);
        //查看初值
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        xiaoming.greet();
        xiaoming.introduce();
    }
}

运行结果：
在这里插入图片描述

1.2.3 访问权限

定义：指对象是否可以通过“.”运算符操作自己的成员变量或通过“.”运算符调用类中的方法
访问限制修饰符：private protected和public，它们都是Java关键字，用来修饰成员变量或方法
这里不再展开阐述，后续代码就直接使用public，可以期待我后续的博客哦

2 继承性

当我们准备编写一个类的时候，发现某个类有我们所需要的成员变量和方法，如果我们想复用这个类的成员变量和方法，即在所编写的类中不用声明成员变量，不用定义方法就相当于有了这个方法，那么我们可以将编写的类定义为这个类的子类，子类可以让我们不必一切从头开始

举个例子，我们想定义一个Student类（此处指大学生），其中它也有name、age属性，拥有方法greet()、introduce(),同时他们也拥有额外的属性GPA,额外的方法getGPA()。为了区别普通people，他们想introduce一点不一样的，因此我们可以将introduce（）方法进行重写

public class Student extends People{
    //此处考虑保护大学生的隐私，使用了私有属性
    //因为私有属性无法继承，所以用final关键字修饰，此处加不加都可以
    private final double GPA;
    //构造方法
    public Student(String name, int age, double GPA) {
        this.name = name;
        this.age = age;
        this.GPA = GPA;
    }
    public void introduce(){
        System.out.println("我是"+this.name+",我今年"+this.age+"岁了,是一位清澈的大学生");
    }
    public double getGPA() {
        return GPA;
    }
}

主程序：

public class Test {
    public static void main(String[] args) {
        //创建对象
        Student lihua=new Student("李华",19,4.0);
        //查看从父类继承的属性
        System.out.println(lihua.name);
        System.out.println(lihua.age);
        //调用从父类继承的方法
        lihua.greet();
        //调用重写的方法
        lihua.introduce();
        //调用子类扩展的方法
        System.out.println(lihua.getGPA());
    }
}

标准定义：继承是指一个类（子类或派生类）可以继承另一个类（父类或基类）的属性和方法。同时也能够通过重写对父类的功能进行修改，也可以在原有的基础上增加属性和方法，来对父类的功能进行扩展。

通过上面例子，我们再回头看一下这个课本上的定义，是不是更清晰了呢？

3 多态性

多态性，即是 “多种形态”，具体指同一操作作用于不同的对象可以有不同的表现形式。在 Java 中，多态性主要通过方法重写和方法重载来实现。

3.1 方法重写

方法重写在前面继承性中我们已经接触了，即子类对父类中同名方法体的重新定义。多态性就是，多个子类对父类中同一个方法体的书写，使得在调用时，出现不同的结果
举个例子，多态，因此我们再定义一个Teacher类继承People，重写方法introduce（）

public class Teacher extends People {
    //构造方法
    public Teacher(String name,int age) {
        this.name=name;
        this.age=age;
    }
    //重写的方法
    void introduce(){
        System.out.println("我是"+name+",我今年"+age+"岁了,是一位人民教师");
    }

}

主程序：

public class Test {
    public static void main(String[] args) {
        //创建对象,此处使用的是上转型对象
        People lihua=new Student("李华",19,4.0);
        People wanglaoshi=new Teacher("王老师",36);
        lihua.introduce();
        wanglaoshi.introduce();
    }
}

运行结果：
在这里插入图片描述
此处使用的是上转型对象，具体使用方法可以看我之前的博客https://blog.csdn.net/2401_85464956/article/details/142696800?fromshare=blogdetail&sharetype=blogdetail&sharerId=142696800&sharerefer=PC&sharesource=2401_85464956&sharefrom=from_link
运行结果显示，调用同一个方法，显示不同的结果，即体现了多种形态

3.2 方法重载

这里不再阐述，欢迎观看我之前的博客：https://blog.csdn.net/2401_85464956/article/details/142695361?fromshare=blogdetail&sharetype=blogdetail&sharerId=142695361&sharerefer=PC&sharesource=2401_85464956&sharefrom=from_link

总结

Java 面向对象编程通过封装、继承和多态等特性，使得代码更加模块化、可维护性和可扩展性。
以上便是我对Java中的面向对象的理解，欢迎批评指正！！！

标签：Java,name,People,age,lihua,introduce,面向对象,理解,public
From： https://blog.csdn.net/2401_85464956/article/details/142863869