Java基础知识2023年最新版

1.变量

 byte a；
 short b； 
 int c；
 long d； 
 float e;
 double f;
 char g;
 boolean h; 
 String i;

1.1什么是变量

变量由数据类型和自己自定义的名称组成，如果未将变量进行赋值则这些数据类型的默认数据为：

数据类型	字节	默认值
byte	1	0
short	2	0
int	4	0
long	8	0L
float	4	0.0F
double	8	0.0D
char	2	\u0000
boolean	-	-
String	-	null

1.2java的内存应用

在java中，内存分为两种一个是栈内存，另一个是堆内存

栈内存：（先进后出）

存放基本类型的变量，对象的引用和调用

堆内存：（先进先出）

存放所有new出来的对象和数组

1.3变量的命名规范

1.变量一般用英文单词表示，首字母小写，遵循驼峰命名规范（变量的名称可以包含字母、数字、下划线、美元符号，但是不能以字母开头命名）
2.不能用java的关键字做变量名，idea里面有颜色的一般是关键字（变量的名称不能是java中的关键字和保留字，但可以包含关键字和保留字）
3.变量名称严格区分大小写，并且命名尽量做到见名知意

1.4java常用关键字

用于定义数据类型的关键字	byte、short、int、long、float、double、char、boolean、class、interface、void
用于定义数据类型值的关键字	true、false、null
用于定义流程控制的关键字	if、else、switch、case、default、while、do、for、break、continue、return
用于定义访问权限修饰符的关键字	private、protected、public
用于定义类，函数，变量修饰符的关键字	abstract、final、static、synchronized
用于定义类与类之间关系的关键字	extends、implements
用于定义建立实例及引用实例，判断实例的关键字	new、this、super、instanceof
用于异常处理的关键字	try、catch、finally、throw、throws
用于包的关键字	package、import
其他修饰符关键字	native、strictfp、transient、volatile、assert

2.运算符

2.1赋值运算

在代码中的‘=’就是赋值运算符，目的是将‘=’右边的数据，赋值给=左边的空间

	int num1 = 10;
	int num2 = 20;
	System.out.print(num1+",");
	System.out.println(num2);
输出结果为10，20

2.2逻辑运算（与、或、非）

• 与（&，&&）

要求，逻辑运算的左右条件都为true

	int num1 = 10;
	int num2 = 20;
 	if (num1<num2&&num1>5){
          System.out.println("条件符合");
    }else{
          System.out.println("条件不符合");
    } 
结果：条件符合

• 或（|，||）

要求逻辑运算的左右条件其中有一个条件为true或左右条件都为true

		int num1 = 10;
        int num2 = 20;
        if (num1 == 10||num2== 10){
            System.out.println("条件符合");
        }else{
            System.out.println("条件不符合");
        }
    }
结果：条件符合

• 非（！）

要求逻辑运算的条件为false

		int num1 = 10;
        if (!(num1>11)){
            System.out.println("条件符合");
        }else{
            System.out.println("条件不符合");
        }
 结果：条件符合

2.3比较运算

比较运算符是用来对运算符左右两个变量的值进行比较，得到结果是boolean类型，因为无论是何种比较，结果只有真或假两种。

    int num1 = 10;
	int num2 = 20;
	System.out.println(num1>num2);结果为false
	System.out.println(num1<num2);结果为true
	System.out.println(num1>=num2);结果为false
	System.out.println(num1<=num2);结果为true
	System.out.println(num1==num2);结果为false
	System.out.println(num1!=num2);结果为true
	

双等号用来比较基本数据类型是否相等或两个对象的内存地址而String属于引用数据类型，equals专门用来判断两个字符串的值是否相等

	String num1 ="苹果";
	String num2 = "香蕉"
	System.out.println(num1.equals(num2));
结果为false

2.4算数运算

加、减、乘、除、取余、自增、自减、+=、-=、*=、/=、%=

	int num1 = 10;
	int num2 = 20;
	System.out.println(num1+num2);结果为30
	System.out.println(num1-num2);结果为-10
	System.out.println(num1*num2);结果为200
	System.out.println(num1/num2);结果为0.5
	System.out.println(num1%num2);结果为10

	System.out.println(num1+=10);结果为20
	System.out.println(num1-=10);结果为0
	System.out.println(num1*=);结果为100
	System.out.println(num1/=);结果为1
	System.out.println(num1%=);结果为0

