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
关系运算符：== ，！=， >=，=<，>，<。运算结果为布尔值
逻辑运算符：非!、与&&、或||，异或^
赋值运算：=以及扩展赋值运算符
x*=y+10 相当于 x=x*(y+10)
x+=y+10 相当于 x=x+y+10判断奇数和偶数
int n=30;
if(n%2!=0) //或 n%2==1
System.out.println("变量n是奇数");//注意：函数println是有换行，print()无换行
else
System.out.println("变量n是偶数");判断是否被x整除
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个数换行。
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(元素类型 元素变量:数组/集合) {}
int[] numbers = {5, 10, 15};
int sum = 0;
for (int num : numbers) {
sum += num;
}
System.out.println(sum); // 输出 30
// 答案：int，numbers作用：遍历数组numbers中的所有元素
length变量
数组名.length
用于获取数组的长度。
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 对象。
StringBuffer sb = new StringBuffer("Hello");
sb.setCharAt(1, 'a');
sb.reverse();
System.out.println(sb.charAt(2));1. sb.setCharAt(1, 'a') 将字符串变为 "Hallo"。
2. sb.reverse() 反转后字符串变为 "ollaH"。
3. charAt(2) 获取索引为2的字符 l。
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 是不可变的 ）。
String s1 = "Hello";
// concat 返回新对象，但没赋值给 s1，所以 s1 还是原来的 "Hello"
s1.concat(" World");
System.out.println(s1); // 输出 "Hello"append方法
直接修改 StringBuffer 对象本身，在末尾拼接内容，不会新建对象（因为 StringBuffer 是可变的 ）。
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关键字时）自动调用，创建对象的本质就是调用构造函数初始化
- 构造函数名字必须与类名完全相同，否则不是构造函数
- 构造函数没有返回值类型，不能声intvoid等返回值类型
- 构造方法作用就是在创建对象时执行初始化操作（如给属性赋值等 ）
“书” 是类（抽象概念 ），“某一本书” 是对象（具体实例 ），体现类与对象关系
电脑类中，品牌、型号、内存大小属于描述电脑的属性（用变量定义 ）
类是对象的抽象，对象是类的具体体现
类的结构通常是属性（变量，描述状态 ）和方法（描述行为、操作 ）
定义一个类，其中需要定义(1) 成员变量 (2) 构造方法 (3) 成员方法
特征：
名称：与它所属的类名相同
返回类型：无，且不能用void修饰，因为返回值类型就是该类本身。
可以不定义构造方法
Cylinder(){}
方法重载
函数重载是指在同一个类中，方法名相同，但参数列表（参数个数、类型、顺序 ）不同的多个方法，与返回值无关。
- 参数顺序不同（func(int, String)func(String, int) ）
- 参数类型不同（func(int)func(String) ）
- 参数名称不同不影响参数列表本质（类型、个数、顺序才决定 ）
- 参数个数不同（func()func(int) ），可构成重载
- 返回值不同不能单独构成重载（方法调用时根据参数选方法，返回值不参与判断 ）
重载：在一个类中，如果出现了两个或者以上的同名函数，只要他们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。
当函数重名时，只看参数列表。和返回值类型没关系。
重写：重写需要满足方法名同/形参列表同；子类方法返回值类型性比父类方法返回值类型更小或相等/子类方法声明抛出的异常类应比父类方法声明跑出的异常类更小或相等；子类方法的访问权限应比父类方法更大或相等。
覆盖于被覆盖方法要么都是类方法，要么都是实例方法。
封装
this
this代表对象，就是所在函数所属对象的引用
this对象
final
这个关键字是一个修饰符，可以修饰类、方法、变量
是一个最终类，不可以被继承。
是一个最终方法，不可以被覆盖
是一个常量，只能赋值一次。final int MINLEN=10，如果加public，则为public final int
static
关键字，是一个修饰符，用户修饰成员。（成员变量和成员函数）
static方法中不能使用this、super关键字。
继承
子类继承父类的属性和方法，避免代码重复
继承后可以添加新属性和方法
如果父类中没有空参数的构造函数，
提高代码复用性
让类与类之间产生关系，提供了另一个特征多态的前提
super和this只能有一个
所有类的父类都是object类
多态
toString：将对象变成字符串
instanceof
抽象
接口
接口中有抽象方法，说明接口不可以实例化
方法体至少要有一个return语句
抽象类只能被继承，而且只能单继承，可以定义非抽象方法，子类可以直接继承使用使用的是is a关系，成员修饰符可以自定义
接口使用的是like a关系，成员修饰符是固定的，全都是public的。
