JAVA语法学习一

）起源：
   源于sun的一个叫Green的项目，给家用电子产品开发一个分布式系统，通过给家用电器发送EMail来控制它们。

开始准备采用C++，但是C++太复杂，安全性差，所以就开发了一个类C的语言，名字叫Oak,这是java的前身。后来竞

争失败，走投无路的时候受NetScape启发，继续完善改名为java,开发了一个HotJava浏览器。

2）特点：
  a:跨平台，编译成与平台无关的中间码

  b:象指针和释放内存等操作被删除，屏弃C++中容易出错的地方，具有内存自动回收功能。是代码具有健壮性。
    去掉了C++中的：指针运算，结构，typedefs，#define，全局变量的定义。释放内存。

  c:包括一个支持http和ftp的基于tcp/ip协议的类库，使开发internet上的程序更容易。

3）文件说明
   javac :java语言编辑器，叫源代码（后缀为java）编译成字节码（后缀为class） ---使用方法：javac 代码文

件.java
   java  :java字节码解释器                                                  ---使用方法：java  字节文

件.class

4）语法：
  a:注释：//---表示注释一行  /*  */---表示注释N行

  b:数据类型：(8进制前面有个0,16进制前面有0x,或者0X)
    1、整型----------byte(-128--128)，short(-32768-32767)，int(-21亿，2的32次方)，long（2的64次方）
    2、浮点型--------float，double
    3、布耳型--------boolean
    4、字符型--------Char     //char b='c';
    5、字符串型------string   //String b="abcdefg";

  c:数组：
    1、定义：一维：int a[],二维：float b[][]
    2、设置长度：a=new int[10] 或者写在一起：int a[]=new int[10];
    3、长度：数组名.length   
  
  d:表达式
    1、基本运算符号----：+，-，*，/，%（取模）
    2、单目运算符号----：++，--，&（位与），|（位或）
    3、判断符号--------： ==，!=，&&（并且），||（或者）
    4、对象运算符------：if (myobjcet instanceof 父类)   //判断是否是该父类的子类
    5、三元运算符------：i=b?1:0 //表示如果b=true 则i=1,否则为0
  
  e:控制结构：
    1、判断结构：  if (条件) {} else {}
    2、开关结构：switch (表达式) {
                  case 值1：... break;
                  case 值2：... break;
                  case 值3：... break;
                  default:...
                   }
    3:for循环结构：   for (int i;i<=N;i++) {....}
    4:while循环结构:  while (条件) {....}
    5:do循环结构：    do {...} while (条件)
    6:其他控制语句：
       ---break;
       ---continue;
       ---return 值;
       ---label:提供break,continue跳出循环的作用.跳转比如:break lab;

5）常用函数：
   1：常用数学函数：java.lang.Math

   2：字符串函数：
      a、Char   CharAt(i) ------------------返回第N个字符：
      b、int    CompareTo(字符串)-----------比较两个字符串：  小于0表示比他小，等于0表示相等，大于0表

示比他大     
      c、String Concat(字符串)--------------将两个字符串连接起来
      d、int    Indexof(字符或者字符串)-----求字符的位置，找不到返回-1
      e、Stinrg Substing(其始位置，结束位置)-求子串
      f、String trim()-----------------------去掉空格

   3：转换函数：
      a.字符串转化为数值：f=new float(s).floatvalue();
                          d=new double(s).doublevalue();

   4：格式化函数：   
      a、格式话数字：format('2222%s3333%s1111',v1,v2) -------没有，java5才有。
      b、格式话日期：java.text.SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Date d = sdf.parse(date);
         java.text.SimpleDateFormat sdfNew = new SimpleDateFormat("MMddyyyy");
         return sdfNew.format(d);

*****************************************************************************************************

6)类结构说明：
  a、构造函数：与类名相同的函数比如： public HelloWorld () {...} ---构造函数没有返回值，void也没有，

如果有那就不是构造函数了
  b、结束函数：java没有提供析构函数，因为java本身具有自动清除功能，但是他也提供了一个自动垃圾箱的成员

函数：
               Protected void finaliaze () {...}
  c、父类与子类：
               class woman extends men {...}
  d、访问控制：
      1、public--------------可以被任意其他类调用
      2、protected-----------只能在该类和其子类调用（自己也不能调用？？？？）
      3、private-------------只能在本类中调用
      4、friendly------------（缺省）可以被本包里的任意对象访问。
  e、静态：static
     1、静态变量：static int i=1;           //无论在哪个对象里面改变了静态变量的值，则所有对象的该静

态变量都要改变。
     2、静态函数：static void add() {...}   //静态函数不能访问非静态函数和变量。他的作用是：可直接调

