Java
配置环境
系统环境变量设置
| Name | Value |
|---|---|
| JAVA_HOME | D:/Environment/java/jdk-14.0.1 |
| CLASSPATH | ;%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar; |
| Path | %JAVA_HOME%/bin;%JAVA_HOME%/jre/bin; |
官方技术文档地址
IDEA 设置问题
在Project Structure中
- 需要在Project指定Project SDK，和文件编译输出路径
- 需要在Modules哪些可以标记为源码，仅被标记为源码的路径下右键可创建Java类文件
基础概述
HelloWorld
public class HelloWorld{
public static void main(String[] args){
System.out.println("HellWorld");
}
}
**注意文件名和类名需要保持一致
基础
注释
单行注释
//单行注释
多行注释
/*
多行注释
*/
文档注释
/**
文档注释
*/
**常用快捷键
| Ctrl+/ | 单行注释（对当前行进行注释） |
|---|---|
| Ctrl+Shift+/ | 对选中的代码多行注释 |
变量
- 需要先声明才能使用，
- 变量作用范围是当前代码块，同一个范围内不能重复声明同一个变量，
- 输出前需要给变量赋值。
ASCII表
| ASCII码值 | 控制字符 | 解释 | ASCII码值 | 字符 | 解释 | ASCII码值 | 字符 | 解释 | ASCII码值 | 字符 | 解释 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | NUT | 空字符 | 32 | (space) | 空格 | 64 | @ | 电子邮件符号 | 96 | ` | 开单引号 |
| 1 | SOH | 标题开始 | 33 | ! | 叹号 | 65 | A | 大写字母A | 97 | a | 小写字母a |
| 2 | STX | 正文开始 | 34 | “ | 双引号 | 66 | B | 大写字母B | 98 | b | 小写字母b |
| 3 | ETX | 正文结束 | 35 | # | 井号 | 67 | C | 大写字母C | 99 | c | 小写字母c |
| 4 | EOT | 传输结束 | 36 | $ | 美元符 | 68 | D | 大写字母D | 100 | d | 小写字母d |
| 5 | ENQ | 请求 | 37 | % | 美元符 | 69 | E | 大写字母E | 101 | e | 小写字母e |
| 6 | ACK | 收到通知 | 38 | & | 和号 | 70 | F | 大写字母F | 102 | f | 小写字母f |
| 7 | BEL | 响铃 | 39 | ‘ | 闭单引号 | 71 | G | 大写字母G | 103 | g | 小写字母g |
| 8 | BS | 退格 | 40 | ( | 开括号 | 72 | H | 大写字母H | 104 | h | 小写字母h |
| 9 | HT | 水平制表符 | 41 | ) | 闭括号 | 73 | I | 大写字母I | 105 | i | 小写字母i |
| 10 | LF | 换行键 | 42 | * | 星号 | 74 | J | 大写字母J | 106 | j | 小写字母j |
| 11 | VT | 垂直制表符 | 43 | + | 加号 | 75 | K | 大写字母K | 107 | k | 小写字母k |
| 12 | FF | 换页键 | 44 | , | 逗号 | 76 | L | 大写字母L | 108 | l | 小写字母l |
| 13 | CR | 回车键 | 45 | – | 减号/破折号 | 77 | M | 大写字母M | 109 | m | 小写字母m |
| 14 | SO | 不用切换 | 46 | . | 句号 | 78 | N | 大写字母N | 110 | n | 小写字母n |
| 15 | SI | 启用切换 | 47 | / | 斜杠 | 79 | O | 大写字母O | 111 | o | 小写字母o |
| 16 | DLE | 数据链路转义 | 48 | 0 | 字符0 | 80 | P | 大写字母P | 112 | p | 小写字母p |
| 17 | DC1 | 设备控制1 | 49 | 1 | 字符1 | 81 | Q | 大写字母Q | 113 | q | 小写字母q |
| 18 | DC2 | 设备控制2 | 50 | 2 | 字符2 | 82 | R | 大写字母R | 114 | r | 小写字母r |
| 19 | DC3 | 设备控制3 | 51 | 3 | 字符3 | 83 | S | 大写字母S | 115 | s | 小写字母s |
| 20 | DC4 | 设备控制4 | 52 | 4 | 字符4 | 84 | T | 大写字母T | 116 | t | 小写字母t |
| 21 | NAK | 拒绝接收 | 53 | 5 | 字符5 | 85 | U | 大写字母U | 117 | u | 小写字母u |
| 22 | SYN | 同步空闲 | 54 | 6 | 字符6 | 86 | V | 大写字母V | 118 | v | 小写字母v |
| 23 | TB | 结束传输块 | 55 | 7 | 字符7 | 87 | W | 大写字母W | 119 | w | 小写字母w |
| 24 | CAN | 取消 | 56 | 8 | 字符8 | 88 | X | 大写字母X | 120 | x | 小写字母x |
| 25 | EM | 媒介结束 | 57 | 9 | 字符9 | 89 | Y | 大写字母Y | 121 | y | 小写字母y |
| 26 | SUB | 代替 | 58 | : | 冒号 | 90 | Z | 大写字母Z | 122 | z | 小写字母z |
| 27 | ESC | 换码(溢出) | 59 | ; | 分号 | 91 | [ | 开方括号 | 123 | { | 开花括号 |
| 28 | FS | 文件分隔符 | 60 | < | 小于 | 92 | / | 反斜杠 | 124 | | | 垂线 |
| 29 | GS | 分组符 | 61 | = | 等号 | 93 | ] | 闭方括号 | 125 | } | 闭花括号 |
| 30 | RS | 记录分隔符 | 62 | > | 大于 | 94 | ^ | 脱字符 | 126 | ~ | 波浪号 |
| 31 | US | 单元分隔符 | 63 | ? | 问号 | 95 | _ | 下划线 | 127 | DEL | 删除 |
数据类型
| 数据类型 | 关键字 | 取值范围 | 内存占用 |
|---|---|---|---|
| 整数 | byte | -128~127 | 1 |
| 整数 | short | -32768~32767 | 2 |
| 整数 | int（默认） | -2147483648~2147483647（10位数） | 4 |
| 整数 | long | -9223372036854775808~9223372036854775807（19位） | 8 |
| 浮点数 | float | 1.401298e-45~3.402823e+38 | 4 |
| 浮点数 | double（默认） | 4.9000000e-324~1.797693e+308 | 8 |
| 字符 | char | 0-65535 | 2 |
| 布尔 | Boolean | true，false | 1 |
**整数、浮点数在赋值时，需要在值后标记，不标记赋值为默认类型
标识符和关键字
- 标志符由数字、字母、下划线（_）和美元（$）等组成
- 不能以数字开头、不能是关键字、区分大小写
- 标识符和类名遵守标识符规范，最好全英文，满足“驼峰模式”。
类型转换
自动类型转换
取值范围小类型的变量，可直接赋值给范围大的变量
**表达式中最终结果类型由表达式中最高类型决定
**表达式中，byte、short、char是直接（默认）转换为int类型参与运算。
强制类型转换
赋值时在变量前标注类型
//强制类型转换
public class Demo{
public static void main(String[] args){
int a =1500;
byte b = (byte)a;
System.out.println("HellWorld");
}
}
//运行结果为-36
- 强制换算超过取值范围会溢出
- 浮点型强制转换整型，会直接丢弃小数部分，保留整数部分返回。
运算符
基本运算符
| 符号 | 作用 |
|---|---|
| + | 加 |
| – | 减 |
| * | 乘 |
| / | 除 |
| % | 取余 |
**默认运算均为int类型
数据拆分案例
//拆分3位数，个位、十位、百位分别输出
public class Demo{
public static void main(String[] args){
int data =567;
int gewei= data % 10 ;
int shiwei = data / 10 % 10;
int baiwei = data / 100;
System.out.println(shiwei);
System.out.println(gewei);
System.out.println(baiwei);
}
}
加符号作为连接运算符
字符串参与运算时，加号为拼接符，其余参与运算符。
自增自减运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 自增 | 变量自身值增1 |
| — | 自减 | 变量自身值减1 |
自增自减运算符参与运算时放在变量前先自增自减再赋值，在后先赋值再自增自减。
//代码代换
public class Demo{
public static void main(String[] args){
int a = 10;
int b = ++a;
/*
int a = 10;
a = a + 1;
int b = a;
*/
int c = 10;
int d = c++;
/*
int c = 10;
int d = c;
c = c + 1;
*/
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
赋值运算符
扩展赋值运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| += | 加后赋值 | a+=b等价于 a = (a的数据类型)（a + b）；将a + b的值给a |
| -= | 减后赋值 | a-=b等价于 a = (a的数据类型)（a – b）；将a – b的值给a |
| *= | 乘后赋值 | a*=b等价于 a = (a的数据类型)（a * b）；将a * b的值给a |
| /= | 除后赋值 | a/=b等价于 a = (a的数据类型)（a / b）；将a / b的值给a |
| %= | 取余后赋值 | a%=b等价于 a = (a的数据类型)（a % b）；将a % b的值给a |
关系运算符
关系运算符为条件判断，成立为true，不成立为false，输出结果为Boolean类型。
| 符号 | 说明 |
|---|---|
| == | a==b,判断a和b是否相等 |
| != | a!=b，判断a和b是否不等 |
| > | a>b，判断a是否大于b |
| >= | a>=b，判断a大于等于b |
| < | a<b，判断a小于b |
| <= | a<=b，判断a小于等于b |
逻辑运算符
| 符号 | 介绍 | 说明 |
|---|---|---|
| & | 与 | 同true为true，其余为false |
| | | 或 | 有true为true，其余为false |
| ! | 非 | 结果取反 |
| ^ | 异或 | 不同为true，相同为false |
| 符号 | 介绍 | 说明 |
|---|---|---|
| && | 短路与 | 与“&”判断结果一致，但是左侧false右侧就停止运算（节省运算资源） |
| || | 短路或 | 与“|”判断结果一致，但是左侧true右侧就停止运算（节省运算资源） |
三元运算符
格式：条件表达式 ？值1 :值2；条件表达式为true返回值1，false返回值2，
//判断两值是否相等
//代码代换
public class Demo{
public static void main(String[] args){
int a=2,b=2;
String c;
c = a == b ? "相等" : "不等";
/*
int a=2,b=2;
String c;
boolean d;
d = a == b;
if (d == true) {
c = "相等";
}else {
c ="不等";
}
*/
System.out.println("两值" + c);
}
}
优先级问题
| 优先级 | 运算符 |
|---|---|
| 1 | () |
| 2 | !、-、++、– |
| 3 | *、/、% |
| 4 | +、- |
| 5 | <<、>>、>>> |
| 6 | <、<=、>、>=、instanceof |
| 7 | ==、!= |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | =、+=、-=、*=、/=、%=、&= |
API 介绍
API : Application Programming Interface应用程序编程接口；
调用导入对应包即可
//获取键盘输入内容
//判断两值是否相等
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
int a,b;
String c;
Scanner Sc = new Scanner(System.in);
System.out.println("输入一个数个数");
a = Sc.nextInt();
System.out.println("输入下一个数");
b = Sc.nextInt();
c = a == b ? "相等" : "不等";
System.out.println("两值" + c);
}
}
程序流程控制
分支结构
if
//if格式
public class Demo{
public static void main(String[] args){
/*true时执行后方代码块，false则跳过，执行一个代码块后结束，
if (条件表达式) {
语句体1;//
}else if(条件表达式) {
语句体2;
}
...
else{
语句体n+1;
}
*/
}
}
switch、switch穿透性
//switch格式
public class Demo{
public static void main(String[] args){
/*表达式匹配执行对应代码块，无匹配执行default代码块。
switch (表达式) {
case 值1:
执行代码1;
break;
case 值2:
执行代码1;
break;
...
case 值n-1:
执行代码n-1;
break;
default:
执行代码n;
}
*/
}
}
**当switch中case不写break会穿透，实现多值执行一个代码段，消除代码冗余。
循环结构
for循环
//for循环格式
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
/*满足条件执行循环语句，不满足结束循环体
for (初始化语句 ；循环条件 ；迭代语句) {
循环语句;
}
*/
//循环a次，a通过键盘输入。
Scanner Sc = new Scanner(System.in);
System.out.println("循环几次？");
int a = Sc.nextInt();
int a = 3;
for (int i = 0; i < a; i++){
System.out.println("hello world");
}
}
}
while循环
//while循环
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
/*满足条件执行循环语句，不满足结束循环体
初始化语句;
while (循环条件){
循环语句;
迭代语句；
}
*/
//循环a次，a通过键盘输入。
Scanner Sc = new Scanner(System.in);
System.out.println("循环几次？");
int a = Sc.nextInt();
int i = 0;
while (i < a){
System.out.println("hello world");
i++;
}
}
}
do-while循环
//do-while循环
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
/*先执行语句再判断是否进行循环
初始化语句;
do {
循环语句;
迭代语句；
} while (循环条件);
*/
//循环a次，a通过键盘输入。
Scanner Sc = new Scanner(System.in);
System.out.println("循环几次？（默认一次）");
int a = Sc.nextInt();
int i = 0;
do {
System.out.println("hello world");
i++;
} while (i < a);
}
}
**break; 结束当前所在循环执行。（只能在switch和循环中使用，不能单独用于if）
//break循环
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
//循环a次，a通过键盘输入。
Scanner Sc = new Scanner(System.in);
System.out.println("循环几次？最大为5次");
int a = Sc.nextInt();
int i = 1;
while (i <= a){
System.out.println("这是第" + i + "次重复hello world");
i++;
if ( i == 5) {
break;
}
}
}
}
**continue; 跳出当前循环的当次循环，进入下一次循环。
//continue循环
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
//循环a次，a通过键盘输入。
Scanner Sc = new Scanner(System.in);
System.out.println("循环几次？拒绝打印第5次");
int a = Sc.nextInt();
int i = 0;
while (i <= a){
i++;
if ( i == 5) {
continue;
}
System.out.println("这是第" + i + "次重复hello world");
}
}
}
随机数Random
//生成a组b长度的数字
import java.util.Random;
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
Random Number = new Random();
//a通过键盘输入。
Scanner Sc = new Scanner(System.in);
System.out.println("生成几组随机密码？");
int a = Sc.nextInt();
System.out.println("每组密码几位数？");
int b = Sc.nextInt();
for (int i = 0; i <= a; i++){
for (int j = 1; j <= b; j++){
int data = Number.nextInt( 10) ;
System.out.print(data);
}
System.out.println();
}
}
}
数组Array
数组定义，访问，注意事项
数组是用来存储一批同种类型数据的内存区域
静态初始化数组
定义
//完整格式
/*
数据类型[] 数组名 = new 数组类型[]{元素1,元素2,元素3,...};
*/
//简化格式
/*
数据类型[] 数组名 ={元素1,元素2,元素3,...};
*/
访问
//数组首位元素编号从0开始
//取值
System.out.println(arr[0]);
//赋值
arr[2] = 1 ;
System.out.println(arr[2]);
//获取数组的长度，数组的元素个数
System.out.println(arr.length);
**数组一但定义长度、类型就固定，访问超出最大个数位置，会报数组索引越界异常错误
**类型定义后，数组内不能存放其他类型数据
动态初始化数组
定义
/*
数据类型[] 数组名 = new 数组类型[长度];
*/
int[] arr = new int[10];
元素默认值
| 数据类型 | 明细 | 默认值 |
|---|---|---|
| 基本类型 | byte、short、char、int、long | 0 |
| float、double | 0.0 | |
| boolean | false | |
| 引用类型 | 类、接口、数组、String | null |
*两种初始化格式严格独立，不可混用
数组的遍历
格式
格式
for ( int i = 0; i < array.length ; i++ ){//遍历快捷键-数组名.fori
a = array[i] +a ;
}
//求a个数的平均数，a通过键盘输入。
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
//创建数组，并将每个数存入数组
Scanner Sc = new Scanner(System.in);
System.out.println("求几个数的平均数？");
int a = Sc.nextInt();
System.out.println("输入所有数字，回车间隔");
int[] array = new int[ a ];
for (int i = 0; i < a; i++ ) {
int b = Sc.nextInt();
array[i] = b ;
}
//计算数组所有元素的平均数
System.out.println("平均数：");
double c = 0;
for ( int i = 0; i < array.length ; i++ ){//遍历快捷键-数组名.fori
c = array[i] + c ;
}
/*代码代换
double c = 0;
for (int value : array) {
c = value + c;
}
*/
c = c / array.length;
System.out.println(c);
//遍历数组取出最高值
System.out.println("最大值为：");
int d = array[0];
for ( int i = 0; i < array.length ; i++ ){
if ( d < array[i]){
d = array[i];
}
}
System.out.println(d);
}
}
冒泡排序
每次从数组中找出最大值，最大的元素向后移动
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
//创建数组，并将每个数存入数组
Scanner Sc = new Scanner(System.in);
System.out.println("几个数排序？");
int a = Sc.nextInt();
System.out.println("输入所有数字，回车间隔");
int[] array = new int[ a ];
for (int i = 0; i < a; i++ ) {
int b = Sc.nextInt();
array[i] = b ;
}
//冒泡排序
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - i - 1; j++) {
if (array[j] > array[j+1]){
int temp = array[j+1];
array[j+1] = array [j];
array[j] = temp;
}
}
}
//遍历输出数组中元素
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + "/t");
}
}
}
数组与内存的存储的关系
数组内容是存在堆内存内，数组变量中存储的是内容的类型和内存地址
**访问超出最大索引时，会报数组索引越界异常错误ArraylndexOutOfBoundsException，程序会在越界处报错结束。
**如果数组变量中没有存储数组的地址，而是null,在访问数组信息时会出现NullPointerException(空指针异常)
Debug工具
启用断点后可逐行执行代码
方法Method
方法的定义
/*方法格式
修饰符 返回值类型 方法名(形参列表){
方法体代码（需要执行的代码）
return 返回值;
}
*/
//示例,加法器
public static int add (int a, int b ){
int c = a + b;
return c;
}
//调用 方法名(传入参数)
int data = add( 10 , 20 );
**无返回值，无参数方法调用
public static void 方法名(){
System.out.print("hello world!");
}
**方法与方法直接是平行关系，不能嵌套定义
**方法的返回类型为void时，方法内不能使用return返回数据，如果方法的返回值写了具体类型，防范内部必须使用return对应的类型数据
**return语句下方代码不执行，属于无效代码；
**方法不调用时不执行，调用时必须严格匹配方法的参数情况；
**方法返回值可以定义变量接收，也可以直接输出调用，无返回值方法只能直接调用。
方法的内存原理
** 方法在栈内存运行，方法先进后出
方法参数传递机制
基本类型的参数传递
传输实参给形参时，不是传输实参变量本身，而是将实参变量中储存的值，这就是值传递。
**实参：方法内部定义的变量
**形参定义方法时，”()”中声明的参数
引用类型的参数传递
引用传递时，传递的是引用的堆内存地址
方法重载
同一个类中，出现多个方法名称相同，但是形参列表不同，那么这些方法就是方法重载。
**只要时同一个类中，方法名称相同，形参列表不同，即是方法重载（不考虑如：修饰符，返回值类型等）
**形参列表不同指的是形参的个数、类型、顺序不同，不是形参的名称
return关键字
当单独在时，可以跳出当前执行的方法，并直接结束该方法。
案例
随机密码生成
业务需求：需要根据键盘键入数据确定生成几组多长的随机字符串
package src;
//求a个数的平均数，a通过键盘输入。
import java.util.Random;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
//创建数组，并将每个数存入数组
Scanner Sc = new Scanner(System.in);
System.out.println("随机几位密码？");
int a = Sc.nextInt();
System.out.println("随机几组？");
int b = Sc.nextInt();
for (int i = 0; i < b ; i++) {
System.out.println(Randombytes(a));
}
}
//生成一组随机字符
public static String Randombytes(int HowLong) {
Random RandomNumber = new Random();
String Codes = "";
for (int i = 0; i < HowLong; i++) {
int type = RandomNumber.nextInt(3);
switch (type) {
case 0:
char ch = (char) (RandomNumber.nextInt(26) + 65);//随机出一个大写字母
Codes += ch;
break;
case 1:
char ch1 = (char) (RandomNumber.nextInt(26) + 97);//随机出一个小写字母
Codes += ch1;
break;
case 2:
Codes += RandomNumber.nextInt(10);//随机出一位阿拉伯数字
break;
}
}
return Codes;
}
}
数组的复制
public static void CopyArrs(int[] arr1,int[] arr2){
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
}
双色球系统开发
业务需求：生成一组7位随机数，组内数据不重复，和一个单独数
import java.util.Random;
public class Demo {
public static void main(String[] args) {
//输出一组双色球彩票
System.out.println("本次双色球号码为：");
for (int i = 0; i < 6; i++) {
System.out.print(CreateLuckNumbers(6) [i] +"/t");
}
System.out.println();
System.out.println("幸运号码是：");
Random RandomNumber = new Random();
int RN = RandomNumber.nextInt(33) + 1;
System.out.println(RN);
}
//生成一个HowLong长度的双色球数
public static int [] CreateLuckNumbers(int HowLong) {
Random RandomNumber = new Random();
int[] arr = new int[HowLong];
for (int i = 0; i < arr.length; i++) {
int RN = RandomNumber.nextInt(33) + 1;
boolean flag =true;
for (int j = 0; j < arr.length; j++) {
if (arr[j] == RN){
flag =false;
i -= 1;
break;
}
}
if (flag){
arr [i] = RN;
}
}
return arr;
}
}
面向对象编程基础Object Oriented Programming
概述
需要创建一个东西后再进行编程，这个东西就是对象
设计对象、注意事项
**先设计类才能创建对象并使用
类：是对象的共同特征的描述。
对象：是真实存在的具体实例。
//设计类
public class 类名 {
1.成员变量（代表属性，一般是名词）
2.成员方法（代表行为，一般是动词）
3.构造器
4.代码块
5.内部类
}
//如何创建类
类名 对象名 = new 类名();
//使用对象
//访问属性
对象名.成员变量；
//访问行为
对象名.方法名(...)；
**类名首字母大写，满足“驼峰模式”，不能用关键字，必须是合法标识符，且有意义
**一个Java文件可以定义多个class类，但是只能有一个是public修饰，且public修饰的类名必须为文件名
**成员变量完整定义格式是：修饰符 数据类型 变量名 = 初始化值；
一般无需指定初始化值，默认规则为
| 类型 | 默认值 |
|---|---|
| byte、short、int、long | 0 |
| double、folat | 0.0 |
| boolran | false |
| String等引用类型 | null |
内存机制
**对象存在于堆内存中，创建引用时，变量名内存储的时对象在堆内存中的地址
垃圾回收机制
当堆内存中引用对象不存在任何内存引用它时（栈内存引用这个对象的变量引用地址设置为null），Java会自动清除堆内存地址内数据.
int[] arr = new int [10];//在堆内存中创建一个长度为10的数组空间，引用为arr
arr = null;//arr堆内存引用地址设置为null；Java会自动释放堆该地址内存
构造器Constructor
//创建构造器
修饰符 类名(形参列表){
...
}
//调用构造器
类名 变量名称 = new 构造器;
**无参数构造器初始化时，成员变量数据均采用默认值
**有参数构造器在初始化对象时，同时接受参数为对象进行赋值
**一个类中默认自带无参数构造器，一但定义有参数构造器，无参数构造器就不存在了，如果还想使用无参数构造器，需要单独手写一个
this关键字
**this可用于构造器，方法中，代表当前对象地址。
this.变量名//引用当前构造器中的变量值
封装
private//私有修饰词，修饰的变量只能在本类中，不能在其他类中被引用和赋值
public//修饰的setter和getter方法来获取值和赋值
标准JavaBean
即为实体类，其对象可以用于在程序中封装数据
** 成员变量必须使用private修饰
**提供成员变量的对应的getter /setter方法
**必须提供一个无参构造器，（有参构造器可有可无）
常用API
String
String被称为不可变字符串类型，他的对象创建后不可被更改
**运算时只是定义的String变量储存的引用地址发生变化，指向新的字符串储存地址，以””方式直接给出的字符串对象，在字符串常量池中储存，而且相同的值储存一次
**通过构造器new出来的对象，每new一次都会产生一个新对象存在堆内存中
**String进行比较时使用equias方法进行比较，只要内容一致即返回true（String变量名.equias(要比较的String变量名)）
String a1 = "我";
String a2 = "爱";
String a3 = "中";
String a4 = "国";
String a5 = "我爱中国";
String a6 = a1 + a2 + a3 + a4;
System.out.println(a6);
System.out.println(a5 ==a6);//false,比较两个字符串变量的引用地址
System.out.println(a5.equals(a6));//ture
String常用API
| 方法名 | 说明 |
|---|---|
| public int length() | 返回字符串长度 |
| public char charAt(int index) | 获取某个索引位置处的字符 |
| public char[] toCharArray(): | 将当前字符串转换成字符数组返回 |
| public String substring(int beginIndex，int endIndex) | 根据开始和结束说因进行截取，得到新的字符串（包前不包后） |
| public String substring(int beginIndex) | 从传入的索引出截取，截取到末尾，得到新的字符串 |
| public String replace(CharSequence target, CharSequence repalcement) | 使用新值，将字符串中的旧值替换，得到新的字符串 |
| public String[] split(String regex) | 根据传入的规则切割字符串，得到字符串数组返回 |
String案例
验证码
//用字符串遍历法设计一个验证码生成器
import java.util.Random;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner Sc = new Scanner(System.in);
System.out.println("取多长的字符串？");
int a = Sc.nextInt();
System.out.println(CAPTCHA(a));
}
//生成一个包含0-9，a-z,A-Z的HowLong长度的验证码
public static String CAPTCHA(int HowLong) {
String db = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
Random r =new Random();
String codes = "";
int a = HowLong;
for (int i = 0; i < a; i++) {
int index =r.nextInt(db.length());//获取字符串长度，并随机出比长度小的值index
char c = db.charAt(index);//获取index位置的字符
codes += c;
}
return codes;
}
}
ArrayList
集合长度不固定，启动后可以动态变化，类型也可以选择不固定，
ArrayList常见功能
创建一个ArrayList对象
ArrayList list = new ArrayList()
添加元素
list.add("Java");
list.add("MySQL");
list.add("中国");
指定索引位置插入元素(指定位置开始元素后移)
list.add(1,"世界");
System.out.println(list);
ArrayList对泛型的支持
ArrayList
ArrayList<String>//只操作字符串类型的元素
ArrayList<Integer>//只操作整数类型的元素
集合只能存储引用类型，不支持基本类型（int和Integer是存在区别的，集合中不可使用int类型）
**默认泛型为String，如果希望所有数据类型都支持，泛型要标注为Object。
ArrayList常用API
| 方法名称 | 说明 |
|---|---|
| public E get(int index) | 返回某个位置处的索引 |
| public int size() | 返回集合中元素个数 |
| public E remove(int index) | 删除某个索引处的元素，返回被删除的元素 |
| public boolen remove(Object o) | 删除指定元素，返回删除是否成功 |
| public E set(int index,E element) | 修改索引处的元素返回被修改的元素 |
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList();
list.add("Java");
list.add("Java");
list.add("MySQL");
list.add("MyBatis");
list.add("Html");
//1.获取某个索引处的元素值
System.out.println(list);
System.out.println(list.get(2));
//2.获取集合的大小
System.out.println(list.size());
//3.删除某个索引处的元素，并返回这个元素
System.out.println(list.remove(0));
System.out.println(list);
//4.删除指定某个元素，返回是是否删除成功，如果有多个元素，默认删除索引值小的
System.out.println(list.remove("Java"));
//5.集合遍历
for (int i = 0; i <list.size() ; i++) {
System.out.println(list.get(i));
}
//一般使用倒着遍历,避免寻址溢出
for (int i = list.size() - 1; i >= 0 ; i--) {
System.out.println(list.get(i));
}
//修改索引处的元素返回被修改的元素
System.out.println(list.set(0, "if"));
}
}
案例
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/282685.html