Tim Buchalka的JavaMasterClass课程笔记

薛迟

于 2024-08-26 15:58:57 发布

阅读量880

点赞数 15

本文链接：https://blog.csdn.net/weixin_31974443/article/details/141576964

版权

本文还有配套的精品资源，点击获取

简介：JavaMasterClass课程旨在帮助学员掌握Java编程。本压缩包包含课程学习资料，涵盖了Java核心概念，包括面向对象编程（类、对象、封装、继承、多态性）、Java语法、集合框架、IO流、线程和异常处理等。通过学习本课程，学员将全面掌握Java编程技能，为成为一名专业的Java开发者打下基础。 javaMasterClass:Tim Buchalka撰写的关于Udemy的Java课笔记

1. Java基础

Java是一种面向对象、跨平台的编程语言，它以其强大的功能和广泛的应用而闻名。本章将介绍Java基础知识，包括数据类型、变量、流程控制和数组，为后续章节的学习打下坚实的基础。

2. 面向对象编程

面向对象编程（OOP）是一种编程范式，它将数据和行为封装在称为对象的对象中。它提供了代码重用、可维护性和可扩展性等优点。

2.1 类和对象

2.1.1 类的定义和实例化

类是一个蓝图，它定义了对象的属性和方法。要定义一个类，可以使用以下语法：

public class MyClass {
    // 属性
    private int age;
    private String name;

    // 方法
    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }
}

要实例化一个类，可以使用以下语法：

MyClass person = new MyClass();

2.1.2 对象的属性和方法

