Java基础--Java编程思想笔记1

1 static关键字

static关键字可以满足一下两方面的需要：

1. 为某特定域分配单一存储空间，而不考虑创建多少对象
2. 不创建对象也能调用方法

注：static方法就是没有this的方法，在static内部不能调用非静态方法，反过来倒可以。

例如如下代码：

class StaticTest{
	static int i = 47;
}

StaticTest st1 = new StaticTest();
st1.i++;
StaticTest st2 = new StaticTest();
st2.i++;
StaticTest.i++;

以上代码中，st1和st2虽然创建了两个对象，但是两者共享一份存储空间。st1.i++执行后 i 的值是48,st2.i++执行后 i 的值是49。也可以直接通过类名访问静态成员，StaticTest.i++;执行后 i 的值是50。
当static作用于字段时，会改变数据创建的方式；当static作用于方法时，差别没那么大，其用法就是在不创建类的前提下就可以调用它。

2 javadoc

javadoc输出的是一个HTML文件，可以使用浏览器查看。
一些标签：

标签	说明
@see	引用其他类
{@link package.class#member label}	链接到某个特定的成员对应的文档中
{@docRoot}	产生到文档根目录的相对路径，用于文档树页面的显示超链接
{@inheritDoc}	从当前这个类的最直接的基类中继承相关文档到当前的文档注释中
@version	版本号
@author	作者
@since	程序代码最早使用版本
@param	方法入参数名及描述信息
@return	返回值
@throws	构造函数或方法所会抛出的异常
@deprecated	指出一些旧特性已由改进的新特性所取代，建议不在使用这些旧特性

1. windows下使用doc命令方式生成。

javadoc -d D:\tmp\java -encoding utf-8 -charset utf-8 CheckController.java

2. Idea 下生成javadoc文档

3. eclipse下j生成javadoc文档
project->Generate Javadoc

3 一元加、减操作符

一元减号用于转变数据的符号，而一元加号只是为了与一元减号相对应，但是它的作用是将较小类型的操作数提升为 int。

4 “短路”现象

一旦能够确定这个逻辑表达式的值，就不在计算表达式余下的部分了。因此，逻辑表达式靠后的部分可能不会被运算。

public class ShortCircuit{
	static boolean test1(int val){
		System.out.println("test1:"+(val<1));
		return val < 1;
	}
	static boolean test2(int val){
		System.out.println("test2:"+(val<1));
		return val < 2;
	}
	static boolean test3(int val){
		System.out.println("test3:"+(val<1));
		return val < 3;
	}
	public static void main(String[] args){
		boolean b = test1(0)&&test2(2)&&test3(2);
		System.out.println("result:"+b);
	}
}

执行结果：

test1:true
test2:false
result:false

5 数据类型提升

对基本数据类型执行算术运算或按位运算，只要类型比int小（char、byte、short），那么在运算之前，这些值会自动转换成int，最终生成的结果就是int类型。

6 窄化转换

数据类型强制转换为较小的数据类型，可能会丢失信息，即窄化转换。

7 运算符优先级

口诀：单目乘除为关系，逻辑三目后赋值。
摘自：http://lasombra.iteye.com/blog/991662
单目：! +(正) -(负) ++ –
乘除：* / %
加减：+ -
位：>> << >>>
关系：> < >= <= == !=
逻辑：& ^ | && ||
三目：A > B ? X : Y
赋值：= += -= *= /= %= &= |= ^= ~= <<= >>= >>>=

8 break和continue

示例代码：

    public static void main(String[] args) {
        out:
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (j==3) {
                    break out;
                }
//                if (j==3) {
//                    continue out;
//                }
//                if (j==3) {
//                    break;
//                }
//                if (j==3) {
//                    continue;
//                }
                System.out.println(i+","+j);
            }
        }
    }

0,0
0,1
0,2

continue：使执行点回到内部迭代起始处
continue out：同时中断内部迭代以及外部迭代，直接转到out处，随后继续从外部迭代开始
break:：中断内部迭代
break out：中断所有迭代回到out处，但不重新进入迭代

9 switch语句

switch语句的选择因子必须是 int 或 char，jdk1.5以后支持enum类型。

10 重载

方法的重载：方法名相同，参数列表的个数、类型、顺序不同，但是返回值不影响，可以相同也可以不同。