用。同delphi中的类函数。
  f、this 和 super
     1、this代表本类。
     2、super代表父类。
  g、类的类型：
     1、abstract------------抽象类，必须至少有一个虚函数。一个抽象类不能创建对象，必须继承子类才能创

建对象。
     2、final---------------结束类：表示该类不能再派生出之类。
     3、public--------------公共类：表示其他类可以调用，其他包要使用该类则：import 包。类。
     4、synchronicable------同步类：表示这些类的成员函数必须同步。
  h、接口：
     1、定义：public interface TestIn {....声明空的方法}
     2、使用：class MyClass implements 接口 {实现接口中的方法}

7)异常处理：
   1、结构1：
          try
            {...}
          catch (Exception e)
            {...}

    2、结构2：
          try
            {...}
          finally
            {...}      
    3、抛出错误 throw e;

8）HelloWorld例子：
   public class HelloWord {
 public static void main(String[] args) {
  System.out.println("Hello,Wrold!");
 }
}
   //接收外部参数参数：int a=Integer.ParseInt(args[0]);
                       int b=Integer.ParseInt(args[1]);
         
     
*****************************************************************************************************

9）JAVA中的类：(根类：object)
  1、输入输出类：java的输入输出类要使用java.lang程序包中的类
     a: java.lang.System
     b: java.lang.Inputstream
     c: java.lang.Printstream
     ------------------------------------------------
     System.in为 Inputstream的对象
     System.out为Printstream的对象
     System.err为Printstream的对象，用于错误信息的输出。
 
  2、Date类  Date d1=new Date();  //定义一个当前时间的类

  import java.utils.*

  3、Hashtable类    //hash:杂乱序号 hash code:混列码
     说明：Hashtable提供一个hash表，定义：Hashtable h1=new Hashtable();  Hashtable h2=new

Hashtable(20,)
 
  4、Random类 随机数类

  5、Vector类：安装一个可延续的对象数组

  6、AWT类
   

10）不明白的代码
     1、System.out.flush

---------flush()的作用是清空缓冲区，更新缓冲区，不然有时候会看不到输出，用BufferedReader用了一个系统

分配的缓冲区,只有缓冲区满了时候才会读出,如果没满而你又想操作的话,就要用flush清空缓冲区,让结果输出!

     2、Integer.parseInt  ---------//pa:z//解析，使用格式：parseInt(String s,int radix)，返回一个整数

，为radix进制的

     3、hashcode  ---------------对象的散列标识，就和你的身份证类似，可以一下子就找到你的资料.数据结

构哈希散列的具体应用
        hashtable和hashmap的区别-a、HashTable是线程安全的一个Collection,HashMap不是线程安全的
                                 b、前者是图，后者是哈希表，在HashMap中不能由get()方法来判断HashMap中

是否存在某个键，而应该用containsKey()方法来判断。
                                 c、前者的关键词是，遍历、查找、搜索（如最短路径）后者的关键词是，冲

突处理，排序，
                                 d、都属于Map接口的类，实现了将惟一键映射到特定的值上。HashMap 类没有

分类或者排序。它允许一个 null 键和多个 null 值。 Hashtable 类似于 HashMap，但是不允许 null 键和 null

值。它也比 HashMap 慢，因为它是同步的。
                                 e、Hashtable缺省的初始大小为101,载入因子为0.75,即如果其中的元素个数

超过75个,它就必须增加大小并重新组织元素，所以,如果你知道在创建一个新的Hashtable对象时就知道元素的确切

