01基础

Java标识符

规则

  • 组成元素：字母（A-Z, a-z）、数字（0-9）、下划线（_）、美元符（$）
  • 限制：
    • 不能以数字开头（如 1name 非法，name1 合法）
    • 不能是关键字（如 class、public 等）
    • 区分大小写（Name 和 name 是不同的标识符）

命名规范

  • 变量/方法名：小驼峰（如 studentName）
  • 类名：大驼峰（如 StudentInfo）
  • 常量名：全大写，下划线分隔（如 MAX_COUNT）

static 修饰符

作用

  • 静态变量（类变量）：所有对象共享同一份数据
  • 静态方法：可直接通过类名调用（无需创建对象）

示例

public class Example {
    static int count = 0;  // 静态变量
    
    public static void printMessage() {  // 静态方法
        System.out.println("Hello!");
    }
}

// 调用静态成员
Example.count = 10;
Example.printMessage();

final 修饰符

作用

  • 常量：值不可修改
  • final类：禁止继承（如 String 类）
  • final方法：禁止子类重写

示例

public class Constants {
    static final double PI = 3.14159;  // 常量（通常全大写命名）
}

// 错误示例：PI = 3.14;  // 编译报错，无法修改常量

注释

三种形式

  1. 单行注释：

    int age = 20;  // 这是单行注释

  2. 多行注释：

    /*
这是多行注释
可以跨多行
*/

  3. 文档注释（生成API文档）：

    /**
 * 计算两个数的和
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数之和
 */
public int add(int a, int b) {
    return a + b;
}

Java基础数据类型

8种基本类型

类型 关键字 大小 取值范围 默认值 示例
字节型 byte 1字节 -128 ~ 127 0 byte b = 100;
短整型 short 2字节 -32768 ~ 32767 0 short s = 2000;
整型 int 4字节 -2^31 ~ 2^31-1 0 int i = 100000;
长整型 long 8字节 -2^63 ~ 2^63-1 0L long l = 100L;
单精度 float 4字节 ±3.4E+38（约6-7位小数） 0.0f float f = 3.14f;
双精度 double 8字节 ±1.7E+308（约15位小数） 0.0d double d = 3.14;
字符型 char 2字节 Unicode字符（如 'A'、'中'） '\u0000' char c = 'A';
布尔型 boolean 无明确大小 true/false false boolean flag = true;

类型转换

自动类型转换（隐式转换）

  • 规则：小类型 → 大类型（如 int → double）

  • 示例：

    int a = 10;
double b = a;  // 自动转换为 10.0

强制类型转换（显式转换）

  • 语法：(目标类型)值

  • 注意：可能导致精度丢失或溢出

  • 示例：

    double x = 3.14;
int y = (int)x;  // y = 3（直接截断小数部分）

循环结构

普通for循环

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

增强for循环（遍历数组/集合）

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);  // 依次输出 1,2,3,4,5
}

方法

定义与调用

public class Calculator {
    // 定义方法：求两个数的最大值
    public static int max(int n1, int n2) {
        return (n1 > n2) ? n1 : n2;
    }

    public static void main(String[] args) {
        int result = max(10, 20);  // 调用方法
        System.out.println("最大值是：" + result);  // 输出 20
    }
}

方法重载

  • 规则：同名方法，参数列表不同（类型、数量、顺序）

  • 示例：

    // 重载方法1：两个int参数
public static int add(int a, int b) {
    return a + b;
}

// 重载方法2：三个int参数
public static int add(int a, int b, int c) {
    return a + b + c;
}

// 重载方法3：两个double参数
public static double add(double a, double b) {
    return a + b;
}

总结表格

特性 示例/说明
标识符命名规则 字母/数字/_/$，不以数字开头，非关键字
static 类变量/方法，直接通过类访问
final 常量（值不可变）、禁止继承（类）、禁止重写（方法）
基本数据类型 8种：byte、short、int、long、float、double、char、boolean
类型转换 自动（小→大）、强制（大→小，可能丢失精度）
增强for循环 简化数组/集合遍历
方法重载 同名方法，参数列表不同

