firemail

标题: Java学习笔记 [打印本页]
作者: java    时间: 2017-6-26 16:20
标题: Java学习笔记
本帖最后由 java 于 2017-6-26 16:32 编辑

https://www.w3cschool.cn/java/java-tutorial.html

Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。
Java可运行于多个平台，如Windows, Mac OS，及其他多种UNIX版本的系统。
本教程通过简单的实例将让大家更好的了解JAVA编程语言。
Java 在线工具
JDK 1.6 在线中文手册

我的第一个JAVA程序
以下我们通过一个简单的实例来展示Java编程，本实例输出"Hello World"，这也是所有语言入门的第一个实例程序：
  1. public class MyFirstJavaProgram {

  3.     public static void main(String []args) {
  4.        System.out.println("Hello World");
  5.     }
  6. }
复制代码

Java分为三个体系：
2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名以取消其中的数字"2"：J2EE更名为Java EE, J2SE更名为Java SE，J2ME更名为Java ME。

主要特性


发展历史




作者: java    时间: 2017-6-26 16:40
本帖最后由 java 于 2017-6-26 16:56 编辑

Java 开发环境配置
window系统安装java下载JDK
首先我们需要下载java开发工具包JDK，下载地址：http://www.oracle.com/technetwork/java/javase/downloads/index.html

点击如下下载按钮：


在下载页面中你需要选择接受许可，并根据自己的系统选择对应的版本，本文以 Window 64位系统为例：



下载后JDK的安装根据提示进行，还有安装JDK的时候也会安装JRE，一并安装就可以了。
安装JDK，安装过程中可以自定义安装目录等信息，例如我们选择安装目录为 C:\Program Files (x86)\Java\jdk1.8.0_91。
配置环境变量
1.安装完成后，右击"我的电脑"，点击"属性"，选择"高级系统设置"；




2.选择"高级"选项卡，点击"环境变量"；





然后就会出现如下图所示的画面：





在"系统变量"中设置3项属性，JAVA_HOME,PATH,CLASSPATH(大小写无所谓),若已存在则点击"编辑"，不存在则点击"新建"。
变量设置参数如下：
JAVA_HOME 设置





PATH设置







CLASSPATH 设置




这是 Java 的环境配置，配置完成后，你可以启动 Eclipse 来编写代码，它会自动完成java环境的配置。
注意：如果使用1.5以上版本的JDK，不用设置CLASSPATH环境变量，也可以正常编译和运行Java程序。
测试JDK是否安装成功
1、"开始"->"运行"，键入"cmd"；
2、键入命令: java -version、java、javac 几个命令，出现以下信息，说明环境变量配置成功；





Linux，UNIX，Solaris，FreeBSD环境变量设置
环境变量PATH应该设定为指向Java二进制文件安装的位置。如果设置遇到困难，请参考shell文档。
例如，假设你使用bash作为shell，你可以把下面的内容添加到你的 .bashrc文件结尾: export PATH=/path/to/javaPATH
流行JAVA开发工具
正所谓工欲善其事必先利其器，我们在开发java语言过程中同样需要依款不错的开发工具，目前市场上的IDE很多，本文为大家推荐以下下几款java开发工具：




Notepad++ : Notepad++ 是在微软视窗环境之下的一个免费的代码编辑器，下载地址： http://notepad-plus-plus.org/



 IntelliJ IDEA 创建Java项目File | New | Project.
Java EE->Web Application
Create project from template
Command Line App


作者: java    时间: 2017-6-26 17:17
本帖最后由 java 于 2017-6-27 10:00 编辑

Java 基础语法
https://www.w3cschool.cn/java/java-basic-syntax.html

编译运行：
  1. public class MyFirstJavaProgram {
  2.    /* 第一个Java程序.  
  3.     * 它将打印字符串 Hello World
  4.     */
  5.     public static void main(String []args) {
  6.        System.out.println("Hello World"); // 打印 Hello World
  7.     }
  8. }
复制代码
C : > javac MyFirstJavaProgram.java  #编码代码
C : > java MyFirstJavaProgram   #运行程序
Hello World


基本语法
编写Java程序时，应注意以下几点：
Java修饰符
像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：




Java变量Java中主要有如下几种类型的变量
Java数组
数组是储存在堆上的对象，可以保存多个同类型变量。

Java枚举
Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。

  1. class FreshJuice {
  2.    enum FreshJuiceSize{ SMALL, MEDUIM, LARGE }
  3.    FreshJuiceSize size;
  4. }

  6. public class FreshJuiceTest {
  7.    public static void main(String args[]){
  8.       FreshJuice juice = new FreshJuice();
  9.       juice.size = FreshJuice. FreshJuiceSize.MEDUIM ;
  10.    }
  11. }
复制代码
注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。
Java关键字
下面列出了Java保留字。这些保留字不能用于常量、变量、和任何标识符的名称。
关键字
描述
abstract抽象方法，抽象类的修饰符
assert断言条件是否满足
boolean布尔数据类型
break跳出循环或者label代码段
byte8-bit 有符号数据类型
caseswitch语句的一个条件
catch和try搭配扑捉异常信息
char16-bit Unicode字符数据类型
class定义类
const未使用
continue不执行循环体剩余部分
defaultswitch语句中的默认分支
do循环语句，循环体至少会执行一次
double64-bit双精度浮点数
elseif条件不成立时执行的分支
enum枚举类型
extends  延伸表示一个类是另一个类的子类  
final表示一个值在初始化之后就不能再改变了
表示方法不能被重写，或者一个类不能有子类
finally为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
float32-bit单精度浮点数
forfor循环语句
goto未使用
if条件语句
implements  实现表示一个类实现了接口
import导入类
instanceof测试一个对象是否是某个类的实例
int32位整型数
interface接口，一种抽象的类型，仅有方法和常量的定义
long64位整型数
native表示方法用非java代码实现
new分配新的类实例
package一系列相关类组成一个包
private表示私有字段，或者方法等，只能从类内部访问
protected表示字段只能通过类或者其子类访问
子类或者在同一个包内的其他类
public表示共有属性或者方法
return方法返回值
short16位数字
static表示在类级别定义，所有实例共享的
strictfp浮点数比较使用严格的规则
super表示基类
switch选择语句
synchronized表示同一时间只能由一个线程访问的代码块
this表示调用当前实例
或者调用另一个构造函数
throw抛出异常
throws定义方法可能抛出的异常
transient 瞬态修饰不要序列化的字段
try表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
void标记方法不返回任何值
volatile  易变的标记字段可能会被多个线程同时访问，而不做同步
whilewhile循环



