Java面向对象

作者：丁明祥 邮箱：2780087178@qq.com

说起来这篇文章还没有写完的，不过前后已经浪费了很多时间写了删删了写，如果再不发出来就永远不能开始干下一件事了。

0.编码风格

1.面向对象导论

《java编程思想》第1章

OO-思想，OO-设计，OO-编码

这一部分等我有了软件架构的思想之后再写，在没有足够项目经验的条件下写这些东西没有意义。

2.操作符和流程控制

《java编程思想》第3,4章

这一部分完全不写，所有的编程语言都涉及的，没有必要学习。

3.类和对象

《java编程思想》第2,5,6,7章

• 面向对象的主要特点是（抽象），封装，继承，多态。（所有初级面试都喜欢问）

1.用引用操作对象

Java中定义的变量除了基本类型变量以外，其他都是引用类型的变量。

用下面这个例子分清楚什么是引用，什么是对象。

String s = "aaa",String s = new String("aaa")

2.存储到什么地方

• 寄存器，这个东西在C/C++中更容易说明，他们直接跑在机器(Register Machine)硬件上，可以直接使用通用寄存器存储数据，因为Java虚拟机是栈机器(Stack Machine)，没有寄存器，所以不详细介绍。
• 栈，用堆栈指针移动来分配和释放内存。Java中的引用变量放在其中。
• 堆，用于存放对象
• 常量，java中的常量放在ROM中
• 非RAM存储，一些数据（比如流，持久化对象）直接存放在媒介之上。

3.基本类型变量而非引用变量

• 这里引出两个概念：装箱和拆箱
• 了解一下：高精度计算类：BigInteger和BigDecimal

Java是面向对象的语言，然而有一类数据类型直接存储值在栈中，称作基本数据类型，定义这些类型的变量不是引用对象，然而Java还是提供了对应的包装器类。基本类型和包装器类型直接相互转换称为装箱与拆箱。

基本类型：boolean,char,byte,short,int,long,float,double,void

包装器类型：Boolean,Character,Byte,Short,Integer,Long,Float,Double,Void

4.Java中的数组

Java中的数组是安全的：

1. 保证被初始化
2. 检查数组越界

创建数组对象实际是创建引用数组，例如String []a;a会直接被初始化为null。

5.垃圾回收

这一部分很有意思，但是我现在还没怎么搞明白，以后再写

参考资料:《深入理解Java虚拟机》

1.Java对象作用域

{
  String s = new String("aaa")
}

一个面试题：引用变量s和String对象"aaa"生命周期是一样的吗？

2.Java不使用析构函数回收内存，因为它没有析构函数概念。Java是自动垃圾回收的，虽然有三种方式可以通知垃圾回收器回收对象，但一般不推荐使用。

1. finalize( )只是通知JVM的垃圾收集器当前的对象不再使用可以被回收了，但是垃圾回收器根据内存使用状况来决定是否回收。

finalize()最有用的地方是在JNI调用本地方法时(C/C++方法)，调用本地方法的析构函数消耗对象释放函数。

1. ** System.gc()**是强制析构，显式通知垃圾回收器释放内存，但是垃圾回收器也不一定会立即执行，垃圾回收器根据当前内存使用状况和对象的生命周期自行决定是否回收。
2. RunTime.getRunTime().gc()和System.gc()类似。

3.垃圾回收算法原理

(1).引用计数(ReferenceCounting)垃圾回收算法：

一种简单但是速度较慢的垃圾回收算法，每个对象拥有一个引用计数器(Reference Counter)，当每次引用附加到这个对象时，对象的引用计数器加1。当每次引用超出作用范围或者被设置为null时，对象的引用计数器减1。垃圾回收器遍历整个对象列表，当发现一个对象的引用计数器为0时，将该对象移出内存释放。

引用计数算法的缺点是，当对象环状相互引用时，对象的引用计数器总不为0，要想回收这些对象需要额外的处理。

