JAVA学习系列（一）

JAVA学习系列（一）


此系列JAVA学习内容来自于网上搜索到的文章，经过自已消化后需要记录下来用备自已查证的东西，
并非系统的从最简单的一级级学习而来，并接合自已接触到的项目代码相参考验证，所以跳跃性比较大。


一 基本数据类型：
1、基本类型的存储空间。byte--8位，short--16位，int--32位，long--64位，float--32位，
   double--64位。这六种数字类型都是有符号的。固定的存储空间正是Java可移植性、跨平台的原因之一！
2、char是16位Unicode字符或者说是16位无符号整数，范围从0到65535。
3、提升。各种基本数据类型进行混合运算，结果会是表达能力最强的那种。如：int和long运算，
   结果是long，整型和浮点型运算结果是浮点型。特殊的一点是：只要类型比int小（如char、byte、short），
   那么在运算之前，这些值会自动地转换成int。
4、String类型,String中的每个字符都是一个16位的Unicode字符，用Unicode很容易表达丰富的国际化字符集，比如很好的中文支持。
a、判断空字符串，使用s==null或者s.length()==0
b、toString()方法：Java的任何对象都有toString()方法，是从Object对象继承而来的。它的作用就是让对象在输出时看起来更有意义，而不是奇怪的对象的内存地址。对测试也是很有帮助的。
c、String对象是不变的！可以变化的是String对象的引用。对于大量字符串操作，要求性能时请使用StringBuffer类（线程安全），否则可以使用StringBuilder类，其字符串操作的效率更高，但线程安全无法保证，不保证同步。
d、字符串的比较：请使用equals()，千万别使用"=="比较引用而非内容
 


二 异常处理：
软件开发中一个古老的说法是：80%的工作使用20%的时间。80%是指检查和处理错误所付出的努力。
在许多语言中，编写检查和处理错误的程序代码很乏味，并使应用程序代码变得冗长。原因之一
就是它们的错误处理方式不是语言的一部分。尽管如此，错误检测和处理仍然是任何健壮应用程序
最重要的组成部分。


1、抛出异常。
所有的标准异常类都有两个构造器：一个是缺省构造器，一个是带参数的构造器，以便把相关信息放入异常对象中。
throw new NullPointerException();
  throw new NullPointerException("t = null");
2、如果有一个或者多个catch块，则它们必须紧跟在try块之后，而且这些catch块必须互相紧跟着，不能有其他任何代码。
3、无论是否抛出异常，finally块封装的代码总能够在try块之后的某点执行。
try {
       return ;    
}
finally{
   System.out.print("You can't jump out of my hand!"); 
}


甚至你在try块内用return语句想跳过去都不可以！finally内的输出语句还是执行了！别想逃出我的手掌心！
这个特性可以用于释放资源的情况下，避免出现内存溢出或文件未关闭之现象
4、调用栈
   调用栈是程序执行以访问当前方法的方法链。被调用的最后一个方法在栈的顶部，它将被最先执行
   完毕，然后弹出；第一个调用方法位于底部，也就是main函数。在catch子句中使用printStackTrace()
   方法打调用栈信息是比较常用的定位异常的方法。printStackTrace()继承自Throwable。方便用于调试
5、异常的传播。在一个方法A中，如果一个异常没有得到处理，它就会被自动抛到调用A方法的B方法中。
   如果B方法也没有处理这个异常，他就会被继续依次向上抛，直到main方法。如果main也没有理会它，
   那么异常将导致JVM停止，程序就中止了。


三 访问权限修饰符：
1、package:包访问权限，在同一包中的类可以访问; 
2、Public :接口访问权限，任何类都可以访问; 
3、Private:你无法访问，除了包含该成员的类，其他类都可以访问。 
4、Protected:继承访问权限，包括包访问权限。在同一包中，还有就是子类可以访问。


四 介绍几个常用的关键字：
1、final: “这是无法改变的”或者“终态的”含义,修饰非抽象类、非抽象类成员方法和变量
final类不能被继承，没有子类，final类中的方法默认是final的。 
在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
    
