scjp 知识点

标识符
    □标识符可以用字母、下划线或货币符号开头。
    □在第一个字符之后，标识符还可以包含数字。
    □标识符可为任意长度。
    □必须使用骆驼命名法则命名JavaBeans方法，并且根据方法的目的，必须以set、get、is、add或remove开头。

声明规则
    □一个源代码文件只能有一个公共类。
    □如果源文件包含公共类，则该文件名应该与公共类名相同。
    □一个文件只能有一条package语句，但可以有多条import语句。
    □package语句（如果有的话），必须位于源文件的第一行（注释语句除外）。
    □import语句（如果有的话），必须位于package语句之后、累声明语句之前。
    □如果没有package语句，则import语句必须是源文件的第一条语句（注释语句除外）。
    □package语句和import语句应用于该文件的所有类。
    □一个文件可以具有多个非公共类。
    □没有公共类的文件没有任何命名限制。

类访问修饰符
    □有3个访问修饰符：public、protected和private。
    □有4个访问级别：public、protected、默认和private。
    □类只能有public或默认访问级别。
    □具有默认访问级别的类只对位于同一个包中的类是可见的。
    □具有public访问级别的类对于所有包中所有类都是可见的。
    □类的可见性涉及到类中的代码是否能够：
        □创建另一个类的实例。
        □扩展（或子类化）另一个类。
        □访问另一个类的方法或变量。

类修饰符（非访问）
    □类也能被修饰成final、abstract、或strictfp。
    □类不能同时被修饰成final和abstract。
    □最终类不能被子类化。
    □抽象类不能被实例化。
    □类的单个抽象方法意味着整个类必须是抽象的。
    □抽象类可以有抽象方法和非抽象方法。
    □扩展抽象类的第一个具体类必须实现其所有的抽象方法。

实现接口
    □接口是类能够做什么的契约，但是他们没有指定类操作的实现方式。
    □接口能够被来自任何继承树的任何类实现。
    □接口就像一个100%抽象类，无论是否在其声明中键入abstract修饰符，它都隐含是抽象的。
    □接口只能有抽象方法，不允许有具体方法。
    □接口方法默认是公共的和抽象的，这些修饰符的显式声明是可选的。
    □接口可以有常量，它们隐含总是公共的、静态的和最终的。
    □公共的、静态的和最终的接口常量声明可以选择任意组合。
    □合法的非抽象实现类具有如下特性：
        □它为接口都所有方法提供具体实现。
        □对于它实现都方法，必须遵守所有的合法重写规则。
        □它一定不能为实现都方法声明任何新的检验异常。
        □它一定不能声明比该接口方法中所声明都异常更宽泛都任何检验异常。
        □无论接口声明如何，它都可以在任何接口方法实现上声明运行异常。
        □它必须包含与它所实现方法完全相同都方法签名和返回类型（但不必声明该接口都异常）。
    □实现接口都类本身可以是抽象的。
    □抽象实现类不必实现接口方法（但第一个具体子类必须实现）。
    □类只能扩展一个类（没有多重继承），但它能够实现多个接口。
    □接口可以扩展一个或多个其他接口。
    □接口不能扩展类，或者实现类或接口。
    □当参加考试时，请在验证其他代码逻辑之前检查接口和类声明的合法性。

成员访问修饰符
    □方法和实例（非局部）变量称为成员。
    □成员可以使用所有4个访问级别：public、protected、默认和private。
    □成员访问有两种形式：
        □一个类中的代码能够访问另一个类都成员。
        □子类能够继承其超类都成员。
    □如果不能访问类，则不能访问其成员。
    □要在确定成员可见行之前确定类的可见行。
    □公共成员能够被其他所有类访问，甚至是不同包中的类。
    □如果超类成员是公共的，则无论在哪个包中，子类都会继承这个属性。
    □不用点运算符（.）访问的成员必须属于同一个类。
    □this总是引用当前执行都对象。
    □this.aMethod()与只调用aMethod()完全相同。
    □私有成员只能被同一个类都代码访问。
    □私有成员对子类是不可见的，因此，不能继承私有成员。
    □默认成员和保护成员的区别是在子类被调用时：
        □默认成员只能被同一个包中的类访问。
        □保护成员能够被同一个包中的其他类访问，也可以被任意包中的子类访问。
        □保护 = 包 + 子孙（子类）。
        □对于包外子类，只能通过继承访问保护成员，不能通过使用对超类实例的引用来访问保护成员（换句话说，继承是包外子类访问其超类保护成员的唯一机制）。
        □对位于子类包中的任何其他类来说，该子类从其他包中继承的保护成员都是不可访问的，但子类自己的子类除外。

局部变量
    □局部（方法、自动或栈）变量声明不能有访问修饰符。
    □final是唯一可用于局部变量的修饰符。
    □局部变量没有默认值，因此，在使用前必须加以初始化。