引用计数算法只是用来解释垃圾回收器的工作原理，没有JVM使用它实现垃圾回收器。

引用计数的改进算法：

任何存活的对象必须被在静态存储区或者栈(Stack)中的引用所引用，因此当遍历全部静态存储区或栈中的引用时，即可以确定所有存活的对象。每当遍历一个引用时，检查该引用所指向的对象，同时检查该对象上的所有引用，没有引用指向的对象和相互自引用的对象将被垃圾回收器回收。

(2).暂停复制(stop-and-copy)算法：

垃圾回收器的收集机制基于：任何一个存活的对象必须要被一个存储在栈或者静态存储区的引用所引用。

暂停复制的算法是：程序在运行过程中首先暂停执行，把每个存活的对象从一个堆复制到另一个堆中，已经不再被使用的对象被回收而不再复制。

暂停复制算法有两个问题：

a.必须要同时维护分离的两个堆，需要程序运行所需两倍的内存空间。JVM的解决办法是在内存块中分配堆空间，复制时简单地从一个内存块复制到另一个内存块。

b.第二个问题是复制过程的本身处理，当程序运行稳定以后，只会产生很少的垃圾对象需要回收，如果垃圾回收器还是频繁地复制存活对象是非常低性能的。JVM的解决方法是使用一种新的垃圾回收算法——标记清除(mark-and-sweep)。

一般来说标记清除算法在正常的使用场景中速度比较慢，但是当程序只产生很少的垃圾对象需要回收时，该算法就非常的高效。

(3).标记清除(mark-and-sweep)算法：

和暂停复制的逻辑类似，标记清除算法从栈和静态存储区开始追踪所有引用寻找存活的对象，当每次找到一个存活的对象时，对象被设置一个标记并且不被回收，当标记过程完成后，清除不用的死对象，释放内存空间。

标记清除算法不需要复制对象，所有的标记和清除工作在一个内存堆中完成。

注意：SUN的文档中说JVM的垃圾回收器是一个后台运行的低优先级进程，但是在早期版本的JVM中并不是这样实现的，当内存不够用时，垃圾回收器先暂停程序运行，然后进行垃圾回收。

(4).分代复制(generation-copy)算法：

一种对暂停复制算法的改进，JVM分配内存是按块分配的，当创建一个大对象时，需要占用一块内存空间，严格的暂停复制算法在释放老内存堆之前要求把每个存活的对象从源堆拷贝到新堆，这样做非常的消耗内存。

通过内存堆，垃圾回收器可以将对象拷贝到回收对象的内存堆中，每个内存块拥有一个世代计数(generation count)用于标记对象是否存活。每个内存块通过对象被引用获得世代计数，一般情况下只有当最老的内存块被回收时才会创建新的内存块，这主要用于处理大量的短存活周期临时对象回收问题。一次完整的清理过程中，内存块中的大对象不会被复制，只是根据引用重新获得世代计数。

JVM监控垃圾回收器的效率，当发现所有的对象都是长时间存活时，JVM将垃圾回收器的收集算法调整为标记清除，当内存堆变得零散碎片时，JVM又重新将垃圾回收器的算法切换会暂停复制，这就是JVM的自适应分代暂停复制标记清除垃圾回收算法的思想。

6.类型转换

Java中有两种常见的类型转换：向上类型转换(upcast)和向下类型转换(downcast)：

1. upcast：

   向上类型转换是将子类对象强制类型转换为父类类型，经典用法是面向对象的多态特性。向上类型转换时，子类对象的特性将不可见，只有子类从父类继承的特性仍然保持可见，向上类型转换时编译器会自动检查是否类型兼容，通常是安全的。

2. downcast:

   向下类型转换是将父类类型强制转换为子类类型，转换过后父类中不可见的子类特性又恢复可见性，向下类型转换时，编译器无法自动检测是否类型兼容，往往会产生类型转换错误的运行时异常，通常不安全。