对象是类的实例，它包含了类中定义的属性和方法。要访问对象的属性，可以使用点运算符（.`）。要调用对象的的方法，可以使用以下语法：

person.setAge(25);
int age = person.getAge();

2.2 继承和多态

2.2.1 继承的概念和语法

继承允许一个类（子类）从另一个类（父类）继承属性和方法。子类可以覆盖父类的方法，并可以定义自己的新方法。要定义一个子类，可以使用以下语法：

public class ChildClass extends ParentClass {
    // 子类特有的属性和方法
}

2.2.2 多态的实现和应用

多态是指对象可以根据其类型表现出不同的行为。当一个子类对象被赋给父类变量时，就会发生多态。例如：

ParentClass parent = new ChildClass();
parent.method(); // 调用的是 ChildClass 的 method() 方法

多态可以提高代码的灵活性，因为它允许在运行时根据对象的类型调用不同的方法。

3. Java语法

3.1 数据类型和变量

3.1.1 基本数据类型和引用数据类型

Java中的数据类型分为基本数据类型和引用数据类型。基本数据类型直接存储在变量中，包括：

整数类型：byte、short、int、long
浮点数类型：float、double
字符类型：char
布尔类型：boolean

引用数据类型存储对对象的引用，对象存储在堆内存中。引用数据类型包括：

类类型：表示自定义类
数组类型：表示数组
接口类型：表示接口

3.1.2 变量的声明、赋值和类型转换

变量用于存储数据。变量声明包括类型、变量名和可选的初始值。例如：

int age = 25;

变量赋值通过赋值运算符 = 完成。例如：

age = 30;

类型转换是指将一种数据类型转换为另一种数据类型。有两种类型转换：

隐式类型转换（自动类型转换）： 编译器自动将较小数据类型转换为较大数据类型。例如：

byte b = 10;
int i = b; //隐式类型转换

显式类型转换（强制类型转换）： 通过 (目标类型)变量 语法强制将一种数据类型转换为另一种数据类型。例如：

double d = 3.14;
int i = (int) d; //显式类型转换

3.2 流程控制

3.2.1 条件语句（if-else、switch-case）

条件语句用于根据条件执行不同的代码块。

if-else语句：

if (condition) {
    //条件为 true 时执行的代码
} else {
    //条件为 false 时执行的代码
}

switch-case语句：

switch (expression) {
    case value1:
        //当 expression 等于 value1 时执行的代码
        break;
    case value2:
        //当 expression 等于 value2 时执行的代码
        break;
    default:
        //当 expression 不等于任何 case 值时执行的代码
        break;
}

3.2.2 循环语句（for、while、do-while）

循环语句用于重复执行一段代码。

for循环：

for (initialization; condition; increment) {
    //循环体
}

while循环：

while (condition) {
    //循环体
}

do-while循环：

do {
    //循环体
} while (condition);

3.3 数组和集合

3.3.1 数组的定义、访问和操作

数组是一种固定大小的数据结构，存储相同类型的数据元素。

int[] numbers = {1, 2, 3, 4, 5};

数组元素通过索引访问。例如：

int firstElement = numbers[0];

数组可以通过 length 属性获取其长度。

3.3.2 集合框架（List、Set、Map）

集合框架提供了各种集合接口和实现，用于存储和操作数据元素。

List： 有序的集合，允许重复元素。实现包括 ArrayList 和 LinkedList 。
Set： 无序的集合，不允许重复元素。实现包括 HashSet 和 TreeSet 。
Map： 键值对集合，键唯一，值可以重复。实现包括 HashMap 和 TreeMap 。

graph LR
subgraph List
    ArrayList
    LinkedList
end
subgraph Set
    HashSet
    TreeSet
end
subgraph Map
    HashMap
    TreeMap
end

4. 集合框架

集合框架是 Java 中用于存储和操作数据的强大工具。它提供了一组接口和类，允许开发人员以高效且可重用的方式管理数据。本章将深入探讨集合框架的三个主要组件：List、Set 和 Map。

4.1 List 集合

List 集合用于存储有序的元素序列。它允许重复元素，并且可以根据索引访问元素。Java 中有两种常用的 List 实现：ArrayList 和 LinkedList。

4.1.1 ArrayList 和 LinkedList 的实现和区别

ArrayList 是基于数组实现的 List。它提供快速随机访问，但插入和删除操作的效率较低，因为需要移动数组中的元素。

import java.util.ArrayList;

public class ArrayListExample {

    public static void main(String[] args) {
        // 创建一个 ArrayList
        ArrayList<String> names = new ArrayList<>();

        // 添加元素
        names.add("John");
        names.add("Mary");
        names.add("Bob");

        // 获取元素
        System.out.println(names.get(0)); // John

        // 遍历元素
        for (String name : names) {
            System.out.println(name);
        }
    }
}

LinkedList 是基于双向链表实现的 List。它提供了高效的插入和删除操作，但随机访问的效率较低。

import java.util.LinkedList;

public class LinkedListExample {

    public static void main(String[] args) {
        // 创建一个 LinkedList
        LinkedList<String> names = new LinkedList<>();

        // 添加元素
        names.add("John");
        names.add("Mary");
        names.add("Bob");

        // 获取元素
        System.out.println(names.getFirst()); // John

        // 遍历元素
        for (String name : names) {
            System.out.println(name);
        }
    }
}

4.1.2 List 的遍历、排序和查找

遍历 List

可以通过使用 for-each 循环或迭代器来遍历 List 中的元素。

// 使用 for-each 循环
for (String name : names) {
    System.out.println(name);
}

// 使用迭代器
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    System.out.println(name);
}

排序 List

可以使用 Collections.sort() 方法对 List 进行排序。

Collections.sort(names);

查找 List 中的元素

可以使用 indexOf() 和 lastIndexOf() 方法查找 List 中的元素。

int index = names.indexOf("John");

4.2 Set 集合

Set 集合用于存储不重复的元素。它不保证元素的顺序，并且可以根据元素本身进行快速查找。Java 中有两种常用的 Set 实现：HashSet 和 TreeSet。

4.2.1 HashSet 和 TreeSet 的实现和区别

HashSet 是基于哈希表实现的 Set。它提供了高效的查找操作，但不能保证元素的顺序。

import java.util.HashSet;

public class HashSetExample {

    public static void main(String[] args) {
        // 创建一个 HashSet
        HashSet<String> names = new HashSet<>();

        // 添加元素
        names.add("John");
        names.add("Mary");
        names.add("Bob");

        // 获取元素
        System.out.println(names.contains("John")); // true

        // 遍历元素
        for (String name : names) {
            System.out.println(name);
        }
    }
}

TreeSet 是基于红黑树实现的 Set。它提供了有序的元素，但查找操作的效率较低。

import java.util.TreeSet;

public class TreeSetExample {

    public static void main(String[] args) {
        // 创建一个 TreeSet
        TreeSet<String> names = new TreeSet<>();

        // 添加元素
        names.add("John");
        names.add("Mary");
        names.add("Bob");

        // 获取元素
        System.out.println(names.first()); // Bob

        // 遍历元素
        for (String name : names) {
            System.out.println(name);
        }
    }
}

4.2.2 Set 的集合运算和去重

集合运算

Set 提供了并集、交集和差集等集合运算。

// 并集
Set<String> union = new HashSet<>(set1);
union.addAll(set2);

// 交集
Set<String> intersection = new HashSet<>(set1);
intersection.retainAll(set2);

// 差集
Set<String> difference = new HashSet<>(set1);
difference.removeAll(set2);

去重

Set 可以用来去除重复元素。

Set<String> uniqueNames = new HashSet<>(names);

4.3 Map 集合

Map 集合用于存储键值对。它允许重复的键，但每个键只能对应一个值。Java 中有两种常用的 Map 实现：HashMap 和 TreeMap。

4.3.1 HashMap 和 TreeMap 的实现和区别

HashMap 是基于哈希表实现的 Map。它提供了高效的查找操作，但不能保证元素的顺序。

import java.util.HashMap;

public class HashMapExample {

    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<String, Integer> ages = new HashMap<>();

        // 添加元素
        ages.put("John", 30);
        ages.put("Mary", 25);
        ages.put("Bob", 40);

        // 获取元素
        System.out.println(ages.get("John")); // 30

        // 遍历元素
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

TreeMap 是基于红黑树实现的 Map。它提供了有序的键，但查找操作的效率较低。

import java.util.TreeMap;

public class TreeMapExample {

    public static void main(String[] args) {
        // 创建一个 TreeMap
        TreeMap<String, Integer> ages = new TreeMap<>();

        // 添加元素
        ages.put("John", 30);
        ages.put("Mary", 25);
        ages.put("Bob", 40);

        // 获取元素
        System.out.println(ages.firstKey()); // Bob

        // 遍历元素
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

4.3.2 Map 的键值对操作和遍历

键值对操作

可以通过 put() 和 get() 方法添加和获取 Map 中的键值对。

// 添加键值对
map.put("key", "value");

// 获取键值对
String value = map.get("key");

遍历 Map

可以通过使用 for-each 循环或迭代器来遍历 Map 中的键值对。

// 使用 for-each 循环
for (Map.Entry<String, Integer> entry : ages.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 使用迭代器
Iterator<Map.Entry<String, Integer>> iterator = ages.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

5. IO流

5.1 文件操作

5.1.1 文件的读写操作

读取文件

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileRead {

    public static void main(String[] args) {
        try {
            // 创建一个文件输入流对象
            FileInputStream fis = new FileInputStream("test.txt");

            // 循环读取文件内容
            int c;
            while ((c = fis.read()) != -1) {
                // 将读取到的字节转换为字符并输出
                System.out.print((char) c);
            }

            // 关闭文件输入流
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

写入文件

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileWrite {

    public static void main(String[] args) {
        try {
            // 创建一个文件输出流对象
            FileOutputStream fos = new FileOutputStream("test.txt");

            // 将字符串写入文件
            String str = "Hello World!";
            fos.write(str.getBytes());

            // 关闭文件输出流
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.1.2 文件的创建、删除和重命名

创建文件

import java.io.File;
import java.io.IOException;

public class FileCreate {

    public static void main(String[] args) {
        try {
            // 创建一个文件对象
            File file = new File("test.txt");

            // 如果文件不存在，则创建文件
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

删除文件

import java.io.File;

public class FileDelete {

    public static void main(String[] args) {
        // 创建一个文件对象
        File file = new File("test.txt");

        // 如果文件存在，则删除文件
        if (file.exists()) {
            file.delete();
        }
    }
}

重命名文件

import java.io.File;

public class FileRename {

    public static void main(String[] args) {
        // 创建一个文件对象
        File file = new File("test.txt");

        // 如果文件存在，则重命名文件
        if (file.exists()) {
            file.renameTo(new File("new_test.txt"));
        }
    }
}

本文还有配套的精品资源，点击获取

薛迟

关注

15
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Tim Buchalka的JavaMasterClass课程笔记

本文还有配套的精品资源，点击获取简介：JavaMasterClass课程旨在帮助学员掌握Java编程。本压缩包包含课程学习资料，涵盖了Java核心概念，包括面向对象编程（类、对象、封装、继承、多态性）、Java语法、集合框架、IO流、线程和异常处理等。通过学习本课程，学员将全面掌握Java编程技能，为成为一名专业的Java开发者打下基础。 1. Java基础...
复制链接

扫一扫