【刷题java自用笔记】

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

1.数组

int[] array=new int[]{11,22,33};
double[] array2=new double[]{11.1,22.2,33.3};
简化
int[] array={11,22,33};
double[] array2={11.1,22.2,33.3}
int[] arr=new int[3];

长度:arr.length

数组遍历

idea提供的:数组名.fori,可自动生成循环

数组中的随机索引

Random r=new Random();
int randomIndex=r.nextInt(arr.length);

二维数组

int[][] arr=new int[][]{{11,22}.{33,44}};
int[][] arr={{11,22}.{33,44}};

二维数组遍历

public static void printArr1(int[][] arr) {
	for (int x = 0; x < arr.length; x++) {
		for (int y = 0; y < arr[x].length; y++) {
			System.out.print(arr[x][y] + " ");
		}
		System.out.println();
	}
}

2.字符串

java.lang.String代表字符串
String s2=new String();
Strng s1=“abc”;
char型数组转字符串；

char[] chs={‘a’,’b’,’c’,’d’};
String s4=new String(chs);

字节数组转字符串：

byte[] bytes={97,98,99,100};
String s5=new String(bytes);

• 字符串是引用地址类型，直接赋值在串池中，会复用，而new的都会创建一个。

String s1=new String(“abc”);
String s2=new String(“abc”);
System.out.println(s1==s2);//false
//引用数据类型比较的是地址值
String s1=“abc”;
String s2=“abc”;
System.out.println(s1==s2);//true

1. s.charAt(0)

返回的是某个索引下的char值
string s=‘12345’ s.charAt(0)=‘1’;

2.getValue()

可能是一个对象的实例方法,用于返回该对象的某个属性值。
int preNum = getValue(s.charAt(0));

3.字符串长度

s.length()
（c++是s.size()）

4.toCharArray

toCharArray（）：将字符串对象中的字符转换为一个字符数组

char[] str1 = ransomNote.toCharArray();
char[] str2 = magazine.toCharArray();

5.字符串比较

Boolean result1=s1.equals(s2);
忽略大小写的比较
s1.equalsIgnoreCase(s2);

6.字符串截取-substring

String start=s1.substring(0,3);//0,1,2左开右闭
String start1=s1.substring(7);//从7到结尾

7.字符串替换-replace()

String result=talk.replace(“abc”,”***”);

StringBuilder-可变

• 可变但不可修改,如需修改需要转成字符数组

StringBuilder sb=new StringBuilder();
char[] arr=sb.toString().toCharArray();

可以看成一个容器，创建之后里面的内容是可变的
StringBuilder sb=new StringBuilder();//空白
StringBuilder sb=new StringBuilder(“abc”);

append	sb.append(", World!");
多个追加	sb.append("Name: ").append("Alice").append("\nAge: ").append(30);
insert	在指定位置插入sb.insert(5, "China ");
delete	删除范围,左开右闭sb.delete(5, 11);
deleteCharAt	删除单个字符sb.deleteCharAt(4);
reverse	反转sb.reverse();
replace	替换sb.replace(6, 11, "China"); // 替换从索引6到11的部分为"China"
setCharAt	允许替换指定位置的字符。sb.setCharAt(0, 'h'); // 将第一个字符替换为小写'h'
length()	int length = sb.length();
capacity容量	返回 StringBuilder 的内部数组的大小StringBuilder sb = new StringBuilder(50); int capacity = sb.capacity(); // capacity = 50
IndexOf	用于查找指定字符或子串的首次出现位置int index = sb.indexOf("W");
lastIndexOf	用于查找指定字符或子串的最后一次出现的位置int lastIndex = sb.lastIndexOf("o");
转换为字符串：toString	String str = sb.toString();

StringJoiner-可指定开始符号,结束符号和中间间隔符号

jdk8出现的
初始化:
StringJoiner sj=new StringJoiner("---");//1---2---3
StringJoiner sj=new StringJoiner(", ","[","]");

add	sj.add("aaa"); 链式添加:sj.add("aaa").add("bbb");
length()	sj.length();
toString()	转成String类型,sj.toString();

---

3. 哈希表-hash_map

map

map提供一个很常用的功能，那就是提供key-value的存储和查找功能。

map namemap;
namemap["岳不群"]="华山派掌门人，人称君子剑";
namemap["张三丰"]="武当掌门人，太极拳创始人";
namemap["东方不败"]="第一高手，葵花宝典";

hash_map

使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素。

hash_map mymap;
mymap[9527]="唐伯虎点秋香";
mymap[1000000]="百万富翁的生活";
mymap[10000]="白领的工资底线";

定义：

 Map<Character,Integer> map = new HashMap<Character,Integer>();

