java基础梳理--朝花夕拾（二）

1、Java语言语法规则和文件格式；

第一个Java程序：
/**
第一个Java程序：
控制台输出Hello world！
*/
public class Test{
//访问修饰符 class关键词用于声明类使用后面跟类名
public static void main(String args[]){//程序的入口，主函数main方法；
System.out.println(“Hello world!”);// 输出语句
}
}

Java语言区分大小写；
public 为访问修饰符；
class关键词，用于声明类；
/**/ 多行注释；注释掉内容不被程序视为可执行内容；
//单行注释；
一条语句结束，需要通过“;” 分号结束，表示这条语句已经结束；
Java语言可以通过空格或者换行符、制表符等将其分隔开.

文件格式：一个Java程序，需要有类的声明，一般一个.java 文件中只有一个类；但是，也可以有多个class存在，此时主意：一个.java文件中，只能存在一个public 修饰的类，即：一个java文件名，应该与这个文件中public 修饰的类名相同；一个java文件中只能存在一个public 修饰的类；

2、程序的入口主函数（主方法）；

在java中主函数main方法，语句格式如下：public static void main(String args[]){}

主函数只能存在于public修饰的类中；否则无法执行该主方法；如果放到其他没有被public修饰的类中，没语法错误，但是无法执行。

3、变量的声明和赋值；

变量主要用于数据的存储，需先声明再使用；
1、全局变量：声明在类中，方法外，多个方法可同时使用,也被称作“属性”、类变量、成员变量等；可以不赋初始值；全局变量可以在类型前面加访问修饰符，来控制该变量被访问的范围：
例如：
private int i=100;
pulic String str=“”;
protected short t;

2、局部变量：声明在方法中，供当前方法使用；声明是必须赋值或者使用时必须有赋值操作；
例如：
字节型：byte b=99;
短整型：int i=11;
整型： short t=5;
长整型：long l=1898989;
字符串变量：String str=“HELLO”;
浮点型：单精度：float f=1.78;
浮点型：双精度：double d=1.7878787878;
布尔类型： boolean b=true;
字符型：char c=‘A’;

4、Java中数据类型的分类；

Java中可以分为两大类数据类型：
1、基本数据类型：
整型：
字节型（8位）： byte -128到127之间的任意整数
短整型（16位）： short -32768~32767之间的任意整数
整型（32位）：int -2^31到2^31-1之间的任意整数
长整型（64位）：long -2^63到2^63-1之间的任意整数
浮点型：
单精度（32位）：float 32位单精度浮点数根据IEEE754-1985标准
双精度（64位）：double
布尔类型： boolean （true/false）
字符型(16位)：char

2、引用数据类型：引用类型的内存单元中只存放对象的地址，而对象本身存贮在内存堆中，只是简单的引用对象的地址。非基本数据类型变量，都是引用数据类型；
（1）类class 例如：Object类 Date类
（2）接口interface
（3）数组array

5、基本数据类型之间的转换；

在Java中有如下几种转换方式：
1、隐式转换（亦称自动类型转换）：系统默认将其转换为我们需要的数据类型；
转换规则：从存储范围小的类型到存储范围大的类型。
具体规则为：byte→short(char)→int→long→float→double

也就是说 short类型的变量可以自动转换为 int 类型
例如：short t=10，10默认为int类型；
注意：在java中，整数默认为int类型，小数默认为double类型；

2、强制转换：在变量前加小括号，写转换类型，将其强制转换为指定类型；强制类型转换，也称显式类型转换，是指必须书写代码才能完成的类型转换。
该类类型转换很可能存在精度的损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。
转换规则:从存储范围大的类型到存储范围小的类型。
具体规则为：double→float→long→int→short(char)→byte
语法格式为：(转换到的类型)需要转换的值
例如：
(1)byte<- short<-int<-long(这里表示赋值方向)例如：
int i=10；short t=(short)i;
float f=(float)10.123;
long l=10; int i2=(int) l; short t2=(short) l;
(2) double->float;（double赋值给float类型）
float/double->（byte/short/int/long）例如：
float f=(float)10.123; float f=10.123f;
double d=10.123;int i3=(int) d;short t3=(short) d;long l2=(long) d; byte b=(byte) d;
（3）(byte/short/int/long/float/double)->char
char c='A';
c=(char) i;
特殊情况下：通过某些JavaAPI相关方法实现类型转换(不是基本数据类型之间的转换了)
例如：
double dRes=Double.valueOf("10.89");