继承
在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
接口
在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。


作者: java    时间: 2017-6-27 10:17
Java 对象和类
Java作为一种面向对象语言。支持以下基本概念：
本节我们重点研究对象和类的概念。
一个类可以包含以下类型变量：
构造方法
每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

创建对象
对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：





源文件声明规则
在本节的最后部分，我们将学习源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。
类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。这些将在访问控制章节介绍。
除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。

Java包
包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。
Import语句
在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
  1. import java.io.*;
复制代码


作者: java    时间: 2017-6-27 11:05
本帖最后由 java 于 2017-6-28 09:57 编辑

Java 基本数据类型
变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。
Java的两大数据类型:
内置数据类型
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte：
short：
int：
long：
float：
double：
boolean：
char：
实例
对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：
  1. public class PrimitiveTypeTest {  
  2.     public static void main(String[] args) {  
  3.         // byte  
  4.         System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
  5.         System.out.println("包装类：java.lang.Byte");  
  6.         System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
  7.         System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
  8.         System.out.println();  
  9.   
  10.         // short  
  11.         System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
  12.         System.out.println("包装类：java.lang.Short");  
  13.         System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
  14.         System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
  15.         System.out.println();  
  16.   
  17.         // int  
  18.         System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
  19.         System.out.println("包装类：java.lang.Integer");  
  20.         System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
  21.         System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
  22.         System.out.println();  
  23.   
  24.         // long  
  25.         System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
  26.         System.out.println("包装类：java.lang.Long");  
  27.         System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
  28.         System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
  29.         System.out.println();  
  30.   
  31.         // float  
  32.         System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
  33.         System.out.println("包装类：java.lang.Float");  
  34.         System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
  35.         System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
  36.         System.out.println();  
  37.   
  38.         // double  
  39.         System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
  40.         System.out.println("包装类：java.lang.Double");  
  41.         System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
  42.         System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
  43.         System.out.println();  
  44.   
  45.         // char  
  46.         System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
  47.         System.out.println("包装类：java.lang.Character");  
  48.         // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
  49.         System.out.println("最小值：Character.MIN_VALUE="  
  50.                 + (int) Character.MIN_VALUE);  
  51.         // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
  52.         System.out.println("最大值：Character.MAX_VALUE="  
  53.                 + (int) Character.MAX_VALUE);  
  54.     }  
  55. }  
复制代码
编译以上代码输出结果如下所示：
  1. 基本类型：byte 二进制位数：8
  2. 包装类：java.lang.Byte
  3. 最小值：Byte.MIN_VALUE=-128
  4. 最大值：Byte.MAX_VALUE=127

  6. 基本类型：short 二进制位数：16
  7. 包装类：java.lang.Short
  8. 最小值：Short.MIN_VALUE=-32768
  9. 最大值：Short.MAX_VALUE=32767

  11. 基本类型：int 二进制位数：32
  12. 包装类：java.lang.Integer
  13. 最小值：Integer.MIN_VALUE=-2147483648
  14. 最大值：Integer.MAX_VALUE=2147483647

  16. 基本类型：long 二进制位数：64
  17. 包装类：java.lang.Long
  18. 最小值：Long.MIN_VALUE=-9223372036854775808
  19. 最大值：Long.MAX_VALUE=9223372036854775807

  21. 基本类型：float 二进制位数：32
  22. 包装类：java.lang.Float
  23. 最小值：Float.MIN_VALUE=1.4E-45
  24. 最大值：Float.MAX_VALUE=3.4028235E38

  26. 基本类型：double 二进制位数：64
  27. 包装类：java.lang.Double
  28. 最小值：Double.MIN_VALUE=4.9E-324
  29. 最大值：Double.MAX_VALUE=1.7976931348623157E308

  31. 基本类型：char 二进制位数：16
  32. 包装类：java.lang.Character
  33. 最小值：Character.MIN_VALUE=0
  34. 最大值：Character.MAX_VALUE=65535
复制代码
Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。
实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。


引用类型

引用类型变量由类的构造函数创建，可以使用它们访问所引用的对象。这些变量在声明时被指定为一个特定的类型，比如Employee、Pubby等。变量一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用与任何与之兼容的类型。
例子：Animal animal = new Animal(“giraffe”)。
Java常量

常量就是一个固定值。它们不需要计算，直接代表相应的值。
常量指不能改变的量。 在Java中用final标志，声明方式和变量类似：
final double PI = 3.1415927;
虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
字面量可以赋给任何内置类型的变量。例如：
byte a = 68;
char a = 'A'
byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
当使用常量的时候，前缀o表明是8进制，而前缀0x代表16进制。例如：
int decimal = 100;
int octal = 0144;
int hexa =  0x64;
和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：
"Hello World"
"two\nlines"
"\"This is in quotes\""
字符串常量和字符常量都可以包含任何Unicode字符。例如：
char a = '\u0001';
String a = "\u0001";
Java语言支持一些特殊的转义字符序列。

