Java笔记

DuanjianBroken1

于 2024-06-13 11:04:03 发布

阅读量263

点赞数 7

文章标签：开发语言 java 笔记

本文链接：https://blog.csdn.net/DuanjianBroken1/article/details/139648383

版权

1.2 Java语言的特点

Java语言的广泛应用主要得益于它的核心特点，主要包括跨平台性、面向对象特性、安全性等。

特性   描述
跨平台性   Java能够在多种操作系统上运行，这得益于JVM（Java虚拟机）。只要设备安装了对应的JVM，Java程序就可以在其上运行。
面向对象   Java是一种面向对象的编程语言。这意味着你可以创建包含属性和方法的对象，并通过对象的交互来实现复杂功能。
安全性   Java为网络编程提供了许多安全特性，包括对源代码的加密，并且在运行时检查类的
1.3 Java开发环境的搭建

Java开发环境的搭建是Java学习的第一步，主要包括安装JDK（Java开发工具包）和配置环境变量。

步骤   描述
安装JDK   JDK是包含了JRE（Java运行环境）和开发工具（如编译器和调试器）的软件包。
配置环境变量   环境变量是让系统知道如何找到Java命令和库的方式。通常需要设置JAVA
1.4 第一个Java程序

编写第一个Java程序时，通常从最简单的输出开始，这里我们以“Hello, World!”为例。

// "HelloWorld.java" 示例代码
public class HelloWorld {
// 主函数，Java 程序入口点
public static void main(String[] args) {
// 输出字符串到控制台
System.out.println("Hello, World!");
}
}
步骤   描述
创建类   使用 class 关键字定义一个类，类名的首字母应大写。
编写主函数   main 方法是程序的入口，是程序开始执行的地方。
输出信息   使用 System.out.println 在控制台打印信息。
进阶用法介绍：掌握基本的输入输出操作后，可以学习复杂的 I/O 流操作，包括文件读写，序列化和网络通信。此外，了解执行时异常处理也是进阶重要的一步。

1.5 Java程序编程规范

遵循Java编程规范能够提高代码的可读性和可维护性。

// Java 编程规范示例代码

/**
* Calculator 类用于执行基本的数学运算。
* 类命名使用大驼峰命名法。
*/
public class Calculator {

/**
* 常量命名使用全大写字母和下划线分隔。
*/
public static final String NAME = "Simple Calculator";

/**
* 方法命名使用小驼峰命名法，方法名应当清晰表达其功能。
*/
public int add(int number1, int number2) {
// 方法内的注释用于解释复杂的逻辑
return number1 + number2; // 返回两个数字的和
}
}

规范类型   描述
类命名规范   使用大写字母开始，后续每个单词首字母大写。
方法命名规范   使用小写字母开始，后续每个单词首字母大写。
常量命名规范   全部使用大写字母，并在单词之间使用下划线分隔。
2.1 关键字和标识符

在Java中，关键字是预定义的保留字，具有特殊的意义；而标识符是程序员自定义的名字，用于变量、方法、类等的命名。

// 关键字和标识符示例代码

public class Student {
// 'public', 'class' 是Java关键字

// 'Student', 'studentName', 'printStudentName' 是标识符
String studentName;

// 'void' 是关键字，表示函数不返回任何值
public void printStudentName() {
System.out.println(studentName);
}
}
类型   描述
关键字   Java预定义的单词，如 public, static, void。
标识符   用户自定义的名称，需要遵守命名规则，不能使用关键字。
2.2 变量与常量

变量和常量是Java中存储数据的基本单元，变量的值可以改变，而常量的值定义后不可更改。

// 变量与常量的示例代码
public class VariableAndConstant {
// 声明一个变量
int age = 18;

// 声明一个常量，一般使用 final 关键字修饰，且常量名大写
final String NAME = "张三";

public void updateAge() {
// 修改变量
age = 20;
// 以下常量赋值会导致编译错误，因为常量不能被改变
// NAME = "李四";
}
}
类型   描述
变量   可变的存储单元，可以在程序执行过程中改变其值。
常量   使用 final 关键字声明，一旦赋初值后不可更改。
进阶用法介绍：

在Java编程中，变量和常量的高级用法涉及到更深层次的理解和运用。例如，变量的作用域决定了在哪个部分的代码中可以访问到该变量，而生命周期则与变量在内存中存在的时间有关。变量的作用域可以是类级（成员变量）、方法级（局部变量）、块级（比如在if或for循环中定义的变量），或者是线程生命周期内（ThreadLocal变量）。

装箱和拆箱是Java中特有的概念，指自动地将基本数据类型转换为相应的包装器类型（装箱），以及将包装器类型转换回基本数据类型（拆箱）。不变设计模式（Immutable Design Pattern）涉及到创建不可变的对象，确保对象一旦被创建后就不能被修改。这种模式有助于创建更加安全和简洁的代码，并容易进行多线程编程，因为不可变对象本身是线程安全的。

// 进阶变量与常量的示例代码
public class AdvancedVariableAndConstant {

// 类级变量（静态变量），与类一起加载，在程序整个运行期间都存在
private static int classVariable = 0;

// 在方法中定义的局部变量，仅在方法调用时存在
public void localVariableExample() {
int localVariable = 1;
}

// 不变对象示例，创建后其状态不能被改变
public final static String IMMUTABLE_STRING = "不可变字符串";

// 装箱:将int基本类型转化为Integer对象类型
int primitive = 100;
Integer wrappedInteger = primitive; // 装箱

// 拆箱:将Integer对象类型转化为int基本类型
int unboxedInteger = wrappedInteger; // 拆箱
}