6、关键字、标识符和常量用法；

1.关键字（词）：是java中特有的词语，是电脑语言（这里我们指Java）里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。
例如：
abstract 抽象类或方法
assert 用来查找内部程序错误
break 跳出一个switch或循环
byte 8位整数类型
case switch的一个分支
catch 捕获异常的try块子句
2.标识符
（1）由字母、数字、_下划线，或者$美元符号组成；
（2）不能以数字开头；
（3）区分大小写，长度无限制，但是要见名知意；
（4）不能是Java关键字或者保留字；
例如：
合法：Person 、 user_name、 _userName、$abc_123、userProject
非法：2Username、#Test、class 、void、pulic

p.s.类、方法、属性（变量）、常量命名规则：
类名：开头字母必须大写，后面每个单词首字母也大写，其他小写字母；
方法名：开头字母小写、后面每个单词首字母大写；
常量：所有字母大写；

3.常量：例如：当我们在项目中定义一个性别标识时，如男性:SEX_MEN="1" ，在我们使用时，永远不会修改这个数据，此时我们可以认为它就是常量；定义常量后，不会被修改；（注意：之声明在类中作为全局变量使用）例如：
public static final String SEX_MAN="0";

7、运算符、表达式；

例如：
int i=6，j，k，m，n;
j = +i; //取原值，即j=6
k = -i; //取负值，即k=-6
m = i++; //先m=i,再i=i+1，即m=6，i=7
m = ++i; //先i=i+1,再m=i，即i=7，m=7
n = j--; //先n=j,再j=j-1，即n=6，j=5
n = --j; //先j=j-1,再n=j，即j=5，n=5;
p.s. ++/-- 在前时，则先运算再取值；在后时，则先取值再运算。

8、条件判断语句： if语句和switch语句；

(1)if语句结构

(2)switch流程控制语句结构：
主意：switch只能实现等值条件判断；而且表达式类型只能是int、char、byte类型变量；其中break表示退出当前判断的执行体；如果再循环中表示退出整个循环；

例如：

（3）三元运算符
语法为：条件表达式？表达式1：表达式2。
说明：问号前面的位置是判断的条件，判断结果为bool型，为true时调用表达式1，为false时调用表达式2。
例如：A>B ? 100 :200;

9、循环语句结构；

（1）for循环流程控制

p.s. for循环中另有此种循环方式: for (循环变量类型循环变量名称 : 要被遍历的对象) 循环体,例如：

(2)while循环流程控制

(3)do…while循环流程

p.s. do...while循环与while循环的区别是do…while的循环主体至少运行一次。

10、字符串的定义和使用；

Java中String声明字符串两种方法及它们的区别 :
方法1：String msg = “Hello”；
直接赋值。该方法执行后会自动将字符串“Hello”保存在字符串池中。则第二次使用直接赋值时，先检测字符串池中是否已存在“Hello”，如果存在，则将堆地址赋给引用。
Public class StringDemo{
String msg1 = “Hello”；
String msg2 = “Hello”；
}
执行后使得msg1与msg2的指向的地址是相同的。即内存中只有一个Hello的值。被两个引用所指向。String类采用了共享的设计模式。

方法2：String msg =new String（“Hello”）；
构造方法赋值。该方法执行后，会开辟两个内存空间（耗费资源），msg会指向其中的一个，而另一个没有引用指向，就会成为垃圾内存被清理掉。使用构造方法声明的“Hello”不会自动保存到字符串池中，不能共享。
Public class StringDemo{
　　String msg1 = new String（“Hello”）；
　　String msg2 = new String（“Hello”）；
}
执行后，虽然内容一样，但是存放的地址是不一样的。他不会自动保存在字符串内存池中。
总结：综上所述，直接赋值及构造方法赋值，因保存到字符串池有差异，导致是否可以共享亦有差异，效果如下：
　　String str1=“weight”;
　　String str2=“weight”;
　　String str3=new String (“weight”);
　　System.out.println(str1==str2);//true
　　System.out.println(str2==str3);//false

字符串常用方法：

