标签：java api 声明 面向 tab 线程 命令 rand exist 十进制
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
博客中要分别讨论的java专题：
- Calendar类
- File类
- Number类
计算机中字节（byte）是最小的存储单元，1byte=8bits。
内存：随机访问存储器（RAM）。内存中每一个字节都有其唯一的地址。
点距是指像素之间以毫米为单位的距离，点距越小，显示效果越好。
计算机能够理解的语言是机器语言，为了使用方便创建了汇编语言（低级语言）。
汇编语言-->汇编器-->机器代码文件
高级语言源代码-->解释器-->机器代码/虚拟机器代码-->立刻执行
高级语言源代码-->编译器-->机器代码文件-->执行机器代码文件
多道程序设计允许多个程序通过共享CPU同时运行。
多线程允许单个程序同时执行多个任务
多处理（并行处理）是指使用两个或者多个处理器同时并行执行子任务，然后将子任务的结果合并以得到整个任务的结果。
java语言定义了Java的语法，Java库在java API中定义，JDK是用于开发和运行java程序的软件。IDE是快速开发程序的集成开发环境。
java:源程序（.java）-->编译-->字节码（.class）（+库代码）-->JVM执行-->结果
JVM执行字节码的过程就是将字节码中的单独的一步翻译为目标机器语言代码，然后立即执行，然后继续解释下一步字节码。
jvm执行一个java程序时，JVM首先会使用一个类加载器的程序将类中的字节码加载到内存中，如果程序中使用到了其他的类，那么类加载器会在使用它们之前动态的加载那些需要的类。当加载该类后，JVM使用一个称为字节码验证器的程序来检验字节码的合理性，确保字节码不会违反Java 的安全规范。
命令行编译执行hello.java文件：javac hello.java生成.class文件java hello执行hello.class文件，注意不能写成java hello.class 否则机器会查找执行hello.class.class文件。
java中的错误：
错误提示|原因
--|---|--
NoClassDefFoundError|运行一个不存在的类时
NoSuchMethodError|类中没有正确的main方法
NullPointerException|调用值为null的引用变量上的方法时会发生此类异常
ArrayIndexOutOfBoundsException|访问数组下标越界时
InputMismatchException|用户输入类型与设定类型不匹配时
程序中事物的名字称为标识符，标识符组成：
首字母：字母、下划线、美元符号
其余：字母、下划线、美元符号、数字
不能是保留字或者true false null
长度任意
习惯上，字符$只用于机器自动生成的代码片中
java数值类型：
类型名|存储大小|Scnner对象方法|最大值|最小值|直接量表示
--|---|--
byte|8位带符号数|nextByte()|Byte.MAX_VALUE|Byte.MIN_VALUE|
short|16位带符号数|nextShort()|Short.MAX_VALUE|.MIN_VAULE|
int|32位带符号数|nextInt()|Integer.MAX_VALUE|Integer.MIN_VAULE|
long|64位带符号数|nextLong()|Long.MAX_VALUE|Long.MIN_VAULE|l或L(21343L)
float|32位，标准IEEE754|nextFloat()|Float.MAX_VALUE|Float.MIN_VAULE|f或F(234.45F)
double|64位，标准IEEE754|nextDouble()|Double.MAX_VALUE|Double.MIN_VAULE
引用类型|
String||next()或nextLine()|
next()方法读取以空白字符结束的字符串（空格，\t,\r,\f,\n）
nextLine()方法读取以回车键为结束标志的字符串
不要在读取数值类型的next方法（nextInt()等）和next()后使用nextLine(),以避免引发错误
整型直接量默认是一个十进制的 int类型的数字
浮点型直接量默认是double类型的数字
为了提高可读性，java允许在数值直接量中两个数字之间添加下划线long ssn=123_456L
引用类型直接量的默认值是null
true和false是直接量；
进制|表示|示例
--|---|--
二进制|0b或0B|0B1100110
八进制|0|06754
十进制|无|2341
十六进制|0x或0X|0XFFFF
17.科学计数法：123E-2等同于$$123*10^{-2}$$
18. java中int类型与Boolean类型之间无法进行（强制）转化。
19. 布尔操作符
| 操作符 | 名称 | 说明 |
|---|---|---|
| ！ | 非 | 逻辑非 |
| && | 与 | 逻辑与 |
| || | 或 | 逻辑或 |
| ^ | 异或 | 逻辑异或 |
switch(switch 表达式){
case vaule1:语句（组）1；
break；
case vaule2:语句（组）2；
break;
……
default:默认情况下执行的语句组
}
- switch表达式必须能够计算出一个
char byte short 或 string类型的值，并且必须总是要用括号括住- vaule1,vaule2,……必须与switch表达式的值具有相同的数据类型，且必须为常量表达式，即不能包含变量。
| 方法 | 描述 |
|---|---|
| sin(radians) | 返回以弧度为单位的角度的三角正弦函数值 |
| cos(radians) | |
| tan(radians) | |
| toRadians(degree) | 将以度为单位的角度转化为以弧度表示 |
| toDegree(radians) | |
| asin(a) | 返回以弧度为单位的角度的反三角值 |
| acos() | |
| atan() | |
| exp(x) | 返回e的x次方 |
| log(x) | 返回x的自然底数 |
| log10(x) | 返回x的以10为底的对数 |
| pow(a,b) | 返回a的b次方 |
| sqrt(x) | 对于x>=0，返回x的平方根 |
| ceil(x) | x向上取整为他最接近的整数，返回double |
| floor(x) | x向下取整为他最接近的整数，返回double |
| rint(x) | 取x最接近的整数，与两个整数距离相等时取偶数 |
| round(x) | 四舍五入，x为单精度数时返回int,双精度数时返回double |
| min(a,b) | 返回数字最小值 |
| max(a,b) | |
| abs(a) | 返回数字绝对值 |
| random() | 返回0.0到1.0之间的double类型 |
Math类不需要导入，因为它在java.lang包中，在一个java程序中java.lang包中的所有类都是隐式导入的。
char 型数据可以被转化为任意数据类型，反之亦然。
将整数转化为char型数据时只用到该数据的低16位，其余的部分都被忽略。
0~FFFF内的所有十六进制正整数都可以隐式的转化为char类型。
Character类中的方法：
方法|描述
--|---|--
isDigit(ch)|如果指定的字符是一个数字，返回true
isLetter(ch)|如果指定的字符是一个字母，返回true
isLetterOrDigit(ch)|如果指定的字符是一个数字或字母，返回true
isLowCase(ch)|如果指定的字符是一个小写字母返回true
isUpperCase(ch)|大写字母
toLowCaese(ch)|转化为小写字母
toUpperCase(ch)|大写
String对象的简单方法
方法|描述
--|---|--
length()|返回字符串中的字符数
charAt(index)|返回字符串s中指定位置的字符
concat(s1)|将本字符串和s1连接，返回一个新的字符串
toUpperCase()|返回一个新的字符串，其中所有的字母大写
toLowCase()|返回一个新的字符串，其中所有的字母小写
replace（oldChar:char,newChar:char）:String|将字符串中所有匹配的字符替换成新的字符，并返回新的字符串
replaceFirst(oldString:String,newString:String):String|将字符串中第一个匹配的子字符串转换成新的子字符串，然后返回新的字符串
replaceAll(oldString:String,newString:String):String|将字符串中所有匹配的子字符串转换成新的子字符串，然后返回新的字符串
split(delimiter:String):String[]|返回一个字符串数组，其中包含被分隔符分隔的子字符串集
toCharArray()|将字符串转化为char型数组
字符串对象的比较方法
方法|描述
--|---|--
equals(s1)|如果该字符串的内容与s1的相同，返回true
equalsIgnoreCase(s1)|如果该字符串的内容与s1的相同，返回true;不区分大小写
声明数组变量：
elementType[] arrayRefVar;//仅仅声明一个数组变量，并不在内存中给数组分配任何空间，只是创建一个对数组的引用的存储位置。
elementType arrayRefVar[];//作用同上，C/C++风格
arrayRefVar=new elementType[arraySize]//创建数组，并将数组的引用赋值给数组变量
//当创建数组后，它的元素会被赋予默认值，其中数值型基本数据类型的默认值为0，char型的基本数据类型为‘\u0000‘,boolean型的默认值为false，String型的默认初始值为null(因为String变量是引用类型，默认值为null)
public class test {
public static void main(String[] args) {
int[] a=new int[]{1,2,3,4,5};
int[] b=a;//传递的是一个引用，a与b同时指向同一个对象
a[0]=9;
System.out.println(a[0]);//9
System.out.println(b[0]);//9
}
}
int[] a={1,2,3,4,5,6,7,8};
int[] b=a;//a与b 指向同一个数组对象
//使用循环语句逐个的复制数组中的元素
int[] c=new int[a.length];
for(int i=0;i<a.length;i++){
c[i]=a[i];
}
//使用System类中的静态方法arraycopy复制数组
int srcPoint=0;//源数组中复制元素的起始位置
int tarPoint=0;//目标数组中复制元素的起始位置
int length=a.length;//从源数组中复制元素的个数
int[] d=new int[a.length];
System.arraycopy(a,srcPoint,d,tarPoint,length);
//使用clone方法
int[] e=new int[a.length];
e=a.clone();
elementType...varArray变量类型和数组名，其中一个方法中只能有一个可变长度参数列表，且只能在参数列表的最后声明。package Chapter7;
/**
* Created by sf on 2017/8/20.
*/
public class test {
/**
*将数组中的元素打印输出
*@param array 要打印的数组
*@author sf
*/
public static void printArray(int...array){
for(int e:array){
System.out.print(e+" ");
}
System.out.println();
}
public static void main(String[] args) {
test.printArray(1,2,3,4,5);
test.printArray(11,22,3,44,55,667,8);
int[] a={6,7,8,9,0};
test.printArray(a);
test.printArray(11,22,3,44,55,667,8);
}
}
package Chapter7;
import java.util.Arrays;
/**
* Created by sf on 2017/8/20.
*/
public class test {
/**
*将数组中的元素打印输出
*@param array 要打印的数组
*@author sf
*/
public static void printArray(int...array){
for(int e:array){
System.out.print(e+" ");
}
System.out.println();
}
public static void main(String[] args) {
int[] a={1,4,2,5,2,6,3,67,23,523,62,46,7};
System.out.println("Array a:"+ Arrays.toString(a));
int[] b=a.clone();
// 对整个数组进行排序
Arrays.sort(b);
System.out.println("Array b:"+Arrays.toString(b));
int[] c=a.clone();
// 对数组进行部分排序
Arrays.sort(c,2,7);
System.out.println("Array c:"+Arrays.toString(c));
int[] d=a.clone();
// 对整个数组进行排序
Arrays.parallelSort(d);//使用与sort()方法类似，但是当电脑有多个处理器的时候，这种方法更加高效
System.out.println("Array b:"+Arrays.toString(d));
int[] e=a.clone();
// 对数组进行部分排序
Arrays.parallelSort(e,2,7);
System.out.println("Array c:"+Arrays.toString(e));
// 二分查找数组中的关键字
System.out.println(Arrays.binarySearch(a,2));
int[] f=a.clone();
System.out.println(Arrays.equals(a,f));//true
System.out.println(Arrays.equals(a,e));//false
int[] g=new int[8];
int[] h=g.clone();
Arrays.fill(g,8);//将8填充满整个的数组
System.out.println(Arrays.toString(g));
Arrays.fill(h,2,5,6);//将8填充到数组2,3,4位置上
System.out.println(Arrays.toString(h));
}
}
args=new String[n],如果在运行时没有参数传入main方法,那么使用new String[0]创建数组，在这种情况下该数组时长度为0的空数组，args是对这个数组的引用。因此args不是null但是args.length=0 int[][] a={
{1,2,3,4,5},
{1,2,3,},
{1,2,3,4},
{1,2,3},
{1,2}
};
int[][] b=new int[3][];//第一个下标是必须指定的，否则会产生语法错误
b[0]=new int[5];
b[1]=new int[6];
b[2]=new int[3];
创建一个Random对象时，必须指定一个种子或者使用默认的种子。种子是一个用于初始化一个随机数字生成器的数字。无参数构造方法使用当前已经逝去的时间作为种子。如果两个Random对象有相同的种子，那他们将产生相同的数列。
子类可以重写它父类中protected方法，并将它的可见性改为public。但是子类不能削弱父类中定义方法的可访问性。例如：如果父类中的方法定义为public，在子类中重写时也必须定义为public。
53. 向方法传递对象参数，是将对象的引用传递给方法
54. 数组既可以存储基本类型值，也可以存储对象。
55. 实例变量和静态变量的作用域是整个类，无论变量在哪个地方声明
56. 如果一个局部变量和一个类变量具有同样的名字，那么局部变量优先。
57. 关键字this引用自身，它也可以用于在构造方法内部调用同一个类的其它的构造方法。
58. 在引用隐藏数据域以及调用一个重载的构造方法时，必须使用this关键字。
59. Java要求在构造方法中，this应在其它任何可执行语句之前出现。
public class Test {
Test(int a){
System.out.println("hello,"+a);
}
Test(double a){
System.out.println("hello,"+a);
}
Test(){
this(1);//必须是第一个语句，所以在一个构造方法中只能调用本类的一个重载构造方法
}
public static void main(String[] args) {
Test test=new Test();
}
}
package Chapter10;
/**
* Created by sf on 2017/8/22.
*/
public class Test {
public static void main(String[] args) {
//创建一个字符串
// 使用字符串直接量创建,如果内存中已经有相同字符串的实例，那么此字符串直接引用内存中字符串对象而不创建新的对象。
String s1="Welcome";//将其看作是String对象
// 创建String对象，直接创建一个新的对象，并将对象引用返回给字符串变量
String s2=new String("Welcome");
// 使用字符数组创建一个字符串
char[] charArray={‘W‘,‘e‘,‘l‘,‘c‘,‘o‘,‘m‘,‘e‘};
String s3=new String(charArray);
String s4="Welcome";
System.out.println(s1==s2);//false
System.out.println(s1==s3);//false
System.out.println(s1==s4);//true
}
}
String s1=String.format("%5d%4f,%7s",123,23.4,"herllo");
- 子类并不是父类的一个子集，实际上，一个子类往往包含比父类更多的方法和信息。
- 不是所有的是一种（is-a）关系都该用继承，正方形是一种矩形，但正方形继承矩形并不合适
- 继承是用来为是一种（is-a）关系建模的。不要仅仅为了重用代码这一个原因而盲目的扩展一个类。父类和子类之间必须存在（is-a）关系。
- 在java中，一个类只能继承自唯一的一个类，这种继承被称为单一继承。
super();方法重写(method overriding)System.out.println(Object);//隐式调用Object.toString()
引用类型调用方法时，它所调用的方法由它的实际类型决定。这称为动态绑定。
动态绑定的工作机制：假设
Object o=new C1();o.method();（中间存在着隐式类型转化）类C1是C2的子类，C2是C3的子类。。。Cn-1是Cn的子类。也就是说C1是最特殊的类，Cn是最通用的类（在java中是Object类），(如果o是C1的实例，那么他也是C2,C3.......Cn的实例),如果对象o调用一个方法method()，那么JVM回依次在类C1,C2,...,Cn中查找方法method（）的实现，知道找到为止。一旦找到这个实现，就会停止然后调用这个首先找到的实现。
89. 总是可以将子类型的实例转化为父类型的实例变量，称为向上转换，因为子类的实例永远是他父类的实例。当把一个父类实例转换为它的子类变量（称为向下转换），必须使用转换标记“（子类名）“进行显示转换。
90. 个人理解向下转换的使用：
public class Test {
public static void main(String[] args) {
Test1 t=new Test2();
if(t instanceof Test2) {
Test2 t2 = (Test2) t;
t2.function1();
}
}
}
class Test1{
public Test1(){
// this.toString1();
}
public String toString(){
System.out.println("Test1.toString");
return null;
}
public void function1(){
System.out.println("Test1.function1");
}
}
class Test2 extends Test1{
public Test2(){
// this.toString1();
}
public String toString(){
System.out.println("Test2.toString");
return null;
}
public void function1(){
System.out.println("Test2.function1");
}
}
class Test3 extends Test2{
public Test3(){
// toString1();
}
public String toString1(){
System.out.println("Test3.toString");
return null;
}
}
为了能够进行通用程序设计，一个好的经验是把变量定义为父类型，这样，它就能够接受任何子类型的值
91. 如同toString（）方法，equal（Object）方法是定义在Object类中的另一个有用的方法。Object类中的实现是使用“==”判定两个变量是否指向同一个对象。因此一般要在自己的类中重写equal()方法。
92. ArrayList对象可以存储一个对象列表。
| 方法 | 描述 |
|---|---|
| ArrayList（） | 创建一个空的列表 |
| add（） | 添加一个新的元素到该列表的末尾，或者指定下标处 |
| clear() | 清空列表中的所有元素 |
| contains（） | 如果列表中包含某一特定的元素，返回true |
| get() | 返回列表中指定下标位置的元素 |
| indexOf() | 返回列表中第一个匹配元素的下标 |
| isEmpty() | 如果列表为空返回true |
| lastIndexOf() | 返回列表中最后一个元素的下标 |
| remove() | 去除列在表中的第一个元素，去除成功则返回true |
| size() | 返回列表中元素的个数 |
| set | 设置指定下标位的元素 |
public class QuotientWothException {
public static int quotient(int number1,int number2){
if(number2==0){
// 抛出的值“new ArithmeticException("Divisor can‘t be zero!")”称为一个异常。throw
// 语句的执行称为抛出一个异常
// 异常就是从异常类中创建的一个对象
// 当异常被抛出的时候，正常执行的流程会被中断。
// 异常被catch块所捕获，catch块中的代码得以执行以处理异常
// 之后catch块外剩下的代码得以执行
// throw语句类似于方法的调用，但不同于调用方法的是，它调用的是catch块。
// 从某种意义上来讲，catch块就像带参数的方法定义，这些参数匹配抛出的值的类型
throw new ArithmeticException("Divisor can‘t be zero!");
}
return number1/number2;
}
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
try {
System.out.println(quotient(input.nextInt(), input.nextInt()));
}
// 标识符ex的作用很像方法中的参数。所以这个参数称为catch块中的参数。
// ex之前的类型称为指定的catch块可以捕获的异常的类型
// 一个异常可以通过try块中的throw语句直接抛出，或者通过在块中调用一个可能会抛出异常的方法来抛出
catch (ArithmeticException ex){
System.out.println(ex.getMessage());
}
}
}
- 这些异常可以分为三类：系统错误，异常和运行时错误
- 系统错误是由java虚拟机抛出的。用error类表示。error类描述的是内部系统错误。
- 异常是用Exception类表示的，它描述的是由程序和外部环境造成的错误。
- 运行时异常是用RuntimeException表示的它描述的是程序的设计错误，例如，错误的类型转换，访问一个越界数组等
- RuntimeException和Error以及他们的子类都被称为免疫异常。所有其他异常都被称为必检异常，意思是编译器会强制程序员检查并通过try-catch块处理他们
- 在大多数情况下，免疫异常都会反映出程序设计上不可恢复的逻辑错误。
声明异常：每个方法都必须在方法头中显式声明它可能抛出的必检异常的类型。这称为声明异常。
如果方法没有在父类中声明异常，那么就不能在子类中对其进行继承来声明异常。
throw关键字用于抛出异常，throws关键字用于声明异常
100.捕获异常：如果try块中的某一条语句捕获了一个异常，java就会跳过try块中的剩余的语句，然后开始查找处理这个异常的代码的过程。处理这个异常的代码称为异常处理器。
可以从当前的方法开始，沿着方法的调用链，按照异常的反向传播方向找到合适的异常处理器。从第一个到最后一个逐个的检查catch块，判断catch筷子中的异常类型是否是该语句块的异常类型。如果是，就将该异常对象赋值给所声明的变量，然后执行catch块中的代码，如果不是，就退出当前方法，将异常传递给调用这个方法的方法。继续同样的过程来查找处理器。
如果在调用的方法链中找不到对象的处理器，程序就会终止并且在控制台中打印出错误信息。
s=>start: 开始
e=>end：结束
code=>condition: 有无异常抛出？
try=>operation: 执行try块
finally=>operation: 执行finally块
finally1=>operation: 执行finally块
finally2=>operation: 执行finally块
catch=>operation: 执行catch块
throw=>operation: 传递异常给调用者
iscatched=>condition: 是否被捕获
s->try->code
code(yes)->iscatched
code(no)->finally
iscatched(yes)->catch
iscatched(no)->finally1->throw
catch->finally2->
public class TestFileClass {
public static void main(String[] args) throws IOException {
File file=new File("/demo");
System.out.println(file.exists());//如果文件或者文件路径存在，返回true
System.out.println(file.getAbsolutePath());//获取文件或者文件路径的绝对路径
System.out.println(file.isDirectory());//file对象存在且代表一个目录时，返回true
System.out.println(file.isFile());//file对象存在且代表一个文件时，返回true
File file1=new File(file,"test.txt");//file为一个路径，在file路径下创建一个子路径
System.out.println(file1.getAbsolutePath());
System.out.println(new Date(file1.lastModified()).toString());//返回文件最后一次被修改的时间
System.out.println(file1.isFile());
System.out.println(file1.isAbsolute());//file1是用绝对路径创建时返回true
System.out.println(file1.isHidden());//file1对象代表的文件是隐藏文件时返回true
System.out.println(file1.getCanonicalPath());//和getAboulutePath()相同，除了从路径名中去除了一些亢余字符
System.out.println(file1.getName());//返回file对象代表的目录和文件名单的最后文件名
File file2=new File("fileTest/test.txt");
System.out.println(file2.exists());//false
System.out.println(file2.mkdir());
System.out.println(file2.exists());
System.out.println(file2.getAbsolutePath());
}
}
- 抽象方法不能包含在子抽象类中，如果抽象类的子类不能实现父类的所有抽象方法，那么子类也应该定义为抽象的。
- 抽象方法是非静态的
- 抽象类是不能够使用new操作符来实例化的。但是仍然可以定义它的构造方法，这个构造方法在他的子类的构造方法中使用。
- 包含抽象方法的类必然是抽象的，但是可以定义一个不包含抽象方法的抽象类。在这种情况下同样不能使用new操作符创建抽象类的实例。
- 子类 可以覆盖父类的构造方法并将它定义为abstract.
- 即使子类的父类是具体的子类也可以是抽象的。
- 抽象类、抽象方法使用斜体表示
- 接口名字和方法使用斜体，并且接口名字出应注明"《interface》",
- 可见性修饰符表示：private（-），public（+），protected（#）
- 静态方法，静态成员加下划线表示
- 父类的方法在子类中通常是被忽略的
- 实线和空心三角形用于表示指向父类
- 虚线和空心三角形用于表示指向接口
Introduce to Java Programming:NOTE
标签：java api 声明 面向 tab 线程 命令 rand exist 十进制
原文地址：http://www.cnblogs.com/gao7fei/p/7591432.html
