Java基础复习

最新推荐文章于 2023-06-22 12:54:35 发布

巧克李529

最新推荐文章于 2023-06-22 12:54:35 发布

阅读量272

点赞数 1

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_55658277/article/details/122143060

版权

Java基础

1.标识符

1）可以有字母、数字、下划线、美元符组成
2）不能以数字开头
3）严格区分大小写
4）标识符尽量做到见名之意
5）标识符不能是Java关键字

2.关键字

在Java中，一些单词被赋予了特定的含义，一共50个，2个保留（const，goto）
abstract assert enum const goto native instanceof stricafp transient try volatile do
while boolean break byte short int long
float double char case continue default else
else if for if extends final finally implements
import interface package protected return throw
static super synchronized void new private
public this throws

3. 注释

1）单行注释： //
2）多行注释： /* /
3）文档注释： /* */

4.变量

变量声明必须赋值，要不不能使用
-> 整形默认是0，小数默认是0.0 引用变量默认为null

5. 常量

被final修饰的字段为常量，是不可改变的值

6.数据的八大基本类型

注：除了基本类型，剩下的都是引用类型
在这里插入图片描述

7.字面值

–> 整数为int 浮点型为double
byte、short、char、比int小的直接赋值
字面值后缀： 1）二进制 0b
2）8进制 0
3）16进制 0X

8.基本类型转换

比int小的类型运算时自动转int
在这里插入图片描述

8.Java运算符

算数运算符： + - * / 基本的四则远算符（+号可以代表字符串的拼接）
% 取余数取模
++ / – 自增自减（++/–写在前先自增自减在参加其他运算）写在后边先使用在自增自减
< >= <= == !=基本比较运算符
逻辑运算符 &/&&、| / || 双与双或具有短路效果
三目运算符表达式 1 ？2:3（1为表达式，成立取2，否则取3）
赋值运算符： =等号右边给左边赋值
+= -= （a+=30 等价与a=a+30）
*= /=

9.Java分支结构

单分支结构
多分支结构

在这里插入图片描述
3. 嵌套分支结构

switch结构

5.循环结构
1)for循环
for(开始条件 ; 循环条件 ; 更改条件){
循环体
}
2）高效for循环
for(遍历元素的类型变量名：要遍历的数组/集合){
循环体
}
3）while循环
while（判断条件）{
符合条件，继续执行
}

4）do-while循环
do{
循环体
}while（判断条件）;
while 和do-while循环的区别是while先判断在执行，do-while先执行一次，在进行判断，所以while可以一此都不执行，do-while至少执行一次

9.方法

1）格式：修饰符返回值类型方法名（参数列表）{
方法体
}
2）一个方法一旦被调用，会执行这个方法的功能，执行完返回方法调用处
3）方法重载 方法名相同，参数列表有本质上的区别，方法重载的意义，不是为了让程序员方便，而是不管传进来什么值，都有对应的参数的方法调用
4）方法的重写子类继承父类后，再不改变父类方法代码的前提下，实现自己的功能
5）四种权限修饰符
在这里插入图片描述 6）变量
a.变量的使用遵循最近原则
b. 局部变量 位置：方法里、或局部代码块中、当方法结束、局部变量也随之释放
c. 成员变量 位置：类中方法外不用初始化，默认会赋值；作用在整个类中，类消失了，变量才能释放
final
final：表示最终的意思
①被修饰的类不能被继承
②被修饰的方法不能重写
③被final修饰的字段是常量，值不可以被修改
④常量名全大写，单词与单词之间用下划线分隔

10. Java数组

创建数组的方式有三种
1）动态化创建

int[] a = new int[10];   //定义一个int类型

2)静态初始化

int[] b = new int[]{1,2,3}
int[] c = {1,2,3}

3)数组长度用length来表示，最大的下标为长度减一

4)数组工具类常用API

int[] arr = {12,23,34,45,56}
System.out.println(Arrays.toString(arr))//将数组转化为字符串

Arrays.parallelSort(arr);
/*parallelSort() 在功能上有所不同。与 sort() 使用单个线程对数据进行顺序排序不同，它使用并行排序-合并排序算法。它将数组分成子数组，这些子数组本身先进行排序然后合并。*/

Arrays.sort(arr, 1, 4);//指定范围排序[arr，起始位置,终止位置)
/***Arrays.parallelSort();**此方法对对象或原始数据类型的数组进行排序。与 sort() 类似，它也有两个变体来对完整数组和部分数组进行排序
parallelSort() 在功能上有所不同。与 sort() 使用单个线程对数据进行顺序排序不同，它使用并行排序-合并排序算法。它将数组分成子数组，这些子数组本身先进行排序然后合并。为了执行并行任务，它使用 ForkJoin 池*/

