面向对象真的让问题变的更简单吗?本人要从程序设计逻辑里不断去寻找类和对象，归类它们的属性和方法，还要考虑类与类

public class One {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner input = new Scanner(System.in);
		Person one = new Person();
		one.setName("张三");
		one.setAge(18);
		one.say();
	}
}
class Person {

	private String name;
	private int age;

	public void setName(String name) {

		this.name = name;
	}

	public void setAge(int age) {

		this.age = age;
	}

	public String getName() {

		return this.name;
	}

	public int getAge() {

		return this.age;
	}

	public void say() {

		System.out.println("本人是" + this.name + ", 本人今年" + this.age + "岁!");
	}
}

程序来源生活，所以生活中的一些模式很适用于代码开发

题主的java和c代码并不等价，等价的c代码大约是下面这样:

//person.h
struct Person;
struct Person*  Person_Create();
void Person_Destroy(struct Person* p);
void Person_SetName(struct Person* p, const char* name);
void Person_GetName(struct Person*p, char* name, int len);
//person.c
#include <limits.h>
#include "person.h"
struct Person
{
    char name[UCHAR_MAX];
    int age;
};
struct Person* Person_Create()
{
    struct Person* p = (struct Person*)calloc(sizeof(struct Person), 1);
    retrun p;
}
void Person_Destroy(struct Person* p)
{
    assert(p);
    free(p);
}
void Person_SetName(struct Person* p, const char* name)
{
    assert(p);
    strncpy(p->name, name, UCHAR_MAX - 1);
}
void Person_GetName(struct Person* p, char* name, int len)
{
    assert(len < UCHAR_MAX);
    strncpy(name, p->name, len);
}

面向对象，是忽略实现，而以抽象写代码
只有涉及细节的时候，才用 实现相关的代码。
面向对象，面向的是问题领域
面向过程，主要从实现方向考虑问题
面向的是实现领域
例如。
C语言，
int ,double ,char ,char*，函数等
关键字 goto ,return,if else ;for; while,do while
用实现领域的概念，描述问题领域的问题。
面向对象，先用问题领域的概念描述问题
归纳出类，类与类之间的交互（消息传递）
把复杂性，限制于概念上
直至，可以用实现领域描述为止
对实现领域的概念，力求少涉及
只有最底层的问题，才考虑怎么样实现。
实际上是分析方法的不同
一个从问题角度出发，考虑事情应该怎么做。
一个从实现出发，考虑代码上怎么样实现一个系统。
面向对象，是建立在面向过程基础上的
任何面向对象的代码，都包含面向过程代码，或最终会写一些面向过程代码在其中。
比面向过程更加底层的，是面向命令，面向指令系统，面向硬件。
面向过程，引入了堆栈。
引入了循环结构。
引入了开关语句。
基本放弃了跳转语句。
引入了，独立的函数和过程模块。
后来还引入了，模块化编程。
面向对象，引入了类（接口）
在类（接口）的基础上
引入了 封装，继承，多态
等概念。
更早的是面向命令的
例如 basic
let a=1
print a;
每个语句，是个命令
写程序主要考虑，这些命令怎么样组合，才能实现某种功能。

做个可能不太恰当的比喻：
人想让狗帮忙逮只兔子，可是人说话狗听不懂，于是人发明了一种介乎人言和狗语之间的语言，即口令。
人想让电脑帮忙做计算，可是人话电脑听不懂，于是人发明了一种介乎人言和汇编机器码之间的语言，即C语言。
人对狗的口令得让人容易学、也得让狗容易懂。
C语言同样得让人容易学、也得让电脑容易懂。
相比之下C++、Java就是人学得费劲、电脑也经常闹不懂。