类与对象

Java类与对象详解

1. 类（Class）

  • 定义：类是对象的蓝图或模板，用于描述一类对象的共同属性和行为。

  • 组成：

    • 属性（成员变量）：描述对象的特征（如颜色、品牌）。
    • 方法（成员函数）：定义对象的行为（如加速、刹车）。
    • 构造方法：用于初始化对象（与类同名，无返回值）。

  • 示例：

    public class Car {
    // 属性
    private String color;
    private String brand;
    private int speed;

    // 构造方法
    public Car(String color, String brand) {
        this.color = color;
        this.brand = brand;
        this.speed = 0;
    }

    // 方法
    public void accelerate(int increment) {
        if (increment > 0) {
            speed += increment;
        }
    }

    public void displayInfo() {
        System.out.println("品牌：" + brand + "，颜色：" + color + "，当前速度：" + speed + "km/h");
    }
}

2. 对象（Object）

  • 定义：对象是类的实例，拥有类中定义的属性和方法。

  • 创建对象：使用 new 关键字调用构造方法。

    Car myCar = new Car("红色", "丰田"); // 创建一个Car对象

  • 访问属性和方法：通过点号 . 操作。

    myCar.accelerate(20);   // 调用方法
myCar.displayInfo();    // 输出：品牌：丰田，颜色：红色，当前速度：20km/h

3. 类与对象的关系

  • 类比：类像建筑设计图，对象是按图纸建成的房子。

  • 独立性：不同对象属性独立。例如：

    Car yourCar = new Car("蓝色", "本田");
yourCar.accelerate(30);
// myCar和yourCar的速度互不影响

4. 封装（Encapsulation）

  • 目的：保护数据，隐藏实现细节。

  • 实现：将属性设为 private，通过公有方法访问。

    public class Car {
    private int speed;

    // Getter方法
    public int getSpeed() {
        return speed;
    }

    // Setter方法（带校验）
    public void setSpeed(int speed) {
        if (speed >= 0) {
            this.speed = speed;
        }
    }
}

5. 静态成员（static）

  • 归属：属于类本身，而非对象。

  • 示例：

    public class Car {
    private static int numberOfCars = 0;

    public Car() {
        numberOfCars++; // 每创建一个对象，计数器+1
    }

    public static int getTotalCars() {
        return numberOfCars;
    }
}

    System.out.println("已创建汽车数量：" + Car.getTotalCars()); // 直接通过类名访问

6. 完整示例

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("红色", "丰田");
        myCar.accelerate(20);
        myCar.displayInfo(); // 输出：品牌：丰田，颜色：红色，当前速度：20km/h

        Car yourCar = new Car("蓝色", "本田");
        yourCar.accelerate(30);
        yourCar.displayInfo(); // 输出：品牌：本田，颜色：蓝色，当前速度：30km/h
    }
}

7. 关键区别

类（Class） 对象（Object）
抽象模板（定义属性/方法） 具体实例（占用实际内存）
程序编译时存在 程序运行时动态创建
通过 class 关键字定义 通过 new 关键字实例化

接口

一、接口是什么？

想象你要造一台手机，先列出一个「必须有的功能清单」：

  • 打电话
  • 发短信
  • 能充电

这个清单就是「接口」！它不管手机怎么实现这些功能，只规定「必须要有这些功能」。

用代码表示：

// 定义接口（功能清单）
interface Phone {
    void call();   // 打电话（没有具体实现）
    void sendSMS();// 发短信
    void charge(); // 充电
}

二、接口怎么用？

假设你要造一个华为手机，必须按照接口的清单实现所有功能：

// 实现接口（具体造手机）
class HuaweiPhone implements Phone {
    // 必须实现接口的所有方法！
    public void call() {
        System.out.println("用5G打电话");
    }
    public void sendSMS() {
        System.out.println("发送带表情的短信");
    }
    public void charge() {
        System.out.println("超级快充");
    }
}