操作：

containsKey()

containsKey():来判断键(key)是否存在。

if(map.containsKey(z))

put

put方法用于向Map中添加键值对。‌
如果Map中不存在该键，则直接添加；如果Map中已经存在该键，则新值会覆盖旧值。‌

 map.put(z,1);

get

‌Java中的‌Map>接口的get方法用于从（key）中取得（value）。
如果映射中不存在该键，则返回null。

map.get(z);

4.随机数Random

Random rand=new Random();
for (int i = 0; i < 10; i++) {
        System.out.println(rand.nextInt(100) + 1);
    }

获取指定范围随机数

• 生成区间 [64,128] 中随机值的代码为：rand.nextInt(65)+ 64;
• randNumber 属于[MIN, MAX]int randNumber = rand.nextInt(MAX - MIN + 1) + MIN;

在集合内随意生成字符

ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            list.add((char)('a' + i));
            list.add((char)('A' + i));
        }
int index = r.nextInt(list.size());

5.集合-ArrayList

• 集合不能用下标,用get方法.
  泛型:限定集合中存储数据的类型
  初始化
  jdk7以前ArrayList list=new ArrayList();
  jdk7以后ArrayList list=new ArrayList<>();
  | | |
  |–|–|
  | add() | 添加元素sites.add("Google"); |
  |get()|访问 ArrayList 中的元素,System.out.println(sites.get(1));|
  |set()|修改sites.set(2, "Wiki"); // 修改第三个元素|
  |remove()|删除sites.remove(3); // 删除第四个元素|
  |size()|长度|

6.character类-char型

Character 类用于对单个字符进行操作。它将基本数据类型 char 包装在一个对象中，并提供了一系列方法来操纵字符

• JDK5以后,charcter和char型可互相转换

char ch = 'a';
Character character = new Character(ch);
System.out.println(character); // 输出 'a'

		char ch = ‘5’
isDigit(char c)	判断字符是否是数字	boolean isDigit = Character.isDigit(ch); // true
isLetter(char c)	判断字符是否是字母	boolean isLetter = Character.isLetter(ch); // false
getNumericValue(char c)	转换为数字	int num = Character.getNumericValue(ch);
toString()	转换为字符串	char ch = 'a';String str = Character.toString(ch); // "a"
toUpperCase(char c)	切换大写	char ch = 'a';char upperCh = Character.toUpperCase(ch); // 'A'
toLowerCase(char c)	切换小写	char ch = 'a';char lowerCh = Character.toLowerCase(ch); // 'a'

字符数组

char[] arr

字符数组转字符串

char[] str = {'h','e', 'l', 'l', 'o', '  ', '1','2','3'};  //创建一个字符数组
	String string1 = new String(str);
	String string2 = String.valueOf(str);

7. 类

• 一个Java文件中可以定义多个class类,且只能一个类是public修饰,而且public修饰的类名必须成为代码文件名。

• 实际开发中建议还是一个文件定义一个class类。

● 成员变量的完整定义格式是:修饰符 数据类型 变量名称=初始化值;一般无需指定初始化值,存在默认值。

javabean类

javabean类-用来描述一类事物的类

• javabean类中,不写main方法

测试类

• 写main方法的类,叫做测试类

main方法

public：被JVM调用，访问权限足够大
static：被JVM调用，不用创建对象，直接类名访问

• 因为main方法是静态的，所以测试类中其他方法也是静态的

void：不需要返回值
main：虽然不是关键字，但被JVM识别
String[] args:以前用于接收键盘录入数据的，现在不用，但为了向下兼容，所以保存

工具类

帮助我们做一些事情的类
私有化构造方法

内部类

A类的里面再定义一个B类,且B单独存在没有意义,B称为内部类
内部类的访问特点

• 内部类可以直接访问外部类的成员,包括私有
• 外部类要访问内部类的成员,必须创建对象

了解	成员内部类	修饰符:private,默认,protected,public,static
了解	静态内部类
了解	局部内部类
掌握	匿名内部类	``

匿名内部类

jtb.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("达咩~不要点我哟~");
            }
        });

---

JDK的安装目录

文件夹	解释
bin	该路径下存放了各种工具命令。其中比较重要的有:javac和java
conf:	该路径下存放了相关配置文件。
include:	该路径下存放了一些平台特定的头文件。
jmods:	该路径下存放了各种模块。
legal:	该路径下存放了各模块的授权文档。
lib:	该路径下存放了工具的一些补充JAR包。

编译(javac)&&运行(java)

编译:javac是JDK提供的编译工具,我们可以通过这个工具,把当前路径下的
HelleWerld.java文件编译成class文件

