Java基础知识——第一话：哈喽！世界！

第一次对话

每门语言学习前，都会有一个 HelloWorld 的示例，Java 当然也不例外。 在 /home/project/ 下新建一个文件 HelloWorld.java。

public class HelloWorld{
    public static void  main(String[] args){
        System.out.println("哈喽！新世界!");
    }
}

上面的例子虽然简单，但是包含了很多的知识点，Java 中所有的代码都必须包含在 class 中，main 方法是程序的入口，并且 Java 是区分大小写的，如果写成 Main，那么程序将因找不到程序入口而无法运行。使用 public 修饰的 class 名（HelloWorld）须和源代码文件名相同。

编译源代码：打开命令行，切换到源代码目录，这里是 /home/project。输入 javac HelloWorld.java，如果程序没有任何提示，并且在同级目录下生成了一个 .class 扩展名的文件，那么说明编译成功，反之编译失败。

运行程序：输入 java HelloWorld，这个时候不需要再添加扩展名了。

C:\Users> javac HelloWorld.java
C:\Users> java HelloWorld
HelloWorld!

认识：变量

变量可以指在计算机存储器里存在值的被命名的存储空间。

变量通常是可被修改的，即可以用来表示可变的状态。这是 Java 的基本概念之一。

程序通过改变变量的值来改变整个程序的状态。为了方便使用变量，所以变量都需要命名，叫做变量名。

在 Java 中，变量需要先声明 (declare) 才能使用。在声明中，说明变量的类型，赋予变量以特别名字，以便在后面的程序中调用它。你可以在程序中的任意位置声明变量，语法格式如下：

数据类型 变量名称;

例如：

int a = 1;
int n = 999;

在该语法格式中，数据类型可以是 Java 语言中任意的类型，如 int。变量名称是该变量的标识符，需要符合标识符的命名规则，数据类型和变量名称之间使用空格进行间隔，使用 ; 作为结束。

在 /home/project/ 新建一个 Test.java 文件：

public class Test
{
  public static void main(String[] args)
  {
    System.out.println("变量：先声明，后赋值，即可食用 ");
    int a; //声明变量a
    a = 18;
    System.out.println(a);  // 打印一个整数a
  }
}

编译运行：

C:\Users>javac Test.java
C:\Users>java Test
变量：先声明，后赋值，即可食用 
18

常量

常量代表程序运行过程中不能改变的值。我们也可以把它们理解为特殊的变量，只是它们在程序的运行过程中是不允许改变的。常量的值是不能被修改的。

Java 中的 final 关键字可以用于声明属性（常量），方法和类。当 final 修饰属性时，代表该属性一旦被分配内存空间就必须初始化，它的含义是“这是无法改变的”或者“终态的”。在变量前面添加关键字 final 即可声明一个常量。在 Java 编码规范中，要求常量名必须大写。

语法格式：

final 数据类型 常量名 = 值;

例如：

final double PI = 3.14;

常量也可以先声明，再进行赋值，但只能赋值一次，比如：

final int FINA;
FINAL = 100;

在 /home/project/ 下新建一个 Final.java：

public class Final{
    public static void main(String[] args){
        final String STRING="知1得N";
        System.out.println(STRING);
    }
}

编译运行：

C:\Users>avac Final.java
C:\Users>java Final
知1得N

数据类型

数据类型
Java 中一共八种基本数据类型，下表列出了基本数据类型的数据范围、存储格式、默认值和包装类型等。

整数
byte、short、int、long 四种基本数据类型表示整数，需要注意的是 long 类型，使用 long 修饰的变量需要在数值后面加上 L 或者 l，比如 long num = 1L;，一般使用大写 L，为了避免小写 l 与数值 1 混淆。

浮点数
float 和 double 类型表示浮点数，即可以表示小数部分。需要注意的是 float 类型的数值后面需要加上 F 或者 f，否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d，也可以不加。

char 类型
char 类型用于表示单个字符。需要将字符用单引号括起来char a = ‘a’，char 可以和整数互相转换，如果字符 a 也可以写成char a = 97。也可以用十六进制表示char a = ‘\u0061’。

boolean 类型
boolean 类型（布尔类型）用于表示真值 true或者假值 false，Java 中布尔值不能和整数类型或者其它类型互相转换。

程序员100%要掌握的引用类型：String

Java 中使用 String 类来定义一个字符串，字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

String 对象的初始化格式有如下两种：

String s0 = "abc";
String s1 = new String("996");

String 类具有丰富的方法，比如计算字符串的长度、连接字符串、比较字符串、提取字符串等等。

计算字符串长度
length() 方法：

//方法原型
public int length(){
}

调用方法：字符串标识符.length(); 返回一个 int 类型的整数（字符串中字符数，中文字符也是一个字符）。例如：

String s1 = "abc";
String s2 = "AI与未来";
int len1 = s1.length();
int len2 = s2.length();

则变量 len1 的值是 3，变量 len2 的值是 6。

字符串比较
equals() 方法，该方法的作用是判断两个字符串对象的内容是否相同。如果相同则返回 true，否则返回 false。