其中重点说一下自增和自减
如num1++是先输出后赋值，++num1是先赋值后输出
自减和自增情况一样

自增

		int num1 = 10;
        System.out.print(num1+++",");
        System.out.println(num1);
结果为10，11

		int num1 = 10;
        System.out.print(++num1+",");
        System.out.println(num1);
结果为11，11

自减

		int num1 = 10;
        System.out.print(num1--+",");
        System.out.println(num1);
结果为10，9

		int num1 = 10;
        System.out.print(--num1+",");
        System.out.println(num1);
结果为9，9

2.5 三目运算

• 表达式？结果1：结果2；

当表达式结果为true，则执行结果1的代码；当表达式结果为false，则执行结果2的代码。

		String num1 = "苹果";
        String num2 = "香蕉";
        int num3 = num1.equals(num2)?100 : 200;
        System.out.println(num3);
结果为：200

2.6运算符优先级

（）> ! > 算数运算符 > 比较运算符 > && > || > 赋值运算符

3.流程控制

3.1顺序结构

按照原本的方式进行执行，从上到下，从左到右

3.2判断结构

	if(表达式){}
	if(表达式){}else{}
	if(表达式){}else if{}else{}
	if(表达式){}else if{}else if{}...else{}
	if(表达式){if(表达式){else[]}} --多从表达，多从嵌套

3.3switch选择结构

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

switch也可以进行多从嵌套

4.循环结构

循环语句：就是在满足一定条件的情况下反复执行某一个操作

for循环

条件成立的时候才会去执行循环体

    for(初始化语句;判断条件语句;控制条件语句) {
 		循环体语句;
 		}
    for(int x=1; x<=10; x++) {
 		System.out.println("HelloWorld");
 	}

foreach循环

通常用来遍历数组来使用

      for (声明语句 : 表达式) {
　 			//代码句子
	  }
      int [] numbers = {10, 20, 30, 40, 50};
      for ( int x : numbers ) {
           	    System.out.print( x );
            	System.out.print(",");
      }

while循环

条件成立的时候才会去执行循环体，直到条件不符合结束

• 基本格式

  while(判断条件语句) {
        循环体语句;
  }
  

• 扩展格式

   初始化语句;
   while(判断条件语句) {
        循环体语句;
        控制条件语句;
   }   
   int x=1;
   while(x<=10) {
          System.out.println("HellloWorld");
                       x++;		
   }
  

do…while循环

至少会执行一次循环体

for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

跳转语句(控制循环结构)

break、continue语句和return语句。

	for(int x=1; x<=10; x++) {
                    if(x > 3) {
                    //break;
                   continue;
          	}
          	System.out.println("HelloWorld");
      	}

continue与break区别：
break 退出当前循环
continue 退出本次循环
break的作用：跳出单层循环
continue的作用：结束一次循环，继续下一次的循环
return的作用：
​ 可以从一个方法返回，并把控制权交给调用它的语句。
​ 直接结束整个方法，从而结束循环。

5.数组（数据类型 [] 数组名 = 初值 ）

1.存储基本数据类型和引用数据类型
2.处理同类型多数据，可以看做成一个容器
3.数组的长度一旦给定，就不能修改
4.数组由零开始访问元素，如int [] array = new int [5],这一数组里面有6个数据；
5.声明数组时不规定数组长度
6.创建数组并赋值的方式必须在一条语句中完成

数值使用：

声明数组→分配内存空间→数组元素赋值→使用数组元素

数组打印：

1.一维（for循环打印，foreach遍历数组），二维（多层for循环嵌套）
2.一维 Arrays.toString(数组名) ，多维Arrays.deepToString(数组名)
3.使用Arrays.asList(数组名)

Arrays.asList()注意事项
（1）该方法不适用于基本数据类型，但可以用基本数据类型的封装类。
（2）该方法将数组与列表链接起来，当更新其中之一时，另一个自动更新
（3）不支持add和remove方法

基本数据类型	封装数据类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

float，Double，没有实现
Byte、Short、Integer、Long、Character、Boolean 实现常量池的技术。
这 5 种包装类默认创建了数值[-128，127] 的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。

