Java 基础语法

注释

给代码写注释是一个良好的编程习惯。可以使代码逻辑更加清晰，方便出错时找 bug，也可以让别人更容易的看懂你的代码。注释在编译时会被编译器忽略，所以它不会对你的代码产生影响。

class HelloWorld{
   /* 这是一个多行注释
    * 这是一个Java程序
    * 它将输出 "Hello World!"
    */
    public static void main(String[] args) {
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World!");
    }
}

基本数据类型

// Java内置了八种基本数据类型
// 基本数据类型：整数类（byte、short、int、long）、浮点类（float、double）、字符类（char）、布尔型（boolean）
int a = 1;        // 4个字节，[-2^31, 2^31-1]
short b = 1;      // 2个字节，[-32768, 32767]
long c = 1;       // 8个字节，[-2^64, 2^64-1]
float e = 1.6f;   // 4个字节，精确到小数点后7位。多数情况下，float类型精度很难满足需要
double d = 1.7;   // 4个字节，精度是float的2倍，一般来说double比float更加常用
// ①默认浮点类型为double；②使用float的时候，数字后面要添加f;
byte h = 127;     // 1个字节，[-128, 127]
boolean f = true; // 布尔型：1个字节，只有true和false两个值
char g = 'x';     // 字符类：2个字节，使用时用单引号表示

声明变量的三个基本部分

类型：即数据的类型，如int（整数）、double（浮点数）、char（字符）、String（字符串）、boolean（布尔值）等
名称：变量的标识符
值（可选）：可以在声明变量时初始化变量

声明变量的语法

1 2	type variableName; // 仅声明 type variableName = value; // 声明并初始化

示例

int age;                 // 声明一个整型变量名为 age
age = 25;                // 初始化变量 age

double salary = 5000.75; // 声明并初始化一个双精度浮点数 salary

变量命名规则

变量名必须以字母A-Z或a-z、美元符$或下划线_开始
变量名的其他部分可以包含字母、数字、美元符和下划线
大小写敏感，即age, Age, AGE 是三个不同的变量
不能使用 Java 的保留关键字作为变量名，例如int, boolean 等。

最佳实践

命名清晰： 变量名应清楚地反映信息或意图，例如使用studentCount而不是sc
遵循约定： Java 通常使用驼峰命名法，如myVariableName。参考：维基百科-驼峰命名法

camel-case

运算符

算数运算符

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B 等于 200
/	除法 - 左操作数除以右操作数	B / A 等于 2
％	取余 - 左操作数除以右操作数的余数	B%A 等于 0
++	自增: 操作数的值增加 1	B++ 或 ++B 等于 21
–	自减: 操作数的值减少 1	B-- 或 --B 等于 19

1 2	int i = 1; // 此时i的值为1 i++; // 此时i的值为2

赋值运算符

操作符	描述	例子
=	赋值运算符，将右操作数的值赋给左侧操作数	C = A + B 将把 A + B 得到的值赋给 C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A 等价于 C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A 等价于 C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C _ = A 等价于 C = C _ A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A

1 2	int i = 1; // 此时i的值为1 i += 10; // 此时i的值为11

关系运算符

关系运算符的运算结果为 boolean（布尔）型，即 true 或 false

运算符	描述
==	检查如果两个操作数的值是否相等，如果相等则条件为真。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。

int i = 1;
int j = 2;
double k = 1.0
boolean equal1 = i == j; // equal1的值为false
boolean equal2 = i == k; // equal2的值为true

逻辑运算符

逻辑运算符的运算结果为 boolean（布尔）型，即 true 或 false

操作符	描述	例子
&&	逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\|\|	逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \| \| B）为真。
！	逻辑非运算符。用来反转操作数的逻辑状态。如果条件为 true，则逻辑非运算符将得到 false。	！（A && B）为真。

boolean a = true;
boolean b = false;

boolean c = a && a; // c的值为true
boolean d = a || b; // d的值为true
boolean e = !a;     // e的值为false
boolean f = a && b; // f的值为false

控制结构

条件语句

if (a) {
  ...
} else if (b) {
  ...
} else {
  ...
}