符号
字符含义
\n换行 (0x0a)
\r回车 (0x0d)
\f换页符(0x0c)
\b退格 (0x08)
\s空格 (0x20)
\t制表符
\"双引号
\'单引号
\\反斜杠
\ddd八进制字符 (ddd)
\uxxxx16进制Unicode字符 (xxxx)



作者: java    时间: 2017-6-28 09:57
本帖最后由 java 于 2017-6-28 14:09 编辑

Java 变量类型
Java 变量类型
在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：
type identifier [ = value][, identifier [= value] ...] ;
格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。
以下列出了一些变量的声明实例。注意有些包含了初始化过程。
  1. int a, b, c;         // 声明三个int型整数：a、 b、c。
  2. int d = 3, e, f = 5; // d声明三个整数并赋予初值。
  3. byte z = 22;         // 声明并初始化z。
  4. double pi = 3.14159; // 声明了pi。
  5. char x = 'x';        // 变量x的值是字符'x'。
复制代码
Java语言支持的变量类型有：
Java局部变量
实例变量

类变量（静态变量）




作者: java    时间: 2017-6-28 14:10
本帖最后由 java 于 2017-7-4 10:03 编辑

Java 修饰符
https://www.w3cschool.cn/java/java-modifier-types.html

Java 修饰符
Java语言提供了很多修饰符，主要分为以下两类：
修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：

  1. public class className {
  2.    // ...
  3. }
  4. private boolean myFlag;
  5. static final double weeks = 9.5;
  6. protected static final int BOXWIDTH = 42;
  7. public static void main(String[] arguments) {
  8.    // 方法体
  9. }
复制代码
访问控制和继承
请注意以下方法继承的规则：



非访问修饰符
为了实现一些其他的功能，Java也提供了许多非访问修饰符。
static修饰符，用来创建类方法和类变量。
Final修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
Abstract修饰符，用来创建抽象类和抽象方法。
Synchronized和volatile修饰符，主要用于线程的编程。

Static修饰符
对类变量和方法的访问可以直接使用classname.variablename和classname.methodname的方式访问。

Final修饰符

Final变量：
Final变量能被显式地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象。但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但是里面的值可以改变。
Final修饰符通常和static修饰符一起使用来创建类常量。
实例:
public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}
Final方法

类中的Final方法可以被子类继承，但是不能被子类修改。
声明final方法的主要目的是防止该方法的内容被修改。
如下所示，使用final修饰符声明方法。
public class Test{
    public final void changeName(){
       // 方法体
    }
}
Final类

Final类不能被继承，没有类能够继承final类的任何特性。
实例：
public final class Test {
   // 类体
}

Abstract修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。

抽象方法
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成final和strict。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

Synchronized修饰符
Synchronized关键字声明的方法同一时间只能被一个线程访问。Synchronized修饰符可以应用于四个访问修饰符。

Transient修饰符
序列化的对象包含被transient修饰的实例变量时，java虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

volatile修饰符
Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个volatile对象引用可能是null。
实例：

  1. public class MyRunnable implements Runnable
  2. {
  3.     private volatile boolean active;
  4.     public void run()
  5.     {
  6.         active = true;
  7.         while (active) // line 1
  8.         {
  9.             // 代码
  10.         }
  11.     }
  12.     public void stop()
  13.     {
  14.         active = false; // line 2
  15.     }
  16. }
复制代码
一般地，在一个线程中调用run()方法，在另一个线程中调用stop()方法。如果line 1中的active位于缓冲区的值被使用，那么当把line 2中的active设置成false时，循环也不会停止。

作者: java    时间: 2017-7-4 10:12
Java 运算符https://www.w3cschool.cn/java/java-operators.html
Java 运算符
计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：
算术运算符
算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。
表格中的实例假设整数变量A的值为10，变量B的值为20：
操作符
描述
例子
+加法 - 相加运算符两侧的值A + B等于30
-减法 - 左操作数减去右操作数A – B等于-10
*乘法 - 相乘操作符两侧的值A * B等于200
/除法 - 左操作数除以右操作数B / A等于2
％取余 - 右操作数除左操作数的余数B%A等于0
++自增 - 操作数的值增加1B ++等于21
--自减 - 操作数的值减少1B --等于19



下表为Java支持的关系运算符
表格中的实例整数变量A的值为10，变量B的值为20：
运算符
描述
例子
==检查如果两个操作数的值是否相等，如果相等则条件为真。（A == B）为假(非真)。
!=检查如果两个操作数的值是否相等，如果值不相等则条件为真。(A != B) 为真。
> 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。（A> B）非真。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。（A <B）为真。
> =检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。（A> = B）为假。
<=检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。（A <= B）为真。