数组排序：

1.Arrays.sort(数组名) 根据需求升序或者降序打印
2.冒泡排序（比较两个相邻的元素，将值大的元素交换到右边）

复制数组：

Arrays.copyOf()(要复制的数组，顶新数组的长度);

变量和数组的区别：

声明一个变量就是在内存空间中划出一块空间
声明一个数组就是在内存空间中划出一串连续的相同类型的空间

6.方法（存在与类中）

方法的四种运用：

1.无参无返回
2.无参有返回
3.有参无返回
4.有参有返回
5.构造方法（特殊）

retrun有关事项：
1.return的结果要和返回值类型相同
2.一个方法中可以有多个return，但被执行的只能有一个
3.return返回值时，只能返回一个值
4.return即表示结束一个方法，也可以将返回值返回给调用当前方法的调用者

方法重载和方法重写

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做出更严格的限制（可以降低限制）

成员（全局）变量和局部变量

区别点	成员（全局）变量	局部变量
作用域不同	成员变量的作用域在整个类内部中都是可见的	局部变量的作用域仅限于定义它的方法
初始值不同	java会给成员变量一个初始值	java不会给局部变量赋予初始值

注意事项：
在一个方法中，不允许有同名的局部变量，不同方法中可以有同名的局部变量
在同一个类中，成员变量和局部变量同名时，局部变量有更高的优先级

this关键字

1.调用属性（区分局部变量和成员(全局)变量）
2.调用方法——表示本对象自己的方法（this.方法名）

public class Text {
    public void show(){
        System.out.println("种类:虎");
        System.out.println("颜色：黄色");
        System.out.println("年龄：8");
    }
    public void eat(){
        this.show();
        System.out.println("爱好：我喜欢吃肉");
    }
    public static void main(String[] args) {
        Text t2 = new Text();
        t2.eat();
    }
}
//输出结果：
种类:虎
颜色：黄色
年龄：8
爱好：我喜欢吃肉

3.调用构造方法——（this(参数)）

注意事项：
1.以重载方法为依据,重载后除了方法名不变外都可以改变
2,这种“this（参数）”方式只能在“构造方法中使用
3.this(参数)”必须写在主调方法的第一行
4.不能出现相互循环调用，如构造方法1⇌构造方法2

4.外部类名.this.属性

public class Text {
   int a = 0;
   void m1(){
       int a = 10;
       System.out.print(a+",");
       System.out.print(this.a+",");
       System.out.println(Text.this.a);
   }
    public static void main(String[] args) {
        Text t = new Text();
        t.m1();
    }
}
输出结果：
10，0，0

super关键字

