java-快速入门篇

温馨提醒：概念固然重要，但通过概念下面的例子更容易理解并运用哦

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的基础入门知识了，有所遗忘记得来这里温习一下，继续努力吧！