1、charCodeAt方法返回一个整数，代表指定位置字符的Unicode编码。
strObj.charCodeAt(index)
说明：
index将被处理字符的从零开始计数的编号。有效值为0到字符串长度减1的数字。
如果指定位置没有字符，将返回NaN。
例如：
var str = "ABC";
str.charCodeAt(0);
结果：65
2、fromCharCode方法从一些Unicode字符串中返回一个字符串。
String.fromCharCode([code1[,code2...]])
说明：
code1，code2...是要转换为字符串的Unicode字符串序列。如果没有参数，结果为空字符串。
例如：
String.fromCharCode(65,66,112);
结果：ABp
3、charAt方法返回指定索引位置处的字符。如果超出有效范围的索引值返回空字符串。
strObj.charAt(index)
说明：
index想得到的字符的基于零的索引。有效值是0与字符串长度减一之间的值。
例如：
var str = "ABC";
str.charAt(1);
结果：B
4、slice方法返回字符串的片段。
strObj.slice(start[,end])
说明：
start下标从0开始的strObj指定部分其实索引。如果start为负，将它作为length+start处理，此处length为字符串的长度。
end小标从0开始的strObj指定部分结束索引。如果end为负，将它作为length+end处理，此处length为字符串的长度。
例如：
012345
var str = "ABCDEF";
str.slice(2,4);
结果：CD
5、substring方法返回位于String对象中指定位置的子字符串。
strObj.substring(start,end)
说明：
start指明子字符串的起始位置，该索引从0开始起算。
end指明子字符串的结束位置，该索引从0开始起算。
substring方法使用start和end两者中的较小值作为子字符串的起始点。如果start或end为NaN或者为负数，那么将其替换为0。
例如：
012345
var str = "ABCDEF";
str.substring(2,4); // 或 str.substring(4,2);
结果：CD
6、substr方法返回一个从指定位置开始的指定长度的子字符串。
strObj.substr(start[,length])
说明：
start所需的子字符串的起始位置。字符串中的第一个字符的索引为0。
length在返回的子字符串中应包括的字符个数。
例如：
012345
var str = "ABCDEF";
str.substr(2,4);
结果：CDEF
7、indexOf方法放回String对象内第一次出现子字符串位置。如果没有找到子字符串，则返回-1。
strObj.indexOf(substr[,startIndex])
说明：
substr要在String对象中查找的子字符串。
startIndex该整数值指出在String对象内开始查找的索引。如果省略，则从字符串的开始处查找。
例如：
01234567
var str = "ABCDECDF";
str.indexOf("CD"，1); // 由1位置从左向右查找 123...
结果：2
8、lastIndexOf方法返回String对象中字符串最后出现的位置。如果没有匹配到子字符串，则返回-1。
strObj.lastIndexOf(substr[,startindex])
说明：
substr要在String对象内查找的子字符串。
startindex该整数值指出在String对象内进行查找的开始索引位置。如果省略，则查找从字符串的末尾开始。
例如：
01234567
var str = "ABCDECDF";
str.lastIndexOf("CD",6); // 由6位置从右向左查找 ...456
结果：5
9、search方法返回与正则表达式查找内容匹配的第一个字符串的位置。
strObj.search(reExp)
说明：
reExp包含正则表达式模式和可用标志的正则表达式对象。
例如：
var str = "ABCDECDF";
str.search("CD"); // 或 str.search(/CD/i);
结果：2
10、concat方法返回字符串值，该值包含了两个或多个提供的字符串的连接。
str.concat([string1[,string2...]])
说明：
string1，string2要和所有其他指定的字符串进行连接的String对象或文字。
例如：
var str = "ABCDEF";
str.concat("ABCDEF","ABC");
结果：ABCDEFABCDEFABC
11、将一个字符串分割为子字符串，然后将结果作为字符串数组返回。
strObj.split([separator[,limit]])
说明：
separator字符串或 正则表达式 对象，它标识了分隔字符串时使用的是一个还是多个字符。如果忽略该选项，返回包含整个字符串的单一元素数组。
limit该值用来限制返回数组中的元素个数。
例如：
var str = "AA BB CC DD EE FF";
alert(str.split(" "，3));
结果：
AA,BB,CC
12、toLowerCase方法返回一个字符串，该字符串中的字母被转换成小写。
例如：
var str = "ABCabc";
str.toLowerCase();
结果：abcabc
13、toUpperCase方法返回一个字符串，该字符串中的所有字母都被转换为大写字母。
例如：
var str = "ABCabc";
str.toUpperCase();
结果：ABCABC

11、数组的定义和使用；

数组的定义和使用：

1.数组：它是一个变量，用于存储相同数据类型的一组数据；
2.建立java数组需要以下三个步骤：
　　声明数组
　　创建数组空间
　　初始化数组元素
3.数组的声明方式：
　　(1)数据类型变量名[];
　　(2)数据类型[] 变量名;