三、为什么要用接口？

场景1：统一标准

  • 所有手机都必须实现相同的功能，但实现方式不同
  • 比如苹果手机的充电方式可能和华为不同

场景2：灵活扩展

  • 你可以同时让手机支持「拍照功能」的接口
class HuaweiPhone implements Phone, Camera {
    // 实现两个接口的功能
}

场景3：隐藏细节

  • 用户只需要知道「能打电话」，不需要关心是4G还是5G实现的

四、接口的特性（记住这3点）

  1. 不能直接创建对象（就像不能直接使用「功能清单」打电话）

    // 错误！
Phone p = new Phone(); 

// 正确：用实现了接口的类
Phone p = new HuaweiPhone();

  2. 所有方法默认是抽象的（Java 8前）

    • 没有方法体（即没有{}中的具体代码）
    • 实现类必须重写所有方法

  3. 变量默认是常量（自动加public static final）

    interface USB {
    int VERSION = 3; // 等同于 public static final int VERSION = 3;
}

五、接口 vs 抽象类

最容易混淆的问题！一张表看懂：

接口（interface） 抽象类（abstract class）
方法 默认全是抽象方法 可以有抽象和具体方法
变量 只能是常量 可以是普通变量
继承 类可以实现多个接口 类只能继承一个抽象类
设计理念 「能做什么」的能力 「是什么」的层级关系

通俗理解：

  • 抽象类：比如「动物」抽象类，派生出「猫」「狗」
  • 接口：比如「会游泳的」「会飞的」，不同动物可以选择实现

六、实际例子：USB接口

1. 定义USB标准

interface USB {
    void transferData(); // 传输数据
    void plugIn();       // 插入
}

2. 不同设备实现

class Mouse implements USB {
    public void transferData() {
        System.out.println("传输鼠标移动数据");
    }
    public void plugIn() {
        System.out.println("USB-A接口接入");
    }
}

class SSD implements USB {
    public void transferData() {
        System.out.println("高速传输文件");
    }
    public void plugIn() {
        System.out.println("USB-C接口接入");
    }
}

3. 使用接口

public class Computer {
    public static void main(String[] args) {
        USB device1 = new Mouse();
        USB device2 = new SSD();
        
        device1.plugIn();  // 输出：USB-A接口接入
        device2.transferData(); // 输出：高速传输文件
    }
}

七、Java 8 后的新特性

为了不增加初学者的负担，你只需要知道：

  1. 默认方法（default methods）
    接口中可以写具体实现的方法，用default修饰

    interface USB {
    default void showVersion() {
        System.out.println("USB 3.0");
    }
}

  2. 静态方法
    直接用接口名调用

    interface USB {
    static void description() {
        System.out.println("通用串行总线");
    }
}

// 使用
USB.description();

八、练习小任务

  1. 定义一个「动物」接口，要求有eat()和sleep()方法
  2. 创建「猫」和「狗」类实现这个接口
  3. 尝试让「狗」类同时实现「会游泳」的接口

输入输出

好的！以下是针对零基础的 Java 控制台输入输出总结，包含基本语法和常见格式示例。

一、控制台输出

Java 使用 System.out 对象的三个方法实现控制台输出：

1. System.out.println()

  • 作用：输出内容并换行。

  • 示例：

    System.out.println("Hello World"); // 输出字符串并换行
System.out.println(100);          // 输出整数并换行
System.out.println(3.14);         // 输出浮点数并换行

2. System.out.print()

  • 作用：输出内容不换行。

  • 示例：

    System.out.print("Hello ");
System.out.print("Java!"); 
// 输出结果：Hello Java!

