Java学习笔记（三）—— 基础语法
看了一些网上的资料发现Java和c的语法是类似的，也有一些不同，之前看的那本书讲到输入输出时已经是两百多页了，，，果断换书。看的这本《Java面向对象程序设计》，目前自我感觉良好。总结如下。
适合有C语言基础和面向对象编程概念。
一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。
- 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
- 类：类是一个模板，它描述一类对象的行为和状态。
- 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
- 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
编写Java程序时，应注意以下几点：
- 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
- 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
- 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
- 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
- 主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。
标识符
Java标识符比c多了一个‘$’，并且这个符号可以作为标识符的开头，并且，Java的字符集为Unicode，就是说，这里面的字符都可以作为Java的‘字母’，也包括汉字，如：‘$surk’、‘ab$3d’、‘_ad2$’，‘这是一个标识符’ 。
Java中变量主要有：局部变量、类变量（静态变量）、成员变量（非静态变量）。
Java的八种基本类型：
| 分 类 |
数据类型 |
关键字 |
占用字节 |
缺省数值 |
取 值 范 围 |
| 整型类 |
字节型 |
byte |
1 |
0 |
-2^7～2^7-1 |
| 短整型 |
short |
2 |
0 |
-2^15～2^15-1 |
|
| 整型 |
int |
4 |
0 |
-2^31～2^31-1 |
|
| 长整型 |
long |
8 |
0L |
-2^63～2^63-1 |
|
| 文本类 |
字符型 |
char |
2 |
′\u 0000′ |
′\u 0000′ ～ ′\u FFFF′ |
| 浮点类 |
浮点型 |
float |
4 |
0.0F |
-3.4E38~3.4E38 |
| 双精度型 |
double |
8 |
0.0D |
-1.7E308~1.7E308 |
|
| 逻辑类 |
逻辑型 |
boolean |
1 |
False |
True、False |
Java中默认的整数类型是int，如果要定义为long ，则要在数值后加上L或者l
默认的浮点型是双精度浮点，如果要定义float，则要在数值后面加上f或者F
一个字节等于8位，1个字节等于256个数。
一个英文字母或者阿拉伯数字占一个字节
一个汉字占2个字节
关键字
下面列出了Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。
| 类别 | 关键字 | 说明 |
|---|---|---|
| 访问控制 | private | 私有的 |
| protected | 受保护的 | |
| public | 公共的 | |
| 类、方法和变量修饰符 | abstract | 声明抽象 |
| class | 类 | |
| extends | 扩允,继承 | |
| final | 最终值,不可改变的 | |
| implements | 实现（接口） | |
| interface | 接口 | |
| native | 本地，原生方法（非Java实现） | |
| new | 新,创建 | |
| static | 静态 | |
| strictfp | 严格,精准 | |
| synchronized | 线程,同步 | |
| transient | 短暂 | |
| volatile | 易失 | |
| 程序控制语句 | break | 跳出循环 |
| case | 定义一个值以供switch选择 | |
| continue | 继续 | |
| default | 默认 | |
| do | 运行 | |
| else | 否则 | |
| for | 循环 | |
| if | 如果 | |
| instanceof | 实例 | |
| return | 返回 | |
| switch | 根据值选择执行 | |
| while | 循环 | |
| 错误处理 | assert | 断言表达式是否为真 |
| catch | 捕捉异常 | |
| finally | 有没有异常都执行 | |
| throw | 抛出一个异常对象 | |
| throws | 声明一个异常可能被抛出 | |
| try | 捕获异常 | |
| 包相关 | import | 引入 |
| package | 包 | |
| 基本类型 | boolean | 布尔型 |
| byte | 字节型 | |
| char | 字符型 | |
| double | 双精度浮点 | |
| float | 单精度浮点 | |
| int | 整型 | |
| long | 长整型 | |
| short | 短整型 | |
| 变量引用 | super | 父类,超类 |
| this | 本类 | |
| void | 无返回值 | |
| 保留关键字 | goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 | |
| null | 空 |
转义字符
转义符是指一些有特殊含义的、很难用一般方式表达的字符，如回车、换行等。所有的转义符以反斜线(\)开头，后面跟着一个字符来表示某个特定的转义符，如下表所示。
| 引用方法 |
含义 |
| \b |
退格 |
| \t |
水平制表符Tab |
| \n |
换行 |
| \f |
表格符 |
| \r |
回车 |
| \' |
单引号 |
| \" |
双引号 |
| \\ |
反斜杠 |
注释
Java支持三种注释：
- 行注释：//注释内容
- 段注释：/*注释内容*/
- 文档注释：/**注释内容*/
继承
在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
接口
在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
Java编程规范
- package的命名: package 的名字由全部小写的字母组成，例如：com.runoob。
- class和interface的命名: class和interface的名字由大写字母开头而其他字母都小写的单词组成，例如：Person，RuntimeException。
- class变量的命名: 变量的名字用一个小写字母开头，后面的单词用大写字母开头,例如：index，currentImage。
- class 方法的命名: 方法的名字用一个小写字母开头，后面的单词用大写字母开头,例如：run()，getBalance()。
- staticfinal变量的命名: static final变量的名字所有字母都大写，并且能表示完整含义。例如：PI，PASSWORD。
- 参数的命名: 参数的名字和变量的命名规范一致。
- 数组的命名: 数组应该总是用这样的方式来命名：byte[] buffer。
- package语句：由于Java编译器为每个类生成一个字节码文件，且文件名与类名相同因此同名的类有可能发生冲突。为了解决这一问题，Java提供包来管理类名空间，包实 提供了一种命名机制和可见性限制机制。
输入输出
Scanner
输入时可以用Scanner来创建对象：
Scanner reader = new Scanner(System.in);然后reader对象调用方法next(),nextBoolean(),nextByte(),nextDouble(),nextInt(),nextFloat(),nextShort(),nextLong()，读取在命令行输入的各种基本类型数据。如：
int a=reader.nextInt(),b=reader.nextInt();
System.out.println() 和 System.out.print()
输出时System.out.println()和System.out.print()可以输出字符、表达式的值，区别在于前者输出时会自动输出一个换行，后者不会，允许使用并置符号“+”来连接前后。如：
int x=1;
System.out.println("x="+x); //输出x=1
格式化输出System.out.printf()
Java还有类似c语言的printf函数用来输出带有格式控制的数据，用法和c相同，特别的，Java的double类型使用“%f”,如：
System.out.printf("%d %f\n",a,b);多实例输入
使用hasNext()来判断有没有输入,相当于c中的scanf()!=EOF，类似的还有hasNextInt(),hasNextDouble()等，用来判断有无int，double等类型的输入。
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int a = in.nextInt();
int b = in.nextInt();
System.out.println(a + b);
}
数组
Java的数组声明和c也差不多，有两种形式：
int[] a;
int a[];
声明不等于创建，变量必须被创建才可以被使用
声明和创建分为两步，这也是Java和c的区别，c在声明变量时自动为其分配内存，Java则需要使用new关键字来为变量分配内存。
特别的，Java不允许在方括号中指定元素个数，上面的语句只是声明一个数组a，并未分配内存。所以还须采用new创建，
int a[];
a=new int[10];
int a=new int[10];
初始化
上面是两种创建方法，这样一维数组就可以使用了，也可以在声明数组时初始化，初始化方面和c差异不大，如：
char ac[]= {'a','v'};
二维数组
二维数组的使用同一维数组，只是多了一个方括号，特别的，二维数组相当于多个一维数组组成，这些一维数组长度不必相等，
int x[][] = new int[2][];
x[0]=new int[10];
x[1]=new int[5];
//或
int x[][]=new int[2][3];Java还允许这样使用
int size=30;
int x[]=new int[size];特别的，Java中数组属于引用类型，
x=y; //这样会把x所指内存空间释放掉，使得x和y指向同一块内存空间，此时x[]={1,2},这时使用x或y实际上是一样的，改变其中一个，另一个也会改变。
遍历数组
一种是：同c一样的
int y[]= {3,0,1};
for(int i = 0;i < y.length;i++) {
System.out.println(y[i]); //3,0,1
}另一种是：Java专门的对于遍历数组的优化使用
int y[]= {3,0,1};
for(int i:y) {
System.out.println(i); //3,0,1
}注意：i的类型应该和数组y的类型相同，而且下面这种写法是错误的，
int y[]= {3,0,1};
int i=0; //错误
for(i:y) {
System.out.println(i);
}变量i必须重新声明，不能使用已有的变量。
clone()的使用
那么如何复制数组呢，可以使用循环来复制，也可以使用clone(),如：
char ac[]= {'a','v'};
char ax[]= {'b'};
ac=ax.clone();
System.out.println(ax); //b
System.out.println(ac); //b
length的使用
对于一维数组x[10],x.length=10，即一维数组的长度，对于二维数组x[2][3],x.length=2,即二维数组中一维数组的个数。
Arrays.toString()的使用
数组a[2]={1,2}; Array.toString(a)可以将整型转换为字符型，需import java.util.*，如：
int a[]= {1,2};
System.out.println(Arrays.toString(a)); //[1, 2]
copyOf()和copyOfRange()
int y[]= {1,2};
int z[]=Arrays.copyOf(y,3); //z[]={1,2,0};
int z[]=Arrays.copyOf(y,1); //z[]={1};int y[]= {1,2};
int z[]=Arrays.copyOfRange(y,0,3); //z[]={1,2,0};
int z[]=Arrays.copyOfRange(y,0,2); //z[]={1,2};其中，copyOf（y，newLength）为从y中0位置开始复制长度为newLength，若newLength的值大于原数组则填充默认值。
copyOfRange(y，from，to)为从y中from开始到to-1的位置，若to的值大于原数组则填充默认值。
Arrays.sort()
int y[]= {3,0,1};
Arrays.sort(y); //y[]={0,1,3};默认升序排序，貌似没有降序的，，，，倒着看就行，问题不大。
Arrays.binarySearch()
Arrays.binarySearch(double[] a,double number)可以查找参数number是否在指定数组中，其中a必须是已排好序的数组，若找到则返回位置，否则返回负数。
int y[]= {3,0,1};
Arrays.sort(y); //y[]={0,1,3};
int index=Arrays.binarySearch(y,3); //index=2
equals()
Arrays.equals()用来比较两个数组是否相等，返回逻辑值true或false，如：
int x[]= {5};
int y[]= {1,2};
System.out.println(Arrays.equals(x,y)); //false
String类
在Java中String为不可变对象，可以如此定义一个字符串：String s = "abc";，常见的还有两种构造方法，其中第二种String（char a[]，startIndex，count）,两个参数分别为字符数组的起始位置和从该位置开始截取的长度。
char ax[]= {'b','d','c'};
String s = new String(ax);
System.out.println(s); //bdc
String h = new String(ax,1,2);
System.out.println(h); //dc
substring(from,to)
可以提取字符串从from到to-1的字符，如：
String T="hello";
System.out.println(T.substring(0,3)); //hel
重载了"+"
字符串和字符串之间可以用"+"拼接，
String T="hello";
String Y="world";
String U=T+Y;
System.out.println(U); //helloworld
join()
如果需要把多个字符串放在一起，用一个定界符分隔，可以使用静态方法join方法，如：
String S=String.join("!","s","b","a","g");
System.out.println(S); //s!b!a!g
s.equals(t)
检测字符串是否相等使用s.equals(t),其中s,t即可以是字符串常量，也可以是字符串变量。
String T="hello";
String Y="world";
System.out.println(T.equals(Y)); //false如果用==比较的话，实际比较的是两个字符串的地址是否相同。
length()
确定字符串长度用length()方法，（数组的length是属性，而非方法）。
toCharArray()
用来把String类转换为字符数组，这样可以进行对字符串进行"数组名+下标"式的修改，
String sa="hello";
System.out.println(sa.toCharArray()); //hello
char sb[];
sb=sa.toCharArray();
sb[1]='a';
System.out.println(sb[1]); //a
String.valueOf()
用来把字符数组转换为字符串，也可以把数值转换为字符串 。
String sa;
char sb[]= {'a','b','c'};
sa=String.valueOf(sb);
System.out.println(sa); //abc
Long类中的toString(long i,int p)
这个方法可以返回整数i的p进制表示。
System.out.println(Long.toString(10,2)); //1010
compareTo()
也可以使用compareTo()来比较字符串是否相等，和C语言中的comcmp()使用方法一样，不在解释。
StringBuffer 和 StringBuilder
这两个可以实现对字符串的增删改。
String 长度大小不可变
StringBuffer 和 StringBuilder 长度可变
StringBuffer 线程安全 StringBuilder 线程不安全
StringBuilder 速度快
通常在99.99%的情况下可以选择用StringBuilder，
append(),insert(),delete(),replace()
StringBuilder s = new StringBuilder();
s.append("abc");
System.out.println(s); //abc
s.insert(1,"qwer");
System.out.println(s); //aqwerbc
s.delete(1,5);
System.out.println(s); //abc
s.replace(0,2,"e");
System.out.println(s); //ec
网上淘来几道面试题，，，，关于常量池的
面试题一：
String s1 = "abc"; // 常量池
String s2 = new String("abc"); // 堆内存中
System.out.println(s1==s2); // false两个对象的地址值不一样。
System.out.println(s1.equals(s2)); // true面试题二：
String s1="a"+"b"+"c";
String s2="abc";
System.out.println(s1==s2);
System.out.println(s1.equals(s2));java 中常量优化机制，编译时 s1 已经成为 abc 在常量池中查找创建，s2 不需要再创建。
面试题三：
String s1="ab";
String s2="abc";
String s3=s1+"c";
System.out.println(s3==s2); // false
System.out.println(s3.equals(s2)); // true先在常量池中创建 ab ，地址指向 s1, 再创建 abc ，指向 s2。对于 s3，先创建StringBuilder（或 StringBuffer）对象，通过 append 连接得到 abc ,再调用 toString() 转换得到的地址指向 s3。故 (s3==s2) 为 false。
Java：String、StringBuffer 和 StringBuilder 的区别
String：字符串常量，字符串长度不可变。Java中String 是immutable（不可变）的。用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。
StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，可以调用 StringBuffer 的 toString() 方法。Java.lang.StringBuffer 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。
StringBuilder：字符串变量（非线程安全）。在内部 StringBuilder 对象被当作是一个包含字符序列的变长数组。
基本原则：
- 如果要操作少量的数据用 String ；
- 单线程操作大量数据用StringBuilder ；
- 多线程操作大量数据，用StringBuffer。
参考文章：打开链接