本篇内容只需要认识、了解即可，请务必养成良好的编程风格
java常用开发工具
详见 http://m.biancheng.net/view/5637.html
这里不再赘述
语言基础
代码注释
与 c/c++ 相同
单行注释 //
多行注释 /**/
注意：多行注释中可以嵌套单行注释，但是多行注释中不可以嵌套多行注释
编码规范
可读性第一
每条语句单独占一行
变量声明时注意初始化
控制好空格的数量
命名规范
Java严格区分大小写
·类名：通常使用名词，第一个字母必须大写，后续单词首字母大写
·方法名：通常使用动词，第一个单词首字母小写，后续单词首字母大写
·变量：第一个单词首字母小写，后续单词首字母大写
·常量：所有字母均大写
变量与常量
标识符
Java语言规定标识符由任意顺序的字母、_（下划线）、$、数字组成，并且第一个字符不能是数字，标识符不能是Java中的关键字（关键字在一般会自动变色，所有的关键字都是小写的）
Tips：中文标识符是非常不好的编码习惯，Java跨平台开发语言，当编译环境的字符编码发生改变后，中文标识符会形成乱码
变量
变量名必须是一个有效标识符，且变量名不能重复
常量
需要关键字final
final 数据类型 常量名称[=值]
基本数据类型
基本同c/c++，这里只介绍不同点和注意点
1、Java中新增了byte类型
2、c/c++ 中long long在Java中只需写long
注意:Java的默认整数类型是int，为作出区分，long类型的整数末尾要加L或l
long a = 123456789 * 987654321 //错误
long a = 123456789L * 987654321L //正确
3、整型数据在Java中有三种表现形式：十进制、八进制、十六进制
十进制不能以0开头（除0外），八进制必须用0开头，十六进制必须以0x或0X开头
4、Java默认浮点类型是double，为作出区分，float型小数须在后面添加f或F
5、bool型在Java中要写成boolean
类型转换
精度从低到高：byte < short < int < long < float < double
低级向高级转换时，自动转换；高级向低级转换时，需要显示类型转换，注意损失的精度
运算符
同c/c++
流程控制
同c/c++,这里只着重提一下foreach
foreach
foreach并不是一个关键字，只是这种写法称之为foreach语句
for (循环变量x : 遍历对象obj) {
}
如
public class Repetition {
public static void main(String args[]) {
int arr = {7, 10, 1};
for (int x : arr) System.out.println(x);
}
}
数组
下标从0开始，与c/c++不同的是，在声明数组后我们还要为其分配内存空间,通常我们一起执行
数组元素类型 数组名 = new 元素类型[个数];
创建&&初始化
一维数组
int a[] = {1, 2, 3};
int b[] = new int[] {4, 5, 6};
int c[] = new int[3];
c[0] = 7; c[1] = 8; c[2] = 9;
二维数组
int a[][] = {{1, 3, 5}, {5, 9, 10}};
int b[][] = new int[][] {{2, 4, 6}, {8, 12, 16}};
int c[][] = new int[2][3];
c[0] = new int[] {49, 81, 100};
c[1][2] = 99;
Java同时支持不规则数组
如
int a[][] = new int[3][];
a[0] = new int[5];
a[1] = new int[3];
a[2] = new int[1];
获取数组长度 length
arr(数组名）.length
其他应用
如fill()、copyOf()、copyOfRange()、sort()等，自行查阅相关资料即可
字符串
创建
创建有很多方法，这里在一段代码中分别罗列出来
public class CreatString {
public static void main(String args[]) {
String a = "I'm born to be successful！"; //直接引用字符串常量
String b = new String("所谓无底深渊,下去也是前程万里"); //构造方法
String c = new String(a); //使用已有字符串变量实例化
char[] charArray = {'t', 'i', 'm', 'e'};
String d = new String(charArray); //利用字符数组实例化
String e = new String(charArray, 0, 2); //提取字符数组部分内容
}
}
连接
用'+'连接其它字符串或其他数据类型
连接字符串
注意：Java中相连的字符串不可以被直接分为两行
System.out.println("I like
Java"); //错误
System.out.println("I like" +
"Java"); //正确
连接其他类型
只要'+'所连接的有一个是字符串时，系统就会将其他转换为字符串形式，即自动调用toString()
其他函数和操作
请自行查询资料，这里不再赘述
可变字符串
StringBuffer
StringBuffer是线程安全的可变字符序列，一个类似于String的字符串缓冲区，String创建的字符串对象是不可以修改的，StringBuffer类创造的字符串序列是可修改的，且实体容量会随字符串增加而自动增加
创建
必须使用new方法
append()
将参数转换为字符串并追加到原序列
sbf.append(obj);
sbf：任意StringBuffer对象
obj：任意数据类型对象，自动转变成字符串
其他
请自行查询学习
StringBuilder
与StringBuffer有完全相同的API，具有相同的使用方式，只不过为了效率而放弃了线程安全控制
String, StringBuffer, StringBuilder 之间的关系
相互转化
public class Stringchange{
public static void main(String args[]) {
Stirng s1 = "Life would be too smooth if it had no rubs in it.";
StringBuffer sbf = new StringBuffer(s1); // String -> StringBuffer
StringBuilder sbd = new StringBuilder(s1); //String -> StringBuilder
s1 = sbf.toString(); // sbf -> string
s1 - sbd.toString(); // sbd -> string
StringBuilder s2 = new StringBuilder(sbf.toString()); // sbf -> sbd;
StringBuffer s3 = new StringBuffer(sbd.toString()); // sbd -> sbf;
}
}
不同之处
【1】String只能赋值一次，每一次改变内容都会在内存创建新的对象，会对系统性能产生影响
StringBuffer 和 StringBuilder每次操作都是对自身对象做操作，不会生成新的对象，不会因生成大量匿名对象而影响系统性能
【2】StringBuffer 的方法都使用了synchronized关键字保证线程安全，StringBuilder不具备，不考虑线程加锁所以运行效率会更高一点，即支持多线程
面向对象编程基础
对象、类的概念、封装性、继承性、多态性的特点,构造方法、局部变量、访问（注意Java中只用'.'操作符访问）、this与c++类似，不再赘述
成员变量
数据类型 变量名称 [=值] //[=值] 是可选内容，定义变量时可以赋值可以不赋值（默认值）
成员方法
[权限修饰符] [返回值类型] 方法名（[参数类型 参数名]) [throw 异常类型] {
···
return 返回值;
}
解释：
[权限修饰符]：public、private、protected中任意一个，没有指定时权限为默认，即只可以在本类及同一个包的类中使用
[返回值类型] 返回的数据类型，若不需要返回值用void；如果有，必须用return返回一个与方法返回值类型相同的数据
[参数]：可以有参数也可以没有参数，分为
·值形参（实参和形参之间按值传递，即修改形参不会影响实参）
·引用参数（形参的类型是数组或其他引用类型，方法中对参数的修改会反映到原数据)
·不定长参数
格式：参数类型... 参数名 //注意是三个点
如：
public class Test {
public static void main(String[] args) {
Test multi = new Test();
System.out.println("Result：" + multi.add(20, 30, 40, 50, 60));
}
int add(int... x) {
int ans = 0;
for (int i = 0; i < x.length; i++) ans += x[i];
return ans;
}
}
static关键字
被static修饰称为类的静态成员，是属于类所有的，区别个别对象
调用：类名.静态成员
静态变量：不同类之间、一个类的不同实例对象需要共同操作同一个变量
静态常量：需要共享一个数据常量，注意给静态常量命名时，所有字母应该大写
静态方法：不创建类的对象，直接调用类中的方法
类的封装
将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。
类的继承
child extends parents
注意：java中的类只支持单继承，即一个子类指能继承一个父类
方法的重写
重写就是在子类中将父类的成员方法的名称保留，冲洗那边写其实现内容，更改其存储权限或修改返回值类型（重写返回值类型是基于J2SE5.0版本以上的编译器提供的新功能）
注意：修改修饰权限只能从小范围到大范围改变
为了在子类的方法中实现父类原有的方法，Java提供了super关键字，super关键字代表了父类的对象
注意：如果在子类的构造方法中使用类似super()的构造方法，其他初始化代码只能写在super()后，不能写在前面，这是由于在继承的机制中，创建一个子类对象将包含一个父类子对象，实例化子类对象的时候，父类对象也会被相应实例化，会自动调用父类无参构造方法，有参的构造方法只能依赖于super关键字显示第调用
类的多态
重载
编译器是根据方法名、方法各参数类型、参数的个数、参数的顺序来确定类中方法是否唯一，注意：只有返回类型不同不足以区别两个方法的重载，还需通过参数个数以及参数的类型
向上转型
通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换
在向上转型时，父类的对象无法调用子类独有的属性或方法
这样做的意义在于:当我们需要多个同父的对象调用某个方法时,通过向上转换后,则可以确定参数的统一.方便程序设计(参考下面示例)
class A {
public void print() {
System.out.println("A:print");
}
}
class B extends A {
public void print() {
System.out.println("B:print");
}
}
class C extends B {
public void print() {
System.out.println("C:print");
}
}
public class Test {
public static void func(A a) {
a.print();
}
public static void main(String args[]) {
func(new B()); //等价于 A a =new B();
func(new C()); //等价于 C c =new C();
}
}
向下转型
通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换
注意：能执行向下转型要求父类对象是子类对象的实例
instanceof
返回值为bool类型
myobject instanceof ExampleClass
解释：
·myobject:某类的对象引用
·ExampClass：某个类
instanceof常与向下转型结合操作，结果为true时才进行向下转型
抽象类和抽象方法
关键字:abstruct
抽象类（抽象类除了被继承外没有任何意义）
[权限修饰符] abstruct class 类名 {
...
}
抽象方法：
[权限修饰符] abstruct 返回值类型 方法名(参数表);//抽象方法直接以分号结尾，其本身没有任何意义除非被重写
注意:构造方法不能定义为抽象方法
例子：使用抽象类模拟“去商场买衣服"场景
分析:
由于我们没有对“买衣服”这个抽象行为指定一个明确的信息，因此我们可以封装一个商场的抽象类、买东西的抽象方法
public abstruct class Market{
public String name;
public String goods;
public abstruct void shop();
}
定义一个TaobaoMarket类
public class TaobaoMarket extends Market {
@Override //编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错
public void shop() {
System.ou.println(name + "网购" + goods);
}
}
定义一个WallMarket类
public class WallMarket extends Market {
@Override //编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错
public void shop() {
System.ou.println(name + "实体店购买" + goods);
}
}
定义一个GoShopping类
public class GoShopping {
public static void main(String[] args) {
Market market = new WallMarket();
market.name = "沃尔玛";
market.goods = "西服";
market.shop();
market = new TaobaoMarket();
market.name = "淘宝";
market.goods = "风衣";
market.shop();
}
}
综上所述，使用抽象类和抽象方法时，需要遵循以下原则：
[1]抽象类中，可以包含抽象方法，也可以不包含抽象方法，但是包含了抽象方法的必须定义为抽象类
[2]抽象类不能直接实例化，即使抽象类中没有抽象方法也不可以实例化
[3]抽象类被继承后，子类需要实现其中所有抽象方法
[4]若继承抽象类的子类声明为抽象类，则可以不用实现父类中所有的抽象方法