Java笔记

概述

编译java文件，要使用JDK中的javac.exe工具

javac负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。生成了jvm可以识别的字节码文件，也就是class文件，也就是java的运行程序

运行java程序，要使用JRE

解释执行生成的class文件，要使用java.exe工具，负责运行的部分，会启动jvm，加载运行时所需的类库，并对class文件进行执行。

一个文件要被执行，必须要有一个执行的起始点，这个起始点就是main函数。

生成的文件扩展名：.class

一个java文件中只能有一个public类，但是一个源文件里可以有多个class声明。

类名必须和文件名一致。

java虚拟机（JVM）：java程序的运行平台

java项目的源文件在工程目录下src目录中

编译后生成的class文件在bin目录中

基础知识

标识符

Java符号分为标识符、关键字、运算符和分隔符

由字母、数字、__和$ 组成。

字母可以是大写或小写的英文字母

数字从0到9，长度不限

第一个字符不能是数字，区分大小写

最好见名知义，规范大小写使用方式

数据类型、变量与运算符

命名规则

变量、方法名用小写字母，多个词组成的名称

从第二个词开始首字母大写（小驼峰）

变量：radius、area 方法：computeArea showInputDialog

类名每一个词的首字母大写（驼峰命名法）

ComputeArea、Math、JOptionPane

常量名 所有字母都要大写每个词下划线分割

PI、MAX_VALUE

包名全部用小写

严格区分大小写定义类时class不能写成Class

定义一个computer时，还可定义一个computer

合法标识符： A、al、$Systembol、square、ex_sa

不合法： Ia、break、TWO WORDS、.NO

char和string的区别

char只能表示单字符，使用单引号包裹

string需要用双引号包裹

变量

在Java中，所有变量必须先定义后使用

格式为：

数据类型标识符1 [=初值],[标识符2…];

int i = 0, j = 1;

变量要先定义/声明，再初始化，才能使用

System.out.println(“字符串”+变量+……);

"+“用作算数运算符和字符串连接运算符，若其中某个操作数不是字符串，在连接之前会自动将其转换为字符串

System.out.println(“i+j is”+ i + j);

System.out.println(“i+j is”+ (i + j));

常量

运行过程中只被赋值一次，不会变化

1.以字面形式给出值的常数值

2.以关键字final定义的标识符常量

如final double PI = 3.1415;

有整数型、浮点型、布尔型、字符型和字符串型5种常量。

常数值

整形常数缺省类型为int

默认情况下，整形常数值为十进制整数

八进制常数以0开头，后跟0~7数字，如035

十六进制常数以0x开头，后跟0~~9数字，或者a~~f之间的小写或大写字母，如0x2f

浮点型常数值：double双精度(默认) 、float单精度

浮点数的计算是近似计算，因此doluble类型比float类型更加准确

布尔型常数值（逻辑型常量）

有true和false两个值

字符型常数值

包定义包用package关键字。

package pack; 定义了一个包，名称为pack

类的全名称时包名.类名

包是一种封装形式，用于包装类，想要被包以外的程序访问，该类必须public

类中的成员，如果被包以外访问，也必须public

import - 导入

导入指定包中的类

import packa.* ; //导入了packa当前目录下所有的类，不包含子包

import packa.abc.*; //导入了packa包中的子包abc下的当前所有类

java.lang：自动被导入

java.awt：图形界面开发

java.swing：图形界面库

java.net：网络编程

java.io：用于操作文件

java.util：工具包、事件对象、集合框架

java.applet：客户端java小程序

数据类型转换

自动：转换前后类型兼容，转换后范围大于转换前，

强制：i = float j，容易丢失精度，转换数值不能超过目标类型的数值范围，如float<double，不满足自动转换条件

运算符

规定表达式中各变量和常量运算的符号。

算数运算符：+ - * / %，除数不能为零，整数相除结果只有整数部分。2/3=0，9.0%2.0=1.0

关系运算符：== ，！=， >=，=<，>，<。运算结果为布尔值

逻辑运算符：非!、与&&、或||，异或^

赋值运算：=以及扩展赋值运算符

1
2


x*=y+10 相当于 x=x*(y+10) 
x+=y+10 相当于 x=x+y+10

判断奇数和偶数

1
2
3
4
5