运行:java也是JDK提供的一个工具。
作用就是用来运行代码的。
运行当前路径下的HelloWorld.class这个文件。在运行的时候是不加后缀名的。

java SE&&java ME&&java EE

java SE:用于桌面应用的开发，标准版
java ME：嵌入式电子设备或小型移动设备
java EE：企业版，用于web方向的网站开发

JVM&&JDK

JVM：虚拟机，真正运行程序的地方
JDK：java开发工具包。JVM+核心类库+开发工具

• 开发工具；
  javac：编译工具
  java：运行工具
  jdb：调试工具
  jhat：内存分析工具
  JRE：运行环境：JVM+核心类库+运行工具(开发的一些工具不需要)

项目结构

项目(project)	相当于创建一个能用 idea 打开的文件夹,包含一个idea文件和一个iml文件
模块(module)	可选java项目,maven项目和springboot项目带一个src下main函数,以及一个iml文件
包(package)	（文件夹）为了保障每个 Java包命名的唯一性，在最新的Java编程规范中，要求程序员在自己定义的包的名称之前加上唯一的前缀。由于互联网上的域名称是不会重复的，所以程序员一般采用自己在互联网上的域名称作为自己程序包的唯一前缀。例如： com.sun.swt.一般公司命名会以com.公司名.项目名.模块名…com.实际表示你类所在的包名，有一定的规则，一般是工程域名的倒序，比如imooc的程序，一般包名起为com.imooc.为前缀。后面就会知道，不同包名中是可以互相调用的，假如我们有两个相同名称的类，那么有不同的包名是至关重要的。也就是说，他可以区分不同包下的类。
类(class)

• 如果同时使用两个包中的同名类，需要用全类名

Java内存分配

栈	方法运行时使用的内存,比如main方法运行,进入方法栈中执行
堆	存储对象或者数组,new来创建的,都存储在堆内存,静态区也在这里(jdk8以后)
方法区	存储可以运行的class文件
本地方法栈	JVM在使用操作系统功能的时候使用,和我们开发无关
寄存器	给CPU使用,和我们开发无关
串池(StringTable):	字符串直接赋值则存放在串池中(在JDK7版本开始，从方法区挪到了堆内存)

找方法:ctrl+B->跟进

API

math类

所有方法都是静态的

abs	绝对值，Math.abs(-2);
ceil	大于或等于参数的最小整数Math.ceil(23.45)
floor	小于或等于参数的最大整数Math.floor(-23.45)
round	根据四舍五入返回最接近参数的int类型的值Math.round(23.45)
max	两个int值中的较大值Math.max(23,45);
min	两个int值中的较小值Math.min(12,34);
pow	a的b次幂Math.pow(2,3);
random	返回[0.0,1.0]的随机值Math.random();

System类-系统

public static long currentTimeMillis()	// 获取当前时间所对应的毫秒值（当前时间为0时区所对应的时间即就是英国格林尼治天文台旧址所在位置）可查运行时间 System.currentTimeMillis();
public static void exit(int status)	// 终止当前正在运行的Java虚拟机，0表示正常退出，非零表示异常退出System.exit(0);
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);	// 进行数组拷贝System.arraycopy(srcArray , 0 , desArray , 1 , 3);参数分别是源数组,源数值的开始位置,目标数组,目标数组开始位置,要复制的元素个数

Runtime-当前虚拟机的运行环境

public static Runtime getRuntime()	当前系统的运行环境对象
public void exit(int status)	停止虚拟机
public int availableProcessors()	获得CPU的线程数
public long maxMemory()	JVM能从系统中获取总内存大小（单位byte）
public long totalMemory()	JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory()	JVM剩余内存大小（单位byte）
public Process exec(String command)	运行cmd命令

Object

public String toString()	//返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj)	//比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone()	//对象克隆,对象复制User u1 = new User(1, "zhangsan", "1234qwer", "girl11", data);User u2 =(User)u1.clone();

• 浅克隆
  不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来
  ​基本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。
  ​Object类默认的是浅克隆

• 深克隆
  基本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的

Objects类

• Objects类中无无参构造方法，因此我们不能使用new关键字去创建Objects的对象。
• Objects类中所提供的方法都是静态的。因此我们可以通过类名直接去调用这些方法。

