IDEA使用说明
创建项目
1.创建空项目
2.创建新模块
3.在模块的src下创建一个包
4.在包下新建java类
生产项目时的class文件在out项目文件out下
项目结构
项目(project)>模块(module)>包(package)>类(class)
内容辅助键和快捷键
快速生成语句：
psvm,回车：快速生成main() 方法
sout,回车：快速生成输出语句
快捷键：
Ctrl+/ : 选中单行代码，然后注释掉
Ctrl+Shift+/ : 选中多行代码，然后注释掉
Ctrl+Alt+/:代码形式格式化
Ctrl+Alt+V:对象调方法时能快速生产等号左边内容（eg:String line=sc.nextLine()）
fn/alt+insert：快速生成构造，get，set方法
Ctrl+B：看方法源码，或者选中方法右键"go to"
模块操作
1.新建模块 :文件->项目结构
2.删除模块 :编辑器内删除模块只是删除项目结构上的模块而不是删除硬盘上文件
3.导入模块 :文件->项目结构->模块->+->导入模块
右键"在Explorer中展示"可以快速打开模块所在目录
Debug
提供程序员使用的程序调试工具，查看程序执行流程，追踪程序执行过程
操作流程：
1.加断点：行号后边区域单击
2.运行加了断点的程序：代码区域右键“调试.......”
3.看：看调试(debug)窗口,和控制台(console)窗口
4.点：按下箭头或者F7进一步调试，红色方块终止调试
5.删除断点：两红色圈案件，选中然后点“-”
当debug过程中需要键盘输入时，一定要输入数据，否则无法继续向下查看
Tips
System.out.println("content");输出内容并换行
System.out.print("content");输出内容不换行
System.out.println();起到换行作用
System.exit(0)Java虚拟机即jvm退出，程序终止
3."\t"这个符号其实就是tab键
4.在1个集合类中快速找方法
view->structure(快捷键alt+7)
JDK,JRE,JVM作用和关系
jvm: jvm(java虚拟机)使得java在windows，macos和Linux等不同操作系统上都可以运行
jre：java运行时环境，包含jvm和运行时需要的核心类库，所以运行已有java程序，只需要jre即可
jdk：java程序开发工具包，包含jre和开发工具(javac.exe,java.exe)
jdk11目录
bin:存放jdk的各种工具命令，包括javac和java
conf：jdk相关配置文件
include：一些平台特定头文件
jmods：jdk的各种模块
legal：jdk各模块授权文件
lib：jdk工具和一些补充的jar包
常用dos命令
8大常用命令
1.盘名称： （ 进入某磁盘）
2.dir （ 查看当前路径下目录）
3.cd 目录（进入单级目录）
4.cd.. （回退一级目录）
5.cd 目录1\目录2...（进入多级目录）
6.cd \（回退到盘目录）
7.cls（清命令窗）
8.exit（退出命令窗口）
上下箭头可以切换使用过的命令
JAVA语法
注释
单行注释：//注释信息
多行注释: / * 注释信息 * /
文档注释：/ ** 注释信息 */
关键字
特点：关键字字母全部小写，且编辑器会有特殊颜色注释，总数大概50个左右
常量
程序运行始终数值不可发生改变
字符串常量：双引号内内容 eg："邵子朋"
整数常量:不带小数数字 eg：-88
小数常量：带小数数字 eg：12.14
字符常量：单引号内内容 eg：'A'，'我'
布尔常量:真假布尔值 eg：true，false
空常量：一个特殊的空值 eg：null
空常量不可以直接输出，其他都可以
原因:
数据类型
基本数据类型
数值型
整数:byte,short,int,long(整数默认为int类型所以定义long类型时:long b=10000000L)
浮点数:float,double(浮点数默认为double类型所以定义float类型时:float c=13.14F)
字符:char
非数值型
布尔:boolean
引用数据类型
类:class
接口:interface
数组:[]
变量
本质上说，变量是内存上的一小块区域
定义格式：数据类型 变量名=变量值；(变量名不能重复，定义的同时一定要赋值)
使用方式：
取值格式：变量名；
修改值格式：变量名=变量值；
标识符
与数字，字母，下划线和美元符组成
不能以数字开头
不能是关键字
区分大小写
小驼峰命名发(针对方法变量)
标识符是一个单词时，首字母小写 eg:name
标识符由多个单词组成，第一个单词首字母小写，其余首字母大写 eg:firstName
大驼峰命名发(针对类)
标识符是一个单词时，首字母大写 eg:Student
标识符由多个单词组成，每个单词首字母都大写 eg:GoodStudent
类型转换
自动类型转换:把一个范围小的数值或者变量赋值给另一个表示数据范围大的变量
eg: double d=10
double>float>long>int>short>byte
double>float>long>int>char(char型的值不可以赋给short或byte)
强制类型转换:把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
eg:int k=(int)88.88;
格式: 目标数据类型 变量名=(目标数据类型)值或者变量;
运算符
算术运算符
+加
-减
*乘
/除
%取余
整数相除只能得到整数，要想有小数需要有浮点数参与
字符的'+'操作
字符可以和整数相加，字符对应的计算机底层数值分别为
'A'到'Z' 65起步
'a'到'z' 97起步
'0'到'9' 48起步
算术表达式中包含多个基本数据类型时，整个算术表达式的类型会自动提升
byte,short,char->int->long->float->double
字符串的'+'操作
1.当'+'操作左右出现字符串时，这个'+'时字符串连接符，而不是算术运算符；
2.当'+'操作左右没有出现字符串，就是算术运算符；
3.从左到右依次运算；
eg:"itheima"+6+66 ->itheima666; 6+66+"itheima" -> 72itheima;
赋值运算符
= 赋值号
a+=b 将a+b的值给a 以下五种扩展的赋值运算符隐含了强制类型转换功能
a-=b 将a-b的值给a
a=b 将ab的值给a
a/=b 将a/b的值给a
a%=b 将a%b的值给a
自增自减运算符
i++后加 ++i前加；i--后减 --i前减；
参与操作时，符号在变量后边，先拿变量参与操作，再拿变量+或-
参与操作时，符号在变量前边，先拿变量+或-，再拿变量参与操作
关系运算符
关系运算符的结果都是boolean类型(true or false)
逻辑运算符
基本逻辑运算符
a&b 逻辑与 有false则false(左右都执行)
a|b 逻辑或 有true则true(左右都执行)
a^b 逻辑异或 相同为false不同为true
!a 逻辑非 与a结果相反
短路逻辑运算符
&& 短路与 ；左边为真，右边执行，左边为假，右边不执行
|| 短路或；左边为假，右边执行，左边为真，右边不执行
三元运算符
格式：关系表达式？表达式1：表达式2；
eg: a>b?a:b; 表达式值为true，a为结果，表达式结果为false，b为结果
数据输入
Scanner使用的基本步骤
1.导包
import java.util.Scanner;
2.创建对象
Scanner sc=new Scanner(System.in);
3.接收数据
int i=sc.nextInt();
分支语句
流程控制
分类：顺序结构，分支结构(if,switch)，循环结构(for,while,do...while)
if语句
格式1
if(关系表达式){
语句体;
}
格式2
if(关系表达式){
语句体1;
}else{
语句体2;
}
格式3
if(关系表达式1){
语句体1;
}else if(关系表达式2){
语句体2;
}
...
else{
语句体n+1;
}
switch语句
格式
switch(表达式){
case 值1：
语句体1；break；
case 值2：
语句体2；break；
...
default:
语句体n+1;[break;]
}
表达式的值可以是byte,short,int,char,String
break用来中断和结束switch语句
default表示所有情况不匹配时，就执行该处内容
循环语句
for循环语句
格式
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
执行顺序：初始化语句->条件判断语句->循环体语句->条件控制语句（注意条件控制语句最后执行）
求水仙花数
1.求数指定位上的数值(个，十，百...)：使用整除操作将要求的数字移动到个位上，再取余操作取出个位上的数值
2.水仙花数指数的各位立方和等于原数
public class NarNumber{
public static void main(String[] args){
for(int i=100;i<1000;i++){
int ge=i%10
int shi=i/10%10
int bai=i/10/10%10
if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
System.out.println(i);
}
}
}
}
再for循环结构内定义的i，在除了for循环之后无法使用
for(;;){}->死循环
while循环语句
格式
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
执行顺序：初始化语句->条件判断语句->循环体语句->条件控制语句
while(true){}->死循环
do..while循环语句
格式
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
执行顺序：初始化语句->循环体语句->条件控制语句->条件判断语句
do{}while(true){}->死循环
跳转控制语句
continue：用在循环中，基于条件控制，跳过某次循环体的内容执行，继续执行下一次操作
break：用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
Random使用
1.导包
import java.util.Random;
2.创建对象
Random r=new Random();
3.接收数据
int number=r.nextInt(10);//获取数据范围:[0,10)
猜数字
猜一个随机数字并给提示
public class RandomTest{
public static void main(String[] args){
Random r=new Random();
int number=r.nextInt(100)+1;
while(true){
Scanner sc=new Scanner(System.in);
System.out.println("请输入猜测数字：")
int guessNumber=sc.nextInt();
if(guessNumber>number){
System.out.println("猜测数字"+guessNumber+"大了") ;
}else if(guessNumber数组
定义
存储多个相同类型数据的存储模型
格式
格式一：数据类型[ ] 变量名
eg： int[] arr
定义一个int类型数组，数组名为arr（推荐）
格式二：数据类型 变量名[]
eg： int arr[]
定义一个int类型变量，变量名为arr数组
初始化
动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[ ] 变量名=new 数据类型[数组长度]
eg： int[] arr=new int[3]
/* 左边：int：说明数组中的元素类型是int
[ ]：说明这是一个数组
arr：这是数组的名称
右边：new：为数组申请内存空间
int：说明数组中的元素类型时int
[ ]：说明这是一个数组
3：数组长度，其实就是数组中元素个数
静态初始化：初始化时指定每个数组元素初始值，由系统决定数组长度
格式：数据类型[ ] 变量名 =new 数据类型[ ]{数据1，数据2，数据3......};
eg: int[ ] arr=new int[ ]{1,2,3};
简化格式：数据类型[ ] 变量名 = {数据1，数据2，数据3......};
eg: int[ ] arr={1,2,3};
数组元素访问
数组变量访问方式： 数组名 eg:arr
数组内部保持数据的访问方式： 数组名[索引] eg:arr[0]
内存分配
红框代表栈内存：
存储局部变量，即定义在方法中的变量(eg:arr)，使用完毕，立即消失
篮框代表堆内存：
存储new出来的内容(实体，对象)数组在初始化时，会为存储空间添加默认值。
(整数0，浮点数0.0，布尔false，字符空字符，引用数据类型null)。
每一个new出来的东西都有一个地址值，使用完毕，会在垃圾回收器空闲时被回收。
ps
int[] arr2=arr;
则两个数组内存地址一致，指向同一块内存存储空间，修改任意1个数值同时修改2个数组的数值
数组操作常见问题
索引越界：访问了数组中不存在的索引对应元素
空指针异常：修改了数组的内存地址 eg:arr=null
数组常见操作
1.遍历:用循环结构，且先获取数组元素数量(数组名.length)
int[ ] arr={.......}
for(int x=0;x2.获取最值
int[] arr={.......}
int max=arr[0];
for(int x=1;xmax){
max=arr[x];
}
}
System.out.println(max);
方法
定义：将独立功能的代码块组织为一个整体的代码集
方法定义和调用
方法定义：方法必须先创建才可以使用
格式：
public static void 方法名(){
方法体
}
方法调用：创建后不是直接运行，需要手动使用
格式：
方法名();
eg:isEvenNumber();
带参数方法定义和调用
方法定义：定义时数据类型和变量名都不能缺少，多个参数间用","分隔
单个参数
public static void 方法名(数据类型 变量名){......}
eg:public static void isEvenNumber(int number){......}
多个参数
public static void 方法名(数据类型 变量名1 ,数据类型 变量名2,......){......}
eg:public static void isEvenNumber(int number1,int number2){......}
方法调用:参数的数量与类型必须与方法定义中的设置相匹配
单个参数
方法名(变量名/常量值)
eg:isEvenNumber(5)；
多个参数
方法名(变量名1\常量值1 ,变量名2/常量值2);
eg:getMax(5,6);
形参和实参
形参：方法定义中的参数
实参：方法调用中的参数
带返回值方法的定义和调用
方法定义：return后面的返回值要和方法定义上的数据类型匹配，否则程序报错```
public static 数据类型 方法名(参数){
return 数据；
}
eg:public static boolean isEvenNumber(int number){
return false;
}
方法调用：返回值通常都用变量接收，否则返回值将无意义
格式1
方法名(参数)；
isEvenNumber(5);
格式2
数据类型 变量名=方法名(参数)；
boolean flag=isEvenNumber(5);
方法注意事项
1.方法之间是平级的，不可以嵌套定义
2.void表示无返回值，可以省略return，如果要写return后面不能写任何内容，且return要为方法的最后一行
方法重载
多个方法在一个类中
多个方法具有相同的方法名
多个方法参数不相同，类型不同或者数量不同
=>多个方法之间构成方法重载
特点
仅针对方法的定义，和方法调用无关
仅针对同一个类中方法的名称和参数进行识别，与返回值无关，不能通过返回值来判断连个方法是否相互构成重载
public static void fn(int a){ }
public static int fn(int a){ }
2方法不重载
public static float fn(int a){ }
public static int fn(int a,int b){ }
2方法重载
public static boolean fn(int a,int b){ return a==b;}
public static boolean fn(byte a,byte b){ return a==b;}
调用1方法：fn(a,b);//整数默认为int类型
调用2方法：fn((byte)a,(byte)b);
方法的参数传递
基本类型
方法change()中形式参数的值的改变不影响main()中number的值，所以两次都输出100
引用类型
修改的是arr数组的值，针对的是存储在堆内存中数据的值
类和对象
对象：万事万物皆可为对象
类：对现实生活中一类具有共同属性和行为的事物的抽象（类是对象的数据类型，类具有相同属性和行为的一组对象集合）
对象的属性：每个对象每个属性拥有的特定的值
对象的行为：对象能够执行的操作
对象和手机类关系：类是对象的抽象，对象是类的实体
eg:类：手机，对象：小米手机、华为手机
类的定义
类是java程序的基本组成单位
定义格式
public class 类名{
//成员变量
数据类型 变量1;
数据类型 变量2；
......
//成员方法
方法1；
方法2；
}
eg:
public class Phone{
String brand;
int price;
public void call(){};
public void sellMessage(){};
}
对象的使用
创建对象
格式
类名 对象名 = new 类名();
eg: Phone p =new Phone();
使用对象
使用成员变量格式
对象名.变量名
eg: p.brand
使用成员方法格式
对象名.方法名()
eg: p.call()
内存执行流程
单个对象
接下来调用Student类中的study方法，调用完成后退栈，doHomework方法同理，最后main方法也退栈。
多个对象指向相同
因为s1地址值赋值给s2，所以二者指向同一块堆内存空间
成员变量和局部变量
成员变量：
类中方法外的变量
处于堆内存
随着对象的存在而存在，消失而消失
有默认的初始化值
局部变量：
方法中的变量，或方法声明上变量
处于栈内存
随方法调用存在而存在，消失而消失
没有默认初始值，先定义赋值才能使用
封装
概述：面向对象三大特征之一(封装、继承、多态)
原则：将类信息隐藏在类内部，不允许直接访问，而是通过该类提供的方法来实现访问和操作
优势：代码安全性，复用性提高
private关键字
增加安全性，避免错误输入
修饰成员变量和方法，被修饰成员只有在本类中才能被访问
eg:private int age
其他类想要使用，要在变量所在类中写相应的方法
"get变量名()"方法，获取成员变量值,方法用public修饰
eg:public int getAge(){return age;}
"set变量名(参数)"方法，设置成员变量值,方法用public修饰
eg:public void setAge(int a){age=a;}
this关键字
修饰的变量用于指代成员变量,用来解决局部变量隐藏成员变量
- 方法的形参如果与成员变量同名，不带this指的是形参，带this指的是成员变量
- 方法的形参如果与成员变量不同名，不带this指的是成员变量
private String name;
public String setName(String a){//不同名
name=a
}
public String setName(String name){//同名
this.name=name
}
方法被哪个对象调用，this就代表哪个对象
this内存原理
构造方法
特殊方法，来创建对象，可以重载
类中无构造方法，则系统自动给出无参构造方法(最好自己写出来)
如果定义了带参构造方法，还要使用无参构造方法，则要再写一个无参构造方法
格式：
public class 类名{
修饰符 类名(参数){
}
}
eg: public class Student{
public Student(){......}
public Student(String name,int age){......}
}
调用：Student s1 = new Student();
Student s2 = new Student(...,...);
字符串
API
API：Application Programming Interface 应用程序编程接口
灵活使用说明文档，查找构造方法和使用方法
String
String类代表字符串，java程序中所有的双引号字符串，都是String类对象
字符串特点
不可变，值在创建后不能被更改
String的值不可变，但是它们可以被共享
底层原理是字节数组byte[]
构造方法
public String()//创建一个空白字符串对象，不含任何内容
eg:String s1 = new String();
public String(char[ ] chs)//根据字符数组的内容，来创建字符串对象
eg:char[ ] chs ={'a','b','c'};
String s2 = new String(chs);
public String(byte[ ] bys)//根据字节数组的内容，来创建字符串对象
eg:byte[ ] bys ={97,98,99};
String s2 = new String(bys);
String s="abc"//直接赋值的方式创建字符串对象，内容就是abc(推荐)
eg:String s4="abc";
String对象特点
- 用new方式创建的字符串对象，每次new都会申请一个内存空间，即使内容相同但是地址值不同
-
以""方式给出字符串，如果字符串内容相同，那么无论出现几次，都指挥创建一个String对象(1个内存空间)
QQ图片20210117165354.png
字符串操作方法
1.==符号
- 对基本类型：比较数据值是否相同 eg: arr[1],arr[2]
- 对引用类型：比较地址值是否相同 eg: arr1,arr2
2.public boolean equals(Object)方法：只比较两字符串数据
某字符串调用该方法和另一字符串进行比较(eg:arr1.equals(arr2))
3.public char charAt(int index)方法：返回指的索引处char值(从0开始)
eg：s.charAt(i);
3.public char length()方法：返回字符串长度
eg：s.length();
StringBuilder
作用：对字符串拼接操作，每次拼接都会有一个新的String对象，耗时、浪费空间且不可避免，而StringBuilder类可以解决这一问题。
String内容不可变，StringBuilder内容可变
构造方法
public StringBuilder()创建一个空白可变字符串对象，不含任何内容
eg:StringBuilder sb = new StringBuilder();
public StringBuilder(String str)根据字符串内容创建可变字符串对象
eg:StringBuilder sb = new StringBuilder("hello");
添加方法
public StringBuilder append(任意类型)添加数据并返回对象本身
对象本身还可以继续调方法
StringBuilder sb = new StringBuilder();
sb.append("hello");
sb.append("world");
sb.append(100);//sb输出结果为helloworld100
<=>sb.append("hello").append("world").append("100");
反转方法
public StringBuilder reverse()返回相反的字符序列
eg:sb.reverse()
String和StringBuilder相互转换
StringBuilder转换为String
public String toString()通过toString()方法
StringBuilder sb=new StringBuilder("hello");
String s=sb.toString();
String转换为StringBuilder
public StringBuilder(String s)通过构造方法实现转换
String s="hello";
StringBuilder sb=new StringBuilder(s);