Java 基础教程 Day2：从数据类型到面向对象核心概念

📚 系列教程：Java 零基础入门

📅 学习天数：Day 2

💡 适合人群：Java 初学者、转行开发者、计算机专业学生

---

📖 目录

1. 变量与数据类型
2. 运算符详解

3. String 字符串操作\](#3-string 字符串操作)

4. 类与对象
5. 构造方法与重载
6. 静态变量与方法
7. 继承
8. 接口
9. 抽象类
10. 访问修饰符

---

1. 变量与数据类型

1.1 基本数据类型

Java 是强类型语言，每个变量都必须声明类型：

public class Hello {
    public static void main(String[] args) {
        // 字符串类型
        String name = "hello";
        name = "chunlei";  // 变量可以重新赋值
        
        // 字符类型
        char c1 = 'a';
        
        // 浮点类型
        double d1 = 3.14;
        float f1 = 3.14f;  // f 后缀指定为 float 类型
        
        // 整数类型
        long l1 = 100000L;  // L 后缀表示 long
        short s1 = 100;
        
        // 常量（final 修饰，不可修改）
        final int size = 18;
    }
}

💡 知识点总结：

• float 类型必须加 f 后缀，否则默认是 double
• long 类型建议加 L 后缀，避免溢出
• final 关键字声明常量，命名通常全大写

---

2. 运算符详解

2.1 算术运算符

int a = 10;
int b = 20;
int c = 25;
int d = 25;

System.out.println("a + b = " + (a + b));  // 30
System.out.println("a - b = " + (a - b));  // -10
System.out.println("a * b = " + (a * b));  // 200
System.out.println("b / a = " + (b / a));  // 2
System.out.println("b % a = " + (b % a));  // 0
System.out.println("c % a = " + (c % a));  // 5

2.2 自增自减运算符

// 前置自增：先加后用
System.out.println("++a = " + (++a));  // 12

// 后置自增：先用后加
System.out.println("a++ = " + (a++));  // 12（下一次 a 才是 13）

⚠️ 注意： 前置 ++a 和后置 a++ 在表达式中的行为不同！

---

3. String 字符串操作

3.1 常用方法

String origin = "请叫我八点虾   ";

// 获取长度
int len = origin.length();  // 10

// 遍历字符串
for (int i = 0; i < len; i++) {
    char item = origin.charAt(i);
}

// 去除空白
String v2 = origin.trim();  // "请叫我八点虾"

// 分割字符串
String[] v5 = origin.split("我");  // ["请", "叫八点虾   "]
System.out.println(Arrays.toString(v5));

// 字符串拼接
String v11 = origin.concat("哈哈哈");
System.out.println(v11);  // "请叫我八点虾   哈哈哈"

// 字符串比较
boolean v8 = origin.equals("请叫我八点虾   ");  // true
System.out.println(v8);

// 包含判断
boolean v9 = origin.contains("请叫我");  // true
System.out.println(v9);

// 大小写转换
String v1 = new String("chunlei");
String res = v1.toUpperCase();  // "chunlei"
System.out.println(res);

💡 重要提示：

• 字符串比较必须用 equals()，不能用 ==
• trim() 只去除首尾空白，不会修改原字符串（String 是不可变的）

---

4. 数组基础

4.1 数组声明与初始化

// 整型数组
int[] numArray = new int[3];
numArray[0] = 123;
numArray[1] = 1;
numArray[2] = 99;

// 遍历数组
for (int idx = 0; idx < numArray.length; idx++) {
    int item = numArray[idx];
    System.out.println(item);
}

// 对象数组
Object[] v3 = new Object[3];
v3[0] = 123;
v3[1] = "chunlei";
System.out.println(Arrays.toString(v3));  // [123, chunlei]

4.2 数组特点

• 数组长度固定，创建后不能改变
• 数组下标从 0 开始
• Object[] 可以存储任意类型的对象
• 访问数组元素时注意不要越界

---

5. 类与对象

5.1 类的定义

public class CLassDemo {
    // 成员变量（属性）
    String name;
    int age;
    
    // 成员方法
    public void call() {
        System.out.println(name + "正在打电话");
    }
    
    public void message() {
        System.out.println(name + "今年" + age + "岁了");
    }
    
    public static void main(String[] args) {
        // 创建对象
        CLassDemo cLassDemo = new CLassDemo();
        
        // 设置属性
        cLassDemo.age = 18;
        cLassDemo.name = "张三";
        
        // 调用方法
        cLassDemo.call();    // 张三正在打电话
        cLassDemo.message(); // 张三今年 18 岁了
    }
}

5.2 面向对象三大特征

1. 封装：将数据和行为包装在类中
2. 继承：子类继承父类的属性和方法
3. 多态：同一操作作用于不同对象产生不同行为

---

6. 构造方法与重载

6.1 构造方法

class Person1 {
    // 实例变量
    public String name;
    public Integer age;
    
    // 静态变量
    public static String city = "北京";
    
    // 构造方法 1：无参构造
    public Person1() {
        this.name = "666";
        this.age = 99999;
    }
    
    // 构造方法 2：一个参数
    public Person1(String names) {
        this.name = names;
        this.age = 99999;
    }
    
    // 构造方法 3：两个参数
    public Person1(String names, int age) {
        this.name = names;
        this.age = age;
    }
}

6.2 方法重载（Overload）

class Person1 {
    // 方法重载：方法名相同，参数列表不同
    public void doSomething() {
        System.out.println(this.name);
    }
    
    public void doSomething(String prev) {
        String text = String.format("%s-%s", prev, this.name);
        System.out.println(text);
    }
    
    public void doSomething(String prev, String age) {
        String text = String.format("%s-%s-%s", prev, this.name, age);
        System.out.println(text);
    }
}

// 使用示例
Person1 person11 = new Person1("666");
person11.doSomething();           // 666
person11.doSomething("hello");    // hello-666
person11.doSomething("666", "188"); // 666-666-188

💡 重载规则：

• 方法名必须相同
• 参数列表必须不同（类型、个数、顺序）
• 与返回值类型无关

---

7. 静态变量与方法

7.1 static 关键字

class Person1 {
    // 静态变量：属于类，所有对象共享
    public static String city = "北京";
    
    // 静态方法：可以直接通过类名调用
    public static void showInfos() {
        System.out.println("没有返回值的静态方法");
    }
    
    public static String showInfos1() {
        return "有返回值的静态方法";
    }
}

// 使用示例
System.out.println(Person1.city);      // 北京
System.out.println(Person1.showInfos1()); // 有返回值的静态方法
Person1.showInfos();                   // 没有返回值的静态方法

7.2 静态 vs 实例

特性	静态 (static)	实例 (非静态)
归属	类	对象
内存	方法区，只有一份	堆内存，每个对象一份
访问	类名.成员	对象名。成员
用途	工具方法、常量、共享数据	对象特有的属性和行为

---

8. 继承

8.1 extends 关键字

// 父类
class Bases {
    public String email;
    
    public Bases(String email) {
        this.email = email;
    }
    
    public void show() {
        System.out.println("111");
    }
}

// 子类
class Persons1 extends Bases {
    public String name;
    public int age;
    
    public Persons1(String name, Integer age, String email) {
        super(email);  // 调用父类构造方法
        this.name = name;
        this.age = age;
    }
    
    // 方法重写
    public void show() {
        System.out.println("222");
    }
}

// 使用示例
Persons1 persons1 = new Persons1("hello", 20, "www.chunlei.fun");
persons1.getSubInfo();    // 继承的方法
System.out.println(persons1.email);  // 继承的属性
persons1.show();          // 输出：222（重写的方法）

// 向上转型
Bases ssss = new Persons1("hello", 20, "www.chunlei.fun");
ssss.show();              // 输出：222（多态）

8.2 继承要点

• 子类使用 extends 继承父类
• 子类构造方法必须调用父类构造方法（super()）
• 子类可以重写父类方法（Override）
• 向上转型：父类引用指向子类对象

---

9. 接口

9.1 interface 定义

// 接口定义
interface IMessage {
    public void send();  // 接口方法默认 public abstract
}

// 类实现接口
class Wechat implements IMessage {
    public void send() {
        System.out.println("发送微信");
    }
}

class DingDing implements IMessage {
    public void send() {
        System.out.println("发送钉钉");
    }
}

class Sms implements IMessage {
    public void send() {
        System.out.println("发送短信");
    }
}

// 使用示例
DingDing v1 = new DingDing();
v1.send();  // 发送钉钉

9.2 接口 vs 抽象类

特性	接口	抽象类
关键字	interface	abstract class
方法	默认抽象（Java8 前）	可以有具体实现
变量	默认 public static final	任意类型
继承	可实现多个	只能继承一个
用途	定义规范、能力	代码复用、模板

---

10. 抽象类

10.1 abstract 关键字

// 抽象类
abstract class Base {
    // 抽象方法：只有声明，没有实现
    public abstract void play(String name);
    
    // 普通方法：有具体实现
    public void stop() {
        System.out.println("Stop");
    }
}

// 子类实现抽象方法
class Xxx extends Base {
    public void play(String name) {
        System.out.println(name);
    }
}

// 使用示例
Xxx xxx = new Xxx();
xxx.stop();    // Stop（继承的普通方法）
xxx.play("xxxx"); // xxxx（实现的抽象方法）

10.2 抽象类特点

• 使用 abstract 修饰
• 可以包含抽象方法和普通方法
• 不能直接实例化（new Base() 会报错）
• 子类必须实现所有抽象方法

---

11. 访问修饰符

11.1 四种访问级别

package utils;

public class Helper {
    public String age;              // public：任何地方可访问
    public static String name;      // public 静态
    private String xxx;             // private：只有本类可访问
    
    // 方法访问权限
    public static void func1() {    // public
        System.out.println("1231232");
    }
    
    private static void fun2() {    // private
        System.out.println("私有");
    }
    
    void func3() {                  // default（默认）
        System.out.println("default");
    }
    
    protected static void func4() { // protected
        fun2();  // 可以访问同类的 private 方法
        System.out.println("protected");
    }
}

11.2 访问权限对比表

修饰符	同类	同包	子类	任何地方
private	✅	❌	❌	❌
default	✅	✅	❌	❌
protected	✅	✅	✅	❌
public	✅	✅	✅	✅

💡 最佳实践：

• 优先使用 private，暴露最小接口
• 需要跨包访问时用 public
• 子类需要访问时用 protected

---

🎯 本章小结

Day2 我们学习了 Java 的核心基础：

✅ 数据类型 ：基本类型、常量定义

✅ 运算符 ：算术运算、自增自减

✅ String 操作 ：常用方法、字符串不可变性

✅ 数组 ：声明、初始化、遍历

✅ 面向对象 ：类、对象、封装

✅ 构造方法 ：无参、有参、重载

✅ static 关键字 ：静态变量、静态方法

✅ 继承 ：extends、super、方法重写

✅ 接口 ：implements、多实现

✅ 抽象类 ：abstract、抽象方法

✅ 访问修饰符：public/private/protected/default

---

📝 课后练习

1. 创建一个 Student 类，包含姓名、年龄、成绩属性
2. 实现构造方法重载，支持不同的初始化方式
3. 创建一个 Calculator 类，实现加减乘除方法重载
4. 定义一个 Animal 抽象类，包含 eat() 抽象方法
5. 定义一个 Runnable 接口，让多个类实现

---

🔗 下一篇预告

Day3：集合框架与泛型

• ArrayList、HashSet、HashMap
• 泛型基础
• 迭代器与 Stream API

---

💬 欢迎在评论区留言讨论！

👍 觉得有帮助请点赞收藏！

🔔 关注我［八点虾］，持续更新 App逆向 教程系列！

---

标签： #Java #编程入门 #面向对象 #Java 基础 #教程