JAVA学习笔记-关于面向对象（2020/2/14）
目录
一 .方法
方法声明格式：
方法的调用方式：
注意事项
练习代码
二.方法的重载（overload）
雷区
练习代码
三.递归结构
递归结构包括两个部分：
求n！的代码
递归的缺陷
四.面向过程和面向对象
·面向对象和面向过程的总结
· 面向对象思考方式
建议
五.对象的进化史（数据管理的方式）
·数据无管理时代
·数组管理和企业部门制
·对象和企业项目制
总结
六.对象和类的概念
总结
七.类的定义
属性
方法
构造方法
一个简单的类
一个典型类的定义和UML图
内存分析
八.垃圾回收机制
一 .方法
方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。是学习的核心
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法声明格式：
| 1 2 3 |
|
方法的调用方式：
对象名.方法名(实参列表)
方法的详细说明
1. 形式参数：在方法声明时用于接收外界传入的数据。
2. 实参：调用方法时实际传给方法的数据。
3. 返回值：方法在执行完毕后返还给调用它的环境的数据。无返回值时用void。
4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
注意事项
1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
2. return 语句终止方法的运行并指定要返回的数据。
3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：
4. 基本类型传递的是该数据值的copy值。
5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。
练习代码
/**
* 测试方法的基本使用
* @author 锤子布
*
*/
public class TestMethod {
public static void main(String[] args) {
//通过对象调用普通方法
TestMethod tm=new TestMethod();
tm.printSomthing();
int c =tm.add(30, 40, 50)+1000;
System.out.println(c);//传入实参
}
void printSomthing() {
System.out.println("somthing");
System.out.println("somthing");
System.out.println("somthing");
}
int add(int a,int b,int c) {
int sum=a+b+c;
System.out.println(sum);
return sum;//return:结束方法的运行，返回值
}
}
二.方法的重载（overload）
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。
雷区
重载的方法，实际是完全不同的方法，只是名称相同而已!是独立的方法。
构成方法重载的条件：
1.不同的含义：形参类型、形参个数、形参顺序不同
2.只有返回值不同不构成方法的重载
如：
| 1 |
|
不构成方法重载
3.只有形参的名称不同，不构成方法的重载
如：
| 1 |
|
不构成方法重载
练习代码
public class Test21 {
public static void main(String[] args) {
// 我们已经见过的方法的重载
System.out.println();// 0个参数
System.out.println(1);// 参数是1个int
System.out.println(3.0);// 参数是1个double
}
/** 求和的方法 */
public static int add(int n1, int n2) {
int sum = n1 + n2;
return sum;
}
// 方法名相同，参数个数不同，构成重载
public static int add(int n1, int n2, int n3) {
int sum = n1 + n2 + n3;
return sum;
}
// 方法名相同，参数类型不同，构成重载
public static double add(double n1, int n2) {
double sum = n1 + n2;
return sum;
}
// 方法名相同，参数顺序不同，构成重载
public static double add(int n1, double n2) {
double sum = n1 + n2;
return sum;
}
//编译错误：只有返回值不同，不构成方法的重载
public static double add(int n1, int n2) {
double sum = n1 + n2;
return sum;
}
//编译错误：只有参数名称不同，不构成方法的重载
public static int add(int n2, int n1) {
double sum = n1 + n2;
return sum;
}
}三.递归结构
递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。
递归结构包括两个部分：
1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
2.递归体。解答：什么时候需要调用自身方法。
求n！的代码
/**
* 测试递归
* @author 锤子布
*
*/
public class TestRecursion {
public static void main(String[] args) {
long d1=System.currentTimeMillis();
System.out.println("阶乘的结果是"+loop(15));
long d2=System.currentTimeMillis();
System.out.println(d2-d1);
}
static int count=0;
static void a() {
System.out.println("a");
count++;
if(count<10) {
a();//递归体，
}else {
return;//递归头
}
}
static int loop(int a) {
if(a==1) {
return 1;//递归头
}else {
return a*loop(a-1);//递归体
}
}
}
递归的缺陷
简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。
任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归;
在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。
四.面向过程和面向对象
面向过程(Procedure Oriented)和面向对象(Object Oriented,OO)都是对软件分析、设计和开发的一种思想,并非是对立的。早期面向简单的问题，专注于其过程。
面向过程思想思考问题时，我们首先思考“怎么按步骤实现?”并将步骤对应成方法，一步一步，最终完成。 这个适合简单任务，不需要过多协作的情况下。比如，如何开车?我们很容易就列出实现步骤：
1. 发动车 2. 挂挡 3.踩油门 4. 走你
面向过程适合简单、不需要协作的事务。适合不需要协作的内容。
但是当我们思考比较复杂的问题，比如“如何造车?”，就会发现列出1234这样的步骤，是不可能的。那是因为，造车太复杂，需要很多协作才能完成。此时面向对象思想就应运而生了。
面向对象(Object)思想更契合人的思维模式。我们首先思考的是“怎么设计这个事物?” 比如思考造车，我们就会先思考“车怎么设计?”，而不是“怎么按步骤造车的问题”。这就是思维方式的转变。
一、面向对象思想思考造车，发现车由如下对象组成：
1. 轮胎
2. 发动机
3. 车壳
4. 座椅
5. 挡风玻璃
为了便于协作，我们找轮胎厂完成制造轮胎的步骤，发动机厂完成制造发动机的步骤;这样，发现大家可以同时进行车的制造，最终进行组装，大大提高了效率。但是，具体到轮胎厂的一个流水线操作，仍然是有步骤的，还是离不开面向过程思想!
因此，面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。 但是，具体到实现部分的微观操作(就是一个个方法)，仍然需要面向过程的思路去处理。
千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面向过程!
·面向对象和面向过程的总结
1、都是解决问题的思维方式，都是代码组织的方式。面向对象适合组织大规模代码，最终还会简化为一步步的方法，仍然还需要面向过程。
2、解决简单问题可以使用面向过程
3、解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。方法和控制语句就是面向过程的产物。
· 面向对象思考方式
遇到复杂问题，先从问题中找名词，然后确立这些名词哪些可以作为类，再根据问题需求确定的类的属性和方法，确定类之间的关系。
建议
1.面向对象具有三大特征：封装性、继承性和多态性，而面向过程没有继承性和多态性，并且面向过程的封装只是封装功能，而面向对象可以封装数据和功能。所以面向对象优势更明显。
2.一个经典的比喻：面向对象是盖浇饭、面向过程是蛋炒饭。盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是“可维护性”比较好，“饭” 和“菜”的耦合度比较低。
五.对象的进化史（数据管理的方式）
事物的发展总是遵循“量变引起质变”的哲学原则;企业管理和数据管理、甚至社会管理也有很多共通的地方。类比企业发展，更容易理解为什么会产生“对象”这个概念。
·数据无管理时代
最初的计算机语言只有基本变量(类似我们学习的基本数据类型)，用来保存数据。那时候面对的数据非常简单，只需要几个变量即可搞定;这个时候不涉及“数据管理”的问题。同理，就像在企业最初发展阶段只有几个人，不涉及管理问题，大家闷头做事就OK了。
·数组管理和企业部门制
企业发展中，员工多了怎么办?我们很自然的想法就是归类，将类型一致的人放到一起;企业中，会将都做销售工作的放到销售部管理;会将研发软件的放到开发部管理。同理在编程中，变量多了，我们很容易的想法就是“将同类型数据放到一起”， 于是就形成了“数组”的概念，单词对应“array”。 这种“归类”的思想，便于管理数据、管理人。
·对象和企业项目制
企业继续发展，面对的场景更加复杂。一个项目可能需要经常协同多个部门才能完成工作;一个项目从谈判接触可能需要销售部介入;谈判完成后，需求调研开始，研发部和销售部一起介入;开发阶段需要开发部和测试部互相配合敏捷开发，同时整个过程财务部也需要跟进。在企业中，为了便于协作和管理，很自然就兴起了“项目制”，以项目组的形式组织，一个项目组可能包含各种类型的人员。 一个完整的项目组，麻雀虽小五脏俱全，就是个创业公司甚至小型公司的编制，包含行政后勤人员、财务核算人员、开发人员、售前人员、售后人员、测试人员、设计人员等等。事实上，华为、腾讯、阿里巴巴等大型公司内部都是采用这种“项目制”的方式进行管理。
同理，计算机编程继续发展，各种类型的变量更加多了，而且对数据的操作(指的就是方法，方法可以看做是对数据操作的管理)也复杂了，怎么办?
为了便于协作和管理，我们“将相关数据和相关方法封装到一个独立的实体”，于是“对象”产生了，我觉得可以比作一个独立的人。 比如，我们的一个学生对象：
有属性(静态特征)：年龄：18，姓名：高淇，学号：1234
也可以有方法(动态行为)：学习，吃饭，考试
请大家举一反三，根据上表理解一下企业的进化史，会发现大道至简。原来，数据管理、企业管理、社会发展也是有很多共通的地方。“量变引起质变，不同的数量级必然采用不同的管理模式”。
| 表4-1对象进化史和企业进化史 |
||||
| 对象进化史 |
企业进化史 |
抽象类比 |
||
| 数据少时 |
基本类型数据阶段 |
人少时 |
作坊时代 |
无管理时代 (对数据或人没有任何管理) |
| 数据多了 |
数组 同类型数据存到数组中 |
人多了 |
部门 工作行为一样的在一个部门 |
弱管理时代 (将同类型数据集中进行管理) |
| 数据多了 数据关系/操作复杂了 |
类和对象 将数据和相关的操作行为放到一起 |
人多了， 业务更复杂， 人的工作行为也复杂 |
项目组 将不同类型的人放到一起实现统一管理 |
强管理时代 (将数据和数据操作/人和人的行为 放到一起管理) |
总结
1.对象说白了也是一种数据结构(对数据的管理模式)，将数据和数据的行为放到了一起。
2.在内存上，对象就是一个内存块，存放了相关的数据集合!
3.对象的本质就一种数据的组织方式!
六.对象和类的概念
类可以看做是一个模版，或者图纸，系统根据类的定义来造出对象。我们要造一个汽车，怎么样造?类就是这个图纸，规定了汽车的详细信息，然后根据图纸将汽车造出来。
类：我们叫做class。 是型。
对象：我们叫做Object,instance(实例)。是体。
抽象：抽出类似的部分。
以后我们说某个类的对象，某个类的实例。是一样的意思。
总结
1.对象是具体的事物;类是对对象的抽象;
2.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
3.类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。
七.类的定义
对于一个类来说，一般有三种常见的成员：属性field、方法method、构造器constructor。这三种成员都可以定义零个或多个。
属性
属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
| 表4-2成员变量的默认值 |
|
| 数据类型 |
默认值 |
| 整型 |
0 |
| 浮点型 |
0.0 |
| 字符型 |
'\u0000' |
| 布尔型 |
false |
| 所有引用类型 |
null |
方法
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。
方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法定义格式：
| 1 2 3 |
|
构造方法
构造器也叫构造方法(constructor)，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器，从而返回该类的实例，是一种特殊的方法。
声明格式：
| 1 2 3 |
|
要点：
1. 通过new关键字调用!!
2. 构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
3. 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
4. 构造器的方法名必须和类名一致
构造方法的重载
构造方法也是方法，只不过有特殊的作用而已。与普通方法一样，构造方法也可以重载。如果方法构造中形参名与属性名相同时，需要使用this关键字区分属性与形参，this表示创建好的对象。this.id 表示属性id;id表示形参id
一个简单的类
public class Student {
//属性
int id;
String name;
int age;
//方法
void study() {
System.out.println("i am playing");
}
void play() {
System.out.println("i am playing");
}
//程序执行的入口，必须要有
public static void main(String[] args) {
Student stu=new Student();
stu.play();
}
}
一个典型类的定义和UML图
public class Student {
//属性
int id;
String name;
int age;
Computer comp;//引入
//方法
void study() {
System.out.println("i am playing "+comp.brand);
}
void play() {
System.out.println("i am playing");
}
//构造方法
Student(){}
//程序执行的入口，必须要有
public static void main(String[] args) {
Student stu=new Student();//创建一个对象
stu.id=1001;
stu.name="syx";
stu.age=18;
Computer c=new Computer();
c.brand="ThinkPad";
stu.comp=c;
stu.study();
}
}
//一个Java文件只能有一个public修饰的类
class Computer{
String brand;
}
对应的UML图如下：
内存分析
java虚拟机的内存可以分为三个区域：栈stack、堆heap、方法区method area。
栈的特点如下：
1. 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)
2. JVM为每个线程创建一个栈，用于存放该线程执行方法的信息(实际参数、局部变量等)
3. 栈属于线程私有，不能实现线程间的共享!
4. 栈的存储特性是“先进后出，后进先出”，类似子弹夹。
5. 栈是由系统自动分配，速度快!栈是一个连续的内存空间!
堆的特点如下：
1. 堆用于存储创建好的对象和数组(数组也是对象)
2. JVM只有一个堆，被所有线程共享
3. 堆是一个不连续的内存空间，分配灵活，速度慢!
4.new 的时候就创建好了一个对象在堆里面。
方法区(又叫静态区)特点如下：
1. JVM只有一个方法区，被所有线程共享!
2. 方法区实际也是堆，只是用于存储类、常量相关的信息!
3. 用来存放程序中永远是不变或唯一的内容。(类信息【Class对象】、静态变量、字符串常量等)
八.垃圾回收机制
c++中没有垃圾回收机制，需要关系内存有没有释放，JAVA不需要关心，可以更好的关心逻辑。
·内存管理
Java的内存管理很大程度指的就是对象的管理，其中包括对象空间的分配和释放。
对象空间的分配：使用new关键字创建对象即可
对象空间的释放：将对象赋值null即可。垃圾回收器将负责回收所有”不可达”对象的内存空间。
·垃圾回收过程
任何一种垃圾回收算法一般要做两件基本事情：
1. 发现无用的对象
2. 回收无用对象占用的内存空间。
垃圾回收机制保证可以将“无用的对象”进行回收。无用的对象指的就是没有任何变量引用该对象。Java的垃圾回收器通过相关算法发现无用对象，并进行清除和整理。
·垃圾回收相关算法
1. 引用计数法
堆中每个对象都有一个引用计数。被引用一次，计数加1. 被引用变量值变为null，则计数减1，直到计数为0，则表示变成无用对象。优点是算法简单，缺点是“循环引用的无用对象”无法别识别。
【示例4-7】循环引用示例
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
|
s1和s2互相引用对方，导致他们引用计数不为0，但是实际已经无用，但无法被识别。
2. 引用可达法(根搜索算法)
程序把所有的引用关系看作一张图，从一个节点GC ROOT开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，当所有的引用节点寻找完毕之后，剩余的节点则被认为是没有被引用到的节点，即无用的节点。
分代垃圾回收机制，
是基于这样一个事实：不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的回收算法，以便提高回收效率。我们将对象分为三种状态：年轻代、年老代、持久代。JVM将堆内存划分为 Eden、Survivor 和 Tenured/Old 空间。
1. 年轻代
所有新生成的对象首先都是放在Eden区。 年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象，对应的是Minor GC，每次 Minor GC 会清理年轻代的内存，算法采用效率较高的复制算法，频繁的操作，但是会浪费内存空间。当“年轻代”区域存放满对象后，就将对象存放到年老代区域。
2. 年老代
在年轻代中经历了N(默认15)次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。年老代对象越来越多，我们就需要启动Major GC和Full GC(全量回收)，来一次大扫除，全面清理年轻代区域和年老代区域。
3. 持久代
用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响。
图4-7 堆内存的划分细节
·Minor GC:
用于清理年轻代区域。Eden区满了就会触发一次Minor GC。清理无用对象，将有用对象复制到“Survivor1”、“Survivor2”区中(这两个区，大小空间也相同，同一时刻Survivor1和Survivor2只有一个在用，一个为空)
·Major GC：
用于清理老年代区域。
·Full GC：
用于清理年轻代、年老代区域。 成本较高，会对系统性能产生影响。
在对JVM调优的过程中，很大一部分工作就是对于Full GC的调节。尽量不要启动Full GC。有如下原因可能导致Full GC：
1.年老代(Tenured)被写满
2.持久代(Perm)被写满
3.System.gc()被显式调用（程序建议GC启动，只是请求，不是调用GC）
4.上一次GC之后Heap的各域分配策略动态变化
垃圾回收过程：
1、新创建的对象，绝大多数都会存储在Eden中，
2、当Eden满了（达到一定比例）不能创建新对象，则触发垃圾回收（GC），将无用对象清理掉，
然后剩余对象复制到某个Survivor中，如S1，同时清空Eden区
3、当Eden区再次满了，会将S1中的不能清空的对象存到另外一个Survivor中，如S2，
同时将Eden区中的不能清空的对象，也复制到S1中，保证Eden和S1，均被清空。
4、重复多次(默认15次)Survivor中没有被清理的对象，则会复制到老年代Old(Tenured)区中，
5、当Old区满了，则会触发一个一次完整地垃圾回收（FullGC），之前新生代的垃圾回收称为（minorGC）