public static String toString(Object o)	// 获取对象的字符串表现形式
public static boolean equals(Object a, Object b	// 比较两个对象是否相等
public static boolean isNull(Object obj)	// 判断对象是否为null
public static boolean nonNull(Object obj)	// 判断对象是否不为null

BigInteger类

int存不下,long也存不下

• 如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
• 如果BigInteger表示的超出long的范围，可以用构造方法获取。
• 对象一旦创建，BigInteger内部记录的值不能发生改变。
• 只要进行计算都会产生一个新的BigInteger对象

构造方法
public BigInteger(int num, Random rnd)	//获取随机大整数，范围：[0 ~ 2的num次方-1]BigInteger bd1 = new BigInteger(4,r);//0-2的4次方-1
public BigInteger(String val)	//获取指定的大整数
public BigInteger(String val, int radix)	//获取指定进制的大整数
public static BigInteger valueOf(long val)	//静态方法获取BigInteger的对象，内部有优化,下面这个不是构造，而是一个静态方法获取BigInteger对象,只能在long的取值范围之内

 BigInteger bd1 = BigInteger.valueOf(10);
 BigInteger bd2 = BigInteger.valueOf(5);

方法
BigInteger bd3 = bd1.add(bd2);	加法
public BigInteger subtract(BigInteger val)	减法
public BigInteger multiply(BigInteger val)	乘法
public BigInteger divide(BigInteger val)	除法
BigInteger[] arr = bd1.divideAndRemainder(bd2); System.out.println(arr[0]); System.out.println(arr[1]);	除法，获取商和余数
boolean result = bd1.equals(bd2);	//比较是否相同
BigInteger bd4 = bd1.pow(2);	//次幂、次方
BigInteger bd5 = bd1.max(bd2);	//返回较大值/较小值
BigInteger bd6 = BigInteger.valueOf(1000); int i = bd6.intValue();	//转为int类型整数，超出范围数据有误

BigDecimal类

0.09+0.01=0.09999999999999999,出现精度缺失
进行浮点数计算,不会出现精度缺失的问题

BigDecimal b1 = new BigDecimal("0.3") ;
BigDecimal b2 = new BigDecimal("4") ;

b1.add(b2)	加法运算
b1.subtract(b2)	// 减法运算
b1.multiply(b2)	// 乘法运算
b1.divide(b2)	// 除法运算

刷题模板

输入:

import java.util.Scanner;
public class df {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int i=sc.nextInt();
        System.out.println(i);
    }
}

字符串输入

Scanner sc=new Scanner(System.in);
String str=sc.next();//new出来的

public class df {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

8.正则表达式

作用:
1.校验字符串是否满足规则
2.在一段文本中查找满足要求的内容

String qq ="1234567890";
qq.matches("[1-9]\\d{5,19}");

正则表达式规则

1. 基本字符匹配

• 普通字符（如 a, b, 1, 2）匹配自身。
• . 匹配任意单个字符（除换行符）。
  • 示例：a.c 匹配 abc, a1c, a@c 等。

2. 字符集（Character Class）

• [abc] 匹配 a、b 或 c 中的任意一个。
• [a-z] 匹配任意小写字母。
• [A-Z] 匹配任意大写字母。
• [0-9] 或 \d 匹配任意数字。
• [^abc] 匹配除 a、b、c 之外的任意字符。
• [^0-9] 或 \D 匹配非数字字符。
• \w 匹配字母、数字或下划线（等价于 [a-zA-Z0-9_]）。
• \W 匹配非 \w 的字符。
• \s 匹配空白字符（空格、制表符、换行等）。
• \S 匹配非空白字符。

3. 量词（Quantifiers）

• * 匹配前面的元素 0 次或多次（等价于 {0,}）。
  • 示例：a* 匹配 "", a, aa, aaa 等。
• + 匹配前面的元素 1 次或多次（等价于 {1,}）。
  • 示例：a+ 匹配 a, aa, aaa 等，但不匹配 ""。
• ? 匹配前面的元素 0 次或 1 次（等价于 {0,1}）。
  • 示例：a? 匹配 "" 或 a。
• {n} 匹配前面的元素 恰好 n 次。
  • 示例：a{3} 匹配 aaa。
• {n,} 匹配前面的元素 至少 n 次。
  • 示例：a{2,} 匹配 aa, aaa 等。
• {n,m} 匹配前面的元素 n 到 m 次。
  • 示例：a{2,4} 匹配 aa, aaa, aaaa。

4. 边界（Anchors）

• ^ 匹配字符串的 开头。
  • 示例：^abc 匹配以 abc 开头的字符串。
• $ 匹配字符串的 结尾。
  • 示例：abc$ 匹配以 abc 结尾的字符串。
• \b 匹配单词边界（字母、数字和标点符号之间的位置）。
  • 示例：\bcat\b 匹配独立的 cat，但不匹配 category 中的 cat。
• \B 匹配非单词边界。

5. 分组和引用

• (abc) 创建一个捕获组，匹配 abc 并捕获到组中。
• (abc|def) 匹配 abc 或 def。
• \1, \2, … 引用前面的捕获组。
  • 示例：(\w)\1 匹配两个连续相同的字母或数字（如 aa, 11）。
  • “\1” 匹配与第一个捕获组相同的字符，即字符串的第一个字符

7. 逻辑操作符

• | 表示“或”，匹配左边或右边的模式。
  • 示例：cat|dog 匹配 cat 或 dog。
• &&：并且
• | ：或者
• \ ：转义字符:System.out.println("\"");此时\表示转义字符，改变了后面那个双引号原本的含义

8. 非捕获组和前瞻

• (?:abc) 非捕获组，匹配 abc 但不捕获。–不包含
• (?=...) 正向先行断言，匹配后面跟着 ... 的位置。–包含
  • 示例：\d+(?=%) 匹配后面跟着 % 的数字。
• (?!...) 负向先行断言，匹配后面不跟着 ... 的位置。–除了
  • 示例：\d+(?!\%) 匹配后面不跟着 % 的数字。
• $1 是正则表达式替换操作中的一个占位符，用于引用第一个捕获组（即正则表达式中第一个括号 () 内匹配到的内容）

9. 常用正则表达式示例

• 邮箱：^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
• 手机号（中国大陆）：^1[3-9]\d{9}$
• 手机号码:1[3-9]\d{9}
• 座机号码：0\d{2,3}-?[1-9]\d{4,9}
• 邮箱号码：\w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}
• 24小时：([01]\d|2[0-3]):[0-5]\d:[0-5]\d
  ([01]\d|2[0-3])(:[0-5]\d){2}