7.class类型

字段：成员数据

方法：成员函数

访问控制权限：

public:公共访问控制权限，既可以用来修饰类成员（字段和方法）的访问权限又可以修饰类的访问权限

protected:继承访问控制权限，只能用来修饰类的成员，不能用于修饰类（事实上也可以用于修饰内部类，以后再介绍吧）

private:内部访问控制权限，只能用来修饰类的成员，不能用于修饰类（事实上也可以用于修饰内部类，以后再介绍吧）

[default] :default包内访问控制权限，default就是指没有访问权限修饰符。如果是默认权限则在包内可以访问。

嵌套类：在一个类或者接口中声明一个类，类有两种形式，静态的和非静态的，非静态的称为内部类

内部类：非静态的嵌套类

static关键字：用于修饰类中的字段和方法。（这个东西感觉没有那么容易说清楚，以后对比C++和Java讨论这个话题）

final关键字：

继承：表达 is - a关系

组合：表达have-a关系，且关系紧密

聚合：表达have-a关系，且关系松散

委派：

以后介绍UML与设计模式的时候再探讨这个话题

1.Java中的方法：

构造函数：当程序员不写构造函数时，Java编译器会自动生成默认构造器，如果程序员写了一个构造器，则编译器不会再生成了。

函数重载：函数重载是通过名字改编实现（name-magling），同一个函数名接受不同类型参数和不同个数的参数，注意不能以返回值重载函数。

2.两个神奇的关键字:final和static

2.1.final

final的三种情况：数据，方法，类

final变量：不允许修改

final方法：不允许该方法被覆盖

final类：明确该类不会被继承

2.2static

3.Java中类的初始化顺序

1. 在一个类中，初始化顺序由变量在类中的声明定义顺序决定，成员变量(非set方法和构造方法的初始化)的初始化发生在方法调用之前，包括构造方法。
2. 静态变量在整个存储区只保留一份拷贝，本地变量不能使用静态关键字，基本类型的静态变量不需要初始化，它会根据类型获得初始化值，引用类型的静态变量默认初始化为null。
3. 静态初始化块和静态变量类似的执行也在构造方法之前，并且仅执行一次。
4. 动态初始化块(与静态初始化块类似，只是没有static关键字，即放在一对大括号中的代码块)在静态初始化块初始化结束后执行，动态初始化块每次创建新对象都会初始化一次。
5. 构造方法执行时，先执行父类的构造方法，后执行子类的构造方法。
6. 本地变量初始化最晚，在方法中初始化。

初始化顺序：

a.父类的静态变量/静态初始化块;

b.子类类的静态变量/静态初始化块;

c.父类的动态初始化块、非构造方法和set方法的成员变量初始化

d.子类的动态初始化块、非构造方法和set方法的成员变量初始化

e.父类的构造方法。

f.子类的构造方法。

g.父类本地变量。

h.子类的本地变量。

4.代码重用

4.多态，抽象类和接口，内部类

《java编程思想》第8,9,10章

《Java与Android开发学习指南》第11章

1.多态：

在面向对象编程中，子类覆盖父类方法，当调用子类方法的某个操作时，不必明确知道子类的具体类型，只需要将子类类型看作是父类的引用调用其操作方法，在运行时，JVM会根据引用对象的具体子类类型而调用应该的方法，这就是多态。

多态的三个条件：

一、要有继承；
二、要有重写；
三、父类引用指向子类对象。

满足条件之一则A a = new B();合法：

1）A是类，B继承A

2）A是接口，B实现A

这种方式叫做向上类型转换，

如果B的方法没有在A中实现，则不能用a调用B该方法，

如果A的方法在B中被覆盖了，用a调用该方法实际调用的是B的方法，因为从运行时来看，a引用对象的实际类型是B类类型。

多态的主要实现原理是动态绑定，也即是java中的绑定是发生在运行时而不是编译时。

