学习笔记

1. 抽象类与接口

         抽象类：

l  不能创建基类对象，只能向上转型(Upcasting)

l  基类只提供未实现的接口函数，继承基类的类，必须全部实现基类中的函数，否则该类也会变成抽象类

l 抽象方法只能在抽象类中

         接口：

l  禁止任何函数定义

l  实现接口与代码完美分割

l  实现多继承

 

2. equals()方法：默认行为是对引用进行比较。但大多数java类库，实现对equals()的重写，实现对对象内容比较

 

4. this

i. 调用本类的另一个构造函数，必须放在第一句，且只能放一个

Constructor call must be the first statement in a constructor

    public Flower(int petals, String ss) {

        this(petals);

        this(s);

    }

ii. 表当前对象，普通方法的形参名与类属性名一样，this指示当前对象。

 

5. 数组

int[] a1 = {1, 2, 3, 4, 5};

int[] a2 = new int[]{1, 2, 3, 4, 5};

int[] a3 = new int[5];

 

数组深拷贝：

    publicstaticvoid main(String[] args) {

        int[] a = {1, 2, 3, 4, 5};

       

        int[] a1 = a.clone();

        print(a1);

       

        int[] a2 = newint[a.length];

        System.arraycopy(a, 0, a2, 0, a.length);

        print(a2);

       

        int[] a3 = Arrays.copyOf(a, a.length);

        print(a3);

       

        int[] a4 = Arrays.copyOfRange(a, 0, a.length);

        print(a4);

    }

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)；

 

6. final

1). final data: 编译时不变，运行时不变

         blank final, it must be initialized in every constructor

2). final parameter: 与final data一样，方法内部，不能改变参数引用指向的对象

3). final method: 防止子类override；efficiency, 允许编译器转换调用为inline call

4). final class: 拒绝inherited

 

 

7. static: static is modifier

1). static import (static import …)

         Single-static-import declaration: import static TypeName.Identifier

2). static initializer (static {})

         只在类初始化时执行一次(这里的初始化，一是指的是new Instance，二指的是调用main方法)

publicclass StaticBlock {

    privatestaticfinal String s = "hello";

   

    static {

        System.out.println("static block is running");

    }

   

    publicstaticvoid main(String[] args) {

        System.out.println(StaticBlock.s);

        new MyStatic();

        System.out.println(MyStatic.ss);

    }

}

 

class MyStatic {

    publicstaticfinal String ss = "hello world";

   

    static {

        System.out.println("my static block is running");

    }

}

3). static field (static type field)

         Static field: class variable。静态变量在内存中只有一个拷贝(节约内存)。JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问，也可通过对象来访问。

         Non-static fields: instance variable

4). static method (static type method())

         Same as above

         静态方法可以直接通过类名调用，任何实例也可以调用，因此静态方法中不能使用this和super关键字，不能直接访问所属类的实例变量和实例方法(即未被static修饰的属性和方法)

         因为静态方法独立于任何实例，因此静态方法必须被实现，不能是抽象的abstract

5). static member type (member class & member interface)

         JVM实现static机制：类变量作为类型信息的一部分存储在方法区(jvm放置类定义的内存结构)。JVM在使用类之前，必须在方法区中为这些类变量分配空间。类变量时所有类实例共享的，及时没有任何类实例，它也可以被访问。这些变量只与类有关。

         被static修饰的属性和方法独立于该类的任何对象。它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，JVM就能根据雷鸣在运行时数据区的方法区找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

 

8. 多态(Polymorphism)

多态性

多态性是指发出同样的消息（指对类成员函数的调用）被不同类型的对象接收时导致完全不同的行为。

多态的实现：

函数重载     静态：编译时的多态

运算符重载  静态：编译时的多态

虚函数        动态：运行时的多态

 

1). 方法调用的绑定：将一个方法调用同一个方法主体连接到一起就称为”绑定”(Binding)

         早期绑定：在程序运行前执行绑定，由编译器和链接程序完成。Java final方法使用该类型绑定。

后期(动态)绑定：绑定在运行时进行，以对象的类型为基础。Java中除了final方法外的所有方法均使用后期绑定

 

2). 抽象类和方法

         抽象方法：只有一个声明，没有方法主体。abstract void f();

         抽象类：包含一个或多个抽象方法的类，必须指定为抽象类。即使不包含任何abstract方法，亦可将一个类声明为抽象类，但该类无法被实例化(new)。

 

9. 设计构造函数的规则：

         用尽可能简单的方法是对象进入就绪状态；如果可能，避免调用任何方法。在构造函数内唯一能安全调用的是在基类中具有final熟悉的那些方法，也适用于private方法，它们自动具有final属性。

 

10. 接口(Interface)

1). 纯抽象类

2). 只有方法名、参数列表及返回类型，无方法主体。

3). 接口中原始数据类型的数据成员(即类属性)，默认为static和final

4). 接口中的方法声明明确定义为”public”，即使不明确定义，它们也会默认为public。

 

11. 匿名类(Anonymous Inner Class)

没有名字的内部类，不能继承其他类，但一个内部类可作为一个接口，由另一个内部类实现

1) 匿名内部类没有名字，所以它没有构造函数。因为它没有构造函数，所以它必须完成借用父类的构造函数来实例化，换言之，匿名内部类完全把创建对象的任务交给了父类去完成。

2) 在匿名内部类里创建新的方法没有太大意义，但它可以通过覆盖父类的方法达到神奇效果。

3) 因为匿名内部类没有名字，所以无法进行向下的强制类型转换，持有对一个匿名内部类对象的引用的变量类型一定时它的直接或间接父类类型

 

使用匿名内部类要注意的原则：

1) 不能有构造方法

2) 不能定义任何静态成员，方法和类

3) 不能是public, protected, private, static

4) 只能创建匿名内部类

5) 一个匿名内部类一定在new的后面，用其隐含实现一个接口或实现一个类

6) 因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效

7) 内部类只能访问外部类的静态变量或静态方法

 

12. 静态内部类(Static Nested Class)

不需要内部类对象与其外围类对象之间有联系，可以将该内部类声明为static

1) 嵌套类的对象，并不需要其他外围类的对象

2) 不能从嵌套类的对象中访问非静态的外围类对象