JAVA学习（一）——基本语法

　　tips：前端开发写惯了弱类型语言，再来学强类型语言，真的是被各种修饰符、类型声明给整的云里雾里，而且java语法和javascript语言差别还是很大的，所以做好笔记，把一些需要注意的地方记下来是非常重要的，接下来就开始学习java啦。

　一、基本语法：

　　1、大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。

　　2、类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。

　　3、方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。

　　4、源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。

　　5、主方法入口：所有的Java 程序由public static void main(String args[])方法开始执行。

　　备注一下：

　　5.1、public static void main(String args[]){}：为java主函数，java虚拟机会自动寻找到main方法，然后开始执行后面的程序，java程序的规定的格式写法；

　    5.2、public：可外部访问；

　　5.3、static：标记为静态函数，将该函数存储在静态存储区，不需要实例化（new）即可使用；

　    5.4、void：无返回值；

　　5.5、String args[]：可在命令行通过此参数给函数传值，可在其他类调用这个类的main函数时传值。

public class MyFirstJavaProgram {
   /* 第一个Java程序.
    * 它将打印字符串 Hello World
    */
    public static void main(String []args) {
       System.out.println("Hello World"); // 打印 Hello World
    }
} 

　　

　　二、类（class）

　　　　1、局部变量

　　　　2、成员变量：定义在类中，方法体之外的变量，和局部变量略有不同。

　　　　3、类变量也声明在类中，方法体之外，但必须声明为static类型。

　　　　4、构造方法：在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // 这个构造器仅有一个参数：name
   }
}

　　

　　三、类型

　　　　1、基本数据类型（内置基本类型，引用类型）

　　　　byte a = 100；—— byte数据类型是8位、有符号的，以二进制补码表示的整数；

　　　　short s = 1000；—— short数据类型是16位、有符号的以二进制补码表示的整数；

　　　　int a = 100000；—— int数据类型是32位、有符号的以二进制补码表示的整数；

　　　　long a = 100000L；—— long数据类型是64位、有符号的以二进制补码表示的整数；（后面加了L）

　　　　float f1 = 234.5f；—— float数据类型是单精度、32位、符合IEEE 754标准的浮点数；（小数，后面加了f）

　　　　double d1 = 123.4；——  double数据类型是双精度、64位、符合IEEE 754标准的浮点数；（小数）

　　　　boolean one = true；——  boolean数据类型表示一位的信息；（true或false）

　　　　char letter = ‘A’；—— char类型是一个单一的16位Unicode字符；

　　　　Animal animal = new Animal(“giraffe”) ； —— 引用类型变量由类的构造函数创建，可以使用它们访问所引用的对象；

　　　　final double PI = 3.1415927；——  常量指不能改变的量。 在Java中用final标志，声明方式和变量类似；

　　　　

　　　　2、变量类型（局部变量，实例变量，类变量）

　　　　局部变量：

　　　　　　1、访问修饰符不能用于局部变量；（局部变量本身只能局部调用，外部没法调用，所以不需要修饰符private ,public protend，但是能加final）

　　　　　　2、局部变量是在栈上分配的。（由于进程的栈空间是有限的，所以要避免申请占用空间过大的局部变量，以及避免函数嵌套层数过多。这些都可能引起栈空间不够导致程序崩溃。）

　　　　实例变量：

　　　　　　1、实例变量声明在一个类中，但在方法、构造方法和语句块之外；

　　　　　　2、实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

　　　　　　3、实例变量可以声明在使用前或者使用后；（有点类型js的变量提升）

　　　　　　4、访问修饰符可以修饰实例变量；

　　　　　　5、一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

　　　　　　6、实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；（局部变量没有默认值哦！）

　　　　类变量（静态变量）：

　　　　　　1、以static关键字声明，必须在方法、构造方法和语句块之外。

　　　　　　2、无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

　　　　　　3、静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。

　　　　　　4、静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。

　　　　　　5、类变量被声明为public static final类型时，类变量名称必须使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

　　四、修饰符

　　　　访问修饰符（private、public、protected）

　　　　　　1、private —— 只能被所属类访问，并且类和接口不能声明为private。

