关于张老师java视频的学习（十）

第三讲：面向对象上
（1）、类的产生：类名C 对象名O = new 类中的构造方法; 该语句执行完毕之后，栈内存中产生一个C类型的引用变量O，并由new在堆内存中分配一个空间，由类的
构造方法来初始化这个空间，并把该空间的首地址赋值给引用变量O，这样，对象O就像对内存中的对象名一样，其实，和指针一样。
（2）、自动初始化： 基本类型变量数据 在声明时，系统自动对其进行初始化，而对于引用变量，系统则不进行初始化。
其中，基本变量类型的初始默认值为：byte = 0、boolea = false、short = 0、char = '/u000'、float = 0.0f、int = 0、double = 0.00、
long = 0L。 除了这八大基本类型之外的数据类型，都是引用类型。
（3）、对象间的比较："=="运算符与equals()方法的区别， （基本数据类型的变量，可以直接利用==号来比较。)
1、"=="运算符用于比较两个变量的值（引用）是否相等，而不考虑该变量所引用的对象的值是否相等。比较的是栈内存中的两个变量的值
2、equals()方法，是用来比较两个对象中内容是否完全一样，即该方法比较的是对象中的值是否相等。比较的是栈和堆内存中的两个对象的值
（4）、如何快速的比较两个数组间的内容是否想等： 数组是存放在堆内存中的对象，不能直接用“==”号来比较，但是，数组也没有equals()方法，故：
我们利用Arrays类中的方法，来比较两个数组的内容是否一样。
（5）、可以在程序中直接new一个对象，但是不引用该对象，而是用该对象的某个方法，如：new Person().shout()，该语句产生一个Person对象，并调用其shout
方法，该对象为匿名对象。（当我们使用一个对象只使用一次的时候，便可以使用匿名对象）
（6）、实现类的良好封装性：通常将成员变量声明为private，成员方法声明为public来实现对这个变量的访问。对象是一个小模块，应该让外界知道必须知道的
内容，而其他内容都封装起来。在进行模块设计时，应尽量避免一个模块直接修改和操作另一个模块的数据成员，模块设计追求强内聚（许多功能尽量在
类的内部独立完成，不许外部干预），弱耦合（提供给外部尽量少的调用）。
（7）、实现类封装的优点：
1、隐藏类的细节
2、只能通过实现定制的方法来访问数据，可方便地加入控制逻辑，限制对属性的不合理操作
3、便于修改，增加代码的可维护性
（8）、构造函数是编译器自动调用的，当我们使用void来修饰构造函数时，编译器不报错，但是，在创建对象的时候，编译器将不在调用该方法。
（9）、可以在构造函数中对成员变量初始化，使得用类产生对象时，对所有的对象都自动初始化，这样就避免了必须额外的对每个对象初始化。
编译器，自动产生默认构造无参构造函数，该构造函数自动初始化类的成员变量。当我们定义了自己的构造函数时，编译器将不再自动产生无参构造函数，
如果仍需调用这个无参构造函数，像这样调用： 类名 对象名 = new 类名() ，是错误的，因为类中没有了这样的无参构造函数，此时，我们需要在类中
重新定义无参构造函数。
（10）、语句 new Person("Tom",18)执行的内存状态分析：
1、首先，在堆内存中申请一个存放Person类实例对象大小的空间，其类中所有的成员变量自动默认初始化，
2、然后，执行构造函数，构造函数内形参接受实参，但是并不马上直接执行构造方法中的主体代码
3、接着，先执行类中变量显示初始化（显示初始化：人工初始化）的代码。
4、之后，才执行构造函数中的代码，实例化完毕。
5、最后，将该对象空间的首地址赋给 栈内存中的Person类型引用变量。
（11）、this关键字：在每个成员方法中的变量都带有默认的this前缀。
· 在方法中使用this.成员变量，来引用类中的成员变量。
· 容器类和部件类中的应用，在容器类的某个方法中要创建部件类的实例对象，而部件类的构造方法要接受一个代表其所在容器的参数。
· 在构造函数中调用构造函数。 this（形参表列），此时的this便是类名。
（12）、垃圾回收过程：
C++中的析构函数：当一个对象从内存中准备释放时，析构方法将自动调用，有了这个析构方法，程序中的对象在释放前，都能自动完成一些清理工作方面
的事情。常用析构方法去释放对象在生成中所占用的一些资源。
java中的finalize()(继承于Object类):类似于C++中的析构方法，当java中的对象没有引用变量引用句柄的时候，该对象变成了垃圾，从而其占用的内存也
变成垃圾。finalize方法，不是在对象变成垃圾之前被调用，而是之后对象被当成垃圾被彻底清除之前调用。而对象变成垃圾之后，何时
清除回收则由垃圾管理器来管理。垃圾回收器的启用，是无法控制的，自动进行，无规律可循。
System.gc():垃圾回收器，如果在程序中调用该语句，那么，在调用该语句之前，编译器自动调用方法finalize方法。

