Android_Log_2_面向对象要点摘录

1．构造方法：

  如果类中不写构造方法，编译器会默认添加构造方法，内部只有一句super();

   Class A {

     public A(){

       super()

     }

    }

2. this是实例内部的一个特殊引用，保存当前实例的内存地址

  方便构造方法之间的相互调用，通常在参数少的构造方法中调用参数多的构造方法

  this() 必须是构造方法中的首行代码

    public A() {

      this(0);

        …

}

3. 方法重载 Overload。同名不同参。简化对外接口。

  public String getPrice(id);

  public string getPrice(name)

4. 访问控制符

使用原则：尽量使用private

Public是与其他开发者的一个契约，公共的成员会保持稳定不变。

5. 继承

  目的：代码重用，只允许继承一个父类

  继承：有访问权限的成员

  不继承：不可见的成员、构造方法、静态成员

创建子类实例执行顺序

  1、先创建父类实例

  2、再创建子类实例

  3、两个子类实例绑定在一起作为子类实例

构造方法执行顺序

  1、先执行父类构造方法

  2、再执行子类构造方法

  3、默认会执行父类的无参构造方法super()

如果父类不存在无参构造方法，子类中必须手动调用父类有参构造方法。

6.  Super：

1、子类中调用父类的构造方法：Super()

2、但必须是构造方法的首行代码

3、重写方法时，可以调用父类中的同一个方法。

4、Super.funcName();

7. 重写Override

用途：从父类继承的方法，不满足子类需要时，在子类中重新编写这个方法。

重写的规则：

  1、  方法签名(返回类型、方法名、参数列表)必须一致

  2、  访问范围不能变小

  3、不能抛出更多的异常

8. 多态：

作用：以一致的类型来处理多种子类型实例

1、向上转型：子类实例转为父类类型

Shape s = new Line();

2、向上转型，子类中特有成员被因擦，只能调用父类中的通用成员。

3、向下转型，必须强制转型

4、被转为父类类型的子类实例，可以还原为原始类型

Line line = (Line) s;

5、运行期类型识别

instanceOf，对子类型和父类型都会返回true。

9. 抽象类：abstract

1、作用：

1).为子类提供通用代码

2).为子类定义通用的API

2、半成品类，不能创建实例

3、包含抽象方法的类，必须是抽象类

4、抽象类不一定有抽象方法（不解）

10.  final：

1、可以用来修饰变量、方法、类

2、常量的定义通常同时使用final、static一起使用

3、译期优化或运行期优化

       final byte a = 2;

       final byte b = 3;

       byte c= a + b;

     编译期优化为：byte c= 5;

4、final方法：不能被子类重写

5、final类：没有子类，不能被继承

11.  Static

1、静态属性

2、属于类，而不属于实例

3、调用时，通常使用类名调用

4、能不用，尽量不用

5、属于非面向对象语法（基本数据类型也是）

6、共享的数据Math.PI

7、工具类方法：Math.sqrt();

8、静态初始化块：

Static {

      ….

}

第一次使用到其所在类的时候，会自动执行，并且只执行这一次。

12.  接口

1、作用：结构设计工具，用来解耦合

2、极端的抽象类

3、只能定义

    1)、抽象方法

    2)、常量

    3)、内部类，内部接口

4、所有的成员都是公共的

5、可以同时继承多个接口

6、接口之间可继承interface A extends B,C,D

13.  内部类

  * 定义在类内部或局部代码块中的类

  * 非静态内部类

       *) 属于实例，要用外部类实例来创建

       *) 不能定义静态成员

       class A {

           class Inner {

           }

       }

       A a = new A();

        A.Inner b = a.new Inner();

       A.Inner b = new A().new Inner();

  * 静态内部类

       class A {

           static class Inner {

           }

       }

        A.Inner a = new A.Inner();

  * 局部内部类

       *) 局部内部类，使用外面的局部变量必须加 final

       class A {

           void a(final int i) {

                final int j=10;

                class Inner {

                  void a() {

                    i+j

                  }

                }

                Inner a = new Inner();

           }

       }

  * 匿名内部类

          Super s = new Super(){};

  * 为什么使用内部类

   *) 基于个人设计理念

   *) 两个类型关系紧密

   *) 完全隐藏类型