String name = "板烧鸡腿堡";
switch (name) {
    case "板烧鸡腿堡":
        System.out.println("我是板烧鸡腿堡");
        break;
    case "麦辣鸡腿堡":
        System.out.println("我是麦辣鸡腿堡");
        break;
    case "麦乐鸡":
        System.out.println("我是麦乐鸡");
        break;
    // 如果上述的case中没有任何匹配的，就会执行default语句
    default:
        System.out.println("让我尝一尝才知道");
}

循环结构

while 循环

1
2
3

while(布尔表达式) {
  // ...
}

int i = 0;
while (i < 5) {
  i++;
  System.out.println(i);
  // 输出：
  // 0
  // 1
  // 2
  // 3
  // 4
}

do…while 循环

对于 while 循环来说，如果不满足条件，则不能进入循环，但对于 do…while 循环来说，至少进入一次循环之后才会判断条件。所以循环至少会执行一次

// 会输出hello, world!
do {
  System.out.println("hello, world!");
} while (false);

for 循环

1
2
3

for(初始化; 布尔表达式; 更新) {
    // ...
}

for (int i = 10; i > 5; i--) {
  System.out.println(i);
  // 输出：
  // 10
  // 9
  // 8
  // 7
  // 6
}

跳转语句

break

break 主要用于跳出循环结构或者 switch 语句块，break 可以跳出当前代码的最里层循环

for (int i = 0; i < 10; i++) {
  for (int j = 0; j < 10; j++) {
    if(j == i){
      break; // 只跳出内层循环
    }
    System.out.println(i + " " + j);
  }
}

continue

continue 用于直接进入下一次循环

for (int i = 0; i < 10; i++) {
  if(i == 5) {
    continue;
  }
  System.out.println(i + " " + j);
}

数组

// type[] name = new type[length];

// 动态初始化，初始化时就指定长度
int[] arr = new int[3];
// 静态初始化，初始化时指定内容
int[] arr2 = new int[]{1,3,5,7};

// 各种数据类型都可以有数组，例如下面就是一个String的数组
String[] departments = {"前端", "后端", "C++", "C#"};

面向对象基础

**在 Java 中，万物皆是对象。**一个 Java 程序可以认为是一系列对象（Object）的集合，而这些对象通过调用彼此的方法（Method）来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

类与对象（Class & Object）

class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, World!");
  }
}

类 (Class)

类可以看作是一种蓝图或模板，它定义了一组具有相同属性（数据元素）和方法（功能）的对象的共同特征。可以将类比喻为建筑图纸，它描述了如何构建某种类型的实体（如房子、学校、医院等）。

特点:

属性：类定义了对象的数据，即有哪些属性（如颜色、大小、形状等）。
方法：类还定义了可以执行的操作（即方法），如计算面积、改变状态等。

对象 (Object)

对象则是根据类的定义创建的实例。每个对象都拥有类中定义的属性和方法，但具体的属性值可以不同。如果类是建筑图纸，那么对象就是根据这些图纸建造的实际建筑。

特点:

实例化：创建具体的对象过程称为实例化，即按照类的蓝图具体化一个实体。
独立性：每个对象都保持其属性独立，互不影响。例如，两座建筑可以根据同一设计图纸建造，但各自的具体使用情况、内部装修等可以完全不同。

类与对象的关系

模板与实例：类是对象的模板，对象是类的实例。
设计与实现：类是设计，确定了创建对象所需的框架；对象是实现，是设计的具体体现

类的创建（new）

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

1
2
3

int sum(int a, int b) {
    return a + b; // 返回两个数的和作为返回值
}

class Cat {
    // 名字
    String name;
    // 年龄
    int age;
    // 种类
    String type;

    // 构造方法
    Cat(String name, int age, String type){
      this.name = name;
      this.age = age;
      this.type = type;
    }

    String getName() {
        return name;
    }

    //吃
    void eat() {
    }

    //跑
    void run() {
    }

    //睡
    void sleep(){
    }
}

构造方法

每个类都有构造方法。如果没有定义构造方法，Java 编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

1 2	Cat cat = new Cat("乐事", 1, "银渐层"); System.out.println(cat.getName()); // 此处返回“乐事”

作业

自行了解 Java 面向对象的进阶内容

Dylan Deng

2024-10-26

授课 #Java

Home

sast-lesson-docs

Trading