11 构造器中的this关键字

在构造器中可以用this关键字调用一个构造器，但却不能调用两个，并且this调用必须置于起始处，否则编译器会报错。

注：static方法就是没有this的方法，在static内部不能调用非静态方法，反过来倒可以。

12 finalize()方法

finalize()方法并不作为普通清理内存的方法。之所以有finalize()方法，是因为在内存分配时可能采用了类似C语言中的做法，在非Java代码中，也许会调用C的molloc()函数系列来分配存储空间，除非调用free()函数，否则存储空间得不到释放，从而造成内存泄露，所以需要在finalize()方法中用本地方法调用它。

13 垃圾回收器机制

三种工作方式：

1. 引用记数
2. 停止-复制
3. 标记-清除

引用记数
每个对象都含有一个引用记数器，当有引用连接至对象时，引用计数加1。当引用离开作用域或被置为null时，引用计数减1。虽然管理引用计数的开销不大，但在整个程序的生命周期中将持续发生。垃圾回收器会在含有全部对象的列表上遍历，当发现某个对象的引用计数为0时，就释放其占用的空间（引用计数模式经常会在记数值变为0时立即释放对象）。
这种方法有个缺陷，如果对象之间存在循环引用，可能会出现“对象应该被回收，但引用计数却不为零”的情况。对于垃圾回收器而言，定位这样的交互自引用的对象组所需的工作量极大。
停止-复制
思想依据：
对任何“活”的对象，一定能最终追溯其存活在堆栈或静态存储区之中的引用。这个引用链条可能会穿过数个对象层次。因此，如果从堆栈和静态存储区开始，遍历所有的引用，就能找到所有“活”对象。对于每个发现的引用，必须追踪它所引用的对象，然后是此对象包含的所有引用，如此反复进行，直到“根源于堆栈和静态存储区的引用”所形成的网全部被访问为止。你所访问过的对象必须都是“活”的。注意，这就解决了“交互自引用的对象组”的问题——这种现象根本不会被发现，因此也就被自动回收了。
停止-复制：
先暂停程序的运行（不属于后台回收模式），然后将所有存活的对象从当前堆复制到另一个堆，没有被复制的全部都是垃圾。当对象被复制到新堆时，它们是一个挨着一个的，所以新堆保持紧凑排列，然后就可以按前述方法简单、直接的分配空间了。
当把对象从一处搬到另一处时，所有指向它的那些引用都必须修正。位于堆或静态存储区的引用可以直接被修正，但可能还有其他指向这些对象的引用，它们在遍历的过程中，才能被找到（可以想象成有个表格，将旧地址映射至新地址）。
这种“复制式回收器”，效率会降低，这有两个原因：
第一，得有两个堆，然后得在这两个分离的堆之间来回倒腾，从而维护比实际需要多一倍的空间。某些Java虚拟机对此问题的处理方式是，按需从堆中分配几块较大的内存，复制动作发生在这些大块内存之间。
第二，复制。程序进入稳定状态后，可能只会产生少量的垃圾，甚至没有垃圾。尽管如此，复制式回收器仍然会将所有内存自一处复制到另一处，这很浪费。
为了避免这种情形，一些Java虚拟机会进行检查：要是没有新垃圾产生，就会转换到另一种工作模式（即“自适应”）。这种模式称为标记-清扫。
标记-清扫
“标记-清扫”所依据的思路同样是从堆栈和静态存储区出发，遍历所有的引用，进而找出所有存活的对象。每当它找到一个存活对象，就会给对象设一个标记，这个过程中不会回收任何对象。只有全部标记工作完成的时候，清理动作才会开始。在清理过程中，没有标记的对象将被释放，不会发生任何复制动作。所以剩下的堆空间是不连续的，垃圾回收器要是希望得到连续的空间，就得重新整理剩下的对象。