例如：char s[]; char[] s;
　　 Object p[]; Object[] p;
注意：
　　为数组开辟内存空间，在创建数组空间时必须为它指明数组的长度。
　　一个数组是一个对象，所以用new来创建数组

语法格式为：数组名 = new 数组元素类型[数组元素的个数]；
例如：
　　int[] MyIntArray;
　　MyIntArray =new int[4];

MyIntArray[0]=0;

　　MyIntArray[1]=1;

　　 MyIntArray[2]=2;

　　 MyIntArray[3]=3;

也可以在创建数组空间的时候，同时将初值给出来，例如：
　　int[] myIntArray={1,2,3,4};

存储空间的分配等价于使用new
有上面描述得知：java中数组长度不可变；

基本数据类型的数组元素会自动初始化成“空”值（对于数值，空值就是零；对于char，它是null；而对于boolean，它却是false）。

多维数组的定义和使用：
1. 定义方式：type 维数　arrayName；
　　例如：int [][] intArray；int[][][] a2；
2. 分配内存空间: 有两种方法：
a.直接为每一维分配空间：
　　如：int[][] a = new int[2][3]；
b.分别为每一维分配空间：
　　如：int[][] a = new int[2][ ]；
　　　　a[0] = new int[4];
　　　　a[1] = new int[3];
p.s.Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。
如：int[][] a = new int[2][3]；
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
3.多维数组（这里我们针对二维数组举例）初始化有两种方式：
例如：
（1）int[][] a = new int[2][3]；先定义后再赋值；
（2）int a[][] = {{2,3,6}, {1,5}, {3,4}}; 定义时直接赋值；

关于java数组的常用操作方法

1. 声明一个数组

1 String[] arr1 = new String[5];  
2 String[] arr2 = {"a","b","c", "d", "e"};  
3 String[] arr3= new String[]{"a","b","c","d","e"};

2. 输出一个数组

1 int[] arr = { 1, 2, 3, 4, 5 };  
2 String arrString = Arrays.toString(arr);  
3    
4 // 直接输出，为内存地址
5 System.out.println(arr);  
6 // [I@139a55
7    
8 System.out.println(arrString );  
9 // [1, 2, 3, 4, 5]

3. 检查一个数组是否包含某值

1 String[] arr= { "a", "b", "c", "d", "e" };  
2 boolean b = Arrays.asList(arr).contains("a");  
3 System.out.println(b);  
4 // true

4. 连接两个数组

1 //使用Apache Commons Lang library
2 
3 1 int[] arr1 = { 1, 2, 3, 4, 5 };  
4 2 int[] arr2= { 6, 7, 8, 9, 10 };  
5 3 int[] combArr = ArrayUtils.addAll(arr1 , arr2);

// System.arraycopy()
1 static String[] concat(String[] a, String[] b) {
2       String[] c = new String[a.length + b.length];
3       System.arraycopy(a, 0, c, 0, a.length);
4       System.arraycopy(b, 0, c, a.length, b.length);
5       return c;
6  }

1 //Arrays.copyOf()
2 
3 public static int[] concat(int[] first, int[] second) {
4     int[] result = Arrays.copyOf(first, first.length + second.length);
5     System.arraycopy(second, 0, result, first.length, second.length);
6     return result;
7 }

5. 逆向输出一个数组

1 // Apache Commons Lang library
2 
3 int[] arr= { 1, 2, 3, 4, 5 };  
4 ArrayUtils.reverse(intArray);  
5 System.out.println(Arrays.toString(intArray));  
6 //[5, 4, 3, 2, 1]

1 int[] arr = { 1, 2, 3, 4, 5 };
2 int[] revArr = new int[arr.length];
3 for(int i = 0; i < arr.length; i++){
4     revArr[i] = arr[arr.length - i -1];
5 }
6 System.out.println(Arrays.toString(revArr));
7 
8 //[5, 4, 3, 2, 1]

6. 移除数组中的元素

1 // Apache common lang  
2 
3 int[] arr= { 1, 2, 3, 4, 5 };  
4 int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array  
5 System.out.println(Arrays.toString(removed))

p.s. 《java基础梳理-朝花夕拾》系列由何东飞根据自己工作几年以来对java的理解梳理而成，笔者闲暇时将持续更新，有不对的地方请各位指教。QQ:983489147