Java基本语言篇

本篇内容只需要认识、了解即可，请务必养成良好的编程风格

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]若继承抽象类的子类声明为抽象类，则可以不用实现父类中所有的抽象方法