1.调用父类方法super.(方法名)
2.调用父类构造函数super(有参或无参）

7.面向对象：（封装，继承，多态）

像这些抽象类的东西最好几句话就能总结，类中总是要定义变量，方法。
变量可以说成是属性，方法呢可以说成是行为，属性定义了最开始的譬如身高、体重、名字、职业、爱好等等等等，行为就好理解了，我做了什么事情，这些就是行为。

封装（private：在同一个类中可见）

封装过后只能用getter方法获取值
两种赋值方式(构造器赋值和setter方法赋值)

继承（extends）

子类拥有父类非 private 的属性、方法
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
子类可以用自己的方式实现父类的方法

多态（存在条件：继承，重写，父类引用子类对象）

强制类型转换要到instanceof关键字

向下转型：

将一个指向子类对象的父类引用赋给一个子类的引用（慎用，可能会溢出值报错）

向上转型：

将父类引用到指向子类对象

8.修饰符（访问和非访问）

访问
1.default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法
2.private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
3.public : 对所有类可见。使用对象：类、接口、变量、方法
4.protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

非访问
1.static 修饰符，用来修饰类方法和类变量
2.final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的
3.abstract 修饰符，用来创建抽象类和抽象方法
4.synchronized 修饰符，主要用于线程的编程，synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符
5.volatile 修饰符，volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

9.抽象（abstract）

抽象方法无方法体,抽象类不能被实例化

10.接口——抽象方法的集合（声明：interface，实现：implements）

规则

一个类通过实现接口的方式，从而来继承接口的抽象方法
接口不是类。类描述对象的属性和方法。接口则包含类要实现的方法
接口无法被实例化，但可以被实现
接口中的所有方法必须是抽象对象
接口中的变量都是静态常量
一个类只能继承一个抽象类，而一个类可以实现多个接口
接口中不能含有静态代码块以及静态方法
接口中的方法不能再接口中实现，只能由实现接口的类来实现接口中的方法

接口实现

1.当类实现接口的时候，类要实现接口中所有的方法。否则，类必须要声明为抽象的类
2.类要使用implements关键字实现接口在类声明中，implement关键字放在class

接口继承（和类继承相似,子接口继承父接口）

11.异常

所有的异常类是从java.lang.Exception类继承的子类

Error用来指示运行时环境发生的错误
Exception有两个子类IOException类和RumtimeException类

异常类型	说明
Exception	异常层次结构的父类
ArithmeticException	算术错误情形，如以零作除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	尝试访问 null 对象成员
ClassNotFoundException	不能加载所需的类
IllegalArgumentException	方法接收到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常，如把"abc"转换成数字

捕获异常

	try{
		//程序代码
	}catch(Exception e){
		e.printStackTrace
		在命令行打印异常信息在程序中出错的位置及原因。
	}catch(异常类型 2 异常的变量名2){
		// 程序代码
	}finally{
		//程序代码
		无论是否发生异常，finally 代码块中的代码总会被执行。
	}

抛出异常

throws关键字

访问权限修饰符 返回值类型 方法名(形参列表) throws 异常类型(异常类){
    //实际书写的位置是形参列表的最后一个括号后面
}

throw关键字

访问权限修饰符 返回值类型 方法名(形参列表) {
    throw new Exception("展示的异常信息");
}

12java高级应用

集合（动态的数组）

使用变量存数据，数据量多时，每一个变量都要自行去取，操作繁琐
使用数组存数据，在创建数组时需指定其长度，数组在使用时长度不可改变，并且数据量不是一成不变的，后续超过指定长度后要进行数组扩容
集合拥有可变长度的容器来存储数据，会自己调整数据

Collection 方法分类

1.修改 add(E) 、remove(Obejct)
2.查询 size()、isEmpty()、contains(Obejct)、iterator()、toArray()、toArray(T[])
3.批量数据操作：
containsAll(Collection<?>)、clear()、 addAll(Collection<? extends E)、spliterator() removeAll(Collection<?>)、stream()
removeIf(Predicate<? super E>)、parallelStream() retainAll(Collection<?>)

-add[E]单次添加数据、addAll(Collection< ? extends E>)批量添加数据

集合类型：set(集)，list(列表),map(映射)
集合接口:collection和map,list,set
数组长度是不可变的，集合长度是可变的

collection接口

有序且重复的元素——list集合
无需且有重复的元素——set集合

13.工具类（API）

常用类：

Object类：所有父类的子类

Object常用方法

方法名	作用	返回值
hashCode()	获取对象hash值	int
toString()	将对象信息变为字符串返回	String
equals(Object obj)	判断两个内存地址是否一样	boolean
getClass	获取类名	Objecrt

String类：

1.String是一个final修饰过的引用数据类型，他的值一旦创建便不能修改,被final修饰的不能被继承
2.字符串存在与常量池。如果new String()会在堆内存中开辟空间，如果是直接赋值，会在常量池中开辟空间
3.String的构造方法：
public String()
public String(bytel] bytes)
public String(bytell bytes,int offset,int length)
public String(char[] value)
public String(charl] value,int offset,int count)
public String(String original)

常用方法：

方法名	作用	返回值
isEmpty()	判断是否为空	boolean
length()	取到该String的长度	int
equals(Object obj)	判断两个字符串是否相等	int
equalslgnoreCase(String as)	不区分大小写比较	Object
charAt(int index)	返回该下标的char	char
substring(int start)	截取字符串下标从start开始	String
substring(int strat,int end)	截取区间字符串从start开始到end结束(包头不包尾)	String
repalce(char old,char new)	去掉字母首位空格	String
indexOf()	寻找某个字符串在目标字符串的位置	int

String的转换功能

