语法.二

包装类(Wrapper Class)
八种基本类型不具备“对象”性，是为了照顾程序员的传统习惯
包装类解决这个问题(也继承自Object)。
基本数据类型    包装类
byte　　　　　　Btye
short　　　　　  Short
int        　　　　Integer
long                 Long
char                 Character
float                 Float
double              Double
boolean             Boolean

基本数据类型 -> 包装类
boolean b1 = true;
Boolean b1Obj = new Boolean(b1);
int i1 = 6;
Integer itObje = new Integer(i1);
Float f1 = new Float("4.56");
Boolean bObj = new Boolean("true");

使用的字符串不能不拿来创建基本数据类型，就会引发
java.long.NumberFormatException
如 Long l1 = net Long("ddd");

包装类 -> 基本数据类型
获得包装类的基本数据类型变量，用xxxValue实例方法。
如
int i = itObje.intValue();

基本类型变量和字符串转换
1.利用包装类提供的parseXxx(String s)静态方法(除了Character,所有包装类都提供了)
2.利用包装类都提供的Xxx(String s)构造器
String类提供了多个重载的ValueOf方法，用于将基本类型转换为字符串
String intStr = "123";
int it1 = Integer.parseInt(intStr);
int it2 = new Integer(intStr);
System.out.println( "it1 is " + it1 + " it2 is " + it2 );    
float fs = 3.44f;
String str = String.valueOf(fs);

比较
基本数据类型和包装类型：基本数据和包装类型取出的实例进行比较
包装类型和包装类型：引用之间的比较，要注意

下面可直接将int转换为string
String str = 1 + "";
-----------------------------------------------------
打印对象和toString
ObjectType p = new ObjectType();
Systen.out.println(p);
==
System.out.println(p.toString());

toString 是Object中的实例，每个对象都有，用于自描述
默认为[类名+@+hashcode] ，要写自定义的自描述，就要自己重载这个函数。
-----------------------------------------------------
==和equals
equals是Object的一个实例方法，用于判断引用的情形，但直接使用它判断对象是否相等和==的标准一致，
同样是引用的同一个对象才返回true，所以需要自己重载这个函数，否则没意义。
String已经重载了这个函数，只要函数序列一致即可。
-----------------------------------------------------
单例类：一个类始终只能创建一个对象，则称为单例类。
1.构造器使用private
2.对象创建后要用静态类成员缓冲
class SingleClass
{
    private static SingleClass instance;
    static {
        System.out.println("static build chunk");
    }
    private SingleClass ()
    {
        System.out.println("object build");
    }
    public static SingleClass getInstance()
    {
        if ( null == SingleClass.instance )
        {
            SingleClass.instance = new SingleClass();
        }
        return SingleClass.instance;
    }
    public void test ()
    {
        System.out.println("test");
    }
}

class Singletion
{
    static public void main ( String[] args )
    {
        SingleClass s1 = SingleClass.getInstance();
        SingleClass s2 = SingleClass.getInstance();
    }
}
-----------------------------------------------------
final 用于表示他修饰的东西不可改变(有点像const)

final变量:final修饰的变量不可被改变，一旦获得了初始值,final变量就不能被重新赋值。
实例变量：
定义处、初始化块和构造器中赋予初值，任选其一。
类变量：
定义处或静态初始化块中初始化。

final方法：final修饰的方法，不可被重写
注：如果父类中对方法用private修饰，因为在子类中本来就看不到此方法，所以子类写的同名同参方法只是一个
新方法，不受限制，只有public才在子类中不能重写。

final类：final修饰的类不能有子类。
-----------------------------------------------------
抽象类
抽象类和抽象方法都使用abstract来修饰，且抽象方法不能有方法体。
抽象类不能实例化，只能引用子类
抽象类可以有成员变量、方法、构造器、初始化块、内部类、枚举类
abstract class Base
{
    public void test()
    {
        System.out.println("test\n");
    }
    abstract public void test2();
}

class Client extends Base
{
    public void test2()//必须重写
    {
        System.out.println("override base");
    }
}

class Demo
{
    public static void main (String[] args)
    {
        Base b = new Client();
        b.test();
        b.test2();
    }
}
abstract 修饰的类，表示这个类需要被基础
abstract 修饰的方法，表示这个方法需要被子类重写。
final 和 abstract只能存在其一
static和abstract不能同时用来修饰方法。
-----------------------------------------------------
接口(interface)：更彻底的抽象类，接口里面不能保护普通方法，接口所有的方法都是抽象方法。
定义
[修饰符] interface 接口名 extends 父接口1, 父接口2
{
    零到多个常量定义
    零到多个抽象方法定义
}

1.修饰符可以是public或省略，省略时，默认采用包权限访问控制符.即只有在相同包结构下才可以访问该接口。
2.接口可以有多个直接父接口，但接口只能继承接口，不能继承类。
3.不能有初始化块和构造体
注：一个源文件中只能有一个public接口，且文件名和此接口名相同
-----------------------------------------------------
使用接口
接口需要被类实现，且一个类可以实现多个接口
[修饰符] class 类名 extends父类 implements 接口1, 接口2...
{
    ...
}
一个类实现一个接口后，必须实现这个接口的所有抽象方法。
否则，该类将保留从父接口那里继承的抽象方法，该类也成为抽象类
-----------------------------------------------------
抽象类和接口
相同
1.都不能被实例化，位于继承树顶端，用于被其它类实现或继承
2.都可以包含抽象方法，实现他们的普通子类必须实现这些方法。
不同
1.接口只能包含抽象方法，不包含已经提供实现的方法，抽象可以包含普通方法
2.接口不能定义静态方法。
3.接口只能包含静态成员变量，抽象类可以包含普通成员变量
4.接口里不包含构造器，抽象类可以包含，抽象类构造器不适用于创建对象，而是让
子类调用这些构造器来完成抽象类的初始化操作。
5.接口里不能包含初始化块，但抽象里可以包含初始化块。
6.抽象类只能包含一个直接父类，接口可以有多个符接口。

接口：规范和实现分离的设计，可以降低模块之间的耦合。
抽象类：一种模版的设计，做为多个子类的共同父类，可以做为一个中间产品。将多个子类共同的部分抽象出来。
-----------------------------------------------------
内部类
定义在其他类内部的类称为内部类或嵌套类，包含内部类的类称为外部类或宿主类
作用：
1.提供更好封装，不允许同一个包中的其他类访问该类
2.内部类成员可以直接访问外部类成员(因为都是类的成员)，但外部类不能访问内部类的实现细节，例如成员函数
定义方法，直接在类内定义类。
编译后出现下面的class
OuterClass.class
OuterClass$InnerClass.class

在内部类中使用变量的查找顺序
局部变量 ，没有继续
内部类成员变量，没有继续
外部类成员变量，没有继续
如果内部类和外部类成员变量名重复，可以用this 外部类名.this来区分

外部静态方法、代码块不能访问非静态内部类。(根据静态成员不能访问非静态成员的规则)
非静态内部类内不能定义静态成员(静态方法，静态初始化块)。

静态内部类不能访问外部类实例成员
接口内只能定义静态内部类。

待续。。。目前觉得没啥用，等需要时再深入
-----------------------------------------------------
闭包(Closure)和回调
闭包是一种能被调用的对象，它保存了创建他的作用域的信息。
待续。。。
-----------------------------------------------------