（13）、函数的参数传递：
· 在函数中定义的形参，相当于该函数中的一个局部变量，只在该函数中起作用。
· 基本数据类型的值传递方式，引用数据类型的地址传递方式。
基本数据类型值传递： 发生于栈内存
* 1、栈内存中的main()函数中的变量x=5，而change()方法中的x=？？？
* 2、主函数main()调用方法change(),将实参x=5传递给change()方法中的形参，形参相当于方法中的局部变量，因而
* change()中的x=5； （对象的引用被传递给形参）
* 3、然后执行change()方法中的主体代码，x的值变成3。 （对象被改变）
* 4、change()方法中的代码执行完毕，局部变量x 被释放。（对象，已经改变，将不被释放）
· 引用数据类型的地址传递：（数组也是引用数据类型，字符串也是） 发生于堆内存
* 1、栈内存的main()函数中，产生一个PassParam对象的引用变量obj，该变量指向堆内存中的对象
* 2、当调用change方法时，形参声明了一个PassParam类的局部引用变量obj，main方法在调用时，传递1中所产生的对象的引用给该形参
* 3、然后执行change方法的主体代码，改变了改对象中的内容。 执行完毕之后，对象已经发生改变，并且，形参obj将释放掉。
* 4、此时，main方法中的引用变量obj所引用的对象在堆内存中已经是发生了改变的对象。
（14）、static关键字的基本运用：
· 使用static关键字声明的成员，在内存中只有一份。所有的类对象都共享该份，任何对象对它的改变，都将影响其他对象。
· 静态方法只能直接访问同类中的其他静态成员，而不能直接访问类中的非静态成员。静态方法不能以任何方式引用关键字this和super，因为这些都代
表着某个当前对象，而在静态方法使用之前，并不产生任何对象。但是，我们也可以产生某个对象，然后再用对象名来调用类中的静态方法.
（15）、static 静态代码块：
· 一个类中可以使用不包含在任何方法体内的静态代码块，当类被载入时，该代码块被执行，且只被执行一次，常用来进行类属性的初始化。
· 类中静态代码块被自动执行，尽管我们产生了多个实例对象，但静态代码只被执行一次。
· 当一个程序中用到了其他的类，类是在第一次被使用的时候才被装载，而不是程序启动时就装载程序中所有可能要用到的类。
· 当程序用到一个类的时候，不管是产生一个类对象，还是直接调用类的静态方法，都会执行其静态方法。
（16）、向main方法传递参数：（main方法是由JVM自动调用的，是类的外部调用）
在控制台中，执行类的时候，使用命令：java 类名 参数1 参数2 参数3... 在类名后面，跟着参数表列，每个参数间用空格格开，
而这些参数都是作为一个String对象来传递给main函数的 形参String[] args。
（17）、内部类对象中，隐含了这样一个对外部类对象的引用：Outer.this
1、当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，内部类中对this的引用会被传递给那个外部类对象的引
用。如在内部类Inner中的一个方法display，假设该方法中访问了一个变量outer_i，首先，检索方法中有无该变量，如果没有，则加上前缀this，则
变量全名为this.outer_i，即到Inner对象中需找该变量，如果还找不到，则继续加上前缀Outer,则变量全名变为:Outer.this.outer_i，即到Outer类
对象中寻找该变量，如果找到，则返回方法display，否则报错。 其中，this是指方法所在类的一个引用，而Outer是所在类的外部类的一个引用。不能
通过多个Outer来调用该类的外外层类。
2、外部类中的方法，是不能访问内部类中定义的变量的。
3、内部类的优点： （1）、两个类中，类1中创建了类2的对象，而类2方法又需要访问类1的变量，这时候，只能通过在类2中定义一个得到类1对象的
引用的构造函数，并在类1中创建类2对象时调用该构造函数，传递实参为this。这样，在类2中得到了类1的一个实例，便可
访问类1的变量了，这样做太过麻烦，使得程序于理解。 只是因为这两个类联系太过紧密，此时，应该把类2嵌套到类1中。
（18）、用static来修饰内部类：
如果用static来修饰一个内部类，这个类就相当于一个外部定义的类，所以static的内部类中可以声明static变量成员，但是，非static的内部类中的
成员是不能声明为static的，static的内部类不能使用外层封装类的非static的成员变量。 （static内部类很少用）
（19）、若有如下内部类定义：
class Outer{
private int size = 10;
public class Inner{
public ovid doStuff(int size){
size++; // 引用的是当前方法中的size变量
this.size; // 引用的是内部类Inner中的size变量
Outer.this.size; // 引用的是当前代码所在类的外部类Outer的size变量。
}
}
}
（20）、使用java的文档注释：我们所做的java文档，类似于JDK文档帮助，需要使用到java文档工具javadoc,该程序将java程序中的注释提取出来生成类似于jdk
文档格式的文档帮助。
注释格式：
1、以 /** 开始，以 */ 结束:
2、要注释某个元素，比如说类，必须紧挨该元之前进行注释。
3、类的注释内容包括：开始符/**<br> *Title 类名 <br> ，*Description 类的功能说明<br>, *Copyright(c) 所有者<br>，*Company 公司 <br>
,*@author 作者名, *@version jdk版本号 */ 结束符
4、方法的标注： 关键字param return，格式： *@param 变量名 变量说明 ，这是传递给方法的参数。 *@return 返回说明。
5、如何生成文档注释：
首先，主要是在类和方法之前进行注释，注释中除了普通文档的注释之外，还有一些关键字，而这些关键字必须是固定的。
然后，能生成文档注释的类的访问权限修饰符必须是public的。
最后、在命令行中运用javadoc命令来生成指定文档。

