JAVA 笔记

1. 用句柄操纵对象
2. 保存方式：

1. 寄存器。这是最快的保存区域，因为它位于和其他所有保存方式不同的地方：处理器内部。然而，寄存器的数量十分有限，所以寄存器是根据需要由编译器分配。我们对此没有直接的控制权，也不可能在自己的程序里找到寄存器存在的任何踪迹。
2. 堆栈。驻留于常规RAM（随机访问存储器）区域.这是一种特别快、特别有效的数据保存

方式，仅次于寄存器。创建程序时，Java 编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java 数据要保存在堆栈里——特别是对象句柄，但Java 对象并不放到其中。

（3）堆。一种常规用途的内存池（也在RAM 区域），其中保存了Java 对象

（4）静态存储。这儿的“静态”（Static）是指“位于固定位置”（尽管也在RAM 里）。程序运行期间，静态存储的数据将随时等候调用。可用static 关键字指出一个对象的特定元素是静态的。但Java 对象本身永远都不会置入静态存储空间。

（5）常数存储。常数值通常直接置于程序代码内部。

（6）非RAM 存储.存储特定的对象

3.staitc 关键字：（1）用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。（2）我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。

4.while：

(1) 简单的一个continue 会退回最内层循环的开头（顶部），并继续执行。

(2) 带有标签的continue 会到达标签的位置，并重新进入紧接在那个标签后面的循环。

(3) break 会中断当前循环，并移离当前标签的末尾。

(4) 带标签的break 会中断当前循环，并移离由那个标签指示的循环的末尾。

5.构建器。构建器的名字与类名相同。这样一来，可保证象这样的一个方法会在初始化期间自动调用。构建器属于一种较特殊的方法类型，因为它没有返回值。这与void 返回值存在着明显的区别。对于void 返回值，尽管方法本身不会自动返回什么，但仍然可以让它返回另一些东西。构建器则不同，它不仅什么也不会自动返回，而且根本不能有任何选择。若存在一个返回值，而且假设我们可以自行选择返回内容，那么编译器多少要知道如何对那个返回值作什么样的处理。

6.重载（overload）：对于类的方法（包括从父类中继承的方法），方法名相同，参数列表不同的方法之间就构成了重载关系。这里有两个问题需要注意：

（1）什么叫参数列表？参数列表又叫参数签名，指三样东西：参数的类型，参数的个数，参数的顺序。这三者只要有一个不同就叫做参数列表不同。

（2）重载关系只能发生在同一个类中吗？非也。这时候你要深刻理解继承，要知道一个子类所拥有的成员除了自己显式写出来的以外，还有父类遗传下来的。所以子类中的某个方法和父类中继承下来的方法也可以发生重载的关系。

大家在使用的时候要紧扣定义，看方法之间是否是重载关系，不用管方法的修饰符和返回类型以及抛出的异常，只看方法名和参数列表。而且要记住，构造器也可以重载。

  覆盖 (override)：也叫重写，就是在当父类中的某些方法不能满足要求时，子类中改写父类的方法。当父类中的方法被覆盖了后，除非用super关键字，否则就无法再调用父类中的方法了。

发生覆盖的条件：

1、“三同一不低” 子类和父类的方法名称，参数列表，返回类型必须完全相同，而且子类方法的访问修饰符的权限不能比父类低。

2、子类方法不能抛出比父类方法更多的异常。即子类方法所抛出的异常必须和父类方法所抛出的异常一致，或者是其子类，或者什么也不抛出；

3、被覆盖的方法不能是final类型的。因为final修饰的方法是无法覆盖的。

4、被覆盖的方法不能为private。否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

5、被覆盖的方法不能为static。所以如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误。反之亦然。即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。

方法的覆盖和重载具有以下相同点：

都要求方法同名

都可以用于抽象方法和非抽象方法之间

 

方法的覆盖和重载具有以下不同点：

方法覆盖要求参数列表（参数签名）必须一致，而方法重载要求参数列表必须不一致。

方法覆盖要求返回类型必须一致，方法重载对此没有要求。

方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类中的所有方法（包括从父类中继承而来的方法）

方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。

父类的一个方法只能被子类覆盖一次，而一个方法可以在所有的类中可以被重载多次。

 

另外，对于属性（成员变量）而言，是不能重载的，只能覆盖。

 

