Hello,World!

首先我们需要完成一个学习新语言的仪式——输出”hello,world!”

在此之前我们需要了解一下java的运行原理：

\1) 将 Java 代码编写到扩展名为 Hello.java 的文件中。
\2) 通过 javac 命令对该 java 文件进行编译， 生成 .class 文件。
\3) 通过 java 命令对生成的 class 文件进行运行。

然后，我们开始编写 Hello,world! 代码

1
2
3
4
5
6
7
public class Hello{

    public static void main(String[] args){

        System.out.println("Hello,World!");
    }
}

对于代码中的细节解读： (了解即可，不必深究，后面学完再回头看更好)

  1. public class Hello { ... }: 这是一个Java类的定义，类名为Hello。Java程序的核心结构就是类，它用来封装数据和方法。
  2. public static void main(String[] args) { ... }: 这是一个特殊的方法，是Java程序的入口点。在程序运行时，JVM（Java虚拟机）会从这个方法开始执行。
  3. public: 这是一个访问修饰符，表示该方法可以从任何地方访问。public修饰符使得main方法在其他类中也可以调用执行。
  4. static: 这也是一个修饰符，表示这个方法是静态方法。静态方法属于类本身，而不是类的实例对象。在Java中，静态方法可以直接通过类名调用，而无需创建类的实例。
  5. void: 这是一个返回类型修饰符，表示这个方法没有返回值。void表示不返回任何数据类型。
  6. main: 这是方法的名称，是Java程序的入口点。当运行程序时，JVM会查找这个方法并开始执行其中的代码。
  7. String[] args: 这是main方法的参数。在Java程序启动时，可以通过命令行传入参数，这些参数会被放入args数组中供程序使用。
  8. System.out.println("Hello, World!");: 这是main方法的主要代码。System.out.println是Java的标准输出语句，用于在控制台打印输出。在这里，它将打印字符串”Hello, World!”，这是一个经典的第一个程序输出。

至此，我们便完成了一个经典程序 Hello,World! 代码的编写，那么该如何运行该程序呢？

如果有现成的IDE，如IDEA或者Eclipse,那就可以直接运行，如果没有那么就在命令行中输入以下命令：

1
2
javac Hello.java  // 编译代码
java Hello        // 运行程序

运行结果如下：


说明：

  1. 一个源文件中最多只能有一个public类，其它类的个数不限，编译后，每一个类都对应一个.class文件。
  2. 如果源文件包含一个public类，则文件名必须按照该类类名命名。
  3. Java语言严格区分大小写。
  4. Java方法又一条条语句构成，每个语句以 “ ; “ 结束。
  5. 大括号都是成对出现的，缺一不可。【一般先写{}再写代码】

Java转义字符

\t ： 一个制表位， 实现对齐的功能
\n ： 换行符
\ ： 一个
" : 一个”
' ： 一个’
\r : 一个回车
【注意】转义字符只能在字符串或字符常量中使用，不能用于其他地方，比如直接作为标识符的一部分。

Java注释

\1) 单行注释 // 如： //这是一句注释
\2) 多行注释 /* / 如： /这是一段注释/
\3) 文档注释 /* / 如：/* 这是文档注释*/

文档注释可以帮助程序员和其他使用你的代码的人理解你编写的类、方法、字段等元素的功能和使用方法。这些注释被提取和处理工具，如Javadoc，用于自动生成项目的文档。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 这个类表示一个简单的计算器。
 * 它可以执行基本的算术运算，如加法、减法、乘法和除法。
 */
public class Calculator {

    /**
     * 这个方法将两个整数相加并返回结果。
     *
     * @param num1 要相加的第一个整数。
     * @param num2 要相加的第二个整数。
     * @return num1和num2的和。
     */
    public int add(int num1, int num2) {
        return num1 + num2;
    }
}

Java的文档注释使用一些特殊的标记（以@开头），例如@param和@return，用于标识方法的参数和返回值。这些标记有助于工具将注释中的信息提取出来，并生成格式良好的文档。Javadoc是一个常用的工具，它会读取代码中的文档注释，并生成HTML格式的API文档，以便开发者查阅和使用。

通过良好的文档注释，你可以使你的代码更易于理解、维护和重用，并帮助其他人正确地使用你的代码。良好的文档注释是Java编程中的一个好习惯，特别是在编写公共库或API时。

变量

在Java中，变量是用来存储数据的容器。每个变量都有一个特定的数据类型，并且在程序执行过程中可以被赋予不同的值。在Java中，变量的使用必须先进行声明，然后才能被使用。

