自学-java-基础-入门、面向对象、java API、集合类

篝火囚徒

于 2025-04-02 18:16:10 发布

阅读量587

点赞数 17

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/qq_53746717/article/details/137183435

版权

java 专栏收录该内容

1 篇文章

订阅专栏

代码环境

IntelliJ IDEA 2023

？问题思考

有一次，我请了10对夫妇来我家参加宴会，我问所有参加宴会的人（包括我妻子在内）他们和多少人握过手，结果得知每个人的握手次数都不相同，当然我没有问自己．假定没有人与自己的配偶握手，也不考虑每个人自己同自己握手，那么请问我妻子与多少人握过手？（我没有问自己任何问题．）
答案在文章末

入门

下载中间件
bin最重要
cmd界面运行方式，先创一个文本文件，然后用javac编译，在用java运行，有c带后缀java，没c不带后缀java

java编程基础

Java 是一种广泛使用的、面向对象的编程语言，具有跨平台性，因其"一次编写，到处运行"的特性而广受欢迎。Java 是由 Sun Microsystems（现属于 Oracle）于 1995 年发布的。

1. Java 基本概念

Java 是一种面向对象的语言，这意味着在 Java 中，几乎一切都是对象，所有的代码都是类的一部分。Java 程序通常由类和方法组成。

2. Java 程序的结构

一个 Java 程序通常由以下几个部分组成：

类：Java 是面向对象的语言，所有的代码都必须包含在类中。类是对象的模板。
方法：Java 中的函数称为方法。方法是类的一部分，定义了类的行为。
主方法：Java 程序的入口点是 main 方法。main 方法是每个 Java 程序执行时的起始点。

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

3. 变量和数据类型

Java 中有两种类型的变量：基本数据类型和引用数据类型。

基本数据类型：包括 int（整数）、double（浮点数）、char（字符）、boolean（布尔值）等。
引用数据类型：指向对象的引用，如 String、数组、类等。

基本数据类型：

int a = 10;
double b = 3.14;
char c = 'A';
boolean flag = true;

4. 运算符

Java 提供了许多运算符，包括：

算术运算符：+, -, *, /, %
关系运算符：==, !=, >, <, >=, <=
逻辑运算符：&&, ||, !
赋值运算符：=, +=, -=, *=, /=
自增/自减运算符：++, --

5. 控制结构

Java 支持常见的控制结构，如：

条件语句：if, else, switch

int x = 10;
if (x > 5) {
    System.out.println("x 大于 5");
} else {
    System.out.println("x 小于或等于 5");
}

循环语句：for, while, do-while

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

6. 数组

数组是相同类型元素的集合，可以通过索引访问元素。在 Java 中，数组是对象。

int[] arr = {1, 2, 3, 4, 5}; // 数组声明与初始化
System.out.println(arr[2]); // 输出数组元素

面向对象

Java 是一种面向对象编程语言，这意味着它支持类、对象、继承、封装、多态和抽象等基本概念。

7.1 类和对象

类是对象的模板，对象是类的实例。
为了更巧妙地理解类和对象，我们可以通过一个日常生活中的例子来做比喻—— “模板”和“实例”。

类：蓝图或模板

类就像是一个蓝图或模板，它定义了一个事物（如“汽车”、“人”、“银行账户”等）应该具备的属性和行为。它描述了一个事物的结构和功能，但并不代表一个实际的存在。

想象一下，房子的 设计图纸 就是类。设计图纸描述了房子的结构（几间房、每个房间的大小、位置等），但它本身只是一个计划，无法提供一个可以住人的房子。房子本身需要按照设计图来建造出来。

对象：实际的实例

对象是类的实例，也就是根据类的定义创建出来的 具体事物。就像是根据房子的设计图纸建造出来的 实际房子。

每个房子都是根据设计图来建造的，但每个房子可能有不同的外观（颜色、大小），每个房子都是一个具体的实例。它们有各自的特性，能进行特定的操作（例如：开灯、开门等）。

类与对象的关系：

类：像是一个模板，描述了如何构建一个对象，规定了对象的属性和行为，但本身不占用内存。
对象：是类的实例，是实际存在的事物，包含了类所定义的属性并可以执行类中定义的操作。

类与对象的比喻：

比喻 1：房子与设计图

类就是房子的 设计图。它描述了房子的形状、大小、房间的功能等。
对象就是根据设计图建造的房子。每个房子都是具体的、可居住的实例。

比喻 2：汽车与汽车模型

类就是汽车的模型，它定义了汽车的属性（如品牌、颜色、速度）和行为（如行驶、停止）。
对象就是每一辆实际的汽车，每辆汽车都是 汽车 类的一个实例，具有不同的品牌、颜色、速度等。

