java基本知识学习

1. 浮点数的赋值是带有小数点的数字缺省是double型的，如果在浮点数后面加 f 或者 F 则是 float，后面加 d 或者D则是double，科学计数法形式的浮点数也是double型的。
   
2. 一个高精度的赋值给一个低精度的，需要时行强制类型转换，反之则不需要。
   如以下试题：
   

   Which of the following assignment is not correct?
   　　A. float f = 11.1;

   　　B. double d = 5.3E12;

   　　C. double d = 3.14159;

   　　D. double d = 3.14D.
   答案选A。
   

3. 在同一个类的不同构造方法中调用该类的其它构造方法，需要使用 this(...) 的形式，而且必须是在构造方法的第一行调用，这个和普通的方法重载调用的方式不同，普通的方法可以直接使用方法名加参数来调用，而且调用位置没有限制。而父类型的构造函数被调用前不能引用类的成员。
          构造方法是一个类对象实例化的起点（虽然严格来说首先执行的并不是构造方法的第一个语句，而是内存分配），因此在构造方法中不能将成员作为参数引用。
   如以下试题：
   

   Given the uncompleted code of a class:
   　　class Person {
   　　String name, department;
   　　int age;
   　　public Person(String n){ name = n; }
   　　public Person(String n, int a){ name = n; age = a; }
   　　public Person(String n, String d, int a) {
   　　// doing the same as two arguments version of constructor
   　　// including assignment name=n,age=a
   　　department = d;
   　　}
   　　}
   Which expression can be added at the "doing the same as..." part of the constructor?

   A. Person(n,a);

   B. this(Person(n,a));

   C. this(n,a);

   D. this(name,age).
   答案选C。
   
   

4. 局部变量： local/ automatic/ temporary/ stack variable ——是定义在方法里的变量
   实例变量： instance variable ——也叫成员变量，是在方法外而在类声明内定义的变量
   类变量： calss variabel ——是用关键字 static 声明的实例变量。（类变量的该类被加载时被创建，不一定要用new Xxxx( )创建，所有该类的实例对象共享该类变量，其生存期是类的生存期。）
   
5. 任何变量在命名用前都必须初始化，但局部变量必须显式初始化，而实例变量不必，原始类型的实例变量在该类的构造方法被调用时为它分配的缺省值，整型是0，布尔型是false，浮点型是0.0f，引用类型（类类型）的实例变量的缺省值是null（没有进行实际的初始化，对它的使用将引起NullPointException)，类变量的规则和实例变量一样，不同的是，类变量的初始化是在类被加载时。
   
6. 代码中的注释
   /* ……*/：可以用于注解一行中的一部分、一整行或者是用于定义一个多行的注释
   //……：    单行注释
   /** ……*/：文档注释
   
7. 字面常量、具名常量(named constant)
   定义一个常量，我们不希望它的值有可能改变，我们需要将这个字段声明为final。final字段或final变量的值一旦经过初始化就不能再改变了。
   我们不想让这个具名常量字段和类的实例相关联，我们可以声明它为static。例子如下：
   
   public   class  Square ... ... {
   
       static final int MAX = 50;
       public static void main(String[] args) ......{
       // TODO Auto-generated method stub
   
       }
   
   }
   
   
8. 新创建的对象将被分配到一个称作堆（heap）的系统内存区域中。所有的对象都是通过对象引用（object reference）来访问的，这种变量类型称作引用类型（reference type）。与之相对的就是基本类型（基础工业类型的变量保存的是基本类型的值）。
   
9. 每个对象（类的实例）都是唯一的，都有一个唯一个字段的副本。
   
10. 类变量（类字段）——特定于类而不是类的对象的字段
            可以通过将字段声明为static来获得特定于类的字段，因此它们通常被称为静态字段（static field）。
    
11. 垃圾回收器：当一个对象不再被引用时，垃圾回收器就可以将它从内存分配堆中移除，但有时候会将这个动作的进行推迟到某个适当的时机（本人理解——程序员无法知道垃圾回收器什么时候回收某个不再被引用的对象）。
    
12. 静态方法不能直接访问非静态成员。当调用静态方法时，不存在该方法能够操作的特定对象，所以也没有this引用。我们可以将一个显式的对象引用作为引元传给静态方法来达到访问非静态成员的目的（但通常没有这么做的）。
    
13. 长度为0的是空数组（empty array）。将数据组作为引元的方法可能会要求它们所接受的数组是非空的，所以需要对数组的长度进行检查。在检查数组长度之前，需要确保数组引用不是null。这两项栓查中只要有一项失败，方法就可以通过抛出IllegalArgumentException异常来报告问题。如下面这个函数：
    
         public   void  function(String[] values)  ... {
        if (values == null || values.length == 0) ...{
            throw new IllegalArgumentException();
        } else
            ... ...
        }
    
    