Java中的变量可以分为两种类型：基本数据类型和引用数据类型。

  1. 基本数据类型： 基本数据类型是Java中最基础的数据类型，用于存储简单的数据值。Java有以下几种基本数据类型：

    例如：

    1
    2
    3
    4
    int age = 25;             // 整数类型变量age，赋值为25
    double pi = 3.14159;      // 浮点数类型变量pi，赋值为3.14159
    char grade = 'A';         // 字符类型变量grade，赋值为'A'
    boolean isStudent = true; // 布尔类型变量isStudent，赋值为true
    • 整数类型：byte、short、int、long
    • 浮点数类型：float、double
    • 字符类型：char
    • 布尔类型：boolean

  2. 引用数据类型： 引用数据类型是用来存储对象的引用，而不是对象本身。Java的引用数据类型包括类、接口、数组等。当我们创建一个对象时，实际上是在堆内存中分配了一块内存，并将其地址赋值给引用变量，从而使引用变量指向这个对象。

    例如：

    1
    2
    String name = "John";          // 引用类型变量name，指向一个字符串对象
    ArrayList<Integer> numbers = new ArrayList<>();  // 引用类型变量numbers，指向一个整数列表对象

    在Java中，变量具有作用域，即它们只在声明它们的代码块内可见。通常，变量的作用域包括它所在的代码块，如方法、循环或条件语句等。在作用域外，变量将不再可用，这有助于避免变量名冲突和内存浪费。

    总结：在Java中，变量是用来存储数据的标识符。它们可以存储不同类型的数据，并且在声明后可以被赋予不同的值。基本数据类型存储简单的值，而引用数据类型存储对象的引用。

【注意】

  1. 给long型变量赋值时，需要在末尾加上”L”或”l”，用于表示这是一个long类型，否则会当作int类型处理。
  2. Java的浮点型常量（具体值）默认为double型，给float型变量赋值时，需要在末尾加上”F”或”f”。

类型转换：

1、自动类型转换

精度小的类型可以自动转换为精度大的数据类型，数据类型按精度大小排序为：

【注意】

  1. 多种类型混合运算时，系统先自动将所有数据类型转化成容量最大的那种数据类型，再计算
  2. byte，short，char之间不会互相自动转换，三者在计算时首先转化成int类型
  3. boolean不参与转换

2、强制类型转换

将容量大的数据类型转换成容量小的数据类型，需要在前面加上强制转换符（要转换的类型），可能会造成精度降低或溢出。

3、String类和基本数据类型互相转换

基本类型转String : 基本类型 + “ “ 如：

1
2
3
4
5
6
7
int n1 = 100;
float n2 = 12.33f;
double n3 = 123.2;
//转换为String
String str1 = n1 + " ";
String str2 = n2 + " ";
String str3 = n3 + " ";

String 转基本数据类型：通过基本类型的包装类调用parseXX方法， 如：

1
2
3
Integer.parseInt("32123");
Double.parseDouble("123.33");
Float.parseFloat("123.22");

【注意】将String转为基本数据类型时，要确保String是能转成基本类型的数据，比如”123.33”可以转化成一个浮点数，但是”hello word”不能转化成任何一种基本数据类型。

运算符

以下是Java中常见的运算符分类：

  • 算术运算符：
    • +：加法
    • -：减法
    • *：乘法
    • /：除法
    • %：取模（取余数）

【说明】

除法运算 整数之间做除法时，只保留整数部分而舍弃小数部分。如 int x = 10 / 3 ,结果为3

取模运算 用于计算两个整数相除后的余数。常用于判断奇偶性、循环计数、周期性计算等。

  • 赋值运算符：
    • =：赋值
    • +=：加并赋值
    • -=：减并赋值
    • *=：乘并赋值
    • /=：除并赋值
    • %=：取模并赋值

【说明】

sum += i 等价于 sum = sum + i , 其余同理。

  • 自增自减运算符：
    • ++：自增1
    • --：自减1

【说明】

作为独立语句使用时， ++i 和 i++ 都完全等价于 i = i + 1 ;

作为表达式使用时 ， ++i 先自增再赋值 ，i++ 先赋值再自增

  • 关系运算符（比较运算符）：
    • ==：相等
    • !=：不相等
    • >：大于
    • <：小于
    • >=：大于等于
    • <=：小于等于
  • 逻辑运算符：
    • &&：短路与
    • &：逻辑与
    • ||：短路或
    • |：逻辑或
    • !：逻辑非

【说明】

短路与（&&）、短路或（||）在进行布尔运算时，对布尔表达式从左到右依次逐个计算条件是否成立，一旦能够确定结果，就立即终止，不再计算其后各条件。

逻辑与（&）、逻辑或（|）在进行布尔运算时，必须将两个都判断是否成立。

所以在实际开发中一般选择短路与（&&）、短路或（||）。

还可以利用这一点来避免错误，例如：

1
x != 0 && 1 / x > x + y