请牢记：源代码本身的书写能否结构化或面向对象或符合设计模式或敏捷…并不重要，重要的是你能否使用结构化或面向对象或符合设计模式或敏捷…的方法命名标识符、阅读、修改、检查、测试源代码。
意思是你程序结构看上去再合理，再简洁，也不一定比看上去一团乱麻的程序结构在运行或修改时更不易出错，更方便修改，出错了更容易找到哪里出错和具体出错的原因，更容易改正错误。
试对比
图书馆（对图书的分类够结构化了吧）
和
搜索引擎（可看作是扁平化任何结构数据，仅支持全文检索）
哪个处理信息更方便、更高效。
所以
与其费劲去重构代码让其看上去更简洁、更合理
不如费劲学习grep、sed、awk、……这类全文搜索和批处理编辑的工具。
结构越复杂，越难修改，越难除错。
有时（甚至大多数时候），看上去越合理、越简洁的代码，运行起来性能越差，出错时查找原因越难，找到出错原因后改正越费劲。
程序员要做的不是尽力避免错误，而是聚焦在快速发现并改正错误。真正以快速方式轻易解决错误，“快速的失败”远胜过“预防错误”。Fred George
前微软C#编辑器的开发主管Jay Bazuzi列出的一些有助于找到正确方向的问题；他觉得前同事们应该用这些问题来问本人；实际上不管在哪里工作的开发者们都应该经常问问本人这些问题：
◆“要保证这个问题不会再出现，本人该怎么做？”
◆“要想少出些Bug，本人该怎么做？”
◆“要保证Bug容易被修复，本人该怎么做？”
◆“要保持对变化的快速响应，本人该怎么做？”
◆“要保证本人的软件的运行速度，本人该怎么做？”
假如大多数团队都能不时问一下本人，必定会从中得益，原因是这些都是真正强而有力的问题。

“从程序设计逻辑里不断去寻找类和对象”，这样做是不对的。

面向对象只是一种编程思想。
再抽象的编程语言，最后不都变成汇编代码了吗？我们完全可以说汇编语言是面向对象、脚本化、动态化、泛函化、并行化、分布化的语言。

这种问题看看就行了。当你发现一个东西的好之前它就是不好的，你不用原因是别人说好而勉强本人去用，原因是你没发现，所以也用不到它的好。用你已经发现了它的好的东西对你来说利益是最大化的

萝卜白菜，各有所爱。

引用:

Quote: 引用:

萝卜白菜，各有所爱。

但有时候必须去接受别人都在用的东西。
作个比喻:
本人喜欢用QQ，朋友都喜欢用微信。后来本人也就不得不也用微信了。

随大溜
和
彰显个性
不矛盾。
为人随和
和
坚持自本人
不矛盾。
双重人格不是贬义词。

题主试试用C语言写个矩阵的加减乘求逆等等。

俗话说“反抗不了那就学会去享受”。不的不用那就尝试去理解为什么大家都要用，去尝试看到美好的东西。
你现在说面向对象和面向对象，实际上围绕这两种思想而发明的知名的编译语言不下几十种，它们的优点体现在不同应用场景，当你遇到了这种场景，也许你会觉得非它莫属。一个优秀的公司和技术leader都会选择出一种适合本人情况的语言

还有一种东西叫面向并发，假如你写过Erlang，就会发现那才是最适合人写的语言

本人预言，程序开发语言永远追不上自然语言。

小程序体会不出面向对象的优势。
假如题主学习了一种类库，理解了类的继承与多态，你会觉得不用面向对象无法想象怎么样实现，代码量会多出多少！
面向对象分析与设计是专门的一门课，比较抽象。

引用:

C代码:

#include <stdio.h>
typedef struct Person {
	char* name;
	int age;
};
int main(int argc, char *argv[]) 
{
	int i = 0;
	Person one = { 0 };
	one.name = "张三";
	one.age = 18;
	printf("本人是%s, 本人今年%d岁!\n", one.name, one.age);
	return 0;
}

这样用有啥优势啊。
public class student:person
{

}
继承接口才是优势 单纯的定义一个类有或结构体有啥意义