equals() 方法比较是从第一字符开始，一个字符一个字符依次比较。

如果想忽略掉大小写关系，比如：java 和 Java 是一样的，那怎么办呢？可以调用 equalsIgnoreCase() 方法，其用法与 equals() 一致，不过它会忽视大小写。

比如：

public class StringTest {
    public static void main(String[] args){
        String s = new String("AI");
        String m = "AI";
        System.out.println("用equals()比较，结果为"+s.equals(m));
        System.out.println("用equalsIgnoreCase()比较，结果为"+s.equalsIgnoreCase(m));
    }
}

编译运行：

C:\Users>javac StringTest.java
C:\Users>java StringTest
用equals()比较，结果为false
用equalsIgnoreCase()比较，果为true

而使用 “==” 比较的是两个对象在内存中存储的地址是否一样。例如：

         String s1 = "abc";
         String s2 = new String("AI");
         boolean b = (s1 == s2);

则变量 b 的值是 false，因为 s1 对象对应的地址是 “abc” 的地址，而 s2 使用 new 关键字申请新的内存，所以内存地址和 s1 的 “abc” 的地址不一样，所以获得的值是 false。

字符串连接
字符串连接有两种方法：

1、使用 +，比如 String s = "Hello " + “World!”。
2、使用 String 类的 concat() 方法。
代码示例：

String s0 = new String("哈喽");
String s1 = "连接世界" + "!";   //+号连接
String s2 = s0.concat(s1); //concat()方法连接
System.out.println(s2);

而且使用 + 进行连接，不仅可以连接字符串，也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。

charAt() 方法
charAt() 方法的作用是按照索引值（规定字符串中第一个字符的索引值是 0，第二个字符的索引值是 1，依次类推），获得字符串中的指定字符。例如：

String s = "abc";
char c = s.charAt(1);

则变量 c 的值是 ‘b’。

字符串常用提取方法

说明：在字符串中，第一个字符的索引为 0，子字符串包含 beginindex 的字符，但不包含 endindex 的字符。

代码验证一下上面的方法

public class StringTest {
    public static void main(String[] args) {
         String s = "就算天塌下来，也无法阻挡学习的脚步";
         System.out.println("字符a第一次出现的位置为："+s.indexOf('天'));
         System.out.println("字符串bc第一次出现的位置为："+s.indexOf("也"));
         System.out.println("字符a最后一次出现的位置为："+s.lastIndexOf('学'));
         System.out.println("从位置3开始到结束的字符串："+s.substring(3));
         System.out.println("从位置3开始到6之间的字符串："+s.substring(3,6));
    }
}

编译运行：

C:\Users>javac StringTest.java
C:\Users>java StringTest
字符天第一次出现的位置为：2
字符串也第一次出现的位置为：7
字符学习最后一次出现的位置为：12
从位置3开始到结束的字符串：塌下来，也无法阻挡学习的脚步
从位置3开始到6之间的字符串：塌下来

运算符

一种符号，它是连接一个以上的操作符，实现某种功能的运算。

算术运算符

算术运算符用在数学表达式中，主要实现的是算术运算，如常见的加减乘除等。

表格中的例子中，变量 a 的值为 5，变量 b 的值为 3，变量 i 的值为 1：

其中，自增 (++) 和自减 (–) 运算符有两种写法：前缀（++i,–i）和后缀（i++,i–）。

前缀自增自减法 (++i,–i): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法 (i++,i–): 先进行表达式运算，再进行自增或者自减运算
新建一个源代码文件 ArithmeticOperation.java：

public class ArithmeticOperation {
    public static void main(String args[]) {
        int a = 5;
        int b = 3;
        int c = 3;
        int d = 3;
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
        System.out.println("a++ = " + (a++));
        System.out.println("++a = " + (++a));
        System.out.println("b-- = " + (b--));
        System.out.println("--b = " + (--b));
        System.out.println("c++ = " + (c++));
        System.out.println("++d = " + (++d));
    }
}

编译运行：

C:\Users>javac ArithmeticOperation.java
C:\Users>java ArithmeticOperation
a + b = 8
a - b = 2
a * b = 15
a / b = 1
a % b = 2
a++ = 5
++a = 7
b-- = 3
--b = 1
c++ = 3
++d = 4

位运算符

Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte) 等类型。位运算时先转换为二进制，再按位运算。

表格中的例子中，变量 a 的值为 60（二进制：00111100），变量 b 的值为 13（二进制：00001101）：

在 /home/project 目录下新建一个源代码文件 BitOperation.java：

public class BitOperation {
    public static void main(String args[]) {
        int a = 60;
        int b = 13;
        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a = " + (~a));
        System.out.println("a << 2 = " + (a << 2));
        System.out.println("a >> 2 = " + (a >> 2));
        System.out.println("a >>> 2 = " + (a >>> 2));
    }
}

编译运行：

C:\Users>javac BitOperation.java
C:\Users>java BitOperation
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

逻辑运算符

逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。

表格中的例子中，假设布尔变量 a 为真（true），变量 b 为假（false）：