1. this. this 关键字（注意只能在方法内部使用）可为已调用了其方法的那个对象生成相应的句柄。可象对待其他任何对象句柄一样对待这个句柄。但要注意，假若准备从自己某个类的另一个方法内部调用一个类方法，就不必使用this。只需简单地调用那个方法即可。

8.static 含义：我们不可从一个static 方法内部发出对非static 方法的调用（注释②），尽管反过来说是可以的。而且在没有任何对象的前提下，我们可针对类本身发出对一个static 方法的调用。事实上，那正是static方法最基本的意义。它就好象我们创建一个全局函数的等价物（在C 语言中）。除了全局函数不允许在Java中使用以外，若将一个static 方法置入一个类的内部，它就可以访问其他static 方法以及static 字段。

②：有可能发出这类调用的一种情况是我们将一个对象句柄传到static 方法内部。随后，通过句柄（此时实际是this），我们可调用非static 方法，并访问非static 字段。但一般地，如果真的想要这样做，只要制作一个普通的、非static 方法即可。

9.一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用finalize()，而且只有在下

一次垃圾收集过程中，才会真正回收对象的内存。所以如果使用finalize()，就可以在垃圾收集期间进行一些重要的清除或清扫工作。Java 不允许我们创建本地（局部）对象——无论如何都要使用new。但在Java 中，没有“delete”命令来释放对象，因为垃圾收集器会帮助我们自动释放存储空间。所以如果站在比较简化的立场，我们可以说正是由于存在垃圾收集机制，所以Java 没有破坏器。

1. 初始化顺序.在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。
2. import java.util.*;它的作用是导入完整的实用工具（Utility）库，该库属于标准Java 开发工具包的一部分。由于Vector 位于java.util 里，所以现在要么指定完整名称“java.util.Vector”（可省略import 语句），要么简单地指定一个“Vector”（因为import 是默认的）。
3. 为Java 创建一个源码文件的时候，它通常叫作一个“编辑单元”（有时也叫作“翻译单元”）。每个编译单元都必须有一个以.java 结尾的名字。而且在编译单元的内部，可以有一个公共（public）类，它必须拥有与文件相同的名字（包括大小写形式，但排除.java 文件扩展名）。
4. 在新类里简单地创建原有类的对象。我们把这种方法叫作“合成”.
5.  14.如果类没有默认的自变量，或者想调用含有一个自变量的某个基础类构建器，必须明确地编写对基础类的调用代码。这是用super 关键字以及适当的自变量列表实现的.
6. final 关键字的含义可能会稍微产生一些差异。但它最一般的意思就是声明.“这个东西不能改变”。
7. Static 强调它们只有一个；而final 表明它是一个常数。注意对于含有固定初始化值（即编译期常数）的fianl static 基本数据类型，它们的名字根据规则要全部采用大写。
8. 当多个类中出现相同功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。抽象类的特点：
   1，抽象方法一定在抽象类中。
   2，抽象方法和抽象类都必须被abstract关键字修饰。
   3，抽象类不可以用new创建和实例化对象。因为抽象类本身就是不完整的。
   4，抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
9. abstract 关键字，和哪些关键字不能共存。
   final：被final修饰的类不能有子类（不能被继承）。而被abstract修饰的类一定是一个父类（一定要被继承）。
   private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
   static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。
10. 接口interface.它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。接口也包含了基本数据类型的数据成员，但它们都默认为static 和final。来自接口的方法必须定义成public。否则的话，它们会默认为“protect”
11. 一个类可以继承多个接口。这就是java 的多继承。
12. 类 继承 类 用 extends,接口 继承 接口用extends .类继承 接口用iimplements
13. 通过继承可以拓展接口。利用继承技术，可方便地为一个接口添加新的方法声明，也可以将几个接口合并成一个新接口。
14. 根据Java 命名规则，拥有固定标识符的static final 基本数据类型（亦即编译期常数）都全部采用大写字母。

24.使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。

      2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。

      3、创建内部类对象的时刻并不依赖于外围类对象的创建。

      4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。

      5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

25.在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。

26.final类：表明自己不希望从这个类继承，或者不允许其他任何人采取这种操作。

27.由于Java 中的一切东西都是对象，所以许多活动变得更加简单，这个问题便是其中的一例。正如下一章会讲到的那样，每个对象的代码都存在于独立的文件中。除非真的需要代码，否则那个文件是不会载入的。通常，我们可认为除非那个类的一个对象构造完毕，否则代码不会真的载入。

28.Java 提供了四种类型的“集合类”：Vector（矢量）、BitSet（位集）、Stack（堆栈）以及Hashtable（散列表）。