Java 中的类与对象示例：

// 定义一个类（模板）
class Car {
    // 属性（成员变量）
    String brand;
    int speed;

    // 方法（行为）
    void drive() {
        System.out.println(brand + " is driving at " + speed + " km/h");
    }

    void stop() {
        System.out.println(brand + " has stopped");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象（根据模板生成实际实例）
        Car car1 = new Car();  // 通过类创建对象 car1
        car1.brand = "Toyota";  // 设置对象 car1 的品牌
        car1.speed = 100;       // 设置对象 car1 的速度

        // 创建另一个对象
        Car car2 = new Car();  // 通过类创建对象 car2
        car2.brand = "BMW";     // 设置对象 car2 的品牌
        car2.speed = 150;       // 设置对象 car2 的速度

        // 调用对象的方法
        car1.drive();  // 输出：Toyota is driving at 100 km/h
        car2.stop();   // 输出：BMW has stopped
    }
}

分析：

类 Car 定义了所有汽车应该具备的属性（brand 和 speed）和行为（drive() 和 stop()）。
car1 和 car2 是 Car 类的两个对象。每个对象代表一辆具体的汽车，它们有自己的属性值（如品牌和速度）。
car1 和 car2 都是 Car 类的实例，通过调用各自的方法（如 drive() 和 stop()）来表现具体的行为。

类是模板或蓝图，它定义了对象的属性和行为。
对象是类的实例，是根据类的定义创建出来的实际事物。每个对象有独立的状态（属性），并且能够执行类定义的行为（方法）。

类和对象是面向对象编程的基础，它们帮助我们将现实世界中的事物和行为抽象成程序中的结构，从而更好地组织和管理代码。

class Car {
    String brand;
    int speed;

    void display() {
        System.out.println("品牌：" + brand);
        System.out.println("速度：" + speed);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // 创建对象
        myCar.brand = "Toyota";
        myCar.speed = 120;
        myCar.display();
    }
}

7.2 继承

为了巧妙地解释继承，我们可以使用家庭的比喻。继承是面向对象编程中的一个核心概念，它允许我们创建新的类（子类）并从现有的类（父类）继承属性和行为。这样可以让新类复用父类的代码，并且可以扩展或修改这些行为。

继承的比喻：家庭遗传

想象一下，你有一个家庭，家庭成员会从父母那里继承一些特征或技能。比如：

父母（父类）可能会有一些特定的属性，比如“眼睛颜色是蓝色”，“能做饭”，“有驾照”等。
孩子（子类）从父母那里继承了这些特征或技能，但他们也可以有自己的特征，比如“喜欢踢足球”或者“擅长弹钢琴”。

在这个比喻中：

父类就是父母，他们定义了基本的特征和行为。
子类就是孩子，他们继承了父母的特征，也可以添加或修改一些特征。

继承在 Java 中的应用

继承使得一个类（子类）能够获得另一个类（父类）的属性和方法，这样子类就能够使用父类的功能，而无需重新编写代码。继承的好处是 代码复用 和 扩展性。

示例：父类和子类的继承

假设我们有一个父类 Animal，它包含了一些基本的特征和行为。然后我们创建一个子类 Dog，它继承了 Animal 类，并添加了一些特有的行为。

// 父类：动物
class Animal {
    String name;

    void eat() {
        System.out.println(name + " is eating");
    }

    void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// 子类：狗，继承自动物
class Dog extends Animal {
    // 子类 Dog 可以继承父类 Animal 的属性和方法

    // 子类特有的方法
    void bark() {
        System.out.println(name + " is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建子类 Dog 的实例
        Dog dog = new Dog();
        dog.name = "Buddy"; // 继承了父类 Animal 的属性
        dog.eat();          // 继承了父类 Animal 的方法
        dog.sleep();        // 继承了父类 Animal 的方法
        dog.bark();         // 子类 Dog 的特有方法
    }
}

分析：

Animal 类是父类，它定义了 name 属性和 eat()、sleep() 方法，这些是所有动物（包括狗）共有的行为。
Dog 类是子类，它通过 extends 关键字继承了 Animal 类的所有属性和方法。也就是说，Dog 可以使用 Animal 类中的 eat() 和 sleep() 方法。
子类 Dog 可以添加自己的方法（如 bark()），这使得 Dog 类具有了自己的特征，除了继承自 Animal 的特性外，还能扩展自己的功能。

继承的关键点：

代码复用：通过继承，子类可以直接使用父类的方法和属性，避免了重复代码。
扩展性：子类可以在继承父类的基础上，添加自己特有的属性和方法，或者修改父类的方法（通过方法重写）。
父类与子类的关系：子类是父类的一种特定类型，可以继承父类的行为，但也可以在此基础上扩展或修改行为。

方法重写：修改继承的行为

继承不仅仅是复用父类的代码，子类还可以重写父类的方法，以实现不同的功能。

示例：方法重写

// 父类：动物
class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类：狗
class Dog extends Animal {
    // 重写父类的 sound 方法
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.sound();  // 输出：Animal makes a sound