static方法和final方法特别需要注意，因为static方法是与类相关联而不是和对象关联，所以不可能实现多态，final方法不能够被重写，所以也不可能实现多态。

多态的原理：

1. JVM中的方法表：以数组的形式记录当前类及其所有父类的可见方法字节码在内存中的直接地址。
2. 动态绑定原理：
   1. 首先会找到被调用方法所属类的全限定名
   2. 在此类的方法表中寻找被调用方法，如果找到，会将方法表中此方法的索引项记录到常量池中（这个过程叫常量池解析），如果没有，编译失败。
   3. 根据具体实例化的对象找到方法区中此对象的方法表，再找到方法表中的被调用方法，最后通过直接地址找到字节码所在的内存空间。

2.从抽象方法到抽象类：

抽象方法：用abstract修饰的不提供实现（没有方法体）的方法，abstract void function();

抽象类是用abstract修饰指包含抽象方法的类（其实抽象类不一定要有抽象方法，但是含有抽象方法的类一定是抽象类），抽象类的一个主要特点是不能实例化。

继承抽象类的时候必须实现所有的抽象方法，如果没有实现则子类也是抽象类。

3.特殊的抽象类——接口

用interface修饰的一种高级抽象。

把接口称为特殊的抽象类是因为接口提供的所有方法都是抽象方法（不用显示声明）。

• 一个类可以实现任意多个接口，但最多只能作为一个抽象类的子类。
• 一个抽象类可以有若干个抽象方法（但到少要有一个），而接口的所有方法都是抽象的，无论是否将它的方法显示地声明为抽象的。
• 一个抽象类可以声明实例变量，其子类可以继承这些实例变量。而一个接口不能声明实例变量，不过接口可以声明static final修饰域。
• 抽象类可以有构造方法，而接口不能。
• 抽象类的可见性修饰符可以是public、protected、private或无修饰符（表示包内可见）；而接口的可见性修饰符只能是 public，或无修饰符（包内可见）。
• 抽象类的方法的可见性修饰符可是以protected、private，或无（表示包内可见）；而一个接口的方法的可见性修饰符只能是 public。
• 抽象类是从object类派生而来，它继承了object的clone()和equals()方法。

4.内部类

Java允许用户将一个类定义在另一个类的内部，并控制其对其他类的可见性。

1.使用内部类

public class Outter{  
    class inner{  
    }  
}  
Outter out = new Outter();  
Outter.Inner inner = out.new Inner();  

warnning：非静态的内部类必须要有外部类对象之后才能创建，因为外部类对象持有内部类的引用，如果内部类是静态的，则不需要外部类对象引用内部类对象。

2.内部类对外部类对象的引用

外部类中所有的元素对内部类都是可见的，内部类持有对外部类对象引用的语法：外部类名称.this。

3.内部类除了定义在类中还可以定义在某个作用域范围内（比如常在某个函数中使用匿名内部类）

{
  
}

4.静态内部类（嵌套类）

区别

(1).对于非静态的内部类来说，内部类和外部类必须保持对象引用，内部类可以访问外部类的任何元素.

(2).静态内部类不需要和外部类保持对象引用，静态内部类只能访问外部类的静态元素。

5.为什么使用内部类

1. 解决多重继承问题
2. 闭包问题

6.枚举

《java编程思想》第19章

enum可以将一组值创建为一种新的类型，而这些值可以作为常规程序组件使用。

public enum Alpha{A,B,C}
public class HelloWorld{
  public static void main(String[]args){
    Alpha a = Alpha.A;
  }
}

enum中的一些有用的方法：

toString()
ordinal()
values()

enum的一个绝佳应用是在switch中作为选项。

创建enum时，编译器会自动生成一个相关类，继承自java.lang.Enum，Enum类实现了Comparable接口和Serializable接口。

enum不能被继承，但是可以有常规的方法。

转载于:https://www.cnblogs.com/mypl-dmx/p/7152689.html