java-快速入门篇
温馨提醒：概念固然重要，但通过概念下面的例子更容易理解并运用哦
文章目录
-
-
- 1. 基础语法
-
- 1.1 变量与数据类型
- 1.2 条件语句
- 1.3 循环结构
- 2. 面向对象
-
- 2.1 类与对象
- 2.2 继承与多态
- 3. 集合框架
-
- 3.1 列表（List）
- 3.2集（Set）
- 3.3 映射（Map)
- 3.4队列（Queue）
- 3.5 堆栈（Stack）
- 3.6 集合遍历
- 4. 异常处理
- 5. 多线程
-
- 5.1. 继承Thread类的方式创建线程：（萌新入门建议先用这个）
- 5.2. 实现Runnable接口的方式创建线程：
-
- 线程池
- 6. I/O 操作
-
- 6.1 文件读写
-
1. 基础语法
1.1 变量与数据类型
int age = 25; // 年龄
double price = 19.99; // 价格
String name = "John"; // 姓名
eg.
public class Main {
public static void main(String[] args) {
int age = 25; // 年龄
double price = 19.99; // 价格
String name = "John"; // 姓名
//不会自带换行需要手动添加换行的输出方法
System.out.print("hello word!\n");
//自带换行的输出方法（两者区别是print和println）
System.out.println(age);
System.out.println(price);
System.out.println(name);
}
}
/*output：
* hello word!
* 25
* 19.99
* John
*/
1.2 条件语句
if (condition) {
// 代码块
} else if (anotherCondition) {
// 另一个代码块
} else {
// 备用代码块
}
eg.
public class Main {
public static void main(String[] args){
String name="鸽鸽";
//判断他的名字是不是墨墨，不是
if(name.equals("墨墨")){
System.out.println("他不是");
}
//判断他的名字是不是玉玉，不是
else if(name.equals("玉玉")){
System.out.println("她不是");
}
//其他的所有情况
else{
System.out.println("哎哟你干嘛~");
}
}
}
/*
* output:
* 哎哟你干嘛~
* */
1.3 循环结构
for (int i = 0; i < 5; i++) {
// 代码块
}
while (condition) {
// 代码块
}
do {
// 代码块
} while (condition);
eg.
public class Main {
public static void main(String[] args) {
//for循环示例
for(int i=0;i<3;i++){
System.out.println(i);
}
/*
* output：
* 0
* 1
* 2
* */
//while循环示例
int num=3;
//先判断符合条件再循环
while(num>0){
System.out.println(num);
num--;
}
/*
* output：
* 3
* 2
* 1
* */
//do-while循环示例
int count=3;
//先循环再判断是否符合条件
//所以do-while会至少执行
do{
System.out.println(count);
count--;
}while(count>0);
/*
* output：
* 3
* 2
* 1
* */
}
}
2. 面向对象
2.1 类与对象
class Car {
String model; // 模型
int year; // 年份
// 构造函数(用于初始化)
public Car(String model, int year) {
this.model = model;
this.year = year;
}
void start() {
// 启动汽车的代码
System.out.printf("汽车 %s 启动了！%n", model);
}
//获取汽车信息
void get_car_mess(){
//print和println是无法格式化字符串的
//所以下面用的是printf
System.out.printf("汽车的模型是：%S\n",model);
System.out.printf("汽车的出厂日期是：%d\n",year);
}
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car("Toyota", 2022);
//也可以对单个类中的变量进行初始化
//eg.myCar.model = "Toyota";
myCar.start();
myCar.get_car_mess();
}
}
/*output:
* 汽车 Toyota 启动了！
* 汽车的模型是：TOYOTA
* 汽车的出厂日期是：2022
* */
2.2 继承与多态
// 父类 Animal
class Animal {
protected String name;
//构造函数
public Animal(String name) {
this.name = name;
}
public void makeSound() {
System.out.println("动物发出声音");
}
}
// 子类 Dog 继承自 Animal
class Dog extends Animal {
//构造函数
public Dog(String name) {
//super的作用：当子类的构造函数被调用时，它首先需要调用父类的构造函数
super(name);
}
//重写 makeSound 函数
@Override
public void makeSound() {
System.out.println("汪汪汪！");
}
//子类的特定函数（这种不能直接多态调用而需要先向下转换）
public void fetch() {
System.out.println("狗狗会捡球");
}
}
// 子类 Cat 继承自 Animal
class Cat extends Animal {
public Cat(String name) {
//super的作用：当子类的构造函数被调用时，它首先需要调用父类的构造函数
super(name);
}
//重写 makeSound 函数
@Override
public void makeSound() {
System.out.println("喵喵喵！");
}
//子类的特定函数（这种不能直接多态调用而需要先向下转换）
public void scratch() {
System.out.println("猫猫会抓东西");
}
}
public class Main {
public static void main(String[] args) {
// 使用多态调用可以在不同子类中重写的方法
Animal animal1 = new Dog("小黑");
Animal animal2 = new Cat("小白");
//makeSound已经被重写了
animal1.makeSound();
// 输出："汪汪汪！"
animal2.makeSound();
// 输出："喵喵喵！"
//错误范例
// 无法调用子类特定的方法
// animal1.fetch(); // 编译错误：无法找到 fetch() 方法
// animal2.scratch(); // 编译错误：无法找到 scratch() 方法
//在多态性下，通过父类类型的引用变量如 animal1，是无法直接访问子类特有的非重写变量的。
// 可以使用向下转型可以调用子类特定的方法（即非重写变量）
if (animal1 instanceof Dog) {//检查 animal1 是否是 Dog 类的实例
Dog dog1 = (Dog) animal1;
dog1.fetch(); // 输出："狗狗会捡球"
}
if (animal2 instanceof Cat) {//检查 animal2 是否是 Cat 类的实例
Cat cat1 = (Cat) animal2;
cat1.scratch(); // 输出："猫猫会抓东西"
}
}
}
3. 集合框架
3.1 列表（List）
- 添加元素：使用
add()方法将元素添加到列表 - 获取元素：使用
get()方法获取列表中指定位置的元素 - 修改元素：使用
set()方法修改列表中指定位置的元素 - 删除元素：使用
remove()方法删除列表中指定位置或指定元素的元素 - 判断列表是否包含元素：使用
contains()方法判断列表中是否包含指定元素 - 获取列表的大小：使用
size()方法获取列表的元素个数
//可以使用不同的包，这里只举例一种
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
// 创建列表
List<String> myList = new ArrayList<>();
List<Integer> int_myList = new ArrayList<>();
// 添加元素
myList.add("项目1");
myList.add("项目2");
myList.add("项目3");
int_myList.add(1);
int_myList.add(0);
// 获取元素
// 列表从0开始
String firstItem = myList.get(0);
System.out.println("第一个元素: " + firstItem);
// 修改元素
myList.set(1, "新项目2");
// 删除元素
myList.remove(0);
//如果内容和索引都是数字的情况
//默认为索引
//应该先转换一下此时指的就是删除内容
int_myList.remove(Integer.valueOf(0));
// 判断列表是否包含元素
boolean containsItem = myList.contains("项目3");
System.out.println("列表是否包含 '项目3': " + containsItem);
// 获取列表的大小
int size = myList.size();
System.out.println("列表大小: " + size);
}
}
3.2集（Set）
- 添加元素：使用
add()方法将元素添加到集 - 删除元素：使用
remove()方法删除set集中指定元素 - 判断集是否包含元素：使用
contains()方法判断集中是否包含指定元素 - 获取集的大小：使用
size()方法获取集中的元素个数
//这里举例的set的接口是没有自动排序功能
//TreeSet才有自动排序的功能
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
// 创建一个集
Set<Integer> mySet = new HashSet<>();
// 添加元素到集
mySet.add(1);
mySet.add(2);
// 判断集是否包含指定元素
boolean contains = mySet.contains(1);
// 删除set集中的元素（填入的是元素本身内容而非索引）
mySet.remove(2);
// 获取集的大小
int size = mySet.size();
// 清空集
mySet.clear();
}
}
3.3 映射（Map)
- 添加键值对：使用
put()方法将键值对添加到映射中 - 获取值：使用
get()方法根据键获取对应的值 - 删除键值对：使用
remove()方法删除映射中指定键的键值对 - 判断映射是否包含键或值：使用
containsKey()和containsValue()方法判断映射中是否包含指定键或值 - 获取映射的大小：使用
size()方法获取映射中键值对的个数
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
// 创建一个映射
Map<String, Integer> myMap = new HashMap<>();
// 添加键值对到映射
myMap.put("键1", 1);
myMap.put("键2", 2);
// 获取映射中的值
int value = myMap.get("键1");
System.out.println(value);
//output:1
// 判断映射是否包含指定键或值
boolean containsKey = myMap.containsKey("键2");
boolean containsValue = myMap.containsValue(2);
System.out.println(containsKey);
//output:true
System.out.println(containsValue);
//output:true
// 删除映射中的键值对
myMap.remove("键1");
// 获取映射的大小
int size = myMap.size();
System.out.println(size);
//output:1
// 清空映射
myMap.clear();
}
}
3.4队列（Queue）
- 入队：使用
offer()方法将元素添加到队尾 - 出队：使用
poll()方法移除并返回队首元素 - 获取队首元素：使用
peek()方法获取队首元素，但不将其移除 - 判断队列是否为空：使用
isEmpty()方法判断队列是否为空 - 获取队列的大小：使用
size()方法获取队列中的元素个数
import java.util.LinkedList;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
// 创建一个队列
Queue<String> myQueue = new LinkedList<>();
// 入队
myQueue.offer("元素1");
myQueue.offer("元素2");
// 获取队首元素
String frontElement = myQueue.peek();
System.out.println(frontElement);
//output:元素1
// 出队
String dequeuedElement = myQueue.poll();
System.out.println(dequeuedElement);
//output:元素1
// 判断队列是否为空
boolean isEmpty = myQueue.isEmpty();
System.out.println(isEmpty);
//output:false
// 获取队列的大小
int size = myQueue.size();
System.out.println(size);
//output:1
}
}
3.5 堆栈（Stack）
- 压栈：使用 push() 方法将元素推入栈顶
- 弹栈：使用 pop() 方法弹出栈顶元素并返回
- 获取栈顶元素：使用 peek() 方法获取栈顶元素，但不弹出
- 判断栈是否为空：使用 isEmpty() 方法判断栈是否为空
- 获取栈的大小：使用 size() 方法获取栈中的元素个数
import java.util.Stack;
public class Main {
public static void main(String[] args) {
// 创建一个堆栈
Stack<String> myStack = new Stack<>();
// 压栈
myStack.push("元素1");
myStack.push("元素2");
// 获取栈顶元素
String topElement = myStack.peek();
System.out.println(topElement);
//output:元素2
// 弹栈(返回值是弹出元素内容)
//如果栈为空则抛出异常
String poppedElement = myStack.pop();
System.out.println(poppedElement);
//output:元素2
// 判断栈是否为空
boolean isEmpty = myStack.isEmpty();
System.out.println(isEmpty);
//output:false
// 获取栈的大小
int size = myStack.size();
System.out.println(size);
//output:1
}
}
3.6 集合遍历
//其他的集合遍历方法是一样的
List<String> myList = new ArrayList<>();
myList.add("项目1");
myList.add("项目2");
for (String item : myList) {
System.out.println(item);
}
4. 异常处理
try {
// 可能引发异常的代码
} catch (ExceptionType1 e1) {
// 处理异常类型1
} catch (ExceptionType2 e2) {
// 处理异常类型2
} finally {
// 无论是否发生异常都会执行的代码
}
eg.
public class Main {
public static void main(String[] args) {
try {
int result = divide(10, 0);
System.out.println("结果: " + result);
} catch (ArithmeticException e) {
System.out.println("算术异常: " + e.getMessage());
} catch (NullPointerException e) {
System.out.println("空指针异常: " + e.getMessage());
} finally {
System.out.println("无论是否发生异常，此处的代码都会执行");
}
}
// 这里抛出异常，封装原始的算术异常，并提供自定义的异常消息，使异常的信息更具体和有意义
public static int divide(int numerator, int denominator) {
try {
return numerator / denominator;
} catch (ArithmeticException e) {
throw new ArithmeticException("除数不能为0");
}
}
}
5. 多线程
5.1. 继承Thread类的方式创建线程：（萌新入门建议先用这个）
- 创建一个继承自Thread类的新类，并重写run()方法来定义线程的执行逻辑。
- 线程类可以直接通过new操作符实例化并调用start()方法启动线程。
- 优点：方便简洁，可以直接访问类的成员变量。
- 缺点：线程类继承自Thread类，不方便继承其他类。
//自定义继承自 Thread 的线程类
class MyThread extends Thread {
//重写 Thread 类的 run 方法，定义线程的具体任务逻辑
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Thread is running: " + i);
}
}
}
public class Main {
public static void main(String[] args) {
// 创建两个 MyThread 实例作为线程
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
// 启动线程
thread1.start(); // 启动第一个线程
thread2.start(); // 启动第二个线程
}
}
5.2. 实现Runnable接口的方式创建线程：
- 创建一个实现了Runnable接口的类，并实现run()方法来定义线程的执行逻辑。
- 创建Thread对象，并将实现了Runnable接口的对象作为参数传递给构造函数。
- 通过Thread对象调用start()方法启动线程。
- 优点：灵活性高，可以实现其他接口或继承其他类。
- 缺点：无法直接访问类的成员变量，需要通过构造函数传递参数。
// 自定义实现 Runnable 接口的类
class MyRunnable implements Runnable {
// run 方法内定义了具体的任务逻辑
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Thread is running: " + i);
}
}
}
public class Main {
public static void main(String[] args) {
// 创建两个线程，并将 MyRunnable 实例作为任务
Thread thread1 = new Thread(new MyRunnable()); // 创建第一个线程，并将 MyRunnable 实例作为任务
Thread thread2 = new Thread(new MyRunnable()); // 创建第二个线程，并将 MyRunnable 实例作为任务
// 启动线程
thread1.start(); // 启动第一个线程
thread2.start(); // 启动第二个线程
}
}
线程池
- 使用线程池可以提供更好的线程管理和复用机制。
- 避免频繁创建和销毁线程的开销。
- Executor框架和ThreadPoolExecutor类提供了线程池的实现。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 实现 Runnable 接口定义自己的任务类
class MyTask implements Runnable {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Task is running: " + i);
}
}
}
public class Main {
public static void main(String[] args) {
// 创建线程池，指定最大线程数为 2
ExecutorService executor = Executors.newFixedThreadPool(2);
// 提交任务到线程池中执行
executor.execute(new MyTask()); // 提交第一个任务
executor.execute(new MyTask()); // 提交第二个任务
// 关闭线程池
executor.shutdown(); // 关闭线程池，不接受新的任务提交
}
}
6. I/O 操作
6.1 文件读写
Java 提供了丰富的 I/O 操作功能，下面是一个文件读写的基本示例：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
// 文件读取
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
String line;
while ((line = br.readLine()) != null) {
// 逐行读取文件内容，并打印输出
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
// 文件写入
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
String content = "Hello, Java I/O!";
// 将content写入文件
bw.write(content);
} catch (IOException e) {
e.printStackTrace();
}
}
}
看到这里，恭喜你已经掌握Java的基础入门知识了，有所遗忘记得来这里温习一下，继续努力吧！