Start：
每个 Java 程序至少应该有一个类，通常类名的第一个字母大写。
若要使用数学方法需要用到 Math 类。随机方法也在该类中。
同样程序也是从 main 方法开始执行的。
然而 Java 的加号 + ，不仅可以用于数值之间，字符串之间，还可以用于数值和字符串之间。
Java 允许两个字符相加，例如：int i = 'a' + 'b';
只是字符串常量不可以跨行。
Java 的输入和输出：
输出: System.out.print("string") 不换行，或者 Sytem.out.println("string") 换行。
输入: 输入要稍微麻烦一些，需要导入 java.util.Scanner。如：import java.util.Scanner
可以用 Scanner 类创建它的对象，来读取 System.in 的输入。
例如：Scanner input = new Scanner(System.in)。
从键盘读取各种数据类型，例如：
byte byteValue = input.nextByte();
short shortValue = input.nextShort();
int intValue = input.nextInt();
long longValue = input.nextLong();
float floatValue = input.nextFloat();
double doubleValue = input.nextDouble();
String string = input.next(); 这种读取方式以碰到空格就结束。
String string = input.nextLine(); 这种读取方式以碰到换行结束。
Java 提供了boolean 数据类型：表示 false 或 true。
Java 还有字符串的数据类型，例如：String message = "Welcome to java";
String 对象也有许多简单的字符串操作方法。
标识符：
标识符是由字母，数字，下划线 _ ，或美元符号 $ 构成的字符序列，不能以数字开头。
命名常量：final 数据类型 数据名称 = 常量值。
例如： final double PI = 3.1415926;
命名习惯：
使用小写字母命名变量和方法，如果一个名字包含多个单词，就把他们连起来，
第一个单词的字母小写，后面的每个单词首字母大写，例如：blackCat。
类名中的每个单词首字母大写，例如 ComputerScience。
大写常量中的所有字母，多个单词间用下划线连接，例如：MAX_VALUE。
为了提高程序可读性，java 允许在数值直接量的两个数字之间使用下划线。例如：1000_000_000。
方法：
定义方法：修饰符 返回值类型 方法名(参数列表) { ...... }
例如：public static int max(int a,int b) {......}
数组：
声明数组：元素类型[ ] 数组变量名; 元素类型[ ][ ] 数组变量名;
创建数组：new 元素类型[数组大小] ; new 元素类型[数组大小][数组大小];
也可以一起使用，例如：int[ ] ary = new int[10]; double[ ][ ] array = new double[10][10];
数组的大小，例如：ary.length。array.length;
为数组设计的循环 forecah：
语法为：for(元素类型 元素名称 : 数组名) { ......}
例如：for(int e : ary) { System.out.println(e) };
数组复制：
除了可以用循环来复制外，Java 提供了一些方法来复制数组。
例如使用 java.lang.System 类的 arraycopy 方法来复制数组，语法为：System.arraycopy(sourceArray,srcPos,targetArray,tarPos,length);
注意：该方法没有遵循命名习惯。
另外，java.util.Arrays 类中有许多常见的数组操作方法，比如查找，排序等等。
数组值交换例子：
public static void main(String[] args) { int[] a = {1,2}; swap(a[0],a[1]); System.out.printf("%d, %d ",a[0],a[1]); swapArray(a); System.out.printf("%d, %d ",a[0],a[1]); } public static void swap(int m,int n) { int temp = n; n = m; m = temp; } public static void swapArray(int[] array) { int temp = array[0]; array[0] = array[1]; array[1] = temp; }
运行结果为：1，2 2，1。这是因为数组的引用传递给了方法。
命令行参数：
或许你已经注意到 main 方法的声明与众不同，它具有 String[ ] 类型参数 args。
很明显 args 是一个字符串类型数组，因此可以给它传递参数。
例如：
public static void main(String[] args) { for(int i = 0; i < args.length; i++) { System.out.println(args[i]); } }
可通过 java 命令来运行该程序，例如：java display 1 2 3。
可变长度参数列表：
方法中的参数声明：(类型名... 参数名) 注意：类型名后紧跟着省略号。
例如：public static int max(int... numbers) { ...... }
对象和类：
包含 main 方法的类称为主类。
访问对象的数据和方法：
在创建一个对象后，它的数据和方法可以使用点操作符 ( . ) 来访问和调用，该操作符也称为对象成员访问操作符。
如果一个引用类型的数据域没有引用任何对象，那么这个数据域就有一个特殊的 Java 值 null。
引用类型数据域的默认值是 null， 数值类型数据域的默认值是 0，boolean 类型数据域 的默认值是 false，
而 char类型数据域的默认值是 'u0000'。但是，Java 没有给方法中的 局部变置陚默认值。
静态变量，常量和方法：
静态变量被类中所有对象所共享，静态方法不能访问类中的实例成员。、
实例方法即可访问静态变量或方法，也可以访问实例变量或方法。
可见性修饰符：
可见性修饰符可以用于确定一个类以及它的成员的可见性。
可以在类、方法和数据域前使用 public 修饰符，表示它们可以被任何其他的类访问。
如果没有使用可见性修饰符，那么则默认类、方法和数据域是可以被同一个包中的任何一个 类访问的。
这称作 包私有 (package-private) 或 包内访问 (package-access)。
除了 public 和默认可见性修饰符，Java 还为类成员提供 private 和 protected 修饰符。
private 修饰符：限定方法和数据域只能在它自己的类中被访问。
修钸符 private 只能应用在类的成员上。
修饰符 public 可以应用在类或类的成员 上。
在局部变量上使用修饰符 public 和 private 都会导致编译構误。
为防止數据被篡改以及使类更易于维护，最好将数据域声明为私有的。
向方法传递对象参数：
可以将对象传递给方法。同传递数组一样，传递对象实际上是传递对象的引用。
this 引用：
关键字 this 引用对象自身。它也可以在构造方法内部用于调用同一个类的其他构造方法。
this 关键字可以用于引用类的隐藏數据域。隐藏的静态变量可以简单地通过 “类名 .静态变量” 的方式引用。
隐藏的实例变量就需要使用关键字 this 来引用。
使用 this 调用构造方法：
Java 要求在构造方法中，语句 this( 参数列表）应在任何其他可执行语句之前出现。
如果一个类有多个构造方法，最好尽可能使用 this(参数列表) 实现它们。
通常，无参數或参数少的构造方法可以用 this(参数列表) 调用参数多的构造方法。
String 类：
String 对象是不可改变的。字符串一旦创建，内容不能再改变。
例如：String message = "Welcome to Java";
message = "Hello world!";
开始 message 引用字符串"Welcome to Java"，之后 message 引用字符串"Hello world"。
"Welcome to Java"字符串并没有改变，只是不可以再引用了。
另外，String 对象之间的比较，比较的是对象不是内容。
例如：String s1 = "Welcome to Java";
String s2 = new String("Welcome to Java");
String s3 = "Welcome to Java";
此时，s1 == s3，s1 != s2。
另外，该类提供了许多方法，可以自己查阅。
StringBuilder类 和 StringBuffer类：
StringBuilder 和 StringBuffer 类似于 String 类，区别在于 String 类是不可 改变的。
— 般来说，只要使用字符串的地方，都可以使用StringBuilder/StringBuffer类。
StringBuilder/StringBuffer 类比 String类更灵活。
除了 StringBuffer 中修改缓冲区的方法是同步的，StringBuilder 类与 StringBuffer 类是很相似的。
如果是多任务并发访问， 就使用StringBuffer, 因为这种情况下需要同步以防止 StringBuffer 崩溃。
而如果是单任务访问，使用StringBuilder 会更有效。
同样，该两个类也提供了许多修改字符串的方法。
继承和多态：
修饰符(public,private,protected) class 类名 extends 要扩展的类名 { ...... }
这样就完成了继承。若要初始要扩展类名里的私有属性，需要调用要扩展类名的初始话私有属性的方法。
不可以用 this 指针来初始化。
关键字 super：
关键字 super 指代父类，可以用于调用父类中的普通方法和构造方法。
关键字 super 是指这个 super 关键字所在的类的父类。
关键字 super 可以用于两种途径：
1) 调用父类的构造方法。
2) 调用父类的方法。
之所以引入该关键字，是因为父类的构造方法不会被子类继承。
调用父类构造方法的语法是：super() 或者 super(parameters)
语句 super() 调用父类的无参构造方法，而语句 super(parameters) 调用与参数匹配的父类的构造方法。
语句 super() 和 super(parameters) 必须出现在子类构造方法的第一行， 这是显式调用父类构造方法的唯一方式。
构造方法链：
构造方法可以调用重载的构造方法或父类的构造方法。
如果它们都没有被显式地调用， 编译器就会自动地将 super() 作为构造方法的第一条语句。
在任何情况下，构造一个类的实例时，将会调用沿着继承链的所有父类的构造方法。
当构造一个子类的对象时，子类构造方法会在完成自己的任务之前，首先调用它的父类的构 造方法。
如果父类继承自其他类，那么父类构造方法又会在完成自己的任务之前，调用它自 己的父类的构造方法。
这个过程持续到沿着这个继承体系结构的最后一个构造方法被调用为止。这就是构造方法链。
调用父类方法：
关键字 super 不仅可以引用父类的构造方法，也可以引用父类的方法。所用语法如下：
super.方法名(参数);
方法重写：
子类从父类中继承方法。有时，子类需要修改父类中定义的方法的实现，这称作方法重写。
要重写一个方法，需要在子类中使用和父类一样的签名以及一样的返回值类型来对该方法进行定义。
方法重写与重载：
重载意味着使用同样的名字但是不同的签名来定义多个方法。重写意味着在子类中提供一个对方法的新的实现。
例如：重写
public static void main(String[] args) { A a = new A(); a.p(10); a.p(10.0); } public static class B { public void p(double i) { System.out.println(i*2); } } public static class A extends B { public void p(double i) { System.out.println(i); } }
运行结果为：10.0，10.0。
例如：重载
public static void main(String[] args) { A a = new A(); a.p(10); a.p(10.0); } public static class B { public void p(double i) { System.out.println(i*2); } } public static class A extends B { public void p(int i) { System.out.println(i); } }
运行结果：10，20.0。
为了避免错误，可以使用一个特殊的 Java 语法，称为重写标注, 在子类的方法前面放一个 @Override。
该标注表示被标注的方法必须重写父类的一个方法。如果具有该标注的方法没有重写父 类的方法，编译器将报告一个错误。
Object 类：
Java 中的所有类都继承自 java.lang.Object 类。
如果在定义一个类时没有指定继承性，那么这个类的父类就被默认为是 Object。
多态：
多态意味着父类的变量可以指向子类对象。
面向对象程序设计的三大支柱是封装、继承和多态。
继承关系使一个子类继承父类的特征，并且附加一些新特征。
子类是它的父类的特殊化，每个子类的实例都是其父类的实例，但是反过来就不成立。
因此，总可以将子类的实例传给需要父类型的参数。
使用父类对象的地方都可以使用子类的对象。这就是通常所说的多态。
简单来说，多态意味着父类型的变量可以引用子类型的对象。
动态绑定：
抽象的说：实例可以使用声明类型或它的子类型的构造方法创建。变量的实际类型是被变量引用的对象的实际类。
假如啊：
People 类里有 goToWC() 方法吧，Man类 和 Women类 是继承于 People类的。
这两个类里都对 goToWC() 方法进行了改造。
例如：People boy = new Man(); 或者 People girl = new Women();
此时调用 boy 或者 girl 的 goToWC() 方法，调用的将是 Man类 或 Women类里的 goToWC() 方法，而不是 People 类里的。
这就是动态绑定的意思了。
ArrayList类：
Java 提供 ArrayList类来存储不限定个数的对象。
ArrayList是一种泛型类，创建一个 ArrayLis 类对象时，可以指定一 个具体的类型来替换该对象。
例如：ArrayList<String> cities = new ArrayList<String>();
或者：ArrayList<java.util.Date> dates = new ArrayList<java.util.Date>();
可以这样简化：ArrayList<String> cities = new ArrayList<>();
修饰符：
使用 private修饰符可以完全隐藏类的成员，这样，就不能从类外直接访问它们。
不使用修饰符就表示允许同一个包里的任何类直接访问类的成员，但是其他包中的类不可以访问。
使用protected 修饰符允许任何包中的子类或同一包中的类访问类的成员。
使用 public 修饰符允许任意类访问类的成员。
修饰符 private 和 protected 只能用于类的成员。
public 修饰符和默认修饰符(也就是没有修饰符)既可以用于类的成员，也可以用于类。
子类可以重写它的父类的 protected 方法，并把它的可见性改为 public。
但是，子类不能削弱父类中定义的方法的可访问性。
例如：如果一个方法在父类中定义为 public, 在子类中也必须定义为 public。
防止扩展和重写：
一个被 final 修饰的类和方法都不能被扩展。被 final 修饰的数据域是一个常数。
有时候，可能希望防止类扩展。在这种情况下，使用 final 修饰符表明一个类是最终的，是不能作为父类的。
修饰符 public、protected、private、static、 abstract以及 final 可以用在类和类的成员(数据和方法)上，
只有 final 修饰符还可以用在方法中的局部变量上。方法内的最终局部变量就是常量。
异常类型：
异常是对象，而对象都采用类来定义。异常的根类是 java.lang.Throwable。
例如：ArithmeticException 是除以 0 异常。更多的异常类型请自己查阅文档。
异常处理：
Java 的异常处理模型基于三种操作：声明一个异常、抛出一个异常、捕获一个异常。
捕获异常：
try { ...... } catch(异常类型 异常类型的对象) { ...... } catch(异常类型 异常类型的对象) { ...... } catch(异常类型 异常类型的对象) { ...... } . . .
如果 try 块中的某条语句抛出一个异常，Java 就会跳过 try块中剩余的语句，然后开始 査找处理这个异常的代码的过程。
处理这个异常的代码称为异常处理器 ; 可以从当前的方法开始，沿着方法调用链，按照异常的反向传播方向找到这个处理器。
从第 一个到最后一个逐个检査 catch 块，判断在 catch 块中的异常类实例是否是该异常对象的类型。
如果是，就将该异常对象陚值给所声明的变量，然后执行 catch 块中的代码。
如果没有发现异常处理器，Java 会退出这个方法，把异常传递给调用这个方法的方法，继续同样的过 程来査找处理器。
如果在调用的方法链中找不到处理器，程序就会终止并且在控制台上打印出错信息。寻找处理器的过程称为捕获异常。
声明异常：
Java 解释器调用 main 方法开始执行一 个程序。每个方法都必须声明它可能抛出的必检异常的类型，这称为声明异常。
为了在方法中声明一个异常，就要在方法头中使用关键字 throws。
例如：public void myMethod() throws ArithmeticException { ...... }
关键字 throws 表明 myMethod 方法可齙会抛出异常 ArithmeticException 。
如果方法可能会抛出 多个异常，就可以在关键字 throws 后添加一个用逗号分隔的异常列表：
public void myMethod() throws ArithmeticException,IndexOutOfBoundsException,...
如果方法没有在父类中声明异常，那么就不能在子类中对其进行继承来声明异常。
抛出异常：
检测到错误的程序可以创建一个合适的异常类型的实例并抛出它，这就称为抛出异常。
假如程序发现除数为 0，就可以创建一个 ArithmeticException 实例并抛出它。
例如：ArithmeticException ex = new ArithmeticException("错误提示信息");
throw ex;
或者：throw new ArithmeticException("除数为 0 错误");
finally 字句：
无论异常是否产生，finally 子句总是会被执行的。
try { ...... } catch(异常类型 异常类型的对象) { ...... } catch(异常类型 异常类型的对象) { ...... } catch(异常类型 异常类型的对象) { ...... } . . . finally { ...... }
在任何情况下，finally块中的代码都会执行，不论 try 块中是否出现异常或者是否被捕获。
考虑下面三种可能出现的情况：
1、如果 try 块中没有出现异常，执行 finally{ ...... }， 然后执行 try 语句的下一条语句。
2、如果 try 块中有一条语句引起异常，并被 catch 块捕获，然后跳过 try 块的其他语句，执行 catch 块和 finally 子句。
执行 try语句之后的下一条语句。
3、如果 try 块中有一条语句引起异常，但是没有被任何 catch 块捕获，就会跳过 try 块中的其他语句，执行 finally 子句，
并且将异常传递给这个方法的调用者。 即使在到达 finally 块之前有一个 return 语句，finally 块还是会执行。
创建自定义异常类：
Java 提供相当多的异常类，尽量使用它们而不要创建自己的异常类。
然而，如果进到一个不能用预定义异常类恰当描述的问题，那就可以通过派生 Exception 类或其子类，来创建自己的异常类。
File 类：
java.io.File 类有一些对文件操作的相关方法，但是不支持创建及读写文件相关的操作。
使用 Scanner 类从文件中读取文本数据，使用 PrintWriter 类向文本文件写入数据。
java.io.File 对象可以绑定一个文件。例如：java.io.File file = new java.io.File("test.txt");
使用 PrintWriter 写数据：
首先，必须为一 个文本文件创建一个 PrintWriter 对象：PrintWriter output = new PrintWriter(fileName 或者 java.io.File 对象);
然后，可以调用PrinterWriter 对象上的 print、println 和 printf 方法向文件写入数据。
使用 Scanner 读数据：
Scanner input = new Scanner(fileName 或者 java.io.File 对象);
接下来就可以像从键盘读入那样读入了。
行分隔符字符串是由系统定义的，在 Windows 平台上 , 而在 UNIX 平台上是 。
为了得到特定平台上的行分隔符，使用 String lineSeparator = System.getProperty('line.separator");
如果从键盘输入，每行就以回车键结束，它对应于 字符。
while( input.hasNext() ) { ...... } 保持循环直到到了文件末尾。
从 Web 上读取数据：
为了读取一个文件，首先要使用 java.net.URL 类的这个构造方法，为该文件创建一个 URL 对象。
例如：URL url = new URL("http://www.cnblogs.com/M-Anonymous/");
前缀 http:// 是必需的，否则将会引起 MaiformedURLException 运行错误，必须说明或处理该错误。
创建一个 URL 对象后，可以使用URL 类中定义的 openStream() 方法来打开输入流和用输人流创建如下 Scanner 对象。
Scanner input = new Scanner( url.openStream() );
现在可以从输人流中读取数据了，如同从本地文件中读取一样。
例如：
public static void main(String[] args) { System.out.println("Enter a URL: "); Scanner input1 = new Scanner(System.in); String URLString = input1.next(); try { int count = 0; java.net.URL url = new java.net.URL(URLString); Scanner input2 = new Scanner(url.openStream()); while(input2.hasNextLine()) { String line = input2.nextLine(); count += line.length(); } System.out.println("The file size is " + count + "characters"); input1.close(); input2.close(); } catch(java.net.MalformedURLException ex) { System.out.println("Invalid URL"); } catch(java.io.IOException ex) { System.out.println("I/O Errors: no such file"); } }
抽象类和接口：
抽象类不可以用于创建对象。抽象类可以包含抽象方法，这些方法将在具体的子类中实现。
抽象方法：在方法头中使用 abstract 修饰符表示。
抽象类：在类头使用 abstract 修饰符表示。
抽象类和常规类很像，但是不能使用 new 操作符创建它的实例。
抽象方法只有定义而没 有实现。它的实现由子类提供。
一个包含抽象方法的类必须声明为抽象类。
抽象类的构造方法定义为 protected, 因为它只被子类使用。
创建一个具体子类的实例时，它的父类的构造方法被调用以初始化父类中定义的数据域。
抽象类的几点说明：
抽象方法不能包含在非抽象类中。如果抽象父类的子类不能实现所有的抽象方法， 那么子类也必须定义为抽象的。
换句话说，在抽象类扩展的非抽象子类中，必须实现所有的抽象方法。还要注意到，抽象方法是非静态的。
抽象类是不能使用 new 操作符来初始化的。但是，仍然可以定义它的构造方法，这 个构造方法在它的子类的构造方法中调用。
子类可以覆盖父类的方法并将它定义为 abstract。 即使子类的父类是具体的，这个子类也可以是抽象的。