IT评测·应用市场-qidao123.com技术社区

标题: java学习笔记 [打印本页]
作者: 农民    时间: 2024-12-11 12:47
标题: java学习笔记
目录

第 1 章: Java 语言概述

1.1 Java 的汗青与发展

1.2 Java 的特点

1.3 Java 的运行环境（JRE）和开发工具包（JDK）

1.4 第一个 Java 程序（Hello World 示例）

1.5 Java 程序的基本结构

Java 程序由以下几个部分组成：
完整示例
  1. package com.example.myapp;import java.util.List;
  2. import java.util.ArrayList;public class HelloWorld {    private String message;    public HelloWorld(String message) {        this.message = message;    }    public void printMessage() {        System.out.println(message);    }    public static void main(String[] args) {        HelloWorld helloWorld = new HelloWorld("Hello, World!");        helloWorld.printMessage();    }}
复制代码

第 2 章: 数据范例与运算符

2.1 基本数据范例（整型、浮点型、字符型、布尔型）

Java 提供了八种基本数据范例，每种数据范例都有特定的用途：
2.2 数据范例转换（自动范例转换、强制范例转换）

数据范例转换可以分为自动范例转换和强制范例转换：
2.3 运算符（算术、关系、逻辑、位运算、赋值等运算符）

Java 提供了多种运算符，用于各种计算和逻辑操作：
2.4 表达式和语句


第 3 章: 控制流程语句

3.1 顺序结构

顺序结构是程序最基本的控制结构。
程序中的语句按照它们在源代码中的顺序依次执行。
所有流程控制语句的默认执行方式都是顺序结构。
3.2 选择结构（if - else、switch - case）

选择结构用于根据条件的真假来决定程序的执行路径。
3.3 循环结构（for、while、do - while）

循环结构用于重复执行一段代码块，直到某个条件为假。
3.4 跳转语句（break、continue、return）

跳转语句用于控制循环的执行流程或退出函数。

第 4 章: 数组

4.1 数组的概念与定义

数组是用于存储相同范例数据的集合。它使用一个单一变量名，通过索引来访问详细的元素。数组在内存中是连续存储的，每个元素占用相同的存储空间。
4.2 一维数组的初始化与访问

一维数组是最简朴的数组范例。它可以通过两种方式进行初始化：
访问一维数组的元素可以通过索引，索引从0开始。比方：
  1. int firstNumber = numbers[0]  //访问第一个元素
复制代码
4.3 二维数组及多维数组

二维数组可以看作是数组的数组。它通常用于表示矩阵或表格数据：
访问二维数组的元素也通过索引。比方：
  1. int element = matrix[1][2]; // 访问第二行第三列的元素
复制代码
4.4 数组的常见操作（排序、查找等）


第 5 章: 类与对象

5.1 面向对象编程（OOP）概念引入

面向对象编程（OOP）是一种编程范式，它将程序计划使命分解为一组相互协作的对象。每个对象都是类的实例，类定义了对象的属性和行为。OOP的四大基本原则是：封装、继续、多态和抽象。
5.2 类的定义（成员变量、成员方法）

类是对象的蓝图，它定义了对象的属性（成员变量）和行为（成员方法）。
5.3 对象的创建与使用

对象是类的实例，通过 new 关键字创建。
  1. Person person = new Person();
  2. person.name = "Alice";
  3. person.age = 30;
  4. person.introduce();
复制代码
5.4 构造方法

构造方法用于初始化对象。它的名称与类名相同，没有返回范例。
  1. public class Person {
  2.     String name;
  3.     int age;
  4.    
  5.     // 构造方法
  6.     public Person(String name, int age) {
  7.         this.name = name;
  8.         this.age = age;
  9.     }
  10. }
