简介:JavaMasterClass课程旨在帮助学员掌握Java编程。本压缩包包含课程学习资料,涵盖了Java核心概念,包括面向对象编程(类、对象、封装、继承、多态性)、Java语法、集合框架、IO流、线程和异常处理等。通过学习本课程,学员将全面掌握Java编程技能,为成为一名专业的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"));
}
}
}
简介:JavaMasterClass课程旨在帮助学员掌握Java编程。本压缩包包含课程学习资料,涵盖了Java核心概念,包括面向对象编程(类、对象、封装、继承、多态性)、Java语法、集合框架、IO流、线程和异常处理等。通过学习本课程,学员将全面掌握Java编程技能,为成为一名专业的Java开发者打下基础。