int[] arr = {10,30,50,45,65,874,64,31,54,87,641,31};
  System.out.println(Arrays.binarySearch(arr, 50));
  //控制台结果为 2
  /*二分查找法：根据元素的值，查询元素的下标不存在返回-1*/

int [] arr1 = {1,3,5,7};
int [] arr2 = {1,3,5,6};
System.out.println(Arrays.equals(arr1, arr2));
//判断两个数组是否相同，相同为true，不同为false

Arrays.fill(a1, value);
//a1是一个数组变量，value是一个a1中元素数据类型的值，作用：填充a1数组中的每个元素都是value

int[] arr2 = {10,20,30,40,50,60};
 Arrays.fill(arr2, 2,4,40);//左开右闭，替换下标2到4不包含4的内容
 System.out.println(Arrays.toString(arr2));
 
int [] arrNew = Arrays.copyOf(arr, 2); //(要复制的数组，个数)

5）创建数组过程分析

在数组中开辟连续的空间，长度为n
给数组完成初始化后，给每个元素赋予默认值，int默认为0
数组完成初始化后，会分配一个唯一的地址值，交给变量保存
数组一旦创建，长度不可更改
二维数组

int[] arr = {{1,2,3},{4,5,6}}

11.Java面向对象

概念
面向过程：买菜–>洗菜–>切菜–>炒菜
面向对象：去饭店点餐吃饭

2.三大特性

封装（关键字：private）
1）意义：提高安全性，提高复用性
2）如何访问？对外提供定义好的get(获取值) set(设置值)方法；把私有属性放在公共的方法里也可以调用
继承（关键字：extends）
特点：

子类继承父类的所有属性和方法，只是在子类中不能访问父类的私有成员
Java只支持单继承
继承可以传递，父类给子类，爷爷类中的属性，父类中能用，孙子类中也能用
继承多用与功能的修改，可以让子类在拥有父类功能的同时拓展自己的功能
方法重写 @Override
->子类对父类的功能不满意
->重写是对方法的重写，跟成员变量无关
->条件：两同两小一大
两同：方法名，参数列表相同
两小：子类返回值类型小于等于父类的返回值类型
子类抛出的异常类型小于等于父类抛出的异常类型
一大：子类方法的修饰符权限大于等于父类的修饰符权限

6. this和super区别
this代表本类，super代表父类
①this可以调用本类无参构造（缺省构造）
②super可以调用父类的无参构造
③this或super使用时，必须在构造方法的第一行
④如果父类没有无参构造，子类需要在构造方法第一行手动调用父类其他有参构造

多态
1）概念：比如你女朋友让你买点水果回来，无论你买苹果还是香蕉，是水果就行，比如小猫小狗可以归纳为动物
2）特点：前提
①子类继承父类
②重写父类方法
③多态中，编译看左边，运行看右边
3）多态的好处
①可以不用关心某个对象是什么类型，就可以使用对象的某些方法
②提高了程序的可扩展性和维护性
③子类可以拥有自己的独有方法
4）多态的使用
前提：多态对象把自己看做是父类类型
①成员变量使用的是父类的，但是父类不能调用子类的独有方法
②成员方法重写后，使用的狮子类的
③静态成员随着类加载，谁调用就返回谁，值就一份。
5）静态常量和实例常量的区别？
①由于实例变量是某个对象的属性，必须建立了实例对象，才会给分配内存空间，才能使用这个实例变量，而静态变量属于类，只要程序加载了类的字节码，静态变量就会被分配内存
②实例对象必须创建对象才能调用，而静态变量可以通过类名直接调用

12.构造函数构造代码块

1）概念：
①构造方法与类名同名，且没有方法返回值
②构造方法的主要功能就是创建对象
③创建对象时会自动调用构造方法

2）静态代码块
在类加载时加载，并且只会加载一次，常常用来初始化

3）构造代码块
每次创建对象都会调用，常用来提取构造器共性

4）局部代码块
因为在方法中，调用方法才会执行，作用是为了缩小变量的使用范围
优先级：静态代码块–>构造代码快–>构造方法–>局部代码块

13.Java异常

结构
try{
需要捕获的代码
}catch(异常类型异常名){
解决方案
}
异常可以抛出，可以自己处理，不能抛给main（throws）
throws 与 throw 区别
throws在方法声明处，其后跟着异常类的名字，表示此方法会抛出异常，需要方法调用处解决。
throw在方法内部，其后跟异常对象名，表示此处会抛出异常

