Javajava知识点汇总（1）

● 用带标号(label)的break和continue代替goto，使得break可以直接跳出到循环外的某个位置，continue跳到当前循环外的循环
label起给给循环命名的作用，在程序中引用label表示跳出label所标示的循环


● 初始化和清除是程序设计安全性的两个最重要的问题

● 创建对象时：1.分配空间    2.调用构造函数对这个对象进行初始化    3.然后把初始化完了对象交给那个引用

● 重载
在日常生活中，我们用相同的词表达多种不同的含义，即词的“重载”。
大多数程序设计语言要求我们为每个函数都设定一个独一无二的标识符。
但是构造函数的出现要求函数名也要能够“重载”。
即函数名相同，参数不同的构造函数
使用时各自调用不同的参数构造函数。

构造函数名与类名相同

● 缺省构造函数
如果一个类没有定义构造函数，则编译程序会帮我们自动创建一个缺省构造函数。
但是一旦定义了一个，就不会帮我们自动生成一个。


● this
this关键字可以为已调用了其方法的那个对象生成相应的句柄。
调用这个函数的那个对象--this，即这个函数要作用在哪个对象之上。
在一个构造函数中可以调用一次另一个构造函数，用this(参数)

● 垃圾收集机制
垃圾收集机制只知道怎样释放由new分配的内存，所以它不知道如何释放对象的“特殊”内存。一旦垃圾收集机制准备好释放对象中占用的存储空间，他首先调用finalize()。
finalize() 由Object定义

在构造函数内只进行基本的初始化

定义初始化：
一个直接的做法是在定义数据成员的同时也为其赋值
可以调用一个方法进行初始化
在构造函数之前就进行定义初始化

用一个类创建类的对象时，先分配一个空间，依次做成员变量的定义初始化，再调用构造函数。


● 静态数据初始化
静态的东西属于类。
类Class与类对象。
如果一个变量是一个静态变量的话，所有对象里的这个变量的值是同一个。
静态数据成员只在这个类的第一个对象要创建的时候初始化（装载这个类的时候）。

运行java命令后，启动jvm，找到类的定义文件，找到类的定义文件之后，装载；装载完成之后在内存里形成了一个类对象来代表这个类，然后要对这个类对象里的静态成员变量进行初始化

初始化顺序
1.类型为Dog的一个对象首次创建时，或者Dog类的静态方法/数据首次访问时，Java解释器必须找到Dog.class。
2.找到Dog.class后，它的所有的静态初始化模块都会运行。因此，静态初始化仅发生一次。
3.创建一个new Dog()时，new语句首先会在堆里分配一个足够的空间。
4.这个空间将会被清除为零，因此Dog中所有的数据成员都得到了缺省值。
5.执行定义初始化。
6.执行构造函数。
先静态后动态；先定义初始化后构造函数。

● 显式初始化
静态初始化块，地位相当于一条静态初始化语句
定义初始化块，地位相当于一条定义初始化语句

● 数组
数组代表一系列对象或者基本数据类型，所有相同类型的对象都封装在一起——采用一个统一的标识符名称。
数组变量实际上是一个指向数组的句柄（引用），所以推荐使用int[] a这样的书写方式
通常情况下java的数组通过new出来： a1=new int[5]，表示a1是一个引用，指向一个int型数组
使用length

对象数组
对于对象数组，数组的成员实际上是句柄（对象的引用）
对象数组也可以定义初始化
Integer i;   i 为对对象的引用

● 隐藏实施过程——访问控制
面向对象程序设计的一个概念：隐藏尽可能多的东西
库创建者应声明哪些是客户程序员可以使用的，哪些是不可一使用的

● 包：库单元
用import来引入包或包里的成员。
import java.util.*;    java.util 表示包名  *号表示包里的所有类
import java.util.Vector;      类的全名
目的是在所有对象范围内唯一的标识一个类
之所以要这样的引入，是为了提供一种特殊的机制，来实现命名空间的管理

● 编译单元
每个编译单元必须是以.java结尾的文件名称，在一个编译单元里，可以有一个 public的类，这个类的名字必须与文件的名字相同。在一个单元内，可以有多个类，但只能有一个public的类。
编译一个.java文件时，对应于文件中的每一个类，会得到一个.class文件，文件名与类的名字相同。一个程序是一堆.class文件。

● 定义包
一个库是一堆这样的.class文件，它们被定义为一个包，但是并不真正地合并在一个文件中。
包没有什么管理机制，包只要声明就可以了
   package mypackage;
   public class MyClass;  //MyClass这个类就属于mypackage这个包