• 用户名: \w{4,16}
• 身份证号码，简单校验：
  [1-9]\d{16}(\d|X|x)
  [1-9]\d{16}[\Dax]
  [1-9]\d{16}(\d(?i)X)
• 身份证号码，严格校验：
  [1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9|[12])\d|3[01])\d{3}[\dXx]
• URL：^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$
• 日期（YYYY-MM-DD）：^\d{4}-\d{2}-\d{2}$

10. 修饰符（Flags）

• i 忽略大小写。
• g 全局匹配（匹配所有，而非第一个）。
• m 多行模式（^ 和 $ 匹配每行的开头和结尾）。
  正则表达式非常灵活，可以根据需求组合这些规则。如果需要更具体的匹配规则，可以进一步优化正则表达式。

Pattern-正则表达式

String regex1 = "((?i)Java)(?=8|11|17)";
爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。

(?i)Java:表示java忽略大小写
?=8|11|17:其中?相当于一个占位符

爬取版本号为8，11，17的Java文本。正确爬取结果为:Java8 Java11 Java17 Java17
String regex2 = "((?i)Java)(8|11|17)";
String regex3 = "((?i)Java)(?:8|11|17)";
:->获取所有的东西

爬取除了版本号为8，11.17的Java文本，
String regex4 = "((?i)Java)(?!8|11|17)";
!->去除的意思

Matcher-文本匹配器

作用按照正则表达式的规则去读取字符串，从头开始读取。
在大串中去找符合匹配规则的子串。

 String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +"因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
//1.获取正则表达式的对象
Pattern p = Pattern.compile("Java\\d{0,2}");
//2.获取文本匹配器的对象
//拿着m去读取str，找符合p规则的子串
Matcher m = p.matcher(str);

//3.利用循环获取
while (m.find()) {
   String s = m.group();
   System.out.println(s);
}

9.爬虫

public class RegexDemo7 {
    public static void main(String[] args) throws IOException {
        /* 扩展需求2:
            把连接:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i
            中所有的身份证号码都爬取出来。
        */

        //创建一个URL对象
        URL url = new URL("https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i");
        //连接上这个网址
        //细节:保证网络是畅通
        URLConnection conn = url.openConnection();//创建一个对象去读取网络中的数据
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line;
        //获取正则表达式的对象pattern
        String regex = "[1-9]\\d{17}";
        Pattern pattern = Pattern.compile(regex);//在读取的时候每次读一整行
        while ((line = br.readLine()) != null) {
            //拿着文本匹配器的对象matcher按照pattern的规则去读取当前的这一行信息
            Matcher matcher = pattern.matcher(line);
            while (matcher.find()) {
                System.out.println(matcher.group());
            }
        }
        br.close();
    }
}

贪婪爬取和非贪婪爬取

贪婪爬取:在爬取数据的时候尽可能的多获取数据
非贪婪爬取:在爬取数据的时候尽可能的少获取数据

只写+和*表示贪婪匹配
+? 非贪婪匹配
*? 非贪婪匹配

10. 细节

注释：单行：// 多行：/* */

其他

\t制表符，补齐到8的倍数

