面向过程和面向对象的区别
- 面向过程：主要关注点是：实现的具体过程，因果关系【集成显卡的开发思路】【蛋炒饭】
- 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。
- 缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑，另外面向过程的方式导致软件元素之间的“耦合度”非常高，只要其中一环出问题，整个系统受到影响，导致最终的软件“扩展力”差。另外，由于没有独立体的概念，所以无法达到组件复用。
- 面向对象 ：主要关注点是：对象【独立体】能完成哪些功能。【独立显卡的开发思路】【盖饭】
- 优点：耦合度低，扩展力强，更容易解决现实世界当中更复杂的业务逻辑。组件复用性强。
- 缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与设计。
- C语言是纯面向过程的、c++半面向对象、Java纯面向对象
- 现在出现的一些新的编程语言多数都是面向对象的。人在认识现实世界的时候以面向对象的方式。
- 面向对象更符合人的思维方式。
- 面向对象的三大特征
- 封装
- 继承
- 多态
- 所有面向对象的编程语言都具有这三种特征
- 采用面向对象的方式开发一个软件，生命周期当中：【整个生命周期中贯穿使用OO面向对象方式】
- 面向对象的分析：OOA
- 面向对象的设计：OOD
- 面向对象的编程：OOP
类和对象的概念
- 什么是类？
- 类在现实世界当中是不存在的，是一个模板，是一个概念，是人类大脑思考抽象的结果。
- 类代表了一类事物。
- 在现实世界当中，对象A与对象B之间具有共同的特征，进行抽象总结出一个模板，这个模板被称为类。
- 什么是对象？
- 对象是实际存在的个体。现实世界当中实际存在。
- 描述一下整个软件开发的过程：
- 程序员先观察现实世界，从现实世界当中寻找对象
- 寻找了N多个对象之后，发现所有的对象都具有共同特征
- 程序员在大脑中形成了一个模板【类】
- Java程序员可以通过java代码来表述一个类
- Java程序中有了类的定义
- 然后通过类就可以创建对象
- 有了对象之后，可以让对象直接协作起来形成一个系统
- 类 - - -【实例化】- - ->对象
- 对象又被称为实例 / instance
- 对象- - -【抽象】- - ->类
- 重点
- 类描述的是对象的共同特征
- 共同特征例如：身高特征
- 这个身高特征在访问的时候，必须先创建对象，通过对象去访问这个特征。因为这个特征具体的某个对象之后， 值不同。有的对象身高1.80，有的对象身高2.80。
- 一个类主要描述什么信息呢？
- 一个类主要描述的是：状态 + 动作
状态信息：名字、身高、性别、年龄
动作信息：吃、唱歌、跳舞、学习 - 状态–>一个类的属性
- 动作–>一个类的方法
- 一个类主要描述的是：状态 + 动作
- 类{
属性：//描述对象的状态信息
方法：//描述对象的动作信息
}
注意：状态和动作当具体到某个对象上之后，发现最终的结果可能不一样。
对象和对象之间有共同特征，但它们之间有数据的差异。
类的定义
- 语法结构：
[修饰符列表]class 类名{
属性：
方法：
}
- 学生类，描述所有学生对象的共同特征：
- 学生对象有哪些状态信息
- 学号【int】
- 名字【string】
- 性别【boolean】
- 年龄【int】【年龄是一个属性，年龄是一个数据，是数据就应该有数据类型】
- 住址【string】
- …
- 学生对象有哪些动作信息
- 吃饭
- 睡觉
- 学习
- 玩
- 唱歌
- 跳舞
- …
- 重点：属性通常是采用一个变量的形式来完成定义的【由于状态信息需要数据来表示，而数据需要存在变量中】
- int no;
- int age;
- …
- 学生对象有哪些状态信息
public class Student
{
//属性【描述的是对象的状态信息】
//属性通常采用变量的方式来定义
//在类体当中，方法体之外定义的变量被称为"成员变量"
//成员变量没有赋值，系统默认赋值，一切向0看齐。
//学号
int no;
//姓名
String name;
//性别
boolean sex;
//年龄
int age;
//住址
String address;
//方法
//方法描述的是对象的动作信息
//这里例子先不涉及方法
}
- java中包括两种数据类型
- 基本数据类型
- byte、int、long、float、double、boolean、char
- 引用数据类型
- String.class //SUN提供的
- Student.class //SUN提供的
- System.class //程序员自定义的
- User.class //程序员自定义的
- Product.class //程序员自定义的
- Customer.class //程序员自定义的
- …
- String username = “zhangsan” ;
- Student s = ???;
- java语言中所有的class都属于引用数据类型
对象的创建和使用
第一部分
- 基本数据类型
//学生类
//学生类是一个模板
//描述了所有学生的共同特征【状态+行为】
//当前类只描述学生的状态信息【属性】
//Student是类，属于引用数据类型，这个类型名是Student
public class Student{
//类体-属性+方法
//属性【存储数据采用变量的形式】
//由于变量定义在类体当中，方法体之外，这种变量称为成员变量
//所有学生都有学号信息
//但是每一个学生的学号都是不同的
//所以要访问这个学号必须先创建对象，通过对象去访问学号信息
//学号信息不能直接通过“类”去访问，所以这种成员变量又被叫做：实例变量
//对象又被称为实例，实例变量又被称为对象变量。【对象级别的变量】
//不创建对象，这个no变量的内存空间是不存在的，只有创建了对象，这个no变量内存空间才会创建。
int no;
}
//成员变量没有手动赋值的话，系统默认值
//默认值
| 数据类型 | 默认值 |
|---|---|
| byte、short、int、long | 0 |
| float、double | 0.0 |
| boolean | false |
| char | \u0000 |
| 引用数据类型 | null(空值) |
//对象的创建和使用
public class OOTest01
{
public static void main(String[] args){
//int是基本数据类型
//i是一个变量名
//10是一个int类型的字面值
int i = 10;
//通过一个类可以实例化N个对象
//实例化对象的语法：new 类名（）
//new是java语言当中的一个运算符
//new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间
//方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间中
//栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈
//堆内存：new的对象在堆内存中存储
//Student是一个引用数据类型
//s是一个变量名
//new Student()是一个学生对象
//s是一个局部变量【在栈内存中存储】
//什么是对象？new运算符在堆内存中开辟的内存空间称为对象
//什么是引用？引用是一个变量，只不过这个变量中保存了另一个java对象的内存地址
//java语言当中，程序员不能直接操作堆内存，java中没有指针，不像C语言
//java语言当中，程序员只能通过“引用”去访问堆内存当中对象内部的实例变量
Student s = new Student();
//访问实例变量的语法格式：
// 读取数据：引用.变量名
// 修改数据：引用.变量名 = 值
int stuNo = s.no;
String stuName = s.name;
int stuAge = s.age;
boolean stuSex = s.sex;
String stuAddr = s.addr;
System.out.println("学号=" + stuNo);
System.out.println("姓名=" + stuName);
System.out.println("年龄=" + stuAge);
System.out.println("性别=" + stuSex);
System.out.println("住址=" + stuAddr);
//换种写法
System.out.println("---------------------------");
System.out.println("学号=" + s.no);
System.out.println("姓名=" + s.name);
System.out.println("年龄=" + s.age);
System.out.println("性别=" + s.sex);
System.out.println("住址=" + s.addr);
s.no = 10;
s.name = "jack";
s.age = 20;
s.sex = true;
s.addr = "北京";
}
}
- 上述代码Java内存结构图：
public class OOTest01
{
public static void main(String[] args){
...//上述代码
//再通过类实例化一个全新的对象
//stu是一个引用
//stu同样也是一个局部变量
//Student是变量的引用数据类型
Student stu = new Student();
System.out.pritnln(stu.no);//0
System.out.println(stu.age);//0
Sysetm.out.println(stu.sex);//false
System.out.println(stu.name);//null
System.out.println(stu.addr);//null
//编译报错，no这个实例变量不能直接采用"类名"的方式访问
//因为no是实例变量，对象级别的变量，变量存储在java对象的内部，必须先有对象
//通过对象才能访问no这个实例变量，不能直接通过"类名"
//System.out.println(Student.no);
}
}
/*
注意：
局部变量在栈内存中存储
成员变量中的实例变量在堆内存的java对象内部存储（成员变量是大概念，实例变量是小概念，当成员变量是这种只能通过对象（实例）去访问时，称为实例变量）
实例变量是一个对象一份，100个对象有100份
*/
//家庭地址类
public class Address
{
//属性【成员变量之实例变量】
//
//城市
String city;
//街道
String street;
//邮编
String zipcode;
}
//用户类
public class User
{
//属性【以下都是成员变量之实例变量】
//用户编号
//int是一种基本数据类型：整数型
//no是一个实例变量
int no;
//用户名
//String是一种引用数据类型：代表字符串
//name是一个实例变量
//name是一个引用
String name;
//家庭住址
//Address是一种引用数据类型：代表家庭住址
//addr是一个实例变量
//addr是一个引用
Address addr;
}
public class OOTest02
{
public static void main(String[] args){
//创建对象
//u是一个局部变量
//u是一个引用
//u保存内存地址指向堆内存的User对象
User u = new User();
//输出User对象内部实例变量的值
System.out.println(u.no);
System.out.println(u.name);
System.out.println(u.addr);
}
}
OOTest02代码的内存结构图1
public class OOTest02
{
public static void main(String[] args){
//........上述代码
//修改User对象内部实例变量的值
u.no = 110;
u.name = "jack";//"jack"是一个java对象，属于String对象
u.addr = new Address();
//在main方法当中目前只能看到一个引用"u"
//一切都是只能通过u来进行访问
System.out.println(u.name + "居住在哪个城市：" + u.addr.city);
System.out.println(u.name + "居住在哪个街道：" + u.addr.street);
System.out.println(u.name + "邮编：" + u.addr.zipcode);
u.addr.city = "北京";
u.addr.street = "朝阳";
u.addr.zipcode = "11111111";
System.out.println(u.name + "居住在哪个城市：" + u.addr.city);
System.out.println(u.name + "居住在哪个街道：" + u.addr.street);
System.out.println(u.name + "邮编：" + u.addr.zipcode);
}
}
OOTest02代码内存结构图2
第三部分
public class OOTest03
{
public static void main(String[] args){
//u是引用
//u是局部变量
User u = new User();
//上一个版本编写的
//u.addr = new Address();
//a是引用
//a是局部变量
Address a = new Address();
u.addr = a;
System.out.pritnln(u.addr.city);//null
}
}
public class OOTest03
{
public static void main(String[] args){
//u是引用
//u是局部变量
User u = new User();
//上一个版本编写的
//u.addr = new Address();
//a是引用
//a是局部变量
Address a = new Address();
u.addr = a;
System.out.pritnln(u.addr.city);//null
a.city = "天津";
System.out.pritnln(u.addr.city);//天津
}
}
第四部分
//丈夫类
public class Husband
{
//姓名
String name;
//丈夫对象当中含有妻子引用
Wife w;
}
//妻子类
public class Wife
{
//姓名
String name;
//妻子对象当中含有丈夫引用
Husband h;
}
//测试类
public class OOTest04
{
public static void main(String[] args){
//创建一个丈夫对象
Husband huangXiaoMing = new Husband();
huangXiaoMing.name = "黄晓明";
//创建一个妻子对象
Wife baby = new Wife();
baby.name = "baby";
//结婚【通过丈夫找到妻子，通过妻子也能找到丈夫】
huangXiaoMing.w = baby;
baby.h = huangXiaoMing;
//得到以上黄晓明妻子的名字
System.out.println(huangXiaoMing.name + "的妻子名字：" + baby.name);
System.out.println(huangXiaoMing.name + "的妻子名字：" + huangXiaoMing.w.name);
}
}
内存结构图
第五部分
关于JVM内存管理的叙述
- 1.JVM(Java虚拟机)主要包括三块内存空间：栈内存、堆内存、方法区内存
- 2.堆内存和方法区内存各有一个，一个线程一个栈内存
- 3.方法调用的时候，该方法所需要的内存空间在栈内存中分配，称为压栈。方法执行结束之后，该方法所属的内存空间释放，称为弹栈。
- 4.栈主要存储的是方法体当中的局部变量
- 5.方法的代码片段以及整个类的代码片段被存储到方法区内存当中，在类加载的时候这些代码片段会载入。
- 6.在程序执行过程中使用new运算符创建的java对象，存储在堆内存当中，对象内部有实例变量，所以实例变量存储在堆内存当中。
- 7.变量分类：
- 局部变量【方法体中声明】
- 成员变量 【方法体外声明】
- 实例变量【前边修饰符没有static】
- 静态变量【前边修饰符有static】
- 8.静态变量存储在方法区内存当中。
- 9.三块内存当中变化最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收器主要针对的是堆内存
- 10.垃圾回收器【自动垃圾回收机制，GC机制】什么时候会考虑将某个java对象的内存回收呢？
- 当堆内存当中的java对象成为垃圾回收数据的时候，会被垃圾回收器回收。
- 什么时候堆内存中的java对象会变成垃圾呢？
- 没有更多的引用指向它的时候。
- 这个对象无法被访问，因为访问对象只能通过引用的方式访问。
第六部分
//顾客类
public class Customer
{
//id
int id;
}
//测试类
public class OOTest05
{
public static void main(String[] args){
Customer c = new Customer();
System.out.println(c.id);//0
c = null;
//以下程序编译可以通过，因为符合语法
//运行出现空指针异常
//空引用访问“实例”相关的数据一定会出现空指针异常
//java.lang.NullPointerException
System.out.println(c.id);
}
}
//“实例”相关的数据表示：这个数据访问的时候必须有对象的参与，这种数据就是实例相关的数据
内存结构图
124
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