现在，如果客户程序员想要使用MyClass，就要用import来引入mypackage包，或者是使用MyClass的全名。
    import mypackage;    //引入mypackage包
    MyClass m = new MyClass(); mypackage.MyClass m = new mypackage.MyClass();
//使用MyClass的全名

rt.jar   java基础类库的所有包
使用jar命令来查看   |more


● CLASSPATH
-  .表示当前目录     d:";.  d盘根下是一个搜索的根
- CLASSPATH包含一个或多个目录，它们作为一种特殊的根使用，从这里展开对.class文件的搜索

● 类成员的访问属性
“Friendly” （缺省包）
public: 界面访问 (accessor/mutator)
private: 不能接触!
protected: "某种友好"  包内可以访问，子类也可以访问。子类和父类不在一个包的情况下。

● 类的访问控制
一个编译单元（文件）中只能有一个public的类。因此一个编译单元只有一个唯一的公共界面，其余的类都是"friendly"的。 public类的名字必须和文件的名字一样。
可以，尽管很少见，一个编译单元没有一个public类，所有的类都是"friendly"的，那么文件名可以任意起。

● 继承
class ThisClass extends SuperClass {
??? //??? class body
}
ThisClass是第三人称弹数，extend要加s---extends

● 传递构造参数
先初始化父类的部分，在初始化自己的
-缺省构造函数
-super(…)  调用父类的一个构造函数并且传递参数

● 初始化和类的装载
-先父类静态，后子类静态
-先父类定义初始化，父类构造函数
-后子类定义初始化，子类构造函数