方法名	作用	返回值
getBytes()	转换成bytes型数组	byte[]
toCharArrav()	转换成char型数组	char[]
String valueOf(charl] chs)	将入参类型转换为String	String
toLowerCase()	将所有英文字母转换为小写字母	String
toUpperCase()	将所有英文字母转换为大写字母将指定字符	String
concat(String str)	串连接到此字符串的结尾	String

StringBuffer：

用来解决String更改字符串造成的时间浪费和空间浪费

StringBuffer和String的区别：内存操作不同
String每次进行更改会产生一个新的对象
StringBuffer不会产生新的对象而是对原有的对象上进行更改

常用方法

方法名	作用	返回值
append(String str)	追加字符串	StringBuffer
insert(int offset,String str)	指定位置追加字符串	StringBuffer
deleteCharAt(int index)	删除下标处的字符	StringBuffer
delete(int start,int end)	删除下标区间的字符	StringBuffer
replace(int start,int end,String str)	替换区间字符	StringBuffer
reverse()	反转字符串	StringBuffer
substring(int start,int end)	截取区间字符串从start开始到end结束 (包头不包尾)	String
substring(int start)	截取字符串	String
split()	拆分字符串	String[]

包装类：

基本数据类型不具备面向对象,相当基本数据类型有与之对应的引用数据
对象型包装类，不继承任何其他类（Object的直接子类）
数值型包装类，继承于Number类

• 装箱：把基本数据类型封装成包装类
• 拆箱：将包装类中包装的基本数据类型数据取出

Integer常用方法：

方法名	作用	返回值
intValue()	转换成int	int
parselnt(String s)	String转换成int	int
valueOf(String s )	String转换成Integer	Integer
String toBinaryString(int i)	转换成2进制	String
toOctalString	转换成8进制	String
toHexString(int i)	转换成16进制	String
toHexString(int i)	十进制到其他进制	String
parselnt(String s,int radix)	其他进制到十进制	int

Character常用方法:

方法名	作用	返回值
isUpperCase(char ch)	判断指定字符是否为大写字母	boolean
isLowerCase(char ch)	判断指定字符是否为小写字母	boolean
isDigit(char ch)	如果字符串中只含有数字则返回True	boolean
toUpperCase(char ch)	将小写字符转换为大写	char
toLowerCase(char ch)	将大写字符转换为小写	char

java.util类

Math常用方法：

方法名	作用	返回值
abs(int a)	取绝对值	int
ceil(double a)	返回最小值	double
floor(double a)	返回最大值	double
max(int a,int b)	取最大值	int
pow(double adouble b)	求幂	double
random0	随机数	double
round(float a)	四舍五入成整数	int
sart(double a)	求double值的正平方根	double

Date构造方法：

public Date()
public Date (long date)
public Date(String s)
public Date(int year,int month,int date)
public Date(int year,int month,int date,int hrs,int min)

• Date常用方法：
  public long getTime0)//获取时间
  public void setTime(long time)//设置时间

Calendar常用方法

方法名	作用	返回值
getInstance()	获取日期	Calendar
get(int field)	获取年/月日/时/分/秒	int
add(int fieldint amount)	计算时间	void
set(int year,int monthint date)	设置时间	void

Randow

· 常用方法：

方法名	作用	返回值
nextInt0)	生产一个随机数	int
nextInt(int n)	生成一个0~n之间的随机数	int

14.Io流

File类

是文件和目录路径名的抽象表示形式

File类常用方法：

方法	作用	返回值
createNewFile()	创建名称的空文件，不创建文件夹	boolean
isDirectory)	判断是否是目录	boolean
isFile()	判断是否是文件	boolean
exists()	判断文件或目录是否存在	boolean
getAbsolutePath()	返回此对象表示的文件的绝对路径名	String
getPath(	返回此对象表示的文件的相对路径名	String
getName(	返回此对象表示的文件或目录的名称	String
length()	返回文件的长度，单位为字节	long

字节输出/输入流

1.字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流
2.字节流因为操作的是字节，所有可以用来操作媒体文件
3.读写字节流：InputStream输入流
OutputStream输出流

字符输入/输出流

1,字符流是可以直接读写字符的IO流，字符流读取字符，就要先读取到字节数据，然后转为字符;如果要写出字符，需要把字符转为字节再写出
2。读写字节流：Reader输入流和Writer输出流

流

1.从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组、和行的高效读取
2.将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组、和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小