final方法不能被子类的方法覆盖，但可以被继承。 
第一、把方法锁定，防止任何继承类修改它的意义和实现。 
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

2、static:表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块
不依赖类特定的实例，被类的所有实例共享,static对象可以在它的任何对象创建之前访问，无需引用任何对象

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为： 
类名.静态方法名(参数列表...) 
类名.静态变量名 


用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块,单例中经常使用

static变量:
被static修饰的变量，叫静态变量或类变量:JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问
没有被static修饰的变量，叫实例变量：创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

static静态方法：
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法

static代码块：
类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

最重要的一个函数：static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。 

static和final一块用表示什么：static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 
对于方法，表示不可覆盖，并且可以通过类名直接访问。

private static final表示什么：
private是访问权限限定,不能在其他类中通过类名来直接引用,其它的与上面相同


3、super & this 
this通常指当前对象，super则指父类的对象或方法
最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参,也可以使用"this.方法名"来引用当前对象的某个方法。
 
super可以调用父类的方法在子类中使用，或者在子类构造函数中调用super(参数)使用 

4、synchronized
a、synchronized当作函数修饰符时，即public synchronized void method(){...}
锁定的是调用这个同步方法对象,即对象p1在不同的线程中调用这个方法时，会形成互斥，但是
对象p2可以任意调用这个方法而不受p1限定。
public synchronized void method(){...}等同于：
public void method()
    　{
　   　synchronized (this)      //  (1)
　　   {
　　       //…..
　　   }
　    }
b、同步块：
public void method(someobject so) {
　　synchronized(so)
　　{
       //…..
　　}
　}

锁就是so这个对象，谁拿到这个锁谁就能够运行他所控制的那段代码，如果没有明确的对象作为锁，可以定义一个特别的instance变量充当锁。

private byte[] lock = new byte[0];  // 特别的instance变量

注：零长度的byte数组对象创建起来将比任何对象都经济,查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而object lock = new object()则需要7行操作码。

C、将synchronized作用于static 函数

class foo{

　　public synchronized static void method1()   // 同步的static 函数
　　{
　　//….
　　}
}
同步的static函数产生的效果是相同的，取得的锁很特别，是当前调用这个方法的对象所属的类（class，而不再是由这个class产生的某个具体对象了）。

重点是搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程式。

五 类定义关键字:

A、abstract class & interface
abstract class和interface在Java语言中都是用来进行抽象类


使用abstract class的方式定义Demo抽象类的方式如下：  


abstract class Demo ｛  
 abstract void method1();  
 abstract void method2();  
 …  
};  

使用interface的方式定义Demo抽象类的方式如下：  

interface Demo {  
 void method1();  
 void method2();  
 …  
};

首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。其次，在abstract class的定义中，我们可以赋予方法的默认行为。
对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。这个后面再继续好好理解下。

在实现接口方法的同时，也拥有了接口中定义的成员变量，这样就构成了一个有机的整体，使整个程序既体现了类的多样性，又不失结构组合的灵活性，
且需要在某个特性增加其他功能，只要修改接口就可以了，其继承的类自动修改


B、implements & extends
1. 在类的声明中，通过关键字extends来创建一个类的子类。
   一个类通过关键字implements声明自己使用一个或者多个接口。
   extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; 
   implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用
   
2.extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，
  继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了。
  
public inerface Runner{...}          //定义接口
interface Animal extends Runner{...} //继承接口
class Fish implements Animal{...}    //实现接口


interface Flyer{...}                 //定义接口
class Bird implements Runner , Flyer{...} //实现多个接口

接口实现的注意点：
a.实现一个接口就是要实现该接口的所有的方法(抽象类除外)。
b.接口中的方法都是抽象的。
c.多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。   

class A extends B implements C,D,E

//一个类通过关键字implements声明自己使用一个或者多个接口。在类的声明中，通过关键字extends来创建一个类的子类。
class 子类名 extends 父类名 implenments 接口名
{...

}