• 布尔类型是boolean
• null不能直接打印，如需打印需要加上双引号
• 在系统可以最先整一个ArrayList集合作为数据库的备选

long 类型

long 类型的变量，变量值后需要加一个L(大小写都可以)
long n=99999999L System.out.println(n);

float类型

float 类型的变量，变量值后需要加一个F(大小写都可以)
float f=10.1F

switch

switch(表达式){
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	default:
		语句体n+1;
		break;
}

jdk14新写法:这种不需要写break

switch (choose)
        {
            case "1"-> System.out.println("添加学生");
            case "2"-> System.out.println("删除学生");
            case "3"-> System.out.println("修改学生");
            case "4"-> System.out.println("查询学生");
            case "5"-> {
            System.out.println("退出");
            break;
            }
        }

loop-跳出想要的循环

loop:while (true) {
	break loop;
}

退出的方法:

System.exit(0);//停止虚拟机运行

静态变量

public static String teacher;
静态变量是随着类的加载而加载的，是优于对象的

• 静态方法只能访问静态变量和静态方法
• 非静态方法可以访问静态变量和静态方法，也可以访问非静态的成员变量和非静态的成员方法
• 静态方法中没有this关键字

继承

public class Student extends Person {}

• 一个子类只能继承一个父类，子类不能继承多个父类（c++允许多继承）
• 可多层继承，爷父子（但没有爷孙关系，只有直接继承和间接继承的关系）
• 每一个类都直接或间接的继承Object
• 子类只能访问父类中非私有的成员
  子类继承父类中的内容

	非私有	私有
构造方法	不能	不能
成员变量	能	能(不能直接使用，用get和set方法)
成员方法	能	不能（具体的说是虚方法表中的可以，否则不能）

抽象-abstract

public abstract class 类名{}
public abstract void work(){}
父类中无法确定方法体
子类必须强制重写,

• 抽象类不能实例化
• 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
• 可以有构造方法

接口-行为的抽象-interface

new 接口
一种行为,有行为的都可以
e.g.游泳接口,青蛙类可以,狗类可以,学生类可以,老师类可以
public interface 运输{}

• 接口不能实例化
• 接口和类之间是实现关系,通过implications关键字表示

子类:public class Frog implications Swim{}

• public class 类名 implement 接口名1,接口名2{}
• 可以在继承一个类的同时实现多个接口public class 类名 extend 父类 implement 接口名1,接口名2{}
• 要么重写接口中所有抽象方法,要么是抽象类

public void 搬家(Car c){}
car以及car的子类都可以调用这个方法

接口中成员的特点
成员变量	常量,默认修饰符:public static final不能修改
构造方法	没有
成员方法	JDK7以前:接口中只能定义抽象方法。JDK8的新特性:接口中可以定义有方法体的方法。JDK9的新特性:接口中可以定义私有方法。

jdk8:public default void show()

• 默认方法不是抽象方法,所以不强制被重写,但是如果被重写,重写的时候去掉default关键字
• public可以省略,default不能省略
• 如果实现了多个接口,多个接口中存在相同名字的默认方法,子类就必须对该方法进行重写

类与接口

类和类	继承关系,只能单继承,不能多继承,但是可以多层继承
类和接口	实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现
接口和接口	继承关系,可以单继承,也可以多继承

虚方法表

• 成员方法有一个虚方法表，非private，非static，非final。
• 只有父类中的虚方法才能被子类继承
• Object有5个虚方法

	String name = "Fu";
}
public class Zi extends Fu{
	String name = "Zi";
	public void ziShow(){
		String name = "ziShow";
		System.out.println(name);//"ziShow"
		System.out.println(this.name);//"Zi";
		System.out.println(super.name);//"Fu";
	}
}

重写

当父类中方法不符合要求时，需要把这个方法进行重写，

• 子类重写的方法上面需要加上@override
• 子类的访问权限必须大于等于父类（空着不写
• 子类的返回值类型子类小于等于父类
• 私有方法不能被重写
• 子类不能重写父类的静态方法，重写会报错
• 只有加到虚方法表中的方法才能被重写

this

理解为一个变量，表示当前方法调用者的地址值

super

代表父类存储空间

final

方法：该方法是最终方法，不能被重写
类：是最终类，不能被继承
变量：只能被赋值一次

• 如果变量是基本类型，则数据值不能改变
• 如果是引用类型，则地址值不能改变，对象内部的可以改变（创建对象就是引用类型）
  public static final double PI=3.1415926;

权限修饰符

• 成员变量私有,方法公开,如果方法中的代码是抽取其他方法中共性代码,这个方法一般也私有

代码块