位运算符
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符作用在所有的位上，并且按位运算。
下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13：
操作符
描述
例子
＆按位与操作符，当且仅当两个操作数的某一位都非0时候结果的该位才为1。（A＆B），得到12，即0000 1100
|按位或操作符，只要两个操作数的某一位有一个非0时候结果的该位就为1。（A | B）得到61，即 0011 1101
^按位异或操作符，两个操作数的某一位不相同时候结果的该位就为1。（A ^ B）得到49，即 0011 0001
〜按位补运算符翻转操作数的每一位。（〜A）得到-60，即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。A << 2得到240，即 1111 0000
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。A >> 2得到15即 1111
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。A>>>2得到15即0000 1111
逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假
操作符
描述
例子
&&称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。（A && B）为假。
| |称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。（A | | B）为真。
！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。！（A && B）为真。
赋值运算符
下面是Java语言支持的赋值运算符：
操作符
描述
例子
=简单的赋值运算符，将右操作数的值赋给左侧操作数C = A + B将把A + B得到的值赋给C
+ =加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数C + = A等价于C = C + A
- =减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数C - = A等价于C = C -
A
* =乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数C * = A等价于C = C * A
/ =除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数C / = A等价于C = C / A
（％）=取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数C％= A等价于C = C％A
<< =左移位赋值运算符C << = 2等价于C = C << 2
>> =右移位赋值运算符C >> = 2等价于C = C >> 2
＆=按位与赋值运算符C＆= 2等价于C = C＆2
^ =按位异或赋值操作符C ^ = 2等价于C = C ^ 2
| =按位或赋值操作符C | = 2等价于C = C | 2
条件运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

  1. variable x = (expression) ? value if true : value if false
复制代码
instanceOf 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
instanceof运算符使用格式如下：
  1. ( Object reference variable ) instanceOf  (class/interface type)
复制代码
Java运算符优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。
下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
类别
操作符
关联性
后缀() [] . (点操作符)左到右
一元+ + - ！〜从右到左
乘性 * /％左到右
加性 + -左到右
移位 >> >>>  << 左到右
关系 >> = << = 左到右
相等 ==  !=左到右
按位与＆左到右
按位异或^左到右
按位或|左到右
逻辑与&&左到右
逻辑或| |左到右
条件？：从右到左
赋值= + = - = * = / =％= >> = << =＆= ^ = | =从右到左
逗号，左到右


作者: java    时间: 2017-7-4 10:25
Java 循环结构 - for, while 及 do…while
顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。
Java中有三种主要的循环结构：
在Java5中引入了一种主要用于数组的增强型for循环。


while循环

while是最基本的循环，它的结构为：
while( 布尔表达式 ) {
        //循环内容
}
只要布尔表达式为true，循环体会一直执行下去。


do…while循环

对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
do {
       //代码语句
}while(布尔表达式);
注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为true，则语句块一直执行，直到布尔表达式的值为false。


for循环

虽然所有循环结构都可以用while或者do...while表示，但Java提供了另一种语句 —— for循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化; 布尔表达式; 更新) {
    //代码语句
}
关于for循环有以下几点说明：
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。


Java增强for循环
Java5引入了一种主要用于数组的增强型for循环。
Java增强for循环语法格式如下:
for(声明语句 : 表达式){   //代码句子}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

break关键字
break主要用在循环语句或者switch语句中，用来跳出整个语句块。
break跳出最里层的循环，并且继续执行该循环下面的语句。

continue关键字
continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在for循环中，continue语句使程序立即跳转到更新语句。
在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。


作者: java    时间: 2017-7-4 11:16
Java 分支结构 - if…else/switchJava 分支结构 - if...else/switch
顺序结构只能顺序执行，不能进行判断和选择，因此需要分支结构。
Java有两种分支结构：
if语句

一个if语句包含一个布尔表达式和一条或多条语句。
语法

If语句的用语法如下：
if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

if...else语句
if语句后面可以跟else语句，当if语句的布尔表达式值为false时，else语句块会被执行。


if...else if...else语句
if语句后面可以跟elseif…else语句，这种语句可以检测到多种可能的情况。
使用if，else if，else语句的时候，需要注意下面几点：


switch语句

switch语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
语法

switch语法格式如下：
switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}
switch语句有如下规则：
switch语句中的变量类型只能为byte、short、int或者char。
switch语句可以拥有多个case语句。每个case后面跟一个要比较的值和冒号。
case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
当变量的值与case语句的值相等时，那么case语句之后的语句开始执行，直到break语句出现才会跳出switch语句。3
当遇到break语句时，switch语句终止。程序跳转到switch语句后面的语句执行。case语句不必须要包含break语句。如果没有break语句出现，程序会继续执行下一条case语句，直到出现break语句。
switch语句可以包含一个default分支，该分支必须是switch语句的最后一个分支。default在没有case语句的值和变量值相等的时候执行。default分支不需要break语句。




作者: java    时间: 2017-7-4 14:08
Java Number类一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double等。
实例

int i = 5000;
float gpa = 13.65;
byte mask = 0xaf;
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类。

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number类属于java.lang包。
下面是一个装箱与拆箱的例子：
  1. public class Test{

  3.    public static void main(String args[]){
  4.       Integer x = 5; // boxes int to an Integer object
  5.       x =  x + 10;   // unboxes the Integer to a int
  6.       System.out.println(x);
  7.    }
  8. }
复制代码
当x被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。

Number类的成员方法
下面的表中列出的是Number类的方法：
序号
方法与描述
1xxxValue()
将number对象转换为xxx数据类型的值并返回。
2compareTo()
将number对象与参数比较。
3equals()
判断number对象是否与参数相等。
4valueOf()
返回一个Integer对象指定的内置数据类型
5toString()
以字符串形式返回值。
6parseInt()
将字符串解析为int类型。
7abs()
返回参数的绝对值。
8ceil()
对整形变量向左取整，返回类型为double型。
9floor()
对整型变量向右取整。返回类型为double类型。
10rint()
返回与参数最接近的整数。返回类型为double。
11round()
返回一个最接近的int、long型值。
12min()
返回两个参数中的最小值。
13max()
返回两个参数中的最大值。
14exp()
返回自然数底数e的参数次方。
15log()
返回参数的自然数底数的对数值。
16pow()
返回第一个参数的第二个参数次方。
17sqrt()
求参数的算术平方根。
18sin()
求指定double类型参数的正弦值。
19cos()
求指定double类型参数的余弦值。
20tan()
求指定double类型参数的正切值。
21asin()
求指定double类型参数的反正弦值。
22acos()
求指定double类型参数的反余弦值。
23atan()
求指定double类型参数的反正切值。
24atan2()
将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25toDegrees()
将参数转化为角度。
26toRadians()
将角度转换为弧度。
27random()
返回一个随机数。