即时编译技术Just-In-Time（JIT）
Java虚拟机中有许多附加技术用以提升速度。尤其是与加载器操作相关的，称为即时编译技术（JIT）。
这种技术可以把程序全部或部分翻译成本地机器码（这本来是Java虚拟机的工作），程序运行速度因此提升。当需要装载某个类（通常是在为该类创建第一个对象）时，编译器会先找到其.class文件，然后将该类的字节码装入内存。此时，有两种方案选择。
一种是就让即时编译器编译所有代码。这种方法有两个缺陷：这种加载动作散落在整个程序生命周期内，累加起来要花更多时间；并且会增加可执行代码的长度（字节码要比即时编译器展开后的本地机器码小很多），这将导致页面调度，从而降低程序速度。
另一种做法称之为惰性评估，即时编译器只在必要的时候才编译代码。这样，从不会执行的代码也许就不会被JIT所编译。HotSpot就采用了类似的方法，代码每次被执行的时候都会做一些优化，所以执行的次数越多，它的速度就越快。

14 访问权限控制

类不可以是private的，也不可以是protected的，只能是包访问权限和public。
构造器可以修饰为private来阻止类创建对象。

15 组合与继承之间的选择

组合和继承都允许在新的类中放置子对象，组合是显示的这么做，而继承则是隐式地做。
组合技术通常用于想在新类中使用现有的类的功能而非它的接口这种情形。即，在新类中嵌入某个对象，让其实现所需要的功能，但新类的用户看到的只是为新类所定义的接口，而非所嵌入对象的接口。为取得此效果，需要在新类中嵌入一个现有类的private对象。

16 向上转型

由导出类转型成基类，在继承图上是向上移动的，因此成为向上转型。如果必须向上转型，则继承是必要的。

17 final关键字

使用final关键字可能出于两种原因：设计和效率。
final关键字可能用到的情况：数据、方法和类。
final数据
数据恒定不变：
1 编译时常量
2 运行时被初始化的值，不希望被改变
编译时常量
编译时执行计算式，减轻运行时的负担，常量必须是基本数据类型，定义时必须赋值
对于基本类型，final使数值恒定不变；而对于对象类型，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改变为指向另一个对象，对象其自身是可以被修改的。对于数组具有同样意义。
运行时常量
空白final：指被声明为final，但又未给定初值的域。无论什么情况，编译器都确保空白final在使用前必须被初始化。
final参数：Java允许在参数列表中以声明方式将参数指明为final。这意味着无法在方法中更改参数引用所指向的对象。
修饰基本类型时，主要用来向匿名内部类传递参数。
final方法
使用final方法有两个原因：

1. 方法锁定，以防任何继承类修改它的含义。（设计考虑）
2. 过去使用final方法，就是同意编译器将针对改方法的所有调用转为内嵌调用。（效率考虑）（现在已不再建议使用，优化工作交给JVM来做）

final类
类整体定义为final时，就表明该类不能被继承。

18 多态

Java 四大特性：抽象、封装、继承、多态。
抽象：把一类事物的共同特性给整理出来，封装成一个抽象类。所以抽象类并不能实例化一个对象
封装：把对象的属性和行为以某种关系整合到一个集合内，就叫做封装。
继承：将具有共同特征的属性和行为封装成父类，子类继承父类继承就获得了父类的所有属性和行为。
多态：建立在封装和继承之上，对同一消息做出不同响应。、
动态绑定
动态绑定也被称为后期绑定或运行时绑定，在运行时根据对象的类型进行绑定。
Java中，除了static和final之外，其他的所有方法都是动态绑定。
例如：Shape类有子类Circle, Rectangle, Square，Shape中有draw()方法，
当执行如下语句时

Shape shape = new Circle();
shape.draw();

shape调用的是Circle中的draw()方法，而不是Shape中的draw()方法，这就是动态绑定。
缺陷：基类中private方法即不可见也不可被重写和重载。
缺陷：域和静态方法

// 域
class Super{
    public int field = 0;
    public int getField(){
        return field;
    }
}

class Sub extends Super{
    public int field = 1;
    public int getField(){
        return field;
    }
    public int getSuperField(){
        return super.field;
    }
}
public class FieldAccess {
    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println("sup.field="+sup.field+", sup.getField()="+sup.getField());
        Sub sub = new Sub();
        System.out.println("sub.field="+sub.field+", sub.getField()="+sub.getField()+", sub.getSuperField()="+sub.getSuperField());

    }
}

输出结果：

sup.field=0, sup.getField()=1
sub.field=1, sub.getField()=1, sub.getSuperField()=0

当Sub对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的。Sub实际上包含两个称为field的域：它自己的和从Super处得到的。要得到Super的，必须显示指明super.field。

