目录
一. 注释
注释是对代码的一种解释,在程序 的指定位置, 添加的一些说明性信息被注释掉的内容, 不会参与程序的编译和运行.
分类:
单行: // 注释信息
多行: /* 注释信息 */
文档: /** 注释信息 */二. 关键字
Java语言中有特殊含义的单词，就是关键字。
关键字的特点： 1.全都是小写字母组成的 2.关键字被高级的代码编辑工具(idea)有特殊的颜色标记。
例如: 上图在idea中橙色标记的, public class static void int ... 等.
三. 自变量(常量)
在程序执行过程中其值不会发生改变的量。
//1.字符串常量： 用双引号括起来的内容
System.out.println("hello");
//2.字符常量：用单引号括起来的内容
System.out.println('a');
//3.整数常量：所有整数
System.out.println(666);
//4.小数常量：所有的小数
System.out.println(3.14);
//5.布尔常量：只有true(真)和false(假)
System.out.println(true);
//6.空常量: null,空常量不能直接输出四. 变量
变量是内存中的一小片空间，空间中存储的数据可以在某个范围内发生改变。
变量的定义格式:
数据类型 变量名 = 初始值;
//定义int类型的变量，赋值为10
int a=10;
System.out.println(a);
//定义short类型变量，赋值为5
short b=5;
System.out.println(b);
//定义double类型变量，赋值为3.14
double c=3.14;
System.out.println(c);
//定义boolean类型变量，赋值为true
boolean d=true;
System.out.println(d);
//定义char类型变量，赋值为'a'
char s='a';
System.out.println(s);
//定义long类型的变量，需要加后缀L <===
long m=8888888888L;
System.out.println(m);
//定义float类型的变量，需要加后缀F <===
float f=3.14F;
System.out.println(f);注意事项:
1.定义long类型的变量，必须加后缀L
2.定义float类的变量，必须加后缀F
3.可以在一行定义多个同类型的变量
int x=3,y=4;
System.out.println(x);
System.out.println(y);
4.变量没有初始值，不能直接使用。
5.变量的名称不同相同五. 标志符
自己给变量, 类起的名字都是标识符
规则 (必须要遵守): 1. 26个英文字母(大小写都可以) 2. 数字0~9 3. _ $ 要求: 1. 不能以数字开头 2. 不能是关键字 3. 严格区分大小写 规范(江湖规矩) 1. 小驼峰命名法 (变量) 如果是一个单词, 所有字母小写 age 如果是多个单词, 从第二个单词开始, 首字母大写 maxAge 2. 大驼峰命名法 (类) 如果是一个单词, 首字母大写 Student 如果是多个单词, 每个单词首字母大写, GoodStudent
六. 基本数据类型
四类八种:
整数:
byte 1个字节
short 2个字节
int 4个字节
long 8个字节
小数:
float 4个字节
double 8个字节
字符:
char 2个字节
布尔:
boolean 1个字节
七. 引用数据类型
在Java中除了8种基本数据类型外，其他数据类型全部都是引用（reference）数据类型，引用数据类型用来表示复杂数据类型。
引用数据类型：有类，接口，数组等。
Scanner(键盘录入)举例以理解：
Java中的引用数据类型,作用于键盘录入. (通俗解释: 就是在程序运行时, 在控制台利用电脑键盘输入,所需要的对象)
// 1. 导包
import java.util.Scanner;
// 2. 创建键盘录入对象
Scanner sc = new Scanner(System.in);
// 3. 接收键盘录入的数据(键盘输入的是什么类型, 就创建什么类型进行接收录入数据)
int age = sc.nextInt();例如:
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
// 2. 创建一个键盘录入对象
Scanner sc = new Scanner(System.in);
// 友好提示:
System.out.println("请输入一个整数: ");
// 3. 键盘录入一个int类型的数据,并用int类型的变量 num 接收数据.
int num = sc.nextInt();
// 4. 打印输出数据
System.out.println("你输入的值是: "+num);
}
}
Random(随机数)
随机生成一定范围的随机数.
格式:
Random r=new Random(); int num = r.nextInt(n)+m; n: 生成随机数的个数(就是在这个随机数范围中, 满足条件的数有几个); m: 生成随机数时,起始值; 例如: 生成 [58~75]之间的随机数
n : 18 (58到75之间有几个数);
// 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 (18个)
m : 58(随机数从58开始);
即:
Random r=new Random();
int num = r.nextInt(18)+58; 例如:
// 1. 导包
import java.util.Random;
public class Demo {
public static void main(String[] args) {
// 2.创建Random对象
Random r=new Random();
// 3.生成指定范围的随机数 生成[70,100]范围内的随机数 包含70包含100
int num = r.nextInt(31)+70;
System.out.println(num);
}
}八. 运算符
算数运算符
+ - * : 没啥需要注意的, 跟小学学的是一样的 / : 整数相除, 结果只能得到整数, 想要得到带有小数的结果, 必须有小数参与运算 % : 取模 ---> 获取的时候除法之后剩余的 余数. 注意: % 一般情况是 判断一个数是否是偶数, 或者是一个数是否能被另一个数整除.
num % 2 == 0; // 这个num就是一个偶数
num % n == 0; // num能被n整除例如:
int a = 5;
int b = 2;
System.out.println(5/2); // 2
System.out.println(5%2); // 1 自增自减运算符
++ : 让变量自身的值 + 1操作
-- : 让变量自身的值 - 1操作
使用方式:
1. 单独使用(推荐)
++, -- 在前在后没有区别
int a = 10;
a++;
++a;
2. 参与运算使用(面试题)
++在前: 先自增, 再操作
++在后: 先操作, 再自增
- 先将该变量, 原本记录的值, 提取出来做操作, 然后再进行自增
int a = 10;
int b = a++;
// ++在a后面, 先将10赋值给b, b=10; 然后在a再去自增,a=11;
System.out.println(a); // 11
System.out.println(b); // 10
int a = 10;
int b = ++a; // ++在a前面, 先a去自增,a=11;然后再将11赋值给b, b=11;
System.out.println(a); // 11
System.out.println(b); // 11
使用场景: 需要做计数的时候, 例如求个数, 求几次. 做变量++操作.
赋值运算符
基本赋值运算符: = : 将符号右边的数据, 赋值给左侧的变量 int a = 10; 扩展赋值运算符:
int a = 2;
int b = 5;
b+=a; // b = b + a ; //结果 : 7
b-=a; // b = b - a ; //结果 : 3
b*=a; // b = b * a ; //结果 : 10
b/=a; // b = b / a ; //结果 : 2
b%=a; // b = b % a ; //结果 : 1+= : 将符号左右两边的数据做加法运算, 将结果赋值给左边 -= : 将符号左右两边的数据做减法运算, 将结果赋值给左边 *= : 将符号左右两边的数据做乘法运算, 将结果赋值给左边 /+ : 将符号左右两边的数据做除法运算, 将结果赋值给左边 %= : 将符号左右两边的数据做取余运算, 将结果赋值给左边
关系运算符
表达式:
> >= < <= == !=
结论: 关系运算符无论简单还是复杂, 结果都只能是boolean类型的true, false
注意: =号是赋值运算符, ==是比较运算符
例如:
int a = 10;
int b = 20;
System.out.println(a > b); // 结果: false
System.out.println(a >= b); // 结果: false
System.out.println(a < b); // 结果: true
System.out.println(a <= b); // 结果: true
System.out.println(a == b); // 结果: false
System.out.println(a != b); // 结果: true逻辑运算符
&(与) : 并且, 符号两边结果必须同时是true,结果才能为true. 遇false结果就是false; |(或) : 或者, 符号两边有一个结果是true,结果就为true. 遇true结果就是true; !(非) : 取反, 取结果的对立面. 例如:
int a = 10;
int b = 20;
int c = 30;
System.out.println(a > b & b < c); // 结果: false
System.out.println(a < b & b < c); // 结果:true
System.out.println(a > b | b < c); // 结果:true
System.out.println(a > b | b > c); // 结果:false
System.out.println( !(a > b) & b < c ); // 结果:true
System.out.println(a > b & !(b < c) ); // 结果:false短路:
短路逻辑运算符: & : 没有短路效果, 无论符号左边是true还是false, 右边都要继续执行 && : 具有短路效果, 符号左边为false的时候, 右边就不执行了 如果符号左边为true, 右边要继续执行 | : 没有短路效果, 无论符号左边是true还是false, 右边都要继续执行 || : 具有短路效果, 符号左边为true的时候, 右边就不执行了 如果符号左边为false, 右边要继续执行
三元运算符
介绍: 可以根据一个判断条件, 达成二者选其一. 格式: 表达式 ? 值1 : 值2; 执行流程: 1. 执行判断条件, 看其返回结果是true, false 2. true : 值1就是运算结果 3. false : 值2就是运算结果 例如: 利用三元运算符求三个整数的最大值 int a = 10; int b = 20; int c = 30; // 谁是最大的? int max = a>b?a:b; int max1 = max>c ? max : c ; System.out.println(max1);
九. 流程控制语句
if语句
if语句的格式1 :
if(判断条件){
语句体;
}
执行流程:
1. 执行判断条件, 看其返回结果是true, 还是false
2. true : 执行 {} 中语句体
3. false : 不执行 {} 中语句体
if语句格式2:
if(判断条件) {
语句体1;
} else {
语句体2;
}
执行流程:
1. 执行判断条件, 看其返回结果是true, 还是false
2. true : 执行语句体1
3. false : 执行语句体2
if语句的格式3:
if(判断条件1){
语句体1;
}else if(判断条件2){
语句体2;
}else if(判断条件3){
语句体3;
}
...
else {
语句体n+1;
}switch语句
if语句的格式1 :
if(判断条件){
语句体;
}
执行流程:
1. 执行判断条件, 看其返回结果是true, 还是false
2. true : 执行 {} 中语句体
3. false : 不执行 {} 中语句体
if语句格式2:
if(判断条件) {
语句体1;
} else {
语句体2;
}
执行流程:
1. 执行判断条件, 看其返回结果是true, 还是false
2. true : 执行语句体1
3. false : 执行语句体2
if语句的格式3:
if(判断条件1){
语句体1;
}else if(判断条件2){
语句体2;
}else if(判断条件3){
语句体3;
}
...
else {
语句体n+1;
}for循环
格式:
for(初始化语句; 判断条件; 条件控制语句){
循环体语句;
}初始化语句: 定义变量 判断条件: 控制循环是否需要继续的条件 循环体语句: 循环要执行的代码 条件控制语句 : 改变控制循环的那个变量
for(int i = 1; i <= 10; i++){ // 循环几次
System.out.println("HelloWorld");
}使用场景: 明确循环次数的时候,使用for循环.
无限循环
for(;;){}
while循环
格式:
初始化语句;
while(判断条件){
循环体语句;
条件控制语句;
}
int i = 1;
while(i <= 5){
System.out.println("HelloWorld");
i++;
}使用场景: 不明确循环的次数, 使用while死循环.
while(true){
循环体语句;
条件控制语句;
}
do...while循环(了解)
格式: 初始化语句;
do {
循环体语句;
条件控制语句;
}while(判断条件);特点: 无论判断条件是否满足, 都至少执行一次循环体
break&continue跳转控制语句
break: 结束\终止 switch语句和循环语句,终止当前循环语句; 注意: break只能在switch和循环中进行使用; continue: 跳过 跳过某一次循环体的执行, 继续下一次; 注意: continue只能在循环中使用; ------------------------------------------------------------ 共同的注意事项: break, continue, 下面不允许写代码, 因为执行不到; 使用细节: 如果在一个循环嵌套的代码中, break和continue, 只能操作自己所在的那一层 想要操作指定层, 可以使用标号(给循环起名字)
十. 数组
两种初始化:
动态初始化: 手动指定长度, 系统分配默认初始化值.
int[] arr = new int[长度];
静态初始化: 手动指定元素, 系统会计算出该数组的长度.
int[] arr = new int[]{100,100,100,90};
int[] arr = {100,100,100,90};
arr[索引] <== 索引代表数组元素的下角标,索引都是从0开始,每个数组的最大索引值等于arr.length-1;
注意:
只要是对数组中的元素进行操作(获取元素,修改赋值元素), 第一个想法是循环遍历数组,这样才能得到数组的每一个元素.
for(int i = 0; i < arr.length; i++){
// arr[i] 代表数组的每一个元素
System.out.println(arr[i]);
}
两种初始化的使用选择:
1. 静态初始化: 如果要操作的数据都已经明确给出了, 推荐使用静态初始化
需求: 计算出班级学生的总成绩 (100,100,100,90)
int[] arr = {100,100,100,99};
2. 动态初始化: 只知道要存储几个元素, 但是不明确具体数值的情况
int[] arr = new int[5];
for(int i = 0; i < arr.length; i++){
arr[i] = sc.nextInt();
}十一. 方法
方法\函数: 一段具有独立功能的代码块, 不调用就不执行.
方法的定义:
定义格式:
public static 返回值类型 方法名(参数列表){
方法体;
return 返回值;
}
public static : 修饰符, 目前来说暂时记住
返回值类型: 跟return返回的结果有关
方法名: 自己给方法起的名字, 小驼峰命名法
参数列表: 方法运行之前所需要的材料
方法体: 方法中所维护的逻辑代码
return :
1. 用于结束方法
2. 用于将返回值返还给调用者
方法调用格式:
方法的调用格式:
1. 带返回值的方法:
A: 单独调用-不推荐,因为没有拿到结果数据.
方法名(实参);
B: 赋值调用-推荐, 因为灵活
返回值类型 变量名 = 方法名(实参)
C: 输出调用-偶尔用
System.out.println(方法名(实参));
2. 不带返回值的方法(void) :
void : 并不是一个数据类型, 只是标识此方法没有返回值的
A: 单独调用
方法名(实参);
示例:
public static void main(String[] args){
// 1. getMax 为方法的调用, ()中的20,30 为方法的实参;
// 2. 用int类型参数接收方法返回的参数;
int max = getMax(20,30);
System.out.println(max);
}
// 1. 方法的定义. int: 方法返回值类型; getMax: 方法名; (int a, int b): 定义方法时使用的形参;
public static int getMax(int a, int b){
// 2. 返回int类型参数;
return a > b ? a : b;
}
方法注意事项:
1. 方法不调用就不执行
2. 方法与方法之间是平级关系, 不允许嵌套定义
3. 方法的编写顺序和执行顺序无关, 要想梳理执行顺序, 就看调用顺序
4. 如果一个方法的返回值类型为void, 表示此方法是没有返回值, return 语句可以省略不写的
但如果非要写return的话, 只能写成 return; 后面不能带有具体的值.
正确: return;
错误: return 10;
5. return 语句下面不能写代码, 因为执行不到
6. 如果一个方法有明确的返回值类型, 一定要通过 return 语句带回一个结果, 无论什么情况下.
方法的重载:
介绍: 方法重载(Overload) : 方法与方法之间的一种关系 - 在同一个类中, 方法名相同, 参数不同, 与返回值无关 (个数不同, 类型不同, 顺序不同)
十二. 面向对象
类和对象的关系:
类 : 是一组相关属性和行为的集合, 将类理解为是对象的设计图
既然类是对象的设计图, 那就是说, 需要根据类, 才能创建出对象
关系 : 依赖关系
需要根据类去创建对象
数量关系
一对多的关系, 根据一个类, 可以创建出多个对象.
标准 JavaBean:
1. 所有成员变量私有化
2. 提供出[空参][带参]构造方法
3. 针对于私有的成员变量, 提供出setXxx\getXxx方法
例如:
// 1. 定义一个Student类
public class Student {
// 2. 成员变量私有化
private String name;
// 2. 成员变量私有化
private int age;
// 2. 成员变量私有化
private String teacherName;
// 3. 提供空参构造方法
public Student() {
}
// 4. 提供带参构造方法
public Student(String name, int age, String teacherName) {
this.name = name;
this.age = age;
this.teacherName = teacherName;
}
// 5. 针对于私有的成员变量, 提供出getXxx方法
public String getName() {
return name;
}
// 5. 针对于私有的成员变量, 提供出SetXxx方法
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getTeacherName() {
return teacherName;
}
public void setTeacherName(String teacherName) {
this.teacherName = teacherName;
}
十三. String与StringBuilder
String介绍
特点:
1. Java 中所有的双引号字符串, 都是String这个类的对象
2. String 一旦被创建就不可改变 - 内容不可改变
- String是一个不可改变的字符序列
String s = "abc";
s = "def"; // 这一步是让s变量, 记录了新的对象, 原来的 "abc" 内容是根本没有改变的
3. 字符串虽然不可改变, 但是其内容可以被共享
- 字符串常量池 :
在使用双引号创建字符串对象时, 会检查该数据在常量池中是否存在
不存在 : 创建
存在 : 复用
创建方式:
1. public String() : 创建一个空白的字符串对象
String s = new String();
2. public String(String s) : 根据传入的字符串, 创建字符串对象
String s = new String("abc");
3. public String(char[] chs) : 根据传入的字符数组, 创建字符串对象
char[] chs = {'a','b','c'};
String s = new String(chs);
1. String s = "abc";两种创建字符串对象的区别 : 1. 双引号直接创建: 数据会在字符串常量池中进行维护 2. 通过构造方法 new 出来的对象: 会在堆内存中有自己独立的内存空间
String常见方法
String类中用于比较的方法:
public boolean equals(Object anObject) :
两个字符串之间做比较, 比较内容, 返回true, false的结果
public boolean equalsIgnoreCase(String anotherString) :
两个字符串之间做比较, 比较内容, 返回true, false的结果, 忽略大小写
String类中用于遍历的方法:
public char[] toCharArray() : 将字符串转换为字符数组
public char charAt(int index) : 根据传入的索引获取字符
public int length() : 返回字符串中字符的个数
String类中用于截取的方法:
public String substring(int beginIndex) :
根据传入的索引截取当前字符串, 截取到末尾, 并返回新的字符串
public String substring(int beginIndex, int endIndex) :
根据传入的开始和结束索引, 截取字符串, 并返回新的字符串
- 包含头, 不包含尾
String类中用于替换的方法:
public String replace(CharSequence target, CharSequence replacement) :
参数1 target : 旧值
参数2 replacement : 新值
String类中用于切割的方法 :
public String[] split(String regex) :
根据传入的字符串参数, 作为规则, 切割当前字符串.
正则表达式 : 本质就是一个字符串 ---> 可以去指定一些规则.
结论: 今后在做切割的时候, 希望都能以 \\ 为开头StringBuilder介绍
- 字符串的缓冲区(容器), 容器可以存储任意数据类型, 但是数据进入到该容器, 都会变成字符串 - 可变的字符序列 - String 和 StringBuilder 区别 - String不可改变的字符序列 - StringBuilder可以改变的字符序列 思考: 如何将一个基本数据类型变成字符串类型?
StringBuilder常用方法
public StringBuilder append(任意类型);
往StringBuilder容器添加任意类型的数据，返回StringBuilder本身。
public StringBuilder reverse();
对StringBuilder进行反转
public int length();
获取StringBuiler容器中字符的个数
public String toString();
把StringBuilder容器转换为字符串StringBuilder和String之间的相互转换
String ---> StringBuilder 的转换
1. 通过StringBuilder的构造方法进行转换
String s = "abc";
StringBuilder sb = new StringBuilder(s);
2. 先创建StringBuilder对象, 再通过append方法进行转换.
String s = "abc";
StringBuilder sb = new StringBuilder();
sb.append(s);
StringBuilder ---> String 的转换
1. 直接通过toString方法即可
StringBuilder sb = new StringBuilder("abc");
String s = sb.toString();