作者: java    时间: 2017-7-4 14:23
Java Character类
使用字符时，我们通常使用的是内置数据类型char。
实例
  1. char ch = 'a';

  3. // Unicode for uppercase Greek omega character
  4. char uniChar = '\u039A';

  6. // 字符数组
  7. char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
复制代码
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情况。为了解决这个问题，Java语言为内置数据类型char提供了包装类Character类。
Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象，例如：
Character ch = new Character('a');
在某些情况下，Java编译器会自动创建一个Character对象。
例如，将一个char类型的参数传递给需要一个Character类型参数时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
实例

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');



前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。
下面列表展示了Java的转义序列：
转义序列
描述
\t在文中该处插入一个tab键
\b在文中该处插入一个后退键
\n在文中该处换行
\r在文中该处插入回车
\f在文中该处插入换页符
\'在文中该处插入单引号
\"在文中该处插入双引号
\\在文中该处插入反斜杠



Character 方法
下面是Character类的方法：
序号
方法与描述
1isLetter()
是否是一个字母
2isDigit()
是否是一个数字字符
3isWhitespace()
是否一个空格
4isUpperCase()
是否是大写字母
5isLowerCase()
是否是小写字母
6toUpperCase()
指定字母的大写形式
7toLowerCase()
指定字母的小写形式
8toString()
返回字符的字符串形式，字符串的长度仅为1
对于方法的完整列表，请参考的java.lang.Character API规范。
作者: java    时间: 2017-7-4 15:12
Java String类字符串广泛应用在Java编程中，在Java中字符串属于对象，Java提供了String类来创建和操作字符串。
和其它对象一样，可以使用关键字和构造方法来创建String对象。
String类有11种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:
  1. public class StringDemo{

  3.    public static void main(String args[]){
  4.       char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.'};
  5.       String helloString = new String(helloArray);  
  6.       System.out.println( helloString );
  7.    }
  8. }
复制代码
注意:String类是不可改变的，所以你一旦创建了String对象，那它的值就无法改变了。 如果需要对字符串做很多修改，那么应该选择使用StringBuffer & StringBuilder 类。
字符串长度
用于获取有关对象的信息的方法称为访问器方法。
String类的一个访问器方法是length()方法，它返回字符串对象包含的字符数。
连接字符串

String类提供了连接两个字符串的方法：
string1.concat(string2);
返回string2连接string1的新字符串。也可以对字符串常量使用concat()方法，如：
"My name is ".concat("Zara");
更常用的是使用'+'操作符来连接字符串，如：
"Hello," + " world" + "!"
结果如下:
"Hello, world!"

创建格式化字符串
我们知道输出格式化数字可以使用printf()和format()方法。String类使用静态方法format()返回一个String对象而不是PrintStream对象。
String类的静态方法format()能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。如下所示：
  1. System.out.printf("The value of the float variable is " +
  2.                   "%f, while the value of the integer " +
  3.                   "variable is %d, and the string " +
  4.                   "is %s", floatVar, intVar, stringVar);
复制代码
你也可以这样写
  1. String fs;
  2. fs = String.format("The value of the float variable is " +
  3.                    "%f, while the value of the integer " +
  4.                    "variable is %d, and the string " +
  5.                    "is %s", floatVar, intVar, stringVar);
  6. System.out.println(fs);