注程序的错误分为三种
编译时错误（checked异常）
运行时错误（unchecked异常）
逻辑错误

14.Java抽象类

关键字：abstract

定义方法权限修饰符 abstract 返回值类型方法名（）{
方法体
}
定义类 abstract Class 类名{ }

特点
3. abstract可以修饰方法或类
4. 被abstract修饰的方法为抽象方法，被修饰的类为抽象类
5. 可以全是普通方法，也可以是全部抽象方法，可以半普通方法和半抽象方法，如果这个方法只要还是抽象类，那么就要子类取实现父类里的抽象方法
6. 抽象类不可以实例化，如果不想被外界创建对象，可以把类声明称抽象类

注意：
abstract不可以和哪些关键字使用？
7. private 被私有化后，子类无法重写，与abstract相违背
8. static 静态优先于对象加载，存在加载问题
9. final 被修饰后，无法重写，与abstract相违背
10.抽象类中有构造函数，是为了给派生类创建对象使用

12.Java 接口

关键字 interface
特点
① 通过implements让子类来实现
②接口中有抽象方法，静态方法，默认方法，java9还有私有方法
③类是对一类事物描述属性和方法，接口是包含实现类要实现的方法
④接口可以多继承，打破了Java单继承的局限性（可插拔）
⑤接口对外暴露的规则，是一套开发规范
⑥接口提高了程序的可扩展性，降低了耦合性
接口中没有构造方法
☆ 如果一个类没有明确继承哪个父类，会默认继承Object顶级父类，调用无参也是用Object的
类和接口是实现关系，可以继承类，在实现接口、一个类可以实现多个接口，一个类只能继承一个父类。

4. 接口和抽象类的区别
1）抽象类是特殊类，类中可以存在没有方法体的抽象方法
2）接口可以理解为一个特殊的抽象类，抽象类中可以有普通方法，接口中只能有抽象方法
3）接口是设计的结果，抽象类是重构的结果

13.Java内部类

特点
1）内部类可以直接访问外部类的私有方法，和属性方法
2）外部类想要访问内部类成员，必须new内部类对象
3）在成员位置里的是局部内部类（类中方法外）
4）在方法位置里的是局部内部类（方法里）
被private修饰的成员内部类怎么调用？

	class outer{
		public void getInner(){
			Inner in = new Innner
			in.say();
		}
	
	private class Inner{
		public void say(){
			System.out.println("我是内部类");
		}	
	}
	
}

匿名内部类
可以创建抽象类和接口的匿名内部类

		new Inner(){
		//实现抽象类或接口中的抽象方法，方法只能调用一次	
	}.方法名

14.Java String类的常用API

特点。
1）字符串的内容一旦创建出来，永不可变，final修饰的常量，被final修饰可能减少性能，但是保证了安全性
2）正因为字符串不可以改变，所以字符串是可以共享使用的
3）String底层是byte[ ] 字节数组，效果上相当于char[ ] 字符数组
常用方法
构造方法
1） String(String original):把字符串数据封装成字符串对象
2）String(char[] value):把字符数组的数据封装成字符串对象
3）String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象


length()//获取字符串的长度，其实也就是字符个数
System.out.println(str.length());

charAt(int index)//获取指定索引处的字符
System.out.println(str.charAt(1));

indexOf(String str)//获取str在字符串对象中第一次出现的索引，从指定索引开始
System.out.println('a',2);//从下标为2的地方开始计找字符a第一次出现的索引，索引是从0好下表开始算的

substring(int start)//从start开始截取字符串
System.out.println(str.substring(1));

String substring(int start,int end)//从start开始，到end结束截取字符串。左开右闭

equals(Object obj)//比较字符串的内容是否相同

equalsIgnoreCase(String anotherString)//比较字符串的内容是否相同,忽略大小写

startsWith(String prefix)//判断字符串对象是否以指定的字符开头（区分大小写）
System.out.println(str.startsWith("a"));

startsWith(String prefix,int toffset)//判断字符串对象是否以指定的字符开头，参数toffset为指定从哪个下标开始

endsWith(String str)//判断字符串对象是否以指定的字符结尾

isEmpty()//判断指定字符串是否为空

toCharArray()//把字符串转换为字符数组

toLowerCase()//把字符串转换为小写字符串

toUpperCase()//把字符串转换为大写字符串

trim()//去除字符串两端空格

split()//去除字符串中指定的的字符，然后返回一个新的字符串

subSequence(int beginIndex,int endIndex )//截取字符串中指定位置的字符组成一个新的字符串

replace(char oldChar, char newChar)//将指定字符替换成另一个指定的字符
String str = "abdc";
System.out.println(str.replace('a', 's'));//结果sbcd