　　　　　　2、public —— Java程序的main() 方法必须设置成公有的，否则，Java解释器将不能运行该类。

　　　　　　3、protected —— 能被同一个包中的任何其他类访问，也能够被不同包中的子类访问；不能修饰类和接口，方法和成员变量能够声明为protected，但是接口的成员变量和成员方法不能声明为protected。

　　　　非访问修饰符（static、final、abstract、synchronized、volatile）

　　　　　　1、static —— 局部变量不能被声明为static变量；可以直接使用classname.variablename和classname.methodname的方式访问。

　　　　　　2、final —— final对象的引用不能改变，但是里面的值可以改变；final修饰符通常和static修饰符一起使用来创建类常量；类中的Final方法可以被子类继承，但是不能被子类修改；final类不能被继承。

　　　　　　3、abstract —— 抽象类不能用来实例化对象；一个类不能同时被abstract和final修饰；抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成final和static；任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类；抽象方法的声明以分号结尾，例如：public abstract sample();

例子：

public abstract class SuperClass{
    abstract void m(); //抽象方法
}

class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

　　　　　　4、synchronized —— 方法同一时间只能被一个线程访问。

　　　　　　5、transient —— java虚拟机(JVM)将跳过transient修饰的实例变量。

　　　　　　6、volatile —— volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。（看得有点晕）

　　五、运算符（感觉所有语言都差不多，略）

　　六、包装类或抽象类

　　　　Number类：内置数据类型，如：int、long、byte、double、float、short等对应了包装类Integer、Long、Byte、Double、Float、Short等，它们都是抽象类Number的子类。（包装类需要拆箱变成内置数据类型才能进行计算）

　　　　Math类：Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

　　　　Character类：对应了内置数据类型char。

　　　　String类：String类是不可改变的，所以你一旦创建了String对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用StringBuffer & StringBuilder类。输出格式化数字可以使用printf()和format()方法；

转 换 符	说 明	示 例
%s	字符串类型	“mingrisoft”
%c	字符类型	‘m’
%b	布尔类型	true
%d	整数类型（十进制）	99
%x	整数类型（十六进制）	FF
%o	整数类型（八进制）	77
%f	浮点类型	99.99
%a	十六进制浮点类型	FF.35AE
%e	指数类型	9.38e+5
%g	通用浮点类型（f和e类型中较短的）
%h	散列码
%%	百分比类型	％
%n	换行符
%tx	日期与时间类型（x代表不同的日期与时间转换符

　　　　StringBuffer和StringBuilder类：StringBuilder相较于StringBuffer有速度优势，所以多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下，则必须使用StringBuffer类。（线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据）。

　　　　数组：

//数组声明
dataType[] arrayRefVar;   // 首选的方法
或
dataType arrayRefVar[];  // 效果相同，但不是首选方法

//数组创建
dataType[] arrayRefVar = new dataType[arraySize];
或
dataType[] arrayRefVar = {value0, value1, ..., valuek};

//foreach循环
public class TestArray {
    public static void main(String[] args) {
       double[] myList = {1.9, 2.9, 3.4, 3.5};       // 打印所有数组元素       
　　　　for (double element: myList) {
          System.out.println(element);       
　　　　}    
　　} 
}

　　　　Array类：能方便地操作数组，它提供的所有方法都是静态的；（fill：给数组赋值，sort：对数组排序，equals：比较数组中元素值是否相等，binarySearch：对排序好的数组进行二分查找法查找数组元素）

　　七、异常处理

　　　　1、异常捕获：使用try和catch关键字可以捕获异常；

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

　　　　2、throws/throw关键字：如果一个方法没有捕获一个检查性异常，那么该方法必须使用throws 关键字来声明。throws关键字放在方法签名的尾部；可以声明抛出多个异常，多个异常之间用逗号隔开。

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

　　　　3、finally关键字：无论是否发生异常，finally代码块中的代码总会被执行；

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }finally{
    // 程序代码
 }

　　　　最后，把上面的这些学懂，再来看java代码，已经不像开始时的那样陌生了，当然，还有一些知识点比较难，需要花更多的时间去学习研究，学得越多，越觉得java的知识体量很大，不过总算是入门了，再接再厉！