其他修饰符——成员
    □final方法在子类中不能被重写。
    □用签名、返回类型以及可选的throws子句声明abstract方法，但是没有实现这些方法。
    □abstract方法以分号而不是波形括号结尾。
    □有3种方法识别非抽象方法：
        □该方法为标识为abstract。
        □该方法有波形括号。
        □该方法在两个波形括号之间有代码。
    □扩展abstract类的第一个非抽象（具体）类必须实现所有抽象类的抽象方法。
    □synchronized修饰符只能应用与方法和代码块。
    □synchronized方法能够具有任何访问控制，也能标识为final。
    □抽象方法必须被子类实现，因此，它们必须是可继承的。原因如下：
        □abstract方法不能是私有的。
        □abstract方法不能是最终的。
    □native修饰符只能应用于方法。
    □strictfp修饰符只能应用于类和方法。

具有var-arg的方法
    □从java5起，方法可以声明一个接受零个或多个变元的参数，即所谓的var-arg方法。
    □var-arg参数的语法type...name，例如：doStuff(int... x){}。
    □var-arg方法只能带有一个var-arg参数。
    □在带有常规参数和一个var-arg参数的方法中，var-arg参数必须出现在后面。

变量声明
    □实例变量能够：
        □具有任何访问控制。
        □被标识为final或transient。
        □实例变量不能标识为abstract、synchronized、native、或strictfp。
        □声明与实例变量同名的局部变量是合法的，这称为“隐藏”。
        □final变量具有如下属性：
            □一旦赋值之后，final变量就不能重新初始化。
            □一旦将对象赋予final变量，则final引用变量不能引用其他对象。
            □在构造函数完成之前，final引用变量必须初始化。
    □根本没有“最终对象”的说法。标识为final的对象引用并不意味着该对象本身是不可改变的。
    □transient修饰符只能应用于实例变量。
    □volatile修饰符只能应用于实例变量。

数组声明
    □数组能够保存基本数据类型或对象类型，但数组本身就是对象。
    □当声明数组时，括号可以位于变量名的左边或右边。
    □在声明中包含数组大小永远是不合法的。
    □对象数组能够保存通过该数组声明类型IS-A（或者instance）测试的任何对象。

静态变量和方法
    □它们不属于类的任何具体实例。
    □不需要类的实例，因为可以使用类的静态成员。
    □静态变量/静态类只有一份副本，所有实例共享此副本。
    □静态方法不能直接访问非静态成员。

枚举
    □枚举指定了一个常量值列表，它们赋予某个类型。
    □枚举不是String或int，枚举常量的类型是枚举类型。
    □枚举可在类外部或内部声明，但不能在方法中声明。
    □在类外声明的枚举不能标识为static、final、abstract、protected或private。
    □枚举可以包含构造函数、方法、变量和常量特定类体。
    □枚举常量可以使用语法BIG(8)将变元发送给枚举构造函数，其中int型字面值8会传递给枚举构造函数。
    □枚举构造函数可以带有变元，并且可以被重载。
    □永远不能在代码中直接调用枚举构造函数。它们总是在初始化枚举时自动调用的。
    □枚举声明末尾的分号是可选的。下面的代码是合法的：
        enum Foo{ ONE, TWO, THREE}
        enum Foo{ ONE, TWO, THREE};
    □MyEnum.values()返回一个数组，包含MyEnum的值。

 

 

 

封装、IS-A、HAS-A
    □封装的目的是隐藏接口（或API）背后的实现。
    □被封装的代码具有两个特性：
        □使实例变量成为受保护的（通常用private修饰符）。
        □getter方法和setter方法提供对实例变量的访问。
    □IS-A指继承或实现。
    □IS-A用关键字extends表达。
    □“IS-A”、“继承自”以及“是。。。的一个子类型”都是等价的表达方式。
    □HAS-A指一个类实例“具有”对另一个类实例的引用，或者“具有”同一个类的另一个实例的引用。

继承
    □继承允许类成为一个超类的子类，从而继承该超类公共的和保护的变量及方法。
    □继承是支持IS-A、多态性、重写、重载和强制转换的关键概念。
    □所有的类（除Object类之外）都是Object类型的子类，因而他们继承Object的方法。
    
多态性
    □多态性意指“多种形式”。
    □引用变量总是单一、不可变的类型，但是它可以引用子类型对象。
    □单一对象可以被许多不同类型的引用变量引用，只要它们具有对象的相同类型或者子类型。
    □引用变量的类型（而不是对象的类型）决定了可以调用哪些方法！
    □多态的方法调用仅适用于被重写的实例方法。
    