二、问题与收获：
（1）、 语句分析：System.out.println()，System是一个类，out是类System中一个静态成员，而该静态成员恰好又是一个类对象，println()是该对象中的一个
静态方法。
（2）、单态设计模式：static 的应用。
所谓类的单态设计模式，指采取一定的方法保证整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法，如果我
们要让类在一个虚拟机中能产生一个对象，首先必须将类的构造函数访问权限设置为private，但类内部仍可以产生该类的对象，因为在类的外部无法直
接的调用构造函数来产生该对象，只能调用该类的某个静态方法可以返回类内部创建的对象，静态方法只能访问类中的静态成员，故，指向类内部产生的
该类对象的变量也必须是静态的。
1、控制外部，使外部不能创建该单态类的对象。
2、既然外部不能创建，那么我们可以在类内部来创建该类的对象。
3、在类内部创建对象并得到其引用之后，我们使用一个静态方法来返回该引用，使得外部能访问该引用，而该引用变量必须是静态的。
（3）、在Eclipse中，"shift + CapsLock + /" ，将注释选中的行。可以单击直接拖动包中的类到另外一个包。
（4）、在某个类中aClass{ aClass instance = new aClass(); } ,该代码将无限循环下去，这是一种错误的引用。
（5）、在程序中，this是对该代码所在的类的一个引用，而Outer则是对该代码所在类的一个外部类的引用。
（6）、自动初始化： 在类中定义的变量，编译器将自动初始化
在类的方法中定义的变量，编译器将不自动初始化。
（7）、在方法中使用final关键字声明了一个变量并初始化之后，该变量就相当于一个常量，其生存周期超过了方法。