如果 x 等于0，那么第二部分就不会计算。因此，如果 x 为0，也就不会计算1 / x ,除以0的错误也就不会出现。

  • 位运算符：
    • &：按位与
    • |：按位或
    • ^：按位异或
    • ~：按位取反
    • <<：左移
    • >>：带符号右移
    • >>>：无符号右移
  • 条件运算符（三元运算符）：
    • ? :：条件表达式，也称为三元运算符。例如：condition ? value1 : value2
  • instanceof运算符：
    • instanceof：用于检查对象是否为特定类的实例。例如：object instanceof ClassName

程序控制结构

顺序控制

程序由上到下逐行执行，中间没有任何判断和跳转。

【注意】Java中定义变量或使用方法时要采用向前引用，即变量或方法要放在引用之前。

分支控制

在Java中，分支控制用于根据条件选择不同的执行路径。Java提供了多种分支控制结构，让你可以根据不同的情况来执行不同的代码块。

if-else语句 和 switch语句 以及三元运算

if-else语句分为三种：单分支（if）、双分支（if-else）、多分支（if-else if-else….-else）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//单分支
if (条件) {
    // 如果条件为真，执行这里的代码
} 
双分支
if (条件) {
    // 如果条件为真，执行这里的代码
} else {
    // 如果条件为假，执行这里的代码
}
//多分支
if (条件1) {
    // 如果条件1为真，执行这里的代码
} else if (条件2) {
    // 如果条件2为真，执行这里的代码
} else {
    // 如果前面的条件都不满足，执行这里的代码
}

switch语句用于根据不同的情况执行不同的代码块。它适用于对一个表达式的值进行多路分支控制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
switch (表达式) {
    case 值1:
        // 当表达式的值等于值1时，执行这里的代码
        break;
    case 值2:
        // 当表达式的值等于值2时，执行这里的代码
        break;
    // ... 可以有更多的 case 分支
    default:
        // 如果没有一个 case 分支匹配，执行这里的代码
}
//示例
int dayOfWeek = 3;

switch (dayOfWeek) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    // ... 其他星期几的情况
    default:
        System.out.println("无效的日期");
}

三元运算符是一种简洁的分支控制结构，用于在一个表达式中根据条件选择不同的值。

1
2
3
int age = 18;
String result = (age >= 18) ? "成年人" : "未成年人";
System.out.println(result);

【说明】

  1. 使用switch语句时，需要注意switch(表达式)中表达式的值与case 后面的值数据类型保持一致，或可以自动转化。
  2. \1) 如果判断的具体数值不多， 而且符合 byte、 short 、 int、 char, enum[枚举], String 这 6 种类型。 虽然两个语句都可以使用， 建议使用 swtich 语句。
    \2) 其他情况： 对区间判断， 对结果为 boolean 类型判断， 使用 if， if 的使用范围更广

循环控制

在Java中，循环控制用于重复执行一段代码块，直到满足某个条件。Java提供了几种不同类型的循环结构，让你可以根据不同的需求选择适合的循环方式。

for循环、while循环、do-while循环

for 循环是一种用于重复执行代码块的结构，通常在已知循环次数的情况下使用。它包含初始化、条件判断和迭代表达式，可以在循环内部访问迭代变量。

1
2
3
4
5
6
for (初始化; 条件; 迭代) {
    // 循环体代码
}
for (int i = 0; i < 5; i++) {
    System.out.println("当前 i 的值是：" + i);
}

while 循环在执行循环体之前检查条件是否为真，只要条件为真，就会继续执行循环体。它适用于不确定循环次数的情况。

1
2
3
4
5
6
7
8
while (条件) {
    // 循环体代码
}
int i = 0;
while (i < 5) {
    System.out.println("当前 i 的值是：" + i);
    i++;
}

do-while 循环与 while 循环类似，但它会先执行一次循环体，然后再检查条件是否为真。这确保循环体至少会执行一次。

1
2
3
4
5
6
7
8
do {
    // 循环体代码
} while (条件);
int i = 0;
do {
    System.out.println("当前 i 的值是：" + i);
    i++;
} while (i < 5);

除了这些基本的循环控制结构，Java还提供了控制循环流程的关键字和语句：

  • break：用于终止当前循环，跳出循环体。
  • continue：用于跳过当前循环迭代，继续下一次循环迭代。
  • return：用于退出方法，并返回指定的值。

数组

数组：数（数据）组（一组），就是一组数据

数组可以存放多个同一类型的数据，是引用类型。

1、数组的声明和初始化

1
2
3
4
5
6
7
8
// 声明一个整数数组
int[] numbers;

// 初始化数组并分配空间
numbers = new int[5];

// 或者可以一步完成声明和初始化
int[] numbers = new int[5];

2、数组的赋值和访问

1
2
3
4
5
6
7
8
9
// 赋值
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

// 访问数组元素
int element = numbers[2]; // 获取数组索引为2的元素值，即30