29.在Vector 中，addElement()便是我们插入对象采用的方法，而elementAt()是提取对象的唯一方法。使用Enumeration，我们不必关心集合中的元素数量。所有工作均由hasMoreElements()和nextElement()自动照管了。

30.Java 不具备象C++的“破坏器”那样的概念。在C++中，一旦破坏（清除）一个对象，就会自动调用破坏器方法。之所以将其省略，大概是由于在Java 中只需简单地忘记对象，不需强行破坏它们。垃圾收集器会在必要的时候自动回收内存。

31.允许我们将自变量设成final 属性，方法是在自变量列表中对它们进行适当的声明。这意味着在一个方法的内部，我们不能改变自变量句柄指向的东西。

32.“过载”是指同一样东西在不同的地方具有多种含义；而“覆盖”是指它随时随地都

只有一种含义，只是原先的含义完全被后来的含义取代了。

1. 包含了抽象方法的一个类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract（抽象）。否则，编译器会向我们报告一条出错消息。即使不包括任何abstract 方法，亦可将一个类声明成“抽象类”。如果一个类没必要拥有任何抽象方法，而且我们想禁止那个类的所有实例，这种能力就会显得非常有用。
2. “interface”（接口）关键字使抽象的概念更深入了一层。我们可将其想象为一个“纯”抽象类。它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。接口也包含了基本数据类型的数据成员，但它们都默认为static 和final。接口只提供一种形式，并不提供实施的细节。
3. 子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。
4.  
5. 1.子类继承父类的成员变量：

当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：

1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；

2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

1. 2.子类继承父类的方法

同样地，子类也并不是完全继承父类的所有方法。

1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；

2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

39.super主要有两种用法：

1）super.成员变量/super.成员方法;

2）super(parameter1,parameter2....)

第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。

40.父类的构造器调用以及初始化过程一定在子类的前面。

41.覆盖只针对非静态方法（终态方法不能被继承，所以就存在覆盖一说了），而隐藏是针对成员变量和静态方法的。这2者之间的区别是：覆盖受RTTI（Runtime type  identification）约束的，而隐藏却不受该约束。也就是说只有覆盖方法才会进行动态绑定，而隐藏是不会发生动态绑定的。在Java中，除了static方法和final方法，其他所有的方法都是动态绑定。

42.static 方便在没有创建对象的情况下来进行调用（方法/变量）。很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

1）static方法

static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

2）static变量

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static成员变量的初始化顺序按照定义的顺序进行初始化。

3）static代码块

static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

　　为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。

static是不允许用来修饰局部变量

1. 当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：外部类.this.成员变量，外部类.this.成员方法
2. 匿名内部类调用形参必须用final,为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。故如果定义了一个匿名内部类，并且希望它使用一个其外部定义的参数，那么编译器会要求该参数引用是final的。
3. 内部类的意义：java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题 没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

43.什么时候使用成员变量和局部变量： 1：考虑变量的生存时间，这会影响内存开销。 2：扩大变量作用域，不利于提高程序的高内聚。 开发中应该尽量缩小变量的作用范围，如此在内存中停留时间越短，性能也就更高。 不要动不动就使用static修饰,一般,定义工具方法的时候,static方法需要访问的变量,该变量属于类,此时才使用static修饰字段. 也不要动不动就使用成员变量,因为存在着线程不安全问题,能使用局部变量尽量使用局部变量.

44.访问权限控制：

private:         表示私有的, 表示类访问权限.  只能在本类中访问,离开本类之后,就不能直接访问. 不写(缺省):  表示包私有,表示包访问权限.  访问者的包必须和当前定义类的包相同才能访问. protected:    表示子类访问权限,同包中的可以访问,即使不同包,但是有继承关系,也可以访问. public:           表示全局的,可以公共访问权限,如某个字段/方法,使用了public修饰,则可以在当前项目中任何地方访问.

45.使用this: ① 解决成员变量和参数(局部变量)之间的二义性,必须使用; ② 同类中实例方法间互调(此时可以省略this,但是不建议省略)。 ③ 将this作为参数传递给另一个方法; ④ 将this作为方法的返回值(链式方法编程); ⑤ 构造器重载的互调，this([参数])必须写在构造方法第一行; ⑥ static不能和this一起使用;               当字节码被加载进JVM,static成员以及存在了.              但是此时对象还没有创建,没有对象,就没有this.