        Dog dog = new Dog();
        dog.sound();  // 输出：Dog barks
    }
}

分析：

Dog 类通过 @Override 注解重写了 Animal 类中的 sound() 方法，使得狗发出的声音变为“Dog barks”。
重写是继承中的一个重要特性，它允许子类修改父类的行为，以适应子类的具体需求。

继承的总结：

继承就像是孩子从父母那里继承了一些特征（属性和行为）。
子类继承父类后，不仅可以拥有父类的属性和行为，还可以自己添加新属性或行为。
子类可以通过重写父类的方法来修改或扩展父类的行为。
继承帮助我们 复用代码，并且为扩展和修改提供了灵活的机制。

继承是面向对象编程的核心特性之一，它让我们能够根据已有的类创建新类，增强了代码的 模块化 和 复用性。

7.3 封装

封装是将数据和方法包装到一个类中，并通过访问控制符（如 private、protected、public）来控制对数据的访问。

class Person {
    private String name; // 私有变量

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

7.4 多态

多态是指同一个方法或操作可以作用于不同类型的对象。

class Animal {
    void sound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("狗叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 多态
        animal.sound(); // 输出 "狗叫"
    }
}

8. 异常处理

异常是程序运行时发生的错误，Java 提供了异常处理机制来捕捉和处理这些错误，防止程序崩溃。

try {
    int result = 10 / 0; // 会抛出 ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("错误：" + e.getMessage());
} finally {
    System.out.println("无论如何都会执行的代码");
}

9. 常用类库

Java 提供了丰富的标准库，用于处理输入输出、集合、日期时间等常见任务：

输入输出：java.io 包中的 File, Scanner, BufferedReader 等
集合框架：java.util 包中的 List, Set, Map 等
日期时间：java.time 包

10. Java 编译和运行

Java 程序的编译和运行过程包括以下几个步骤：

编写代码：使用文本编辑器或集成开发环境（IDE）编写 .java 文件。
编译：通过 javac 命令编译 .java 文件，生成 .class 文件（字节码文件）。
```
javac HelloWorld.java
```
运行：通过 java 命令运行 .class 文件。
```
java HelloWorld
```

java API

集合集中

问题答案：

这道题想明白第一组和第二组，就知道答案了。
第一对情侣，假设一个人握手是20，他（她）的伴侣一定是那个从头到尾没有握手的，假设一个人握手是19，他（她）的伴侣一定是那个从头到尾只握手一次的。
这句话看懂了，剩下的就不需要看了，就已经可以推出答案了。
1 总共22个人，不能和自己握手，不能和伴侣握手，所以每个人最多握手20次。
2 每个人的握手次数不一样，除开“我”没有计算次数，共有21个人，所以有21种握手次数，在1的条件下，说明有一个人的握手次数为0。
3 先讨论握手20次的人。除开他的伴侣，他自己，握手次数为0的人，只剩下19次握手的情况，在1的条件下，说明握手次数为0的人是他的伴侣。可得出结论：握手20次的人与0次的人是伴侣。握手1次的人只与握手20次的人握过手。
4 再讨论握手19次的人。除开他的伴侣，他自己，握手次数为0的人，剩下19次握手的情况，在3的条件下，握手1次的人不可能再与他握手，在1的条件下，握手1次的人是他的伴侣。可得出结论：握手19次的人与握手1次的人是伴侣。握手2次的人只与握手20次，19次的人握过手。
5 再讨论握手18次的人，除开他的伴侣，他自己，握手次数为0的人，剩下19次握手的情况，，在3，4的条件下，握手1次，2次的人不可能再与他握手，在1 3 4的条件下，握手2次的人只能是他的伴侣。可得出结论：握手18次的人与握手次数2次的人是伴侣。握手3次的人只与握手20次，19次，18次的人握过手。
以此类推……
6 情侣配对：20次-0次
19次-1次
18次-2次
……
10次-10次
……
n次-（20-n）次
在2的条件下，10次-10次不可能是其他计算次数的情侣，只能是“我”和“我”的伴侣，即我的妻子，与别人握手10次。

在这里插入图片描述