面向对象和面向过程的区别题
面向对象的术语和面向对象的三大特征
类和对象的概念
类的定义
关于编译的过程
对象的创建和使用
在语法及别上是如何完成对象的创建的
什么是实例变量，如何访问
对象和引用的区别
JVM的内存分配以及程序执行内存图
引用一定是局部变量吗
从语言方面出发： 对于C语言来说，是完全面向过程的。 对于C++语言来说，是一半面向过程，一半是面向对象。（C++是半面向对象的） 对于Java语言来说，是完全面向对象的。
什么是面向过程的开发方式？
面向过程的开发方式主要的特点是：
注重步骤，注重的是实现这个功能的步骤。
第一步干什么
第二步干什么
....
另外面向过程也注重实现功能的因果关系。
因为A所有B
因为B所以C
因为C所以D
.....
面向过程中没有对象的概念。只是实现这个功能的步骤以及因果关系。
面向过程有什么缺点？（耦合度高，扩展力差。）
面向过程最主要是每一步与每一步的因果关系，其中A步骤因果关系到B
步骤，A和B联合起来形成一个子模块，子模块和子模块之间又因为因果
关系结合在一起，假设其中任何一个因果关系出现问题（错误），此时
整个系统的运转都会出现问题。（代码和代码之间的耦合度太高，扩展力
太差。）
螺栓螺母拧在一起：耦合度高吗？
这是耦合度低的，因为螺栓螺母可以再拧开。（它们之间是有接口的。）
螺栓螺母拧在一起之后，再用焊条焊接在一起，耦合度高吗？
这个耦合度就很高了。耦合度就是黏连程度。
往往耦合度高的扩展力就差。
耦合度高导致扩展力差。（集成显卡：计算机显卡不是独立的，是集成到主板上的）
耦合度低导致扩展力强。（灯泡和灯口关系，螺栓螺母关系）
采用面向过程的方式开发一台计算机会是怎样？
这台计算机将没有任何一个部件，所有的都是融合在一起的。
你的这台计算机是一个实心儿的，没有部件的。一体机。
假设这台一体机的任何一个“部位”出问题，整个计算机就不能用了，
必须扔掉了。（没有对象的概念。）
采用面向对象的方式开发一台计算机会是怎样？
内存条是一个对象
主板是一个对象
CPU是一个对象
硬盘是一个对象
然后这些对象组装在一起，形成一台计算机。
假设其中CPU坏了，我们可以将CPU拆下来，换一个新的。
面向过程有什么优点？（快速开发）
对于小型项目（功能），采用面向过程的方式进行开发，效率较高。
不需要前期进行对象的提取，模型的建立，采用面向过程
方式可以直接开始干活。一上来直接写代码，编写因果关系。
从而实现功能。
什么是面向对象的开发方式？
采用面向对象的方式进行开发，更符合人类的思维方式。（面向对象成为主流的原因）
人类就是以“对象”的方式去认识世界的。
所以面向对象更容易让我们接受。
面向对象就是将现实世界分割成不同的单元，然后每一个单元
都实现成对象，然后给一个环境驱动一下，让各个对象之间协
作起来形成一个系统。
对象“张三”
对象“香烟”
对象“打火机”
对象“吸烟的场所”
然后将以上的4个对象组合在一起，就可以模拟一个人的抽烟场景。
其中“张三”对象可以更换为“李四”
其中“香烟”也可以更换品牌。
其中“打火机”也可以更换。
其中“吸烟的场所”也可以更换。
采用面向对象的方式进行开发：
耦合度低，扩展力强。
找一个合适的案例。说明一下面向对象和面向过程的区别？
蛋炒饭：
鸡蛋和米饭完全混合在一起。没有独立对象的概念。
假设客户提出新需求：我只想吃蛋炒饭中的米饭，怎么办？
客户提出需求，软件开发者必须满足这个需求，于是
开始扩展，这个软件的扩展是一场噩梦。（很难扩展，耦合度太高了。）
盖饭：
老板，来一份：鱼香肉丝盖饭
鱼香肉丝是一道菜，可以看成一个独立的对象。
米饭可以看成一个独立的对象。
两个对象准备好之后，只要有一个动作，叫做：“盖”
这样两个对象就组合在一起了。
假设客户提出新需求：我不想吃鱼香肉丝盖饭,想吃西红柿鸡蛋盖饭。
这个扩展就很轻松了。直接把“鱼香肉丝”对象换成“西红柿鸡蛋”对象。
当我们采用面向对象的方式贯穿整个系统的话，涉及到三个术语： OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
整个软件开发的过程，都是采用OO进行贯穿的。
实现一个软件的过程：
分析(A) --> 设计(D) --> 编程(P)
在软件公司当中，一般同事与同事之间聊天，有的时候会突然说出来一个英语单词。
这种情况是很常见的。所以一些术语还是要知道的，不然会闹出笑话。
leader 领导/经理/组长
team 团队
PM 项目经理（整个项目的监管人）Project Manager
面向对象包括三大特征
封装
继承
多态
任何一个面向对象的编程语言都包括这三个特征
例如：
python也有封装 继承 多态。
java也有封装 继承 多态。
注意：java只是面向对象编程语言中的一种。
除了java之外，还有其它很多很多的编程语言也是面向对象的。
面向对象当中最主要“一词”是：对象。
什么是类？
类实际上在现实世界当中是不存在的，是一个抽象的概念。
是一个模板。是我们人类大脑进行“思考、总结、抽象”的一个
结果。(主要是因为人类的大脑不一般才有了类的概念。)
类本质上是现实世界当中某些事物具有共同特征，将这些共同
特征提取出来形成的概念就是一个“类”，“类”就是一个模板。
明星是一个类
什么是对象？
对象是实际存在的个体。（真实存在的个体）
宋小宝就是一个对象
姚明就是一个对象
刘德华就是一个对象
....
宋小宝、姚明、刘德华这3个对象都属于“明星”这个类。
在java语言中，要想得到“对象”，必须先定义“类”，“对象”是通过“类”
这个模板创造出来的。
类就是一个模板：类中描述的是所有对象的“共同特征信息”
对象就是通过类创建出的个体。
总结出来就是
类：不存在的，人类大脑思考总结一个模板（这个模板当中描述了共同特征。）
对象：实际存在的个体。
实例：对象还有另一个名字叫做实例。
实例化：通过类这个模板创建对象的过程，叫做：实例化。
抽象：多个对象具有共同特征，进行思考总结抽取共同特征的过程。
类 --【实例化】--> 对象(实例)
对象 --【抽象】--> 类
类是一个模板，是描述共同特征的一个模板，那么共同特征包括什么呢？
潘长江对象：
名字：潘长江
身高：165cm
打篮球：非专业的，自己玩儿呢，无所谓了
学习：考试80分
姚明对象：
名字：姚明
身高：240cm
打篮球：NBA专业球员，打篮球非常棒
学习：考试100分
共同特征包括哪些？
名字、身高都属于名词（状态特征）
打篮球、学习都属于动词（动作特征）
类 = 属性 + 方法
属性来源于：状态
方法来源于：动作
类是如何定义的
public class 明星类<br>
{<br>
//属性-->状态，多见于名词<br>
名字属性;
身高属性;
//方法-->动作，多见于动词<br>
打篮球方法(){
}
学习方法(){
}
}总结
[修饰符列表] class 类名
//类体 = 属性 + 方法
// 属性在代码上以“变量”的形式存在（描述状态）
// 方法描述动作/行为>
}
为什么属性是“以”变量的形式存在的？
假设我们要描述一个学生：
学生包括哪些属性：
学号: 110
姓名："张三"
性别：'男' (true/false)
住址："深圳宝安区"
答案：是因为属性对应的是“数据”，数据在程序中只能放到变量中。
结论：属性其实就是变量。
变量的分类还记得吗？
变量根据出现位置进行划分：
方法体当中声明的变量：局部变量。
方法体外声明的变量：成员变量。（这里的成员变量就是“属性”）
关于编译的过程
/*
1、观察学生对象的共同特征（只观察属性）
有哪些共同特征：
学号：采用int类型
姓名：采用String类型
年龄：采用int类型
性别：采用char或者boolean类型
住址：采用String类型
注意：属性是成员变量。
2、以上是分析总结的结果，可以开始写代码了：
定义XueSheng类，编写成员变量作为属性。
3、变量有一个特点：
必须先声明，再赋值，才能访问。
成员变量可以不手动赋值？？？？？？？？？？
XueSheng既是一个类名，同时又是一个“类型名”，属于引用数据类型。
*/
public class XueSheng{ // 这个程序编译之后，会生成XueSheng.class字节码文件。
// 属性
// 学号（成员变量）
int xueHao;
// 姓名
String xingMing;
// 年龄
int nianLing;
// 性别
boolean xingBie;
// 住址
String zhuZhi;
}
```java
/*
对象的创建和使用。
*/
public class XueShengTest{
public static void main(String[] args){
int i = 100;
System.out.println("i = " + i);
// 在这里可以访问XueSheng类吗？
// 当然可以。
/*
创建对象的语法是什么？
目前死记硬背，先记住。后面你就理解了。
new 类名();
类是模板，通过一个类，是可以创建N多个对象的。
new是一个运算符。专门负责对象的创建。
XueSheng s1 = new XueSheng();
和
int i = 100;
解释一下：
i是变量名
int是变量的数据类型
100是具体的数据。
s1是变量名（s1不能叫做对象。s1只是一个变量名字。）
XueSheng是变量s1的数据类型（引用数据类型）
new XueSheng() 这是一个对象。（学生类创建出来的学生对象。）
数据类型包括两种：
基本数据类型：byte short int long float double boolean char
引用数据类型：String、XueSheng.....
java中所有的“类”都属于引用数据类型。
*/
XueSheng s1 = new XueSheng(); // 和 int i = 10;一个道理。
// 再通过该类创建一个全新的对象
XueSheng s2 = new XueSheng();
// 再创建一个呢？
XueSheng xsh = new XueSheng();
// 以上的这个程序就相当于通过XueSheng类实例化了3个XueSheng对象。
// 创建对象的个数没有限制，可以随意。只要有模板类就行。
// 3个对象都属于学生类型。
}
}
按说应该先编译XueSheng.java，然后再编译XueShengTest.java
但是对于编译器来说，编译XueShengTest.java文件的时候，会自动
找XueSheng.class，如果没有，会自动编译XueSheng.java文件，生成
XueSheng.class文件。
第一种方式：
javac XueSheng.java
javac XueShengTest.java
第二种方式：
javac XueShengTest.java
第三种方式：
javac *.java
对象是如何创建的
类名 变量名 = new 类名();
这样就完成了对象的创建。
public class 学生{
int 学号;
String 姓名;
// 入口
public static void main(String[] args){
学生 张三 = new 学生();
System.out.println(张三.学号); // 0
System.out.println(张三.姓名); // null
张三.学号 = 1111;
张三.姓名 = "张三";
System.out.println(张三.学号);
System.out.println(张三.姓名);
}
}
// 和刚才的程序一样，只不过标识符采用了中文。
// 标识符可以有中文。
public class 学生测试{
// 程序入口
/*
public static void main(String[] args){
学生 张三 = new 学生();
System.out.println(张三.学号); // 0
System.out.println(张三.姓名); // null
张三.学号 = 1111;
张三.姓名 = "张三";
System.out.println(张三.学号);
System.out.println(张三.姓名);
}
*/
}
实例变量的定义以及如何访问
对象又被称为实例。
实例变量实际上就是：对象级别的变量。
实例变量的访问:通过"引用."的方式进行访问
注意：对于成员变量来说，没有手动赋值时，系统默认赋值。
赋的值都是默认值，那么默认值是什么？
| 类型 | 默认值 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| char | 0 |
| float | 0 |
| double | 0 |
| boolean | false |
| 引用数据类型 | null |
null是一个java关键字，全部小写，表示空。是引用类型的默认值。
分析：对于成员变量来说，是不是应该一个对象有一份。
李四有李四的学号
张三有张三的学号
李四和张三的学号不一样。所以应该有两块不同的内存空间。
类名也是引用数据类型
用代码来更清晰的说明实例变量的定义以及访问情况
public class 明星类{
double height;
}
身高这个属性所有的明星对象都有，但是每一个对象都有“自己的身高值”。
假设创建10个明星对象，height变量应该有10份。
所以这种变量被称为对象级别的变量。属于实例变量。
所有的实例变量（属性）在访问的时候都是先创建对象然后通过“引用.”来访问的，不能用“类名.”的方式访问
//访问用户对象的id属性即实例变量
User u = new User();
//u是引用。
System.out.println(User.id);
对象和引用的区别
| 对象 | 引用 |
|---|---|
| new出来的,在堆内存中存储。 | 但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象的 |
通俗一点：
只要这个变量中保存的是一个对象的内存地址，那么这个变量就叫做“引用”。
JVM内存分配图
/*
学生类
学号：int
姓名：String
年龄：int
性别：boolean
住址：String
*/
public class Student{
// 属性（描述状态），在java程序中以“成员变量”的形式存在。
// 学号
// 一个对象一份。
int no; // 这种成员变量又被称为“实例变量”。
// 姓名
String name;
// 年龄
int age;
// 性别
boolean sex;
// 住址
String addr;
}
/*
学生测试类
对象的创建和使用。
*/
public class StudentTest{
public static void main(String[] args){
//局部变量
//错误: 可能尚未初始化变量k
/*
int k;
System.out.println(k);
*/
//访问学生姓名可以直接通过类名吗？
// 学生姓名是一个实例变量。实例变量是对象级别的变量。
// 是不是应该先有对象才能说姓名的事儿。
// 不能通过“类名”来直接访问“实例变量”。
//System.out.println(Student.name);
// i属于局部变量吗？当然是。
// 局部变量存储在栈内存当中。（栈主要存储局部变量。）
//int i = 100;
// 创建学生对象1
// s1属于局部变量吗？当然是。
// s1这个局部变量叫做引用
Student s1 = new Student();
// 怎么访问实例变量？
// 语法：引用.实例变量名
System.out.println(s1.no);
System.out.println(s1.name);
System.out.println(s1.age);
System.out.println(s1.sex);
System.out.println(s1.addr);
System.out.println("-----------------------------");
// 创建学生对象2
// s2也是局部变量。
// s2也叫做引用。
Student s2 = new Student();
System.out.println(s2.no);
System.out.println(s2.name);
System.out.println(s2.age);
System.out.println(s2.sex);
System.out.println(s2.addr);
// 程序执行到此处我可以修改s1这个学生的学号吗？
// 通过“=”赋值的方式将内存中实例变量的值修改一下。
s1.no = 110;
s1.name = "张三";
s1.age = 20;
s1.sex = true;
s1.addr = "深圳宝安区";
System.out.println("学号=" + s1.no);
System.out.println("姓名=" + s1.name);
System.out.println("年龄=" + s1.age);
System.out.println("性别=" + s1.sex);
System.out.println("住址=" + s1.addr);
// 再次赋值
s1.addr = "北京大兴区";
System.out.println("住址：" + s1.addr);
}
public static void method(){
// i s1 s2都是main方法中的局部变量，在这里是无法访问的。
/*
System.out.println(i);
System.out.println(s1);
System.out.println(s2);
*/
}
}
引用一定是局部变量吗
不一定
通过代码和程序运行内存图都可以得出该结论，以下是代码和内存图的展示
// 住址类
public class Address{
// 一个家庭住址有3个属性。
// 城市
String city; // 实例变量
// 街道
String street;
// 邮编
String zipcode;
}
public class User{
// 类=属性+方法
// 以下3个都是属性，都是实例变量。（对象变量。）
// 用户id
// int是一种基本数据类型
int id; // 实例变量
// 用户名
// String是一种引用数据类型
String username; // 实例变量
// 家庭住址
// Address是一种引用数据类型
// addr是成员变量并且还是一个实例变量
// addr是否是一个引用呢？是。addr是一个引用。因为它里面保存的是一个Adrress类型的对象的内存地址
Address addr;
}
// 实例变量都存储在哪里？
// 实例变量都在堆内存的对象内部。
// 方法体外，类体内定义的变量叫做：成员变量。
/*
思考：
引用一定是局部变量吗？
不一定。
*/
public class Test{
public static void main(String[] args){
// 家庭住址对象
Address a = new Address();
a.city = "北京";
a.street = "大兴区";
a.zipcode = "121221";
// 用户对象
User u = new User();
System.out.println(u.id); // 0
System.out.println(u.username); // null
System.out.println(u.addr); // null
u.id = 11111;
u.username = "zhangsan";
u.addr = a;
//由此可以判断出 a是局部变量，他的类型是Adress类型的，存储Adress类型对象的内存地址,而addr是实例变量,也叫做成员变量，因为它是在User类体,main方法以外定义的
// 思考一个问题：
// 我想直到zhangsan他是哪个城市的，代码应该怎么写？
System.out.println(u.username + "是"+u.addr.city+"城市的！");
// u.addr.city 这行代码可否拆分呢？u.addr.city 节省变量。
// 拆分成以下代码和以上效果完全相同，原理完全相同，不同的是以下代码多了两个变量。
Address ad = u.addr;
String zhuZhi = ad.city;
System.out.println(zhuZhi);
}
}
程序运行内存图
我们已知堆内存保存的是创建出来的对象以及和对象相关的属性(实例变量)，数组和字符串，而栈内存遵循先进先出的原则，保存方法以及局部变量，当方法执行的时候进行压栈,方法执行完以后进行弹栈，方法以及与之相关的局部变量销毁。
综上我们根据程序运行内存分配图可以得知addr保存在堆内存里，所以addr它是一个实例变量
扫一扫
1825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