复制代码
String 方法
下面是String类支持的方法，更多详细，参看Java API文档:
SN(序号)
方法描述
1char charAt(int index)
返回指定索引处的 char 值。
2int compareTo(Object o)
把这个字符串和另一个对象比较。
3int compareTo(String anotherString)
按字典顺序比较两个字符串。
4int compareToIgnoreCase(String str)
按字典顺序比较两个字符串，不考虑大小写。
5String concat(String str)
将指定字符串连接到此字符串的结尾。
6boolean contentEquals(StringBuffer sb)
当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
7static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String。
8static String copyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String。
9boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
10boolean equals(Object anObject)
将此字符串与指定的对象比较。
11boolean equalsIgnoreCase(String anotherString)
将此 String 与另一个 String 比较，不考虑大小写。
12byte[] getBytes()
使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13byte[] getBytes(String charsetName)
使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组。
15int hashCode()
返回此字符串的哈希码。
16int indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。
17int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18int indexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引。
19int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20String intern()
返回字符串对象的规范化表示形式。
21int lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现处的索引。
22int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。
24int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25int length()
返回此字符串的长度。
26boolean matches(String regex)
告知此字符串是否匹配给定的正则表达式。
27boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
28boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
29String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30String replaceAll(String regex, String replacement
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31String replaceFirst(String regex, String replacement)
使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。
33String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串。
34boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始。
35boolean startsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36CharSequence subSequence(int beginIndex, int endIndex)
返回一个新的字符序列，它是此序列的一个子序列。
37String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。
38String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
39char[] toCharArray()
将此字符串转换为一个新的字符数组。
40String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41String toLowerCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42String toString()
返回此对象本身（它已经是一个字符串！）。
43String toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44String toUpperCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45String trim()
返回字符串的副本，忽略前导空白和尾部空白。
46static String valueOf(primitive data type x)
返回给定data type类型x参数的字符串表示形式。




作者: java    时间: 2017-7-4 15:53
Java StringBuffer和StringBuilder类
当对字符串进行修改的时候，需要使用StringBuffer和StringBuilder类。
和String类不同的是，StringBuffer和StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder类在Java 5中被提出，它和StringBuffer之间的最大不同在于StringBuilder的方法不是线程安全的（不能同步访问）。
由于StringBuilder相较于StringBuffer有速度优势，所以多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下，则必须使用StringBuffer类。
StringBuffer 方法
以下是StringBuffer类支持的主要方法：
序号
方法描述
1public StringBuffer append(String s)
将指定的字符串追加到此字符序列。
2public StringBuffer reverse()
将此字符序列用其反转形式取代。
3public delete(int start, int end)
移除此序列的子字符串中的字符。
4public insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中。
5replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。
下面的列表里的方法和String类的方法类似：
序号方法描述
1int capacity()
返回当前容量。
2char charAt(int index)
返回此序列中指定索引处的 char 值。
3void ensureCapacity(int minimumCapacity)
确保容量至少等于指定的最小值。
4void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst。
5int indexOf(String str)
返回第一次出现的指定子字符串在该字符串中的索引。
6int indexOf(String str, int fromIndex)
从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7int lastIndexOf(String str)
返回最右边出现的指定子字符串在此字符串中的索引。
8int lastIndexOf(String str, int fromIndex)
返回最后一次出现的指定子字符串在此字符串中的索引。
9int length()
返回长度（字符数）。
10void setCharAt(int index, char ch)
将给定索引处的字符设置为 ch。
11void setLength(int newLength)
设置字符序列的长度。
12CharSequence subSequence(int start, int end)
返回一个新的字符序列，该字符序列是此序列的子序列。
13String substring(int start)
返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14String substring(int start, int end)
返回一个新的 String，它包含此序列当前所包含的字符子序列。
15String toString()
返回此序列中数据的字符串表示形式。


作者: java    时间: 2017-7-4 16:06

Java 数组
https://www.w3cschool.cn/java/java-array.html
Arrays 类
java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：
具体说明请查看下表：
序号
方法和说明
1public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

作者: java    时间: 2017-7-4 16:18
本帖最后由 java 于 2017-7-6 14:25 编辑

Java 日期时间
Java 日期时间
java.util包提供了Date类来封装当前的日期和时间。 Date类提供两个构造函数来实例化Date对象。
第一个构造函数使用当前日期和时间来初始化对象。
Date( )
第二个构造函数接收一个参数，该参数是从1970年1月1日起的微秒数。
Date(long millisec)
Date对象创建以后，可以调用下面的方法。
序号
方法和描述
1boolean after(Date date)
若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2boolean before(Date date)
若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3Object clone( )
返回此对象的副本。
4int compareTo(Date date)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5int compareTo(Object obj)
若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6boolean equals(Object date)
当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8int hashCode( )
返回此对象的哈希码值。
9void setTime(long time)

用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10String toString( )
转换Date对象为String表示形式，并返回该字符串。
获取当前日期时间
Java中获取当前日期和时间很简单，使用Date对象的 toString()方法来打印当前日期和时间，如下所示：
  1. import java.util.Date;
  2.   
  3. public class DateDemo {
  4.    public static void main(String args[]) {
  5.        // 初始化 Date 对象
  6.        Date date = new Date();
  7.         
  8.        // 使用 toString() 函数显示日期时间
  9.        System.out.println(date.toString());
  10.    }
  11. }
复制代码
日期比较
Java使用以下三种方法来比较两个日期：
使用SimpleDateFormat格式化日期
SimpleDateFormat是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat允许你选择任何用户自定义日期时间格式来运行。例如：
  1. import java.util.*;
  2. import java.text.*;

  4. public class DateDemo {
  5.    public static void main(String args[]) {

  7.       Date dNow = new Date( );
  8.       SimpleDateFormat ft =
  9.       new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

  11.       System.out.println("Current Date: " + ft.format(dNow));
  12.    }
  13. }
复制代码
以上实例编译运行结果如下:
  1. Current Date: Sun 2004.07.18 at 04:14:09 PM PDT
复制代码
简单的DateFormat格式化编码
时间模式字符串用来指定时间格式。在此模式中，所有的ASCII字母被保留为模式字母，定义如下：
字母
描述
示例
G纪元标记AD
y四位年份2001
M月份July or 07
d一个月的日期10
h A.M./P.M. (1~12)格式小时12
H一天中的小时 (0~23)22
m分钟数30
s秒数55
S微妙数234
E星期几Tuesday
D一年中的日子360
F一个月中第几周的周几2 (second Wed. in July)
w一年中第几周40
W一个月中第几周1
aA.M./P.M. 标记PM
k一天中的小时(1~24)24
K A.M./P.M. (0~11)格式小时10
z时区Eastern Standard Time
'文字定界符Delimiter
"单引号`
日期和时间转换字符
字符描述例子
c完整的日期和时间Mon May 04 09:51:52 CDT 2009
FISO 8601 格式日期2004-02-09
DU.S. 格式日期 (月/日/年)02/09/2004
T24小时时间18:05:19
r12小时时间06:05:19 pm
R24小时时间，不包含秒18:05
Y4位年份(包含前导0)2004
y年份后2位(包含前导0)04
C年份前2位(包含前导0)20
B月份全称February
b月份简称Feb
n2位月份(包含前导0)02
d2位日子(包含前导0)03
e2位日子(不包含前导0)9
A星期全称Monday
a星期简称Mon
j3位年份(包含前导0)069
H2位小时(包含前导0), 00 到 2318
k2位小时(不包含前导0),  0 到 2318
I2位小时(包含前导0), 01 到 1206
l2位小时(不包含前导0),  1 到 126
M2位分钟(包含前导0)05
S2位秒数(包含前导0)19
L3位毫秒(包含前导0)047
N9位纳秒(包含前导0)047000000
P大写上下午标志PM
p小写上下午标志pm
z从GMT的RFC 822数字偏移-0800
Z时区PST
s自 1970-01-01 00:00:00 GMT的秒数1078884319
Q自 1970-01-01 00:00:00 GMT的毫妙1078884319047
还有其他有用的日期和时间相关的类。对于更多的细节，你可以参考到Java标准文档。

解析字符串为时间
SimpleDateFormat 类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat 对象的格式化存储来解析字符串。例如：
  1. import java.util.*;
  2. import java.text.*;
  3.   
  4. public class DateDemo {

  6.    public static void main(String args[]) {
  7.       SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");

  9.       String input = args.length == 0 ? "1818-11-11" : args[0];

  11.       System.out.print(input + " Parses as ");

  13.       Date t;

  15.       try {
  16.           t = ft.parse(input);
  17.           System.out.println(t);
  18.       } catch (ParseException e) {
  19.           System.out.println("Unparseable using " + ft);
  20.       }
  21.    }
  22. }
复制代码
Java 休眠(sleep)
你可以让程序休眠一毫秒的时间或者到您的计算机的寿命长的任意段时间。例如，下面的程序会休眠10秒：
  1. import java.util.*;
  2.   
  3. public class SleepDemo {
  4.    public static void main(String args[]) {
  5.       try {
  6.          System.out.println(new Date( ) + "\n");
  7.          Thread.sleep(5*60*10);
  8.          System.out.println(new Date( ) + "\n");
  9.       } catch (Exception e) {
  10.           System.out.println("Got an exception!");
  11.       }
  12.    }
  13. }
复制代码
测量时间
下面的一个例子表明如何测量时间间隔（以毫秒为单位）：
  1. import java.util.*;
  2.   
  3. public class DiffDemo {

  5.    public static void main(String args[]) {
  6.       try {
  7.          long start = System.currentTimeMillis( );
  8.          System.out.println(new Date( ) + "\n");
  9.          Thread.sleep(5*60*10);
  10.          System.out.println(new Date( ) + "\n");
  11.          long end = System.currentTimeMillis( );
  12.          long diff = end - start;
  13.          System.out.println("Difference is : " + diff);
  14.       } catch (Exception e) {
  15.          System.out.println("Got an exception!");
  16.       }
  17.    }
  18. }
复制代码
Calendar类

我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。
Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
创建一个代表系统当前日期的Calendar对象

Calendar c = Calendar.getInstance();//默认是当前日期
创建一个指定日期的Calendar对象

使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
Calendar类对象字段类型

Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想
常量
描述
Calendar.YEAR年份
Calendar.MONTH月份
Calendar.DATE日期
Calendar.DAY_OF_MONTH日期，和上面的字段意义完全相同
Calendar.HOUR12小时制的小时
Calendar.HOUR_OF_DAY24小时制的小时
Calendar.MINUTE分钟
Calendar.SECOND秒
Calendar.DAY_OF_WEEK星期几
Calendar类对象信息的设置
Set设置
如：
Calendar c1 = Calendar.getInstance();
调用：
public final void set(int year,int month,int date)
c1.set(2009, 6 - 1, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12
利用字段类型设置
如果只设定某个字段，例如日期的值，则可以使用如下set方法：
public void set(int field,int value)
把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算
c1.set(Calendar.DATE,10);
把c1对象代表的年份设置为2008年，其他的所有数值会被重新计算
c1.set(Calendar.YEAR,2008);
其他字段属性set的意义以此类推
Add设置
Calendar c1 = Calendar.getInstance();
把c1对象的日期加上10，也就是c1所表的日期的10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
把c1对象的日期减去10，也就是c1所表的日期的10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);
其他字段属性的add的意义以此类推


作者: java    时间: 2017-7-6 14:28
本帖最后由 java 于 2017-7-6 14:45 编辑

Java 正则表达式
https://www.w3cschool.cn/java/java-regular-expressions.html

java.util.regex包主要包括以下三个类：
  1. import java.util.regex.Matcher;
  2. import java.util.regex.Pattern;

  4. public class RegexMatches
  5. {
  6.     public static void main( String args[] ){

  8.       // 按指定模式在字符串查找
  9.       String line = "This order was placed for QT3000! OK?";
  10.       String pattern = "(.*)(\\d+)(.*)";

  12.       // 创建 Pattern 对象
  13.       Pattern r = Pattern.compile(pattern);

  15.       // 现在创建 matcher 对象
  16.       Matcher m = r.matcher(line);
  17.       if (m.find( )) {
  18.          System.out.println("Found value: " + m.group(0) );
  19.          System.out.println("Found value: " + m.group(1) );
  20.          System.out.println("Found value: " + m.group(2) );
  21.       } else {
  22.          System.out.println("NO MATCH");
  23.       }
  24.    }
  25. }
复制代码


正则表达式语法
字符
说明
\
将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，"n"匹配字符"n"。"\n"匹配换行符。序列"\\"匹配"\"，"\("匹配"("。
^
匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。
$
匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。
*
零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。
+
一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。
?
零次或一次匹配前面的字符或子表达式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。
{n}
n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。
{n,}
n 是非负整数。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*"。
{n,m}
M 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。'o{0,1}' 等效于 'o?'。注意：您不能将空格插入逗号和数字之间。
?
当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。
.
匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。
(pattern)
匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"\("或者"\)"。
(?:pattern)
匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。
(?=pattern)
执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
(?!pattern)
执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
x|y
匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。
[xyz]
字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。
[^xyz]
反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。
[a-z]
字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
[^a-z]
反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。
\b
匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
\B
非字边界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。
\cx
匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。
\d
数字字符匹配。等效于 [0-9]。
\D
非数字字符匹配。等效于 [^0-9]。
\f
换页符匹配。等效于 \x0c 和 \cL。
\n
换行符匹配。等效于 \x0a 和 \cJ。
\r
匹配一个回车符。等效于 \x0d 和 \cM。
\s
匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S
匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\t
制表符匹配。与 \x09 和 \cI 等效。
\v
垂直制表符匹配。与 \x0b 和 \cK 等效。
\w
匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
\W
与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。
\xn
匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。
\num
匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。
\n
标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
\nm
标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
\nml
当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
\un
匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。
Matcher类的方法索引方法
索引方法提供了有用的索引值，精确表明输入字符串中在哪能找到匹配：
序号
方法及说明
1public int start()
返回以前匹配的初始索引。
2public int start(int group)
返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
3public int end()
返回最后匹配字符之后的偏移量。
4public int end(int group)
返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
研究方法
研究方法用来检查输入字符串并返回一个布尔值，表示是否找到该模式：
序号
方法及说明
1public boolean lookingAt()
尝试将从区域开头开始的输入序列与该模式匹配。
2public boolean find()
尝试查找与该模式匹配的输入序列的下一个子序列。
3public boolean find(int start）
重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
4public boolean matches()
尝试将整个区域与模式匹配。
替换方法
替换方法是替换输入字符串里文本的方法：
序号
方法及说明
1public Matcher appendReplacement(StringBuffer sb, String replacement)
实现非终端添加和替换步骤。
2public StringBuffer appendTail(StringBuffer sb)
实现终端添加和替换步骤。
3public String replaceAll(String replacement)
替换模式与给定替换字符串相匹配的输入序列的每个子序列。
4public String replaceFirst(String replacement)
替换模式与给定替换字符串匹配的输入序列的第一个子序列。
5public static String quoteReplacement(String s)
返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。
start 和end 方法
下面是一个对单词"cat"出现在输入字符串中出现次数进行计数的例子：
  1. import java.util.regex.Matcher;
  2. import java.util.regex.Pattern;

  4. public class RegexMatches
  5. {
  6.     private static final String REGEX = "\\bcat\\b";
  7.     private static final String INPUT =
  8.                                     "cat cat cat cattie cat";

  10.     public static void main( String args[] ){
  11.        Pattern p = Pattern.compile(REGEX);
  12.        Matcher m = p.matcher(INPUT); // 获取 matcher 对象
  13.        int count = 0;

  15.        while(m.find()) {
  16.          count++;
  17.          System.out.println("Match number "+count);
  18.          System.out.println("start(): "+m.start());
  19.          System.out.println("end(): "+m.end());
  20.       }
  21.    }
  22. }
复制代码
作者: java    时间: 2017-7-6 15:18
本帖最后由 java 于 2017-7-6 16:39 编辑

Java 异常处理
https://www.w3cschool.cn/java/java-exceptions.html

throws/throw关键字：
如果一个方法没有捕获一个检查性异常，那么该方法必须使用throws 关键字来声明。throws关键字放在方法签名的尾部。
也可以使用throw关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
下面方法的声明抛出一个RemoteException异常：
  1. import java.io.*;
  2. public class className
  3. {
  4.    public void deposit(double amount) throws RemoteException
  5.    {
  6.       // Method implementation
  7.       throw new RemoteException();
  8.    }
  9.    //Remainder of class definition
  10. }
复制代码

Java 继承https://www.w3cschool.cn/java/java-inheritance.html
继承中最常使用的两个关键字是extends和implements。

IS-A关系
通过使用关键字extends，子类可以继承父类的除private属性外所有的属性。
我们通过使用instanceof 操作符，能够确定Mammal IS-A Animal

Implements关键字使用在类继承接口的情况下， 这种情况不能使用关键字extends。

HAS-A 关系
HAS-A代表类和它的成员之间的从属关系。这有助于代码的重用和减少代码的错误。
  1. public class Vehicle{}
  2. public class Speed{}
  3. public class Van extends Vehicle{
  4.         private Speed sp;
  5. }
复制代码
Van类和Speed类是HAS-A关系(Van有一个Speed)，这样就不用将Speed类的全部代码粘贴到Van类中了，并且Speed类也可以重复利用于多个应用程序。
在面向对象特性中，用户不必担心类的内部怎样实现。
Van类将实现的细节对用户隐藏起来，因此，用户只需要知道怎样调用Van类来完成某一功能，而不必知道Van类是自己来做还是调用其他类来做这些工作。
Java只支持单继承，也就是说，一个类不能继承多个类。
Java只支持单继承（继承基本类和抽象类），但是我们可以用接口来实现（多继承接口来实现）,脚本结构如：
  1. public class Apple extends Fruit implements Fruit1, Fruit2{}
复制代码
一般我们继承基本类和抽象类用extends关键字，实现接口类的继承用implements关键字。


Java 重写(Override)与重载(Overload)
https://www.w3cschool.cn/java/java-override-overload.html
Super关键字的使用
当需要在子类中调用父类的被重写方法时，要使用super关键字。

区别点
重载方法
重写方法
参数列表必须修改一定不能修改
返回类型可以修改一定不能修改
异常可以修改可以减少或删除，一定不能抛出新的或者更广的异常
访问可以修改一定不能做更严格的限制（可以降低限制）


ss
作者: java    时间: 2017-7-11 09:59
Java 接口https://www.w3cschool.cn/java/java-interfaces.html




接口的实现
当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。






欢迎光临 firemail (http://firemail.wang:8088/) Powered by Discuz! X3