局部代码块	定义变量使用周期
构造代码块	两种不同的构造函数中重复的代码抽取出来
静态代码块	数据的初始化-通过static关键字修饰,随着类的加载而加载,自动触发,只执行一次(写在方法里可能会被重复调用)

命名规则

常量：单个单词，全部大写
多个单词：全部大写，单词之间用下划线隔开

多态

Student s=new Student;
Person p=new Student;
Fu f=new Zi();

• 有方法的重写
• 使用父类型作为参数，可以接收所有子类对象
• 不能调用子类的特有功能：（强制类型转换Dog d=(Dog)a);

instanceof:判断前面所记录的对象是不是后面类型

变量调用：编译看左边，运行也看左边（正常父的优先级更高）
方法调用：编译看左边(看左边有没有这个方法，有则编译成功，没有则报错)，运行看右边（子类覆盖了）

快捷键

生成generate,get和set方法的快捷键:alt+insert

• 按住alt键,鼠标滚轮往下拖,可以实现一竖排的选中

包裹快捷键:ctrl+alt+t

ctrl+alt+m:选中需要的代码快速独立成一个方法

shift+F6:选中某一个变量,下面凡是用到这个变量的地方都改掉

ctrl+B:选中方法,按住,可以进入方法内部

ctrl+alt+左键;回到刚刚看的地方

9.GUI

SWING

组件

JFrame-最外层的窗体

JFrame()	创建一个无标题的窗口。JFrame gameJFrame = new JFrame();
setTitle():	标题,gameJFrame.setTitle("拼图");
setAlwaysOnTop();	界面置顶gameJFrame.setAlwaysOnTop(true);
setSize(int width, int height)：	设置窗口的大小。gameJFrame.setSize(603,680);
setLocationRelativeTo();	设置界面居中gameJFrame.setLocationRelativeTo(null);
setLocation(int x, int y)：	设置窗口的位置，默认位置为（0,0）。
setBounds(int a, int b, int width, int height)：	设置窗口的初始位置和大小。
setBackground(Color color)：	设置窗体的背景颜色。
setVisible(boolean b)：	设置窗口是否可见，默认窗口是不可见的。gameJFrame.setVisible(true);
setResizable(boolean b)：	设置窗口是否可以调整大小，默认窗口是可调整的。
setDefaultCloseOperation(int operation)：	设置窗口关闭操作。(关闭图形的×,程序没有停止运行)0:什么都不做,1:默认关闭方式2:当打开很多界面时,只有关闭最后一个界面,整个虚拟机才停止,3:只要关了一个界面,整个虚拟机全都停止gameJFrame.setDefaultCloseOperation(3); gameJFrame.setDefaultCloseOperation(windowConstants.EXIT_ON_CLOSE);

JMenuBar-最上层的菜单

菜单制作
JMenuBar	this,setJMenuBar(JMenuBar);给整个界面设置菜单
JMenu	如果菜单中需要嵌套二级菜单,则可以用JMenu完成
JMenuItem

JMenuBar

JMenu functionJMenu=new JMenu("功能");
JMenuItem reLoginItem=new JMenuItem("重新登录");

JMenu add(JMenu c)	将指定的菜单附加到菜单栏的末尾。 functionJMenu.add(reLoginItem);
void addNotify()	覆盖 JComponent.addNotify 以向当前键盘管理器注册此菜单栏。
AccessibleContext getAccessibleContext()	获取与此 JMenuBar 关联的 AccessibleContext。
Component getComponent()	实现为 MenuElement。
Component getComponentAtIndex(int i)	已弃用。 替换为 getComponent(int i)
int getComponentIndex(Component c)	返回指定组件的索引。
JMenu getHelpMenu()	获取菜单栏的帮助菜单。
Insets getMargin()	返回菜单栏的边框与其菜单之间的边距。
JMenu getMenu(int index)	返回菜单栏中指定位置的菜单。
int getMenuCount()	返回菜单栏中的项目数。
SingleSelectionModel getSelectionModel()	返回处理单个选择的模型对象。
MenuElement[] getSubElements()	实现为 MenuElement。 返回此菜单栏中的菜单。
MenuBarUI getUI()	返回菜单栏的当前 UI。
String getUIClassID()	返回呈现此组件的 L&F 类的名称。
boolean isBorderPainted()	如果应该绘制菜单栏边框，则返回 true。
boolean isSelected()	如果菜单栏当前选择了一个组件，则返回 true。
void menuSelectionChanged(boolean isIncluded)	实现为 MenuElement，什么都不做。
protected void paintBorder(Graphics g)	如果 BorderPainted 属性为 true，则绘制菜单栏的边框。
protected String paramString()	返回此 JMenuBar 的字符串表示形式。
protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed)	子类化以检查所有子菜单。
void processKeyEvent(KeyEvent e, MenuElement[] path, MenuSelectionManager manager)	实现为 MenuElement，不执行任何操作。
void processMouseEvent(MouseEvent event, MenuElement[] path, MenuSelectionManager manager)	实现为 MenuElement，不执行任何操作。
void removeNotify()	覆盖 JComponent.removeNotify 以在当前键盘管理器中取消注册此菜单栏。
void setBorderPainted(boolean b)	设置是否应绘制边框。
void setHelpMenu(JMenu menu)	设置当用户在菜单栏中选择"帮助"选项时出现的帮助菜单。
void setMargin(Insets m)	设置菜单栏的边框与其菜单之间的边距。
void setSelected(Component sel)	设置当前选定的组件，对选择模型产生更改。
void setSelectionModel(SingleSelectionModel model)	设置模型对象以处理单个选择。
void setUI(MenuBarUI ui)	设置呈现此组件的 L&F 对象。
void updateUI()	使用当前外观中的值重置 UI 属性。