高级用法   描述
变量作用域   确定变量可以被访问的代码范围。
变量生命周期   变量从创建到销毁的过程。
装箱与拆箱   自动类型转换，基本数据类型与对象类型之间的转换。
不变设计模式   一种创建不可变对象的设计模式，用于创建线程安全和不可修改的对象。
2.3 数据类型

Java是静态类型语言，数据类型定义了变量可以存储的数据种类和范围。

// 数据类型的示例代码
public class DataTypes {
// 基本数据类型
int intNum = 100; // 整数
float floatNum = 10.99f; // 单精度浮点数
double doubleNum = 3.14159; // 双精度浮点数
char letter = 'A'; // 字符
boolean flag = true; // 布尔

// 对象数据类型（类）
String text = "Hello Java"; // 字符串
}
数据类型   描述
基本数据类型   包括整数、浮点数、字符和布尔等类型，直接存储值。
对象数据类型   类的实例，通过引用来操作，例如字符串。
2.5 程序控制结构

程序控制结构决定了程序的流程，包括分支结构如 if、else、循环结构如 for、while。

// 程序控制结构的示例代码
public class ControlStructure {
public void checkNumber(int number) {
// 分支结构
if (number > 0) {
System.out.println("数字正数");
} else {
System.out.println("数字非正数");
}

// 循环结构
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
}
}

控制结构   描述
分支结构   根据条件执行不同的代码路径。
循环结构   重复执行一段代码直至满足退出条件。
3.1 数组概述

数组在Java中是用来存储固定大小的同类型元素的集合。

// 数组概述示例代码
public class ArrayExample {
public void arrayDemo() {
// 声明一个整型数组
int[] numbers = {10, 20, 30, 40, 50};
// 遍历数组并打印元素
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
}
}
概念   描述
数组声明   定义数组的类型和名称，可以初始化数组。
数组遍历   使用循环结构去访问数组中的每个元素。
数组长度   属性 length 用来获得数组的大小。
进阶用法介绍：

数组的高级功能涉及多维数组的使用、数组和集合之间的转换、利用Java的集合框架进行动态数组的操作，以及对数组进行高效排序和搜索等操作。

多维数组：在Java中，除了一维数组，还可以创建多维数组，如二维数组通常被用于表示矩阵或者表格数据。

// 多维数组示例代码
public class MultiDimensionalArray {
public void multiArrayDemo() {
// 声明一个二维数组
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 访问二维数组中的元素
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println(); //新的一行
}
}
}

Java集合框架：对于更复杂的数据结构操作，可以使用Java的集合框架，如 ArrayList 和 HashMap 提供了动态的、可以改变大小的数组。

// Java集合框架示例代码
import java.util.ArrayList;
import java.util.HashMap;

public class CollectionExample {
public void collectionDemo() {
// 创建ArrayList
ArrayList<Integer> numberList = new ArrayList<>();
numberList.add(10);
numberList.add(20);

// 创建HashMap
HashMap<String, Integer> nameToAge = new HashMap<>();
nameToAge.put("张三", 30);
nameToAge.put("李四", 40);
}
}

数组的高级排序与搜索：使用如排序算法 Arrays.sort() 和搜索算法 Arrays.binarySearch() 可以对数组进行高效的排序和搜索。

// 数组高级排序与搜索示例代码
import java.util.Arrays;

public class ArrayAdvancedOperations {
public void advancedArrayDemo() {
// 标准数组排序
int[] numbers = {40, 10, 20, 30};
Arrays.sort(numbers);

// 用二分搜索法在数组中搜索值，前提是数组已经排序
int index = Arrays.binarySearch(numbers, 30);
System.out.println("Index of 30: " + index);
}
}
高级功能   描述
多维数组   可以用来表示多维数据结构，例如矩阵。
Java集合框架   动态数组和映射，用于在程序运行时动态存储元素。
高级排序与搜索   利用Java提供的工具类对数组进行高效的排序和搜索。
4.2 类

类是Java面向对象程序设计的基础，是创建对象的蓝图或原型。

// 类的示例代码
public class Book {

// 实例变量（属性）
private String title;
private String author;
private int year;

// 类构造器
public Book(String title, String author, int year) {
this.title = title;
this.author = author;
this.year = year;
}

// 实例方法
public void displayInfo() {
System.out.println("Book: " + title + ", Author: " + author + ", Year: " + year);
}
}

概念   描述
类定义   包含属性和方法的模板定义。
构造器   特殊的方法，用于在创建对象时初始化对象。
实例变量   在类中定义，为每个对象实例保留其独有的状态。
实例方法   属于对象的方法，能够访问对象的状态和行为。
第五章继承与多态

继承允许一个类继承另一个类的属性和方法，而多态允许子类重写父类的方法。

// 继承与多态示例代码

// 父类
class Animal {
public void makeSound() {
System.out.println("Some sound");
}
}

// 子类
class Dog extends Animal {
// 重写方法（多态）
@Override
public void makeSound() {
System.out.println("Bark bark");
}
}

public class TestInheritance {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.makeSound(); // 输出: Bark bark
}
}

概念   描述
继承   使用 extends 关键字，子类获得父类的属性和方法。
方法重写   子类提供父类方法的特定实现。
类型转换   子类对象可以被视为是父类的实例，反之不行。
第六章抽象类与接口

抽象类和接口都不能实例化，用于声明类的某些行为，具体实现由子类完成。

// 抽象类与接口示例代码

// 抽象类
abstract class Shape {
String color;

// 抽象方法
abstract double area();

public String getColor() {
return color;
}
}

// 接口
interface Drawable {
void draw();
}

// 子类
class Circle extends Shape implements Drawable {
double radius;

Circle(double radius) {
this.radius = radius;
}

// 实现抽象方法
@Override
double area() {
return Math.PI * radius * radius;
}

// 实现接口方法
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}