数目如为110,那么,就应将其初始大小设为110/0.75=148,这样,就可以避免重新组织内存并增加大小

        一个hashtable的例子：
        HashTable h=new HashTable();
        h.put("用户1",new Integer(90));
        h.put("用户2",new Integer(50));
        h.put("用户3",new Integer(60));
        h.put("用户4",new Integer(70));
        Enumeration e=h.elements();
        while(e.hasMoreElements()){System.out.println(e.nextElement());

     4、没有结构怎么处理？-----------------用类代替。
     5、vector //向量与arraylist-----a、Vector和ArrayList Vector和ArrayList在使用上非常相似,都可用来

表示一组数量可变的对象应用的集合,并且可以随机地访问其中的元素。
                             

b、Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的

同步必然要影响性能，因此,ArrayList的性能比Vector好。
                             c、当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,

而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间

11）常出现的错误信息
    1、The method readLine() from the type DataInputStream is deprecated  //deprikeit//抗议，不赞成。
       说明：说明这个方法或类java不再建议您使用，以后的版本也不会再更新这个方法或类。 

    2、Unhandled exception type IOException
       说明：要用try   ...catch...语句把会出错的地方包含起来  //Throws IOException

    3、XXX cannot be resolved 
       说明：该变量没有定义或者不在定义范围之内。在{}内定义的变量只在{}内有效。

 Java语法学习：字符串

Java的String太特别了，也太常用了，所以重要。我初学Java就被它搞蒙了，太多混淆的概念了，比如它的不变性。所以必须深入机制地去理解它。


1、String中的每个字符都是一个16位的Unicode字符，用Unicode很容易表达丰富的国际化字符集，比如很好的中文支持。甚至Java的标识符都可以用汉字，但是没人会用吧（只在一本清华的《Java2实用教程》看过）。

2、判断空字符串。根据需要自己选择某个或者它们的组合
   if ( s == null )   //从引用的角度
   if ( s.length() == 0 )    //从长度判别
   if ( s.trim().length () == 0 )    //是否有多个空白字符
trim()方法的作用是是移除前导和尾部的Unicode值小于'"u0020'的字符，并返回“修剪”好的字符串。这种方法很常用，比如需要用户输入用户名，用户不小心加了前导或者尾部空格，一个好的程序应该知道用户不是故意的，即使是故意的也应该智能点地处理。
判断空串是很常用的操作，但是Java类库直到1.6才提供了isEmpty()方法。当且仅当 length() 为 0 时返回 true。

3、未初始化、空串""与null。它们是不同的概念。对未初始化的对象操作会被编译器挡在门外；null是一个特殊的初始化值，是一个不指向任何对象的 引用，对引用为null的对象操作会在运行时抛出异常NullPointerException；而空串是长度为0的字符串，和别的字符串的唯一区别就是 长度为0。
例子：
   public class StringTest{
       static String s1;
       public static void main(String[] args) {
           String s2;
           String s3 = "";
           System.out.print(s1.isEmpty());   //运行时异常
           System.out.print(s2.isEmpty());   //编译出错
           System.out.print(s3.isEmpty());   //ok！输出true
       }
   }

4、String类的方法很多，在编写相关代码的时候看看JDK文档时有好处的，要不然花了大量时间实现一个已经存在的方法是很不值得的，因为编写、测试、维护自己的代码使项目的成本增加，利润减少，严重的话会导致开不出工资……

5、字符串的比较。
Java不允许自定义操作符重载，因此字符串的比较要用compareTo() 或者 compareToIgnoreCase()。s1.compareTo(s2)，返回值大于0则，则前者大；等于0，一般大；小于0，后者大。比较的依 据是字符串中各个字符的Unicode值。

6、toString()方法。
Java的任何对象都有toString()方法，是从Object对象继承而来的。它的作用就是让对象在输出时看起来更有意义，而不是奇怪的对象的内存地址。对测试也是很有帮助的。

7、String对象是不变的！可以变化的是String对象的引用。
String name = "ray";
name.concat("long"); //字符串连接
System.out.println(name); //输出name，ok，还是"ray"
name = name.concat("long"); //把字符串对象连接的结果赋给了name引用
System.out.println(name); //输出name，oh！，变成了"raylong"
上述三条语句其实产生了3个String对象，"ray"，"long"，"raylong"。第2条语句确实产生了"raylong"字符串，但是没有 指定把该字符串的引用赋给谁，因此没有改变name引用。第3条语句根据不变性，并没有改变"ray"，JVM创建了一个新的对象，把"ray"， "long"的连接赋给了name引用，因此引用变了，但是原对象没变。

8、String的不变性的机制显然会在String常量内有大量的冗余。如："1" + "2" + "3" +......+ "n" 产生了n+(n+1)个String对象！因此Java为了更有效地使用内存，JVM留出一块特殊的内存区域，被称为“String常量池”。对 String多么照顾啊！当编译器遇见String常量的时候，它检查该池内是否已经存在相同的String常量。如果找到，就把新常量的引用指向现有的 String，不创建任何新的String常量对象。

那么就可能出现多个引用指向同一个String常量，会不会有别名的危险呢？No problem！String对象的不变性可以保证不会出现别名问题！这是String对象与普通对象的一点区别。

乍看起来这是底层的机制，对我们编程没什么影响。而且这种机制会大幅度提高String的效率，实际上却不是这样。为连接n个字符串使用字符串连接操作 时，要消耗的时间是n的平方级！因为每两个字符串连接，它们的内容都要被复制。因此在处理大量的字符串连接时，而且要求性能时，我们不要用String， StringBuffer是更好的选择。

8、StringBuffer类。StringBuffer类是可变的，不会在字符串常量池中，而是在堆中，不会留下一大堆无用的对象。而且它可将字符串 缓冲区安全地用于多个线程。每个StringBuffer对象都有一定的容量。只要StringBuffer对象所包含的字符序列的长度没有超出此容量， 就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。这个固定的容量是16个字符。我给这种算法起个名字叫“添饭算法”。先给你一满碗 饭，不够了再给你一满碗饭。
例子：
   StringBuffer sb = new StringBuffer();   //初始容量为 16 个字符
   sb.append("1234");   //这是4个字符，那么16个字符的容量就足够了，没有溢出
   System.out.println(sb.length());   //输出字符串长度是4
   System.out.println(sb.capacity());   //输出该字符串缓冲区的容量是16

   sb.append("12345678901234567");       //这是17个字符，16个字符的容量不够了，扩容为17+16个字符的容量
   System.out.println(sb.length());   //输出字符串长度是17
   System.out.println(sb.capacity());   //输出该字符串缓冲区的容量是34

   sb.append("890").reverse().insert(10,"-");  
   System.out.println(sb);       //输出0987654321-09876543214321

字符串的长度和字符缓冲区的容量是两个概念，注意区别。
还有串联的方式看起来是不是很酷！用返回值连接起来可以实现这种简洁和优雅。

10、StringBuilder类。 从J2SE 5.0 提供了StringBuilder类，它和StringBuffer类是孪生兄弟，很像。它存在的价值在于：对字符串操作的效率更高。不足的是线程安全无法保证，不保证同步。那么两者性能到底差多少呢？很多！
请参阅：http://javadby.com#副标题#e#
实践：
单个线程的时候使用StringBuilder类，以提高效率，而且它的API和StringBuffer兼容，不需要额外的学习成本，物美价廉。多线程时使用StringBuffer，以保证安全。

11、字符串的比较。
下面这条可能会让你晕，所以你可以选择看或者不看。它不会对你的职业生涯造成任何影响。而且谨记一条，比较字符串要用equals()就ok了！一旦用了 “==”就会出现很怪异的现象。之所以把这部分放在最后，是想节省大家的时间，因为这条又臭又长。推荐三种人：一、没事闲着型。二、想深入地理解Java 的字符串，即使明明知道学了也没用。三、和我一样爱好研究“茴”字有几种写法。

还是那句老话，String太特殊了，以至于某些规则对String不起作用。个人感觉这种特殊性并不好。看例子：
例子A：
   String str1 = "java";
   String str2 = "java";
   System.out.print(str1==str2);
地球上有点Java基础的人都知道会输出false，因为==比较的是引用，equals比较的是内容。不是我忽悠大家，你们可以在自己的机子上运行一 下，结果是true！原因很简单，String对象被放进常量池里了，再次出现“java”字符串的时候，JVM很兴奋地把str2的引用也指向了 “java”对象，它认为自己节省了内存开销。不难理解吧 呵呵
例子B：
   String str1 = new String("java");
   String str2 = new String("java");
   System.out.print(str1==str2);
看过上例的都学聪明了，这次肯定会输出true！很不幸，JVM并没有这么做，结果是false。原因很简单，例子A中那种声明的方式确实是在 String常量池创建“java”对象，但是一旦看到new关键字，JVM会在堆中为String分配空间。两者声明方式貌合神离，这也是我把“如何创 建字符串对象”放到后面来讲的原因。大家要沉住气，还有一个例子。
例子C：
   String str1 = "java";
   String str2 = "blog";
   String s = str1+str2;
   System.out.print(s=="javablog");
再看这个例子，很多同志不敢妄言是true还是false了吧。爱玩脑筋急转弯的人会说是false吧……恭喜你，你会抢答了！把那个“吧”字去掉你就完 全正确。原因很简单，JVM确实会对型如String str1 = "java"; 的String对象放在字符串常量池里，但是它是在编译时刻那么做的，而String s = str1+str2; 是在运行时刻才能知道（我们当然一眼就看穿了，可是Java必须在运行时才知道的，人脑和电脑的结构不同），也就是说str1+str2是在堆里创建的， s引用当然不可能指向字符串常量池里的对象。没崩溃的人继续看例子D。
例子D：
   String s1 = "java";
   String s2 = new String("java");
   System.out.print(s1.intern()==s2.intern());
intern()是什么东东？反正结果是true。如果没用过这个方法，而且训练有素的程序员会去看JDK文档了。简单点说就是用intern()方法就 可以用“==”比较字符串的内容了。在我看到intern()方法到底有什么用之前，我认为它太多余了。其实我写的这一条也很多余，intern()方法 还存在诸多的问题，如效率、实现上的不统一……
例子E：
   String str1 = "java";
   String str2 = new String("java");
   System.out.print(str1.equals(str2));
无论在常量池还是堆中的对象，用equals()方法比较的就是内容，就这么简单！