// 静态方法
class StaticSuper{
    public static String staticGet(){
        return "Base staticGet()";
    }
    public String dynamicGet(){
        return "Base dynamicGet()";
    }
}
class StaticSub extends StaticSuper{
    public static String staticGet(){
        return "Derived staticGet()";
    }
    public String dynamicGet(){
        return "Derived dynamicGet()";
    }
}
public class StaticPolymorphism {
    public static void main(String[] args) {
        StaticSuper sup = new StaticSub();
        System.out.println(sup.staticGet());
        System.out.println(sup.dynamicGet());
    }

}

输出结果

Base staticGet()
Derived dynamicGet()

静态方法与类相关联，而非与单个对象相关联。

19 构造器和多态

构造方法的调用顺序
基类构造器总是在导出类的构造过程中被调用，而且按照继承层次逐渐向上链接，以使每个基类的构造器都能得到调用。
构造器有一项特殊任务：检查对象是否被正确地构造。
导出类只能访问它自己的成员，不能访问基类的成员（通常是private类型）。
构造器内部多态方法的行为

class Glyph{
    void draw(){
        System.out.println("Glyph.draw()");
    }
    Glyph(){
        System.out.println("Glyph() before draw()");
        draw();
        System.out.println("Glyph() after draw()");
    }
}
class RoundGlyph extends Glyph{
    private int radius = 1;
    RoundGlyph(int r){
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph().radius="+radius);
    }
    void draw(){
        System.out.println("RoundGlyph().draw().radius="+radius);
    }
}
public class PolyConstuctors {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}

输出结果

Glyph() before draw()
RoundGlyph().draw().radius=0
Glyph() after draw()
RoundGlyph.RoundGlyph().radius=5

Glyph.draw()方法设计为将要被覆盖，这种覆盖是在RoundGlyph中发生的。但是Glyph构造器会调用这个方法，结果导致了对RoundGlyph.draw()的调用。但是输出结果，Glyph的构造器调用draw()方法时，radius不是默认初始值1，而是0。
这是因为初始化的实际过程：
1）在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制的零。
2）按照层次调用基类构造器。此时调用被覆盖后的draw()方法，由于步骤1的缘故，此时radius的值为0.
3）按照声明的顺序调用成员的初始化方法。
4）调用导出类的构造器主体。
因此编写构造器应该遵循的准则：用尽可能简单的方法使对象进入正常状态，如果可以的话，避免调用其他方法。

20 协变返回类型

JavaSE5添加了协变返回类型，表示在导出类(子类)中的被覆盖方法可以返回基类方法的返回类型的某种导出类型。

class Grain{
    public String toString(){
        return "Grain";
    }
}
class Wheat extends Grain{
    public String toString(){
        return "Wheat";
    }
}
class Mill{
    Grain process(){
        return new Grain();
    }
}
class WheatMill extends Mill{
    Wheat process(){
        return new Wheat();	//返回Grain类型的子类
    }
}
public class CovariantReturn {
    public static void main(String[] args) {
        Mill m = new Mill();
        Grain g = m.process();
        System.out.println(g);
        m = new WheatMill();
        g = m.process();
        System.out.println(g);
    }
}

输出结果

Grain
Wheat

21 接口

接口支持多继承。注意，在组合不同的接口的时候，尽量避免使用相同的方法名，这会造成代码可读性的混乱。
接口最吸引人的地方就是一个接口具有多个不同的具体实现。
接口的一种常用方法就是策略设计模式。
接口中的域
放入接口中的任何域都自动是static和final的。所以，接口也成为创建常来常量组的工具。JavaSE5之后，可以使用enum类型来创建了。
嵌套接口
接口可以嵌套如下：

public interface A {
    void aMethod();
    interface B{
        void bMethod();
        interface C{
            void cMethod();
        }
    }
}

接口与工厂
接口是实现多重继承的途径，而生成遵循某个接口的对象的典型方式就是工厂方法设计模式。

public interface Service {
    void method();
}
public class ServiceImp implements Service {
    @Override
    public void method() {
        System.out.println("implements Service");
    }
}
public interface ServiceFactory {
    Service getService();
}
public class ServiceFactoryImp implements ServiceFactory {
    @Override
    public Service getService() {
        return new ServiceImp();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        ServiceFactory factory = new ServiceFactoryImp();
        Service service = factory.getService();
        service.method();
    }
}