重写和重载
    □可以重写或重载方法。构造函数可以重载，但不能重写。
    □第一个具体（非抽象）子类必须重写抽象方法。
    □与原方法相比，重写方法：
        □必须具有相同的变元列表。
        □必须具有相同的返回类型。但是从Java5起，返回类型可以是子类型--这成为协变式返回。
        □一定不能有限制性更强的访问修饰符。
        □可以有限制性更弱的访问修饰符。
        □一定不能抛出新的或更广的检验异常。
        □可以抛出更少的更窄的检验异常，或者任何非检验异常。
    □不能重写final方法。
    □只有继承的方法才可以被重写，并且要记住，私有方法不能被继承。
    □子类使用super.overriddenMethodName()调用重写方法的超类版本。
    □重载意味着复用相同的方法名称，但是具有不同的变元。
    □重载方法：
        □必须有不同的变元列表。
        □可以有不同的返回类型，但是变元列表也必须是不同的。
        □可以有不同的访问修饰符。
        □可以抛出不同的异常。
    □来自超类的方法在子类中可以重载。
    □多态性适用于重写而不是重载。
    □对象类型（不是引用变量的类型）决定在运行时使用哪个重写方法。
    □引用类型决定了在编译时使用哪个重载方法。
    
引用变量强制转换
    □引用变量强制转换有两类：向下强制转换和向上强制转换。
    □向下强制转换：如果具有引用子类型对象的引用变量，则可以赋予它一个子类型的引用变量。必须执行显式强制转换来完成这项工作，其结果是：可以使用这个新的引用变量来访问子类型的成员。
    □向上强制转换：可以显式或隐式地赋予引用变量一个超类型的引用变量。这是一个天生安全的操作，因为赋值限制了新变量的访问能力。
    
实现接口
    □当实现一个接口时，就是在履行一份契约。
    □通过正确地、具体地重写接口定义的所有方法，就可以实现一个接口。
    □一个类可以实现多个接口。
    
返回类型
    □重载方法能够改变返回类型。但是除斜变式返回的情况外，重写方法不能改变返回类型。
    □对象引用返回类型可以接受null作为返回值。
    □对于声明和作为一个值返回来说，数组都是一个合法的返回类型。
    □对于带基本返回类型的方法，可以返回能够隐式转换为返回类型的任何值。
    □不能从void返回任何值，但是可以什么也不返回。允许在具有void返回类型的任何方法内只写一条return语句，返回到以前的方法。但是不能让一个具有非void返回类型的方法什么也不返回。
    □对于具有对象引用返回类型的方法，可以返回这种类型的子类型。
    □对于具有接口返回类型的方法，可以返回该接口的任何实现。
    
构造函数和实例化
    □当创建一个新对象时，总是需要调用构造函数。
    □对象继承树中的每个超类都将有一个构造函数调用。
    □每个类（即使是抽象类）都至少有一个构造函数。
    □构造函数必须具有与其类相同的名称。
    □构造函数一定不能有返回类型。如果看到代码具有返回类型，则它就是一个方法而不是构造函数，只不过具有与类相同的名字。
    □典型的构造函数执行方式如下：
        □构造函数调用其超类的构造函数，超类构造函数又调用其超类的构造函数，如此继续，知道Object构造函数为止。
        □Object构造函数执行，然后返回到调用构造函数，它运行完成后返回来它的调用构造函数，如此继续，知道所创建实际实例的构造函数完成为止。
    □构造函数能够使用任何访问修饰符，包括private。
    □如果在类中没有创建任何构造函数，则编译器将创建一个默认构造函数。
    □默认构造函数是一个无变元的构造函数，它带有对super()的无变元调用。
    □每个构造函数中的第一条语句必须调用this()（一个重载构造函数）或super()。
    □如果没有调用super()，则编译器将添加它，除非已经插入了对this()或super()的调用。
    □只有在运行超类构造函数之后才可以访问实例成员。
    □抽象类具有的构造函数在实例化具体子类时被调用。
    □接口没有构造函数。
    □如果超类没有无变元构造函数，则必须创建构造函数，并插入带有变元的super()调用，这些变元要与超类构造函数的那些变元匹配。
    □构造函数永远不能被继承，因此不能重写它们。
    □构造函数只能由另外一个构造函数直接调用[使用对super()或this()的调用]。
    □使用this()的问题：
        □只可以作为构造函数内的第一条语句出现。
        □变元列表决定了调用哪个重载构造函数。
    □构造函数能够调用构造函数，并且可以如此循环下去，但是，它们中的一个迟早要调用super()，否则将膨胀到爆炸。
    □对this()和super()的调用不能位于同一个构造函数内。构造函数内只能有其中之一，不能二者兼有。
    
静态成员
    □使用静态方法实现的行为不受任何实例状态的影响。
    □使用静态变量保存类特有的数据，而不是实例特有的数据--静态变量只有一个副本。
    □所有的静态成员都属于类，而不属于任何实例。
    □静态方法不能直接访问实例变量。
    □不能重写静态方法，但是可以重新定义。

耦合和内聚
    □耦合指一个类了解或使用另一个类成员的程度。
    □松耦合是一种理想状态，它具有良好封装的类，将相互间的引用减至最少，并且限制了API使用的幅度。
    □紧耦合不是一种理想状态，它具有破环松耦合规则的类。
    □内聚是指类具有单一的、良好定义的角色或职责的程度。
    □高内聚是一个理想状态，其中类的成员支持单一的、明确的角色或职责。
    □低内聚不是一种理想状态，其中类的成员支持多种、不明确的角色或职责。