复制代码
使用构造方法创建对象：
  1. Person person = new Person("Alice", 30
复制代码
5.5 this 关键字

this 关键字用于引用当前对象的实例。它常用于区分成员变量和局部变量。
  1. public class Person {
  2.     String name;
  3.    
  4.     public Person(String name) {
  5.         this.name = name; // 使用 this 来区分成员变量和局部变量
  6.     }
复制代码

第 6 章: 封装、继续与多态

6.1 封装（访问控制修饰符: private、protected、public）

封装是面向对象编程的基本原则之一，它通过访问控制修饰符来保护对象的属性和方法。Java 提供了三种访问控制修饰符：
示例：
  1. public class Person {
  2.     private String name; // 私有成员变量
  3.     protected int age;   // 受保护成员变量
  4.     public void setName(String name) {
  5.         this.name = name;
  6.     }
  7.     public String getName() {
  8.         return name;
  9.     }
  10. }
复制代码
6.2 继续（extends 关键字、super 关键字、方法重写）

继续允许一个类从另一个类继续属性和方法，从而实现代码重用。
示例：
  1. public class Animal {
  2.     public void eat() {
  3.         System.out.println("This animal eats food");
  4.     }
  5. }
  7. public class Dog extends Animal {
  8.     @Override
  9.     public void eat() {
  10.         System.out.println("This dog eats bones");
  11.     }
  12. }
复制代码
6.3 多态（方法重载、对象的多态性）

多态性允许一个接口被多种不同范例的对象实现，程序可以动态选择调用哪个方法实现。
示例：
  1. public class MathOperation {
  2.     public int add(int a, int b) {
  3.         return a + b;
  4.     }
  5.    
  6.     public double add(double a, double b) {
  7.         return a + b;
  8.     }
  9. }
  11. Animal myDog = new Dog();
  12. myDog.eat(); // 调用 Dog 类的 eat 方法
复制代码
6.4 抽象类与抽象方法

抽象类是不能被实例化的类，可以包罗抽象方法，这些方法必须在子类中实现。
示例：
  1. public abstract class Animal {
  2.     public abstract void makeSound(); // 抽象方法
  3. }
  5. public class Dog extends Animal {
  6.     @Override
  7.     public void makeSound() {
  8.         System.out.println("Woof");
  9.     }
  10. }
复制代码
6.5 接口（interface）

接口定义了一组方法，但不包罗实现。类可以实现多个接口，从而支持多继续的特性。
示例：
  1. public interface Animal {
  2.     void eat();
  3.     void sleep();
  4. }
  6. public class Dog implements Animal {
  7.     @Override
  8.     public void eat() {
  9.         System.out.println("Dog eats");
  10.     }
  12.     @Override
  13.     public void sleep() {
  14.         System.out.println("Dog sleeps");
  15.     }
  16. }
复制代码

第 7 章: 异常处置惩罚

7.1 异常的概念与分类

异常是程序在运行过程中发生的意外事件，通常是由程序错误或外部因素导致的。异常的处置惩罚是确保程序在发生错误时仍能正常运行的重要机制。
7.2 异常处置惩罚机制（try - catch - finally）

Java提供了 try - catch - finally 结构来处置惩罚异常，确保即使在异常发生时，程序也能继续运行或安全退出。
示例：
  1. try {
  2.     // 可能发生异常的代码
  3.     int result = 10 / 0;
  4. } catch (ArithmeticException e) {
  5.     // 处理异常
  6.     System.out.println("Cannot divide by zero");
  7. } finally {
  8.     // 必定执行的代码
  9.     System.out.println("This block is always executed");
复制代码
7.3 自定义异常

有时，需要创建自定义异常来表示特定的错误环境。可以通过继续 Exception 类或 RuntimeException 类来实现。
示例：
  1. public class CustomException extends Exception {
  2.     public CustomException(String message) {
  3.         super(message);
  4.     }
  5. }
  7. // 使用自定义异常
  8. public class Main {
  9.     public static void main(String[] args) {
  10.         try {
  11.             throw new CustomException("This is a custom exception");
  12.         } catch (CustomException e) {
  13.             System.out.println(e.getMessage());
  14.         }
  15.     }
  16. }
复制代码
7.4 异常处置惩罚的最佳实践


第 8 章: 字符串处置惩罚

8.1 String 类的基本操作（创建、毗连、比力等）

8.2 StringBuffer 和 StringBuilder 类

8.3 字符串的格式化输出

8.4 字符串相干的常用方法与应用场景


第 9 章: 集合框架

9.1 集合框架概述（接口与实现类）

集合框架提供了用于存储和操作数据的标准方法。它包罗多个接口和实现类，主要接口有 List、Set、Map 等，每个接口有多个实现类，如 ArrayList、HashSet、HashMap 等。
9.2 List 接口（ArrayList、LinkedList）

ArrayList：
示例：
  1. List<String> arrayList = new ArrayList<>();
  2. arrayList.add("Element1");
  3. arrayList.add("Element2");
复制代码
LinkedList：
示例：
  1. List<String> linkedList = new LinkedList<>();
  2. linkedList.add("Element1");
  3. linkedList.add("Element2");
复制代码
9.3 Set 接口（HashSet、TreeSet）

HashSet：
示例：
  1. Set<String> hashSet = new HashSet<>();
  2. hashSet.add("Element1");
  3. hashSet.add("Element2");
复制代码
TreeSet：
示例：
  1. Set<String> treeSet = new TreeSet<>();
  2. treeSet.add("Element1");
  3. treeSet.add("Element2");
复制代码
9.4 Map 接口（HashMap、TreeMap）

HashMap：
示例：
  1. Map<String, Integer> hashMap = new HashMap<>();
  2. hashMap.put("Key1", 1);
  3. hashMap.put("Key2", 2);
复制代码
TreeMap：
示例：
  1. Map<String, Integer> treeMap = new TreeMap<>();
  2. treeMap.put("Key1", 1);
  3. treeMap.put("Key2", 2);
复制代码
9.5 集合的遍历（迭代器、增强 for 循环等）

迭代器：
示例：
  1. List<String> list = new ArrayList<>();
  2. list.add("Element1");
  3. list.add("Element2");
  4. Iterator<String> iterator = list.iterator();
  5. while (iterator.hasNext()) {
  6.     System.out.println(iterator.next());
  7. }
复制代码
增强 for 循环：
示例：
  1. for (String element : list) {
  2.     System.out.println(element);
  3. }
复制代码

第 10 章: 输入/输出(I/O)流

10.1 I/O 流的概念与分类

I/O（输入/输出）流是Java中处置惩罚读写数据的机制，主要用于文件操作、网络通讯等场景。I/O流按照数据处置惩罚方式和数据范例分类：
10.2 字节流（InputStream、OutputStream）

字节流用于处置惩罚二进制数据（如图像、音频文件等）。
10.3 字符流（Reader、Writer）

字符流用于处置惩罚文本数据（如文本文件）。
10.4 文件操作（文件读取、写入、复制等）

文件读取：
  1. BufferedReader br = new BufferedReader(new FileReader("input.txt"));
  2. String line;
  3. while ((line = br.readLine()) != null) {
  4.     System.out.println(line);
  5. }
  6. br.close();
复制代码
文件写入：
  1. BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
  2. bw.write("Hello, World!");
  3. bw.newLine();
  4. bw.write("Goodbye, World!");
  5. bw.close();
复制代码
文件复制：
  1. FileInputStream fis = new FileInputStream("input.txt");
  2. FileOutputStream fos = new FileOutputStream("output.txt");
  3. byte[] buffer = new byte[1024];
  4. int length;
  5. while ((length = fis.read(buffer)) > 0) {
  6.     fos.write(buffer, 0, length);
  7. }
  8. fis.close();
  9. fos.close();
复制代码
10.5 缓冲流和对象流

缓冲流：用于进步I/O操作的服从，通过减少直接对物理设备的读写次数来实现。
  1. BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"));
  2. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"));
复制代码
对象流：用于读写Java对象，实现对象的序列化和反序列化。
  1. ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
  2. oos.writeObject(new Person("Alice", 30));
  3. oos.close();
  5. ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));
  6. Person person = (Person) ois.readObject();
  7. ois.close();
复制代码

第 11 章: 多线程编程

11.1 线程的基本概念

线程是程序中的一个单独执行路径。多线程编程允许程序同时执行多个操作，进步程序的并发性和性能。
11.2 线程的创建（继续 Thread 类、实现 Runnable 接口）

继续 Thread 类：
  1. public class MyThread extends Thread {
  2.     public void run() {
  3.         System.out.println("Thread is running");
  4.     }
  5. }
  7. MyThread t1 = new MyThread();
  8. t1.start();
复制代码
实现 Runnable 接口：
  1. public class MyRunnable implements Runnable {
  2.     public void run() {
  3.         System.out.println("Thread is running");
  4.     }
  5. }
  7. Thread t2 = new Thread(new MyRunnable());
  8. t2.start();
复制代码
11.3 线程的生命周期与状态转换

线程的生命周期包罗以下几种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、等待（Waiting）、计时等待（Timed Waiting）和停止（Terminated）。
11.4 线程同步（synchronized 关键字、Lock 接口）

synchronized 关键字：
  1. public class Counter {
  2.     private int count = 0;
  3.    
  4.     public synchronized void increment() {
  5.         count++;
  6.     }
  7. }
复制代码
Lock 接口：
  1. import java.util.concurrent.locks.Lock;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. public class Counter {
  5.     private int count = 0;
  6.     private Lock lock = new ReentrantLock();
  7.    
  8.     public void increment() {
  9.         lock.lock();
  10.         try {
  11.             count++;
  12.         } finally {
  13.             lock.unlock();
  14.         }
  15.     }
  16. }
复制代码
11.5 线程间通讯（wait、notify、notifyAll）

线程间通讯用于和谐多个线程之间的操作。

第 12 章: Java 图形用户界面（GUI）编程

12.1 GUI 编程概述（AWT 和 Swing 简介）

AWT（Abstract Window Toolkit）：Java最早的GUI工具包，提供了一些基本的GUI组件，如按钮、文本框等。AWT直接依靠于本地平台的GUI组件，因此具有较好的性能，但其跨平台体现较差。
Swing：基于AWT开发的更先辈的GUI工具包，提供了一套更加丰富的组件，如表格、树、标签等。Swing是纯Java实现的，具有精良的跨平台兼容性，并提供了更多的外貌和感觉。
12.2 简朴的窗口创建（JFrame）

JFrame 是Swing提供的顶层容器，用于创建窗口。
示例：
  1. import javax.swing.JFrame;
  3. public class SimpleWindow {
  4.     public static void main(String[] args) {
  5.         JFrame frame = new JFrame("My First Swing Application");
  6.         frame.setSize(400, 300);
  7.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  8.         frame.setVisible(true);
  9.     }
  10. }
复制代码
12.3 布局管理器（FlowLayout、BorderLayout 等）

布局管理器用于管理组件在容器中的布局。
12.4 常用组件（按钮、文本框、标签等）

按钮（JButton）：
  1. JButton button = new JButton("Click Me");
  2. frame.add(button);
复制代码
文本框（JTextField）：
  1. JTextField textField = new JTextField(20);
  2. frame.add(textField);
复制代码
标签（JLabel）：
  1. JLabel label = new JLabel("This is a label");
  2. frame.add(label);
复制代码
12.5 事件处置惩罚机制（ActionListener 等）

事件处置惩罚机制用于响应用户的操作，如点击按钮、输入文本等。
示例：
  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  6. public class SimpleGUI {
  7.     public static void main(String[] args) {
  8.         JFrame frame = new JFrame("Simple GUI");
  9.         frame.setSize(400, 300);
  10.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  11.         frame.setLayout(new FlowLayout());
  13.         JButton button = new JButton("Click Me");
  14.         button.addActionListener(new ActionListener() {
  15.             public void actionPerformed(ActionEvent e) {
  16.                 System.out.println("Button Clicked");
  17.             }
  18.         });
  20.         frame.add(button);
  21.         frame.setVisible(true);
  22.     }
  23. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/) Powered by Discuz! X3.4