14. String对象是只读的或不可变的，即String的内容从不改变。如下，在下面的语句中：
    
    str  =   " redwood " ;
    //  ... do something with str ..
    str  =   " str " ;
    第二条赋值语句将一个新的值赋给了变量str，这个值是加一个内容为“oak”字符串对象的引用。每当我们执行那些看似会改变String对象的操作时，实际上是获得了新的只读的String对象。
    如果我们使用==来比较字符串对象，那实际上是在判断两个字符串是否指向同一个对象，而不是在比较它们的内容是否相同。故应用equals方法进行字符串内容的比较。
    
15. 调用超类的方法：调用super.clear()看起来是在调用超类去执行clear方法，但实际上调用的是超类Point的对象。当我们调用super.method()时，运行时系统会自下而上地在继承层次结构中查找第一个拥有method方法的超类。对于所有其他的引用，方法调用使用的是对象的实际类，而不是对象引用的类型。
    
16. Object类：没有显式扩展任何其他类的类其帝都隐式地扩展自Object类。所有的对象都是类Object的多态形式，所以Object是所有类的对象引用的通用类型。
    
17. 接口
    一个类可以实现我们所选择的多个接口。
    接口也可以声明static和final的具名常量。另外，接口还可以声明其他的嵌套接口和类（以后学习）。
    类的超类型（supertype）是指该类扩展的类以及实现的接口，包括这些类和接口的所有超类型。
    类的子类型（subtype）是指扩展自该类的类，包括这些类的所有子类型。
    
18. 参数和异类收集
    具有共同点的类的收集被称作同类收集，如：数组；
    具有不同对象的收集叫做异类收集，如：从各种其它类继承的类的收集。
    Java编程语言有一个对象类（Object），由于多态性，它能收集所有种类的元素，正如所有镭都扩展类对象一样。这种收集被称作异类收集。
    在面向对象语言中，可以创建许多东西的收集。所有的都有一个共同的祖先类--Object类。如：
    
     
    异类收集就是不相似的东西的收集。在面向对象语言中，可以创建许多东西的收集。所有的都有一个共同的祖先类 -Object 类。如：
    
    

    Employee [] staff  =   new  Employee[ 1024 ];
    staff[ 0 ]  =   new  Manager();
    staff[ 1 ]  =   new  Employee();

    
    注：每个类都是Object的一个子类，因此，可以用Object数组作为任何对象的容器。唯一不能被增加到Object数组中的东西就是基本变量（以及包装类）。比Object数组更好的是向量类，它是设计来贮存异类收集对象的。
    
19. 构造函数不能被继承
    -- 子类丛超类（父类）继承所有方法和属性
    -- 子类不从超类继承构造函数
    -- 包含构造函数的两个办法是： 使用缺省构造函数；写一个或多个显式构造函数
    
20. instanceof运算符
    例子：a  instanceof  A
    找到a最底层的类别，比如说C有好多子类，子类还有子类，所以首先要判断a具体是哪个类的对象，从这个类以及往上的parent类都会返回true.否则返回false。
    如：
    

    public   class  Employee  extends  Object
    public   class  Manager  extends  Employee
    public   class  Contractor  extends  Employee
    
    Employee e1  =   new  Employee();
    Manager  e2  =   new  Manager ();
    Contractor  e3  =   new  Contractor ();
    Employee  e4  =   new  Contractor();
    
    e2  instanceof  Manager  =  ture
    e2  instanceof  Employee  =   true
    e2  instanceof  Contractor  =   false
    
    注：
    e4  instanceof  Contractor  =   true

    
    
21. 对象的类型转换
    要对对象类型进行强制类型转换，必须先使用instanceof来测试一个对象的类型。否则很可能在运行时抛出异常，从而导致程序异常终止。
    
22. 覆盖方法
    先看例子：
    

    public   class  Employee {
        String name;
    
         int  salary;
    
         public  String getDetails() {
             return   "  Name:  "   +  name  +   "     "   +   " Salary:  "   +  salary;
        }
    }

    
    

    public   class  Manager  extends  Employee {
        String department;
    
         public  String getDetails() {
             return   "  Name:  "   +  name  +   "     "   +   "  Manager of  "   +  department;
        }
    }

    　
    Employee e = new Manager ( );
    e.getDetails( );
    
    或某些相似效果，比如一个通用方法参数或一个来自异类集合的项。
    事实上，e.getDetails( ); 调用的是他的真实类型（Manager类）中的方法。
    结论：在这种情况下，得到的是与变量运行是类型（即，变量所引用的对象的类型）相关的行为，而不是与变量的编译是类型相关的行为。这是面向对象语言的一个重要特征。它也是多态性的一个特征，并通常被称作虚拟方法调用。