弹窗-JDialog

JDialog jDialog = new JDialog();

设置大小	jDialog.setSize(344,344);
弹框置顶	jDialog.setAlwaysOnTop(true);
居中	jDialog.setLocationRelativeTo(null);
弹框不关闭则无法操作下面的界面	jDialog.setModal(true);
显示出来	jDialog.setVisible(true);

JLabel-管理文字和图片的容器

可设置宽高,位置

ImageIcon	图片
JLabel jLabel = new JLabel("步数");	文字
JTextField	明文输入框
JPasswordField	密文输入框

setBounds()	指定图片位置jLabel.setBounds(0,0,105,105); 四个属性,x轴,y轴,宽,高
setBorder()	添加边框jLabel.setBorder(new BevelBorder(0));0:让图片凸起来1:让图片凹下去;替换常量:jLabel.setBorder(new BevelBorder(BevelBorder.LOWERED));

ImageIcon-图片-可指定图片在电脑中的位置

• 先加载的图片在上方,后加载的图片在下方

//创建一个图片对象
ImageIcon icon= new ImageIcon("URL");
//创建一个JLable对象
JLabel jLabel = new JLabel(icon);
//创建位置
jLabel.setBounds(0,0,105,105);
//将管理容器添加到界面中
//this.add(jLabel);

//获取隐藏容器,将jLabel1添加进去
this.getContentPane().add(jLabel1);

//取消内部默认的居中位置
在JFrame中
this.setLayout(null);

按钮-JButton

JButton jtb = new JButton("点我啊");
        jtb.setBounds(0,0,100,50);//设置位置和宽高
        //给按钮添加动作监听
        //jtb:组件对象，表示你要给哪个组件添加事件
        //addActionListener：表示我要给组件添加动作监听（动作监听包含鼠标左键点击，空格）
        //参数：表示事件被触发之后要执行的代码
        jtb.addActionListener(new MyActionListener());
        //调用ActionListener接口
       // 用MyActionListener实现ActionListener接口
       
       //把按钮添加到界面当中
        jFrame.getContentPane().add(jtb);

public class MyActionListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按钮被点击了");
    }
}

隐藏界面-this.getContentPane()

添加	jFrame.getContentPane().add(jtb);
清空	this.getContentPane().removeAll();
刷新界面	this.getContentPane().repaint();

事件

事件源:按钮,图片

常见的三种事件监听

键盘监听 KeyListener-(快捷键)

在窗体添加键盘监听this.addKeyListener();

keyPressed	按下 keyPressed(KeyEvent e):按下按键没有松开会反复调用这个方法
keyReleased	释放keyReleased(KeyEvent e)
keyTyped	键入:ctrl,alt键监听不了
e.getKeyCode	int code=e.getKeyCode();获取键盘上每一个按键的编号(跟ASCII码表无关)

• getKeyCode:

//左:37 上:38 右:39 下:40
int code=e.getKeyCode();
if(code==65){
}else if(code==66){
}

鼠标监听 MouseListener

在窗体添加:this.addMouseListener(this);

1.划入动作	mouseEntered
2.单击动作(按下并释放)	mouseClicked
2.1.按下动作	mousePressed
2.2松开动作	mouseReleased
3.划出动作	mouseExited

动作监听 ActionListener-鼠标左键点击，空格

	方法
	actionPerformed

jtb.addActionListener(new MyActionListener());

 jtb.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("达咩~不要点我哟~");
            }
        });

打包代码

将所有代码打包成一个压缩包,jar后缀
jar包转换成exe安装包
将第二步的exe,图片,JDK整合在一起,变成最终的exe包