来源：(http://blog.sina.com.cn/s/blog_514a73190100bngh.html) - java知识点汇总（1）_蒍袮變乖_新浪博客
● Upcasting
-子类和父类之间的关系是： The new class is a type of the existing class.
-Upcasting是安全的.

● Method call binding
-早绑定（静态绑定））  晚绑定（动态绑定）
-Java中所有的绑定都是晚绑定，除了final的方法
-早绑定有早绑定的优点，晚绑定有晚绑定的优点。但是，晚绑定带来了多态性。
-多态性就是把一个子类的对象当作父类的对象来看待，然后让它执行父类所能执行的函数。
静态绑定：若方法类型为priavte static final 编译器会准确知道该调用哪个方法
动态绑定：是很重要的特性,它能使程序变得可扩展而不需要重编译已存代码

● 多态性
多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为

● final
final : This cannot be changed
-final for data
-final for methods
-final for a class

● Final data
-只能被赋值一次的变量
-可以看作是常量
final Value v2 -- final的Value类的引用v2，final保护了对象的引用v2不被改变（这个引用的本身不能被改变）但是Value所指的对象是可以改变的

● Final Methods
-有两种final方法：
1.在方法上加上一把锁，防止继承者改变它的意义。
2.编译器把对该方法的调用变成inline（嵌入）调用。
-Private is Final，不存在override问题

● Final classes
-Final classes是不允许被继承的。为防止他人从你的类上派生新类，此类是不可扩展的。主要是安全上的作用。


● abstract类和abstract方法（抽象类和抽象方法）
可以定义某个类是抽象的（只制造概念）
-一个类的作用仅仅是表达接口，而不是具体的实现细节
-抽象的方法是不完全的，它只是一个声明，没有方法体
-包含一个抽象方法的类被称作抽象类
-不能制造抽象类的对象
-从抽象类继承的类必须override所有父类的抽象方法，否则子类本身成为一个抽象类
-可以声明一个抽象类但是里面没有一个抽象方法
关键字abstract定义抽象类
做这样类的目的是禁止产生这样类的对象

abstract类不能用new运算符创建对象，必须产生其子类，由子类创建对象。
对于abstract方法，只允许声明，而不允许实现
如果一个类是一个abstract类的子类，它必须具体实现父类的abstract方法
如果一个类中含有abstract方法，那么这个类必须用abstract来修饰（abstract也可以没有abstract方法）
一个abstract类只关心它的子类是否具有某种功能，而不关心功能的具体行为，功能的具体行为由子类负责实现

● Interface
——totally abstract class（完全抽象的类）
-Interface在java中的地位和class一样  可以继承
-Interface没有body（也没有构造函数），只表达概念 
-在Interface中所有的方法都是public的，即使你没有声明它是public的。
-在Interface中所有的数据成员都是public static final的，即使你没有声名。但不能是blank final
使用implements，表示实现了什么功能
-Interface编译后也生成一个class文件。其实Interface也是class，只不过是一种完全抽象的类

● 实现interface
-实现interface的类，其interface中所有的方法必须被“实现”，否则这个类成为一个抽象类。
-所有实现interface中的方法必须被申明为public
-Interface可以从多个Interface得到继承，但是不能继承类。

-为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口
-接口体中只进行方法的声明，不许提供方法的实现，所以，方法的定义没有方法体，且用分号结尾
-一个类通过使用implements声明自己使用一个或多个接口，如使用多个接口，用逗号隔开接口名
- 要注意的是，接口中的方法被默认是public的，所以类在实现接口方法时，一定要用public来修饰。另外，如接口方法的返回类型不是void的，那么在类中实现该接口方法时，方法体至少要有一个return语句；如果是void型，类体除了两个大括号外，也可以没有任何语句。
-Java为我们提供的接口都在相应的包中，通过引入包可以使用Java提供的接口，也可以自己定义接口，一个Java源文件就是由类和接口组成的。

● Inner class（内部类）
-In Java 1.1, it is possible to place a class definition within another class definition.
-所谓内部类就是定义在另外一个类内部的类（某个类的定义，在另一个类的内部）
新的消息机制需要有一个类能够访问另外一个类的私有成员
为了解决因为多类类同时继承一个很小的类时，所带来的命名问题。
-什么是使用一个类或访问一个类：用这个类去制造对象
-类里面除了有成员变量、成员函数，还有成员类，实际上内部类可以称之为成员类，成员类也具有成员函数和成员变量一样的属性。成员类可以访问私有变量，成员类里面的所有的成员函数可以访问内部类外面那个类的所有私有变量。
-内部类什么时候被初始化？编译时生成几个class文件？
每个内部类生成一个class文件


1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据
2.对于同一个包中的其他类来说,内部类能够隐藏起来
3.匿名内部类可以很方便的定义回调
4.使用内部类可以非常方便的编写事件驱动程序

● Private inner class
Inner classes可以完全被封闭起来，不被外界所看到

● Why inner classes?
两个理由要在方法和scope中定义inner class:
-我们准备实现某种形式的interface，使自己能创建和返回一个句柄。
-要解决一个复杂的问题，并希望创建一个类，用来辅助自己的程序，同时不愿意把类的细节公开。


在函数里面定义的类都加一个数字（序号），从1开始
有变量有函数就是一个类，这个类没有名字，是匿名类，生成一个“父类名$序号”的class文件
子类送参数给父类的构造函数：在子类的构造函数里用super

如何让内部类访问外部类，被访问的
匿名类没有名字，也就没有构造函数，定义初始化块相当于匿名类的构造函数

● Outter class?
inner classer拥有访问外部类的所有成员的能力，这是使用inner类的主要理由

父类与子类函数与函数之间的关系，如果函数名相同，参数表相同，则构成override的关系。
私有的为静态绑定
inner class 与 inner class 之间不会构成override关系。

● Exception机制处理
但是如果你完全检查任何时刻的错误，你的代码就会变成无法阅读的梦魇。
所有的函数调用的返回值都要判断，但是可能发生由于嵌套过多而造成代码阅读和维护困难，所以java里使用了try...catch，每一个catch针对一种错误，将事务逻辑与错误处理分开
-使用异常机制，读、写和调试代码变得清晰。它把处理错误的代码和正常的代码分开。

● Throw an exception
-throw new NullPointerException();
-throw new NullPointerException("HERE!");
异常发生时，你不能解决问题，所以必须扔(throw)出一个异常。
1.一个异常对象建立起来了。
2.当前运行的路径被停止，异常对象被弹出(eject)。
3.异常处理机制接管，开始寻找一个合适的地方来继续执行。

● Catch an exception
Java的异常机制的好处就在于它使我们在一个地方将精力集中在要解决的问题上，而在另一个地方处理来自那部分代码的异常情况。
  try {      //   code that may make exception
  } catch ( Type1 id1) {
  } catch ( Type2 id2) {
  }
catch的匹配不是一种精确匹配，只要这个对象是那个类的对象就可以了
catch不管再多，只需满足一个就结束了。

● Catch all kind of exception
一个捕捉任何异常的捕捉器是一个捕捉基本类型异常的捕捉器。
catch ( Exception e) {
System.out.println("caught an exception")
}
捕捉任何异常的catch

● Interface: Throwable
String getMessage();
String toString();
void printStackTrace();
void printStackTrace(PrintStream);

● Re-throwing
catch (Exception e) {
throw e;
}
-关于fillInStackTrace()
-也可以抛出一个与接收到的异常不同的异常

● Announce for exception
通知客户程序员自己写的方法中可能抛出什么样的异常是一种文明的做法。
void f() throws tooBig, tooSmall, oldStyle { // Body of f() }
如果你要从你的方法中抛出某种异常，你必须申明。
但是你可以撒谎申明你并不真正抛出的异常。

● Override of exception
当你override一个方法，你只能申明和抛出不比它的父类版本中申明的异常多的异常

● finally