java-快速入门篇

2023-12-13 15:57:55

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

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

文章来源:https://blog.csdn.net/m0_73756108/article/details/134794839
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。