int n=30;
if(n%2!=0) //或 n%2==1
    System.out.println("变量n是奇数");//注意：函数println是有换行，print()无换行
else
    System.out.println("变量n是偶数");

判断是否被x整除

1
2
3


n%x==0 //判断一个数是否被x整除
if(n%5==0 || n%8==0) //判断一个数是否被5或8整除
if(n%5==0 && n%8==0) //判断一个数是否同时被5和8整除

在 Java 里，/ 是除法运算符，% 是取余（模）运算符，核心区别如下：

运算目的：
\ 计算商，整数相除会向下取整（如 10 / 3 = 3 ）；若有浮点数参与，结果含小数（如 10.0 / 3 = 3.333... ）。 -
% 计算余数，返回被除数除以除数后剩余的数（如 10 % 3 = 1 ，即 10 除以 3 商 3 余 1 ）。
使用场景： \ 用于普通除法需求（如均分物品、计算比例）； - % 常用在判断奇偶（x % 2 == 0 为偶数）、循环取索引（如数组遍历控制）等场景。简单说，/ 求“能分几份”，% 求“分完剩下多少” 。

ASCII字符：

48~57：0-9

65~90：A-Z

97~122：a-z

流程控制

while do循环：先执行语句块再判断条件

for each循环：将字符串orders中的每个元素赋值给order，使用order.equals语句进行比较，相同之后break终止

每10个数换行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int count=0;
do{
    if(条件2){
        输出满足条件2的数;
        count++;
        }
        if(count %10==0){
            System.out.println();
        }
}while(条件1)

Scanner库

导入：import java.util.Scanner;

创建对象：Scanner scanner = new Scanner(System.in);

new Scanner(...)：创建 Scanner 对象，专门处理输入；
System.in：把 Scanner 绑定到 “控制台输入”，这样输入会从键盘读。
nextLine()：读一整行字符串（含空格）

数组

概念：相同数据类型的元素按一定顺序排列的集合，可以为简单数据类型，也可以为对象。

主要特点：各元素有先后顺序，按照这个先后顺序连续存放在一起。数据元素用整合数组的名字和他自己在数组中的顺序位置来表示，a[0]表示名字为a的数组中的第一个元素，a[1]代表数组a的第二个元素，以此类推

使用new，要表明数组的长度：

定义长度是5的数组，类型为char、boolean、String

char[] arrar = new char[5];

boolean[] array1 = new boolean[5];

String[] array2 = new String[5]

数组大小：array.length;

array1[0] = 30;

int i=0,count=0; 同类型变量，可以只写一次类型

for(i=0; i < array1.length;i++)

或

for(i=0; i <= array1.length;i++)

if(array1[i] > 50)

count++;

类的构造方法、访问对象的成员、调用对象的成员方法、方法要先定义后调用

为要创建的对象中成员变量赋初始值

访问对象中的成员变量，使用“对象名.成员变量名”。

class A{}

一维数组

格式为：

`数组类型[] 数组名或数组类型数组名[]

声明（等号左边）：

`数组类型[] 数组名;

`数据类型数组名[];

创建（等号右边）：

数组名[数组长度];

数组名[]{元素1,元素2,元素3...};

{元素1,元素2,元素3...};

foreach循环

for(元素类型元素变量:数组/集合) {}

1
2
3
4
5
6
7
8


int[] numbers = {5, 10, 15};
int sum = 0;
for (int num : numbers) {
    sum += num;
}

System.out.println(sum); // 输出 30
答案：int，numbers

作用：遍历数组numbers中的所有元素

length变量

数组名.length

用于获取数组的长度。

1
2
3
4


int[] numbers = {5, 10, 15};
// 用“数组名.length”获取长度
int len = numbers.length; 
System.out.println(len); // 输出 3（数组有 3 个元素）

Java数组的元素类型既可以是基本数据类型（简单数据类型），也可以是引用类型（对象类型）。

例如：

1、int[]、char[]、double[] 等，直接存储基本类型的值。

int[] numbers = {1, 2, 3}; // 存储基本类型int的值

2、String[]、Object[] 或自定义类的数组，存储的是对象的引用（内存地址），而非对象本身。

String[] names = {“Alice”, “Bob”}; // 存储String对象的引用

数组查找：

线性查找法：

将要查找的关键元素key顺序的与数组中的每一个元素进行比较

二分查找法：

前提是数组中的元素必须已经被排好序

数组排序：

冒泡排序法

二维数组

类型标识符数组名[][]

数组名[]

类型标识符[],[] 数组名

例：

`int arr[][];