3. System.out.printf()

  • 作用：格式化输出（类似 C 语言的 printf）。

  • 语法：System.out.printf("格式字符串", 参数1, 参数2, ...);

  • 常用格式符：

    格式符 说明 示例
    %d 整数 printf("%d", 10)
    %f 浮点数 printf("%.2f", 3.1415) → 3.14
    %s 字符串 printf("%s", "Java")
    %c 单个字符 printf("%c", 'A')
    %b 布尔值 printf("%b", true) → true
    %n 换行符（推荐使用） printf("Hello%nWorld") → 两行

  • 对齐和宽度：

    // 左对齐，总宽度10字符
System.out.printf("%-10s:%5d%n", "Tom", 20); 
// 输出：Tom       :   20

// 右对齐，保留两位小数
System.out.printf("Price: %10.2f%n", 99.5); 
// 输出：Price:      99.50

二、控制台输入

Java 使用 Scanner 类读取控制台输入。

1. 基本步骤：

  1. 导入包：

    import java.util.Scanner;

  2. 创建 Scanner 对象：

    Scanner scanner = new Scanner(System.in);

  3. 读取输入：

    方法 说明 示例
    nextInt() 读取整数 int num = scanner.nextInt();
    nextDouble() 读取浮点数 double d = scanner.nextDouble();
    next() 读取单词（空格分隔） String s = scanner.next();
    nextLine() 读取整行（包含空格） String line = scanner.nextLine();
    nextBoolean() 读取布尔值 boolean b = scanner.nextBoolean();

2. 示例代码：

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入姓名：");
        String name = scanner.nextLine(); // 读取整行
        
        System.out.print("请输入年龄：");
        int age = scanner.nextInt();      // 读取整数
        
        System.out.print("请输入身高（米）：");
        double height = scanner.nextDouble();
        
        System.out.printf("姓名：%s，年龄：%d，身高：%.2f米%n", name, age, height);
        scanner.close(); // 关闭 Scanner
    }
}

3. 注意事项：

  • 输入顺序：混合使用 nextInt() 和 nextLine() 时，可能会因换行符导致错误。
    解决方法：在 nextInt() 后加一个 nextLine() 清空缓冲区：

    int num = scanner.nextInt();
scanner.nextLine(); // 清除换行符
String s = scanner.nextLine();

三、综合示例

import java.util.Scanner;

public class ConsoleDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 输入部分
        System.out.print("请输入商品名称：");
        String product = scanner.nextLine();
        
        System.out.print("请输入价格（元）：");
        double price = scanner.nextDouble();
        
        System.out.print("请输入库存数量：");
        int stock = scanner.nextInt();
        
        // 输出表格
        System.out.println("\n===== 商品信息 =====");
        System.out.printf("%-10s | %-8s | %-6s%n", "商品", "价格", "库存");
        System.out.printf("%-10s | %8.2f | %6d%n", product, price, stock);
        
        scanner.close();
    }
}

输出示例：

请输入商品名称：Java编程书
请输入价格（元）：59.9
请输入库存数量：100

===== 商品信息 =====
商品       | 价格      | 库存  
Java编程书 |    59.90 |    100

四、总结

  • 输出：掌握 println、print 和 printf，注意格式化符号（如 %.2f 保留两位小数）。
  • 输入：使用 Scanner 类，注意不同数据类型的读取方法。
  • 常见问题：输入顺序导致的换行符问题，使用 nextLine() 清空缓冲区。

String&StringBuilder

一、String（不可变字符串）

1. 什么是 String？

String 是 Java 中用来表示不可变字符序列的类。
不可变：一旦创建，内容就不能被修改。任何对字符串的操作（如拼接、替换）都会生成一个新的字符串对象。

2. 如何创建 String？

方式一：直接赋值（推荐）
String str1 = "Hello";  // 直接赋值，字符串存储在常量池
方式二：通过构造方法
String str2 = new String("Hello");  // 通过 new 创建，存储在堆内存

3. String 的特点

  • 不可变性：修改字符串会生成新对象，原对象不变。
  • 线程安全：因为不可变，多线程操作安全。
  • 性能问题：频繁修改会产生大量临时对象，影响性能。