replaceAll(String regex,String replasement)//用新的内容替换全部旧内容
String str4 = "Hello,world!";
System.out.println(str4.replaceAll("l", "&"));

replaceFirst(String regex,String replacement)//替换首个满足条件的内容

lastIndexOf(String str)//返回指定字符出现的最后一次的下标

contains(CharSequence s)//查看字符串中是都含有指定字符

concat(String str)//在原有的字符串的基础上加上指定字符串

StringBuilder和StringBuffer区别
StringBuffer
1）可以用append或add方法，把字符串添加在末尾，或指定位置
2）有同步锁，线程安全
StringBuilder
1）能力上与StirngBuffer没有本质区别
2）去掉了线程安全，减少了性能开销，提高了效率
3）绝大部分情况下，拼接字符串的首选

15.Java自动拆箱与自动装箱

1.什么时候需要包装
1）当使用int数据类型调用实例方法时，调用不成功，实例方法只能用引用调用
2）需要将int类型的数据转化为对应的Integer包装类，才能调用实例方法
3）基本类型默认值是0，包装类默认值是null

注：除了int对应的是Integer，char对应的是Character 其他都与基本类型一样，首字母大写

16.IO流

流（Stream）
1）流是单方向的
2）输入流用来读取
3）输出流用来写出
4）数据只能从头到尾读一次
字节流---->针对二进制文件
InputStream字节输入流
OutputStream字节输出流
BufferedInputStream高效字节输入流
BufferedOutputStream高效字节输出流
FileInputStream文件输入流
FileOutputStream文件输出流
字符流
Reader 字符输入流
Writer字符输出流
BufferedReader高效字符输入流
BufferedWriter高效字符输出流
FileReader文本文件读取流
FileWriter文本文件输入流
File常用方法文件
length（）文件字节量
exists（）是否存在，是的话返回true，反知
isFile（）是否为文件，是的话返回true，反知
isDirecatory（）是否为文件夹，是的话返回true，反知
getName（）获取文件/文件夹名
getPorent（）获取符文件夹路径
getAbsolutePath（）获取文件完整路径
mkdir（）创建文件夹
mkdirs（）创建多层文件夹
delete（）删除空文件或文件夹

17.Java集合

collection根接口下的集合
在这里插入图片描述 Map集合

18.多线程

并行：同一时刻，多个程序同时执行
并发：同一时间段，多个程序交替执行（java就是并发执行）
进程有线程
1）进程：正在执行的应用程序，每个进程都有自己独立的内存空间
—>线程：是进程中的一条路径，进程中的子程序（比如杀毒软件是进程，那么清除垃圾，扫描木马等功能就是线程）
2）所谓的多线程，就是多个线程交替执行（并发执行）
3）线程执行需要抢夺cup资源，谁抢上谁执行
4）只要创建了Thread类的子类，like开辟一条新的到cpu的执行路径
5）一旦调用start，说明该线程上可以执行代码了
6）线程与线程之间互不影响，某一个线程出现异常，其他线程均正常执行
7）每个Run方法执行栈空间，属于线程私有
创建线程有两种常用方式
一、继承Thread类创建线程类
（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务，因此把run()方法称为执行体
（2）创建Thread子类的实例，即创建了线程对象
（3）调用线程对象的start()方法来启动该线程

二、通过Runnable接口创建线程类
（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体
（2）创建 Runnable实现类的实例
（3）创建Thread时把Runnable接口实现类对象写到Thread对象构造方法里

用Runnable接口实现类创建线程的好处
1）可以实现数据共享，接口实现类里变量等
2）如果继承Thread，由于Java里类是单继承原则，则不能继承其他类，但是实现了Runnable接口，还可以实现或者继承等其他操作，避免了Java中类单继承的局限性，更灵活

线程的三态模型
在这里插入图片描述
线程五态模型

在这里插入图片描述
同步代码块–>synchronized

synchronized(任意对象){
	//需要加锁的代码
}
//1.任意对象，也叫锁对象，专业属于监视器对象，对象要唯一。默认会调用this，代表的是本类的对象锁
//2.所有操作共享数据的语句必须写在{}里
//3.执行同步代码块时，要么全执行，要么全部执行
//4.加同步代码块，一定要加在合理的范围内

同步：体现了排队的效果，同一时刻只有一个线程独占资源，其他没有权利的线程排队
优点安全性高
缺点是效率低
异步：多个线程同时抢夺cpu资源
优点效率高
缺点同时安全隐患也高
理解性记忆：效率高了，执行快了，就不安全，反知