`int[]arr[];

`int[][] arr;

字符串和字符

String类

创建方法 String()

String(char[] chararray)

String(char[] chararray,int offset, int count)

public int indexOf (String value, int startIndex)

在字符串中从startIndex开始查找子串value，返回从 beginIndex 开始到串尾的子串，正确。

public int indexOf (char c) 查找字符 c

public String subString(int fromIndex, int endIndex)

返回从 beginIndex 开始到 endIndex - 1 的子串，不是到 endIndex。

public char chatAt(int index)

是获取指定索引的字符，不符合。

String是引用数据类型，本质是类，而非基本数据类型

字符串获取长度用length()方法"abc".length()

数组获取长度用 length 属性int[] arr = {1,2}; arr.length

StringBuffer类

StringBuffer 是 Java 提供的可变字符串类（还有类似的 StringBuilder ），存放在 java.lang 包中。

特点：
字符串内容可以被修改（append、insert 等操作直接改原对象），不像 String 是 “不可变” 的（每次修改都会新建对象）。
用途：
当需要频繁拼接、修改字符串时（比如循环里拼接），用 StringBuffer 更高效，避免创建大量临时 String 对象。
1 2 3 4

StringBuffer sb = new StringBuffer("Hello"); sb.setCharAt(1, 'a'); sb.reverse(); System.out.println(sb.charAt(2));

sb.setCharAt(1, ‘a’) 将字符串变为 “Hallo”。
sb.reverse() 反转后字符串变为 “ollaH”。

charAt(2) 获取索引为2的字符 l。

1
2
3
4
5
6
7
8
9


public class StringTest {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
       }
}

s2为常量池中的字符串对象，节省内存

s3是堆内存中的新对象，是强制在堆内存新建的对象（内存地址不同）。

concat方法 拼接字符串，返回新的 String 对象（原 String 不会被修改，因为 String 是不可变的）。

1
2
3
4


String s1 = "Hello";
// concat 返回新对象，但没赋值给 s1，所以 s1 还是原来的 "Hello"
s1.concat(" World"); 
System.out.println(s1); // 输出 "Hello"

append方法 直接修改 StringBuffer 对象本身，在末尾拼接内容，不会新建对象（因为 StringBuffer 是可变的）。

1
2
3
4


StringBuffer s2 = new StringBuffer("Hello");
// append 直接修改 s2，拼接后 s2 变成 "Hello World"
s2.append(" World"); 
System.out.println(s2); // 输出 "Hello World"

Character类

类

由成员变量和成员方法组成。

类是对象的抽象

类是对象的模板，对象是类的实例。

成员变量用于存储对象的状态，成员方法

访问修饰符：包括public、private、protected和默认访问权限，只能同一包

public拥有最大的权限，可以在本项目的任意类中访问

protected可以在本包下和其子类访问

default本包下的当前类和其他类可以访问

private只能在当前类下访问。

面向对象程序设计

定义相同类型对象的结构

使用变量定义数据域，用方法定义行为

用类构建对象时会调用构造方法

访问修饰符：public、abstract、final、缺省

abstract与final相互对立

构造方法

是一种特殊的方法，调用它来初始化对象。

构造函数是 Java 中用于创建对象时初始化对象的特殊方法，与类名同名，无返回值类型（连void都不能写）。
构造方法只能在创建对象（new关键字时）自动调用，创建对象的本质就是调用构造函数初始化
构造函数名字必须与类名完全相同，否则不是构造函数
构造函数没有返回值类型，不能声明int、void等返回值类型
构造方法作用就是在创建对象时执行初始化操作（如给属性赋值等）

“书” 是类（抽象概念），“某一本书” 是对象（具体实例），体现类与对象关系

电脑类中，品牌、型号、内存大小属于描述电脑的属性（用变量定义）

类是对象的抽象，对象是类的具体体现

类的结构通常是属性（变量，描述状态）和方法（描述行为、操作）

定义一个类，其中需要定义(1) 成员变量 (2) 构造方法 (3) 成员方法