4. String 的常用方法

(1) 获取信息

  • length()：返回字符串长度。

    String str = "Hello";
int len = str.length();  // len = 5

  • charAt(int index)：返回指定位置的字符。

    char ch = str.charAt(1);  // ch = 'e'
(2) 截取与拼接

  • substring(int begin, int end)：截取子字符串（包含 begin，不包含 end）。

    String sub = str.substring(1, 4);  // sub = "ell"

  • concat(String s)：拼接字符串（返回新字符串）。

    String newStr = str.concat(" World");  // newStr = "Hello World"
(3) 比较与查找

  • equals(Object obj)：比较字符串内容是否相等。

    boolean isEqual = str.equals("hello");  // false（区分大小写）

  • equalsIgnoreCase(String s)：忽略大小写比较。

    boolean isEqual = str.equalsIgnoreCase("hello");  // true

  • indexOf(String s)：返回子字符串第一次出现的索引。

    int index = str.indexOf("e");  // index = 1
(4) 修改字符串（生成新对象）

  • toLowerCase() 和 toUpperCase()：转换大小写。

    String lower = str.toLowerCase();  // "hello"
String upper = str.toUpperCase();  // "HELLO"

  • trim()：去除两端空格。

    String trimmed = "  Hello  ".trim();  // "Hello"

  • replace(oldChar, newChar)：替换字符。

    String replaced = str.replace('l', 'L');  // "HeLLo"

二、StringBuilder（可变字符串）

1. 什么是 StringBuilder？

StringBuilder 是 Java 中用来表示可变字符序列的类。
可变：可以直接修改内容，不会生成新对象，适合频繁修改字符串的场景。

2. 如何创建 StringBuilder？

StringBuilder sb = new StringBuilder();        // 空字符串
StringBuilder sb2 = new StringBuilder("Hello");  // 初始值为 "Hello"

3. StringBuilder 的特点

  • 可变性：直接在原对象上修改，性能高效。
  • 非线程安全：单线程环境下使用更高效。
  • 适合场景：频繁拼接、插入、删除等操作。

4. StringBuilder 的常用方法

(1) 基本操作

  • append(数据)：追加内容（支持任意类型）。

    sb.append("Hello");
sb.append(123);  // sb = "Hello123"

  • insert(位置, 数据)：在指定位置插入内容。

    sb.insert(5, " World");  // sb = "Hello World123"

  • delete(起始位置, 结束位置)：删除指定范围的字符。

    sb.delete(5, 11);  // sb = "Hello123"
(2) 修改内容

  • reverse()：反转字符串。

    sb.reverse();  // sb = "321olleH"

  • setCharAt(位置, 新字符)：替换指定位置的字符。

    sb.setCharAt(0, 'X');  // sb = "X21olleH"

  • replace(起始位置, 结束位置, 新字符串)：替换指定范围的字符串。

    sb.replace(0, 3, "ABC");  // sb = "ABColleH"
(3) 获取信息

  • length()：返回字符串长度。

    int len = sb.length();  // len = 7

  • charAt(位置)：返回指定位置的字符。

    char ch = sb.charAt(2);  // ch = 'C'
(4) 转换为 String

  • toString()：将 StringBuilder 转为 String。

    String result = sb.toString();  // result = "ABColleH"

三、String vs StringBuilder 对比

特性 String StringBuilder
可变性 不可变 可变
线程安全 安全（不可变） 不安全（但单线程性能高）
适用场景 不频繁修改的字符串操作 频繁修改的字符串操作
性能 频繁修改时差（生成新对象） 频繁修改时好（直接修改原对象）

四、如何选择？

  • 用 String：字符串内容固定，或修改不频繁（如配置信息）。
  • 用 StringBuilder：需要频繁拼接、修改字符串（如循环中拼接 SQL 语句）。
posted @ 2025-02-21 20:25  咋还没来  阅读(37)  评论(0)    收藏  举报