&& 与 || 是具有短路性质，当按优先级顺序计算到当前表达式时，表达式的结果可以确定整个表达式的结果时，便不会继续向后进行判断和计算，而直接返回结果。

例如：当使用 && 逻辑运算符时，在两个操作数都为 true 时，结果才为 true，但是当得到第一个操作为 false 时，其结果就必定是 false，这时候就不会再判断第二个操作了。在计算表达式 (a & b) && (a | b) 时，首先计算 a & b 得到了 false，因为之后是 &&，任何值与 false 进行与操作都是 false，所以可以不用再计算下去，而直接返回 a & b 的结果 false。

在/home/project目录下新建一个LogicOperation.java。

public class LogicOperation {
    public static void main(String args[]) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a && b));
        System.out.println("a || b = " + (a || b));
        System.out.println("!a = " + (!a));
        System.out.println("a ^ b = " + (a ^ b));
    }
}

编译运行：

C:\Users>javac LogicOperation.java
C:\Users>java LogicOperation
a && b = false
a || b = true
!a = false
a ^ b = true

关系运算符

关系运算符生成的是一个 boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，结果为 true（真），否则，结果为 false（假）。

表格中的例子中，假设变量 a 为 3，变量 b 为 5：

除了上表列出的二元运算符，Java 还有唯一的一个三目运算符 ?: 。

语法格式：

布尔表达式 ？表达式 1 : 表达式 2;

运算过程：如果布尔表达式的值为 true，则返回表达式 1的值，否则返回表达式 2的值。

在 /home/project 目录下新建一个源代码文件 RelationalOperation.java：

public class RelationalOperation {
    public static void main(String args[]) {
        int a = 3;
        int b = 5;
        System.out.println("a == b = " + (a == b));
        System.out.println("a != b = " + (a != b));
        System.out.println("a > b = " + (a > b));
        System.out.println("a < b = " + (a < b));
        System.out.println("a >= b = " + (a >= b));
        System.out.println("a <= b = " + (a <= b));
        System.out.println("a > b ? a : b = " + (a > b ? a : b));
    }
}

编译运行：

C:\Users>javac RelationalOperation.java
C:\Users>java RelationalOperation
a == b = false
a != b = true
a > b = false
a < b = true
a >= b = false
a <= b = true
a > b ? a : b = 5

强调：

	== 和 != 适用于所有的基本数据类型，其他关系运算符不适用于 boolean，因为 boolean 值只有 true 和 false，比较没有任何意义。
	== 和 != 也适用于所有对象，可以比较对象的引用是否相同。

引用：Java 中一切都是对象，但操作的标识符实际是对象的一个引用。

运算符优先级

运算符的优先级是帮助我们在一个表达式中如何对于不同的运算符和相同的运算符，进行正确的运算顺序。

运算符的优先级不需要特别地去记忆它，比较复杂的表达式一般使用圆括号 () 分开，提高可读性。

两数之和

import java.util.Scanner;

public class Sum {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        System.out.println(a + b);
    }
}

关键字和语句

关键字
Java 的关键字对 Java 的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名。

Java 关键字有如下表所列，目前共有 50 个 Java 关键字，其中，“const” 和 “goto” 这两个关键字在 Java 语言中并没有具体含义。

方法

Java 中的方法，可以将其看成一个功能的集合，它们是为了解决特定问题的代码组合。

方法的定义语法：

访问修饰符 返回值类型 方法名(参数列表) {
    方法体
}

如下：

public void functionName(Object arg) {
  System.out.println("哈喽世界");
}

在上面的语法说明中：

访问修饰符：代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略（default） ，其中 public 表示该方法可以被其他任何代码调用。

返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void （代表无类型）；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值。

方法名：是方法的名字，必须使用合法的标识符。

参数列表：是传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

方法体：方法体包含具体的语句，定义该方法的功能。

根据方法是否带参、是否带返回值，可将方法分为四类：

	无参无返回值方法
	无参带返回值方法
	带参无返回值方法
	带参带返回值方法

当方法定义好之后，需要调用才可以生效，我们可以通过 main 方法（main 方法是 Java 程序的入口，所以需要用它来调用）来调用它，比如：

在 /home/project 下建立 MethodDemo.java：

public class MethodDemo {
    public static void main(String[] args){
        method();
    }
    //这里要加上 static 关键字 因为静态方法只能调用静态方法
    public static void method(){
        System.out.println("方法被调用");
    }
}

编译运行：

C:\Users>javac MethodDemo.java
C:\Users>java MethodDemo
方法被调用

方法使用

在 /home/project/ 目录下新建文件 MethodTest.java，在其中新建一个方法 methodDemo，运行该方法，在控制台输出 Hello Shiyanlou。

public class MethodTest {
    private static void methodDemo() {
        System.out.println("哈喽 知1而N");
    }

    public static void main(String[] args) {
        methodDemo();
    }
}

Java 常见的 IDE 有 IDEA，Eclipse 等

我一般学Java使用 WebIDE 进行开发来开发