Java学习小结1_引用类型声明会引起类加载吗-CSDN博客

本文链接：https://blog.csdn.net/qq_46338854/article/details/125689621

简单介绍

1、Java 是一个跨平台的语言，即一次编译，到处运行。
2、

JVM：Java虚拟机
JDK：Java开发环境
JRE：Java运行环境

3、J2EE：（Enterrise）企业版
4、Java是开源的：rt.jar中部分源代码开源
5、package：（包）

提供对Java类的分类
相当于目录
相关的类声明在一个包中

6、习惯包起名方式：

公司域名.项目名.模块名.功能名

7、什么情况会导致类加载？

执行Java命令时
创建对象时
访问静态资源时
调用Class.forName时

8、IDE：集成开发环境
9、类加载：把.class文件（硬盘）读取到jvm中（内存）的过程
10、jvm搜索 .class文件的位置

当前目录
rt.jar
CLASSPATH

11、代码的加载

由类加载器（class loader）负责把字节码文件加载到jvm中，在此过程中需要检验该class文件是否符合class文件规范

12、代码的校验

字节码校验器（bytecode verifier）
检验该文件中的代码是否存在非法操作
如果字节码检验通过，由Java解释器负责把字节码解释成机器语言进行执行

13、代码的执行：由解释器完成

相关语法

1、变量

声明：变量类型变量名
注意：变量必须先初始化才能使用，否则会报错
变量的作用域：从定义变量开始，一直到这个变量所在的块结束
注意：局部变量不能复制定义

2、注释

/* */ 多行注释
// 单行注释
/** */ 文档注释

3、Java的变量类型

基本类型
引用类型
空类型

基本类型:byte、short、int 、long、float、double、char 、boolean

整数：

byte 1byte 8bit -128~127

short 2byte 16bit -32768~32767

int 4byte 32bit -21亿~21亿

long 8byte 64bit -2^63~263-1

注意：Java内部没有byte、short 类型，当做int来处理
byte不能提高效率也不能节省空间
整数的直接量（字面量）是int类型
整数的字面量以l/L结尾是long类型

小数：不够精确

float 32位（ 11符号位 8 底数 23指数）

double 64位（ 11符号位 11底数 52指数）

double 比float 精确
浮点数的直接量是double类型
浮点数的直接量以F/f结尾是float类型

字符：char

字符使用’ ’
在Java内部，char当做int来处理

面试题：char 能否存储中文（Java中）

能。因为Java中char类型是以int类型存在的，占4个字节，而不管什么编码格式的中文它的编码所占的字节都小于4，所以是可以存储一个中文的。

布尔： boolean

true 和false是boolean类型的字面量

引用类型

引用类型其实是一个存储了地址值的变量
类似于C/C++中的指针
不同的是Java中不允许使用指针操作
String类型（字符串）是引用类型而不是基本类型

4、生成随机数

生成[0,1)之间的随机小数

Math.random() ;

生成[0,6]之间的随机中整数

Random r =new Random();
int num=r.nextInt(7);

产生一个[a,b]之间的随机整数

(int)(Math.random()*(b-a+1)+a);

5、变量命名规范
语法要求

除了有特殊意义的文字，其他都能使用
只能是数字，字母，_，$组成
数字不能是第一个字符
长度有限制
不能是java关键字
支持中文

编码规范

不允许使用中文
类名/接口名所有单词首字母大写，其他字母小写
变量名/属性名/方法名除了第一个单词其他单词首字母大写，其他字母小写
常量所有字母大写，单词与单词之间使用_连接
代码加缩进，对齐

6、运算符
赋值运算符
= += -= *= /= %=
<<= >>= >>>=
&= ^=

=计算结果为等号右边的值

比较运算符
> >= < <= instanceof

等值运算符
== !=
比较的是栈里的值
堆里的值比较使用equals方法
跟null比较使用==/!=

算术运算符
+ - * / %

位移运算符
<< >> >>>

<<左移
>>有符号右移正数补0，负数补1
>>>无符号右移补0

位运算符
& | ^ ~

逻辑运算符
&& || & |

&& 短路与
|| 短路或
& 与
| 或

三目运算符
条件?代码1:代码2

如果条件结果为true，使用代码1运行
如果结果为false，使用代码2运行

其他运算符
++
- -

7、JDK在编译的时候会做优化，把所有的常量计算出来
8、自动类型转换：符号位扩展

小范围–>大范围
强制类型转换：（转换后数据类型）变量

9、运算符重载

java中有运算符重载，但不能自定义

+
字符串使用加法
字符串拼接
任何类型和字符串+
结果都是字符串类型

10、运算符的优先级

=优先级最低
加上()

11、流程控制：顺序结构、选择结构、循环结构

选择结构

多段代码，根据提供的条件选择其中一段代码运行

if else

switch case



	if(条件){
		代码块
	}



	if(条件){
		代码块1
	}else{
		代码块2
	}
	

	if(条件){
		代码块1
	}else if(条件){
		代码块2
	}else if(条件){
		代码块3
	}

//结果是个值，类型 基本类型，枚举，jdk1.7支持String
	switch(常量表达式){
	case 常量1：
		代码块
	case 常量2：
		代码块
	case 常量3：
		代码块
	default:
		代码块
	}

	//根据常量表达式的值选择从匹配的case开始往下执行

break
	//跳出break所在的块

循环结构
for
while
do while

for (代码1; 代码2; 代码3) {
		代码块
	}

执行代码1
执行代码2（条件），如果没写相当于true
如果条件为true，执行代码块，条件为false，循环结束
执行代码3
循环

12、Java输出

system.out.println();//换行

system.out.print();//不换行

continue 退出本次循环
break 退出循环
return 退出方法
System.exit(0) 退出虚拟机

14、输入样例

Scanner sc=new Scanner(System.in);
int num=sc.nextInt();

15、思路

Java中char 当做int
当随机产生char类型值时，先看其是否连续，如果连续直接通过随机数产生即可，如果不连续，通过随机产生的数字为其重新赋值
奇偶 2n±1
倒叙最大值-当前值
对称循环从（-n,n）

16、方法

表示行为，动作
一段代码的封装
对一段代码起一个名字（方法名）以后可以通过这个名字反复的使用这段代码
代码的维护及复用
语法

修饰符 返回类型 方法名(参数类型 变量名,...)[异常声明]{
			方法体
		}

方法名：行为的名称，一般使用动词
返回类型：方法结果的类型，如果没有结果写void
参数列表：做这件事需要什么
异常声明：做这件事会出什么错

注意

如果方法有返回类型
方法体重一定要有return语句
return 返回值;
如果方法返回类型是void 方法也中可以没有return
方法执行到return语句方法终止
return语句后不能跟任何代码

17、执行顺序
程序遇到方法调用时
先执行这个方法里的代码
执行完以后
回来继续往下运行

18、引用类型
数组 array

一组相同类型元素的集合，个数固定
内存中是连续的空间
数组的声明
数组中元素的类型[] 变量名;

int[] a;

为了跟传统的编程语言兼容

int a[];

19、例子

int[] arr;
arr=new int[4];

1、分配空间
2、数据初始化
3、将这块空间的首地址赋值给arr

20、堆空间中的变量都会自动初始化值为“0”

整数 0
小数 0.0
字符 \u0000(不可见字符)
引用类型 null（空类型）

21、数组的初始化

int[] a;
a=new int[4];

a=new int[]{1,2,4,5,732,79};


int[] a=new int[]{1,3,5,56,65};


int[] a={1,4,67,8,95,3};
//这种省略写法只能作初始化，不能修改

system.out.println(a.length);//求数组长度
system.out.println(Arrays.toString(a));//以固定格式[。。。]输出数组

22、java.lang.ArrayIndexOutOfBoundsException

数组下标越界异常
访问数组下标超过长度（包括等于长度）或小于0时

23、方法的重载

在同一个类中
方法名相同,返回类型在某些jdk版本要求相同
参数列表不同
参数类型不同、参数个数不同
目的方便使用者

24、二维数组

Java内部没有二维数组
二维数组通过一维数组来实现
数组中放数组

int arr[][] arr=new int[4][5];
//arr.length 行的长度
//arr[0].length 列的长度

int[][] arr2=new int [3][];//后面这个里面可以不写
arr2[0]=new []{1,2,3};
arr2[1]=new[]{4,5};
arr2[2]=new[]{7,8,9,10};

int [][] arr3={ {1,2,3},
				{4,5,6},
				{7,8,9}
};

25、读取

Scanner sc=new Scanner(System.in);
//这一句其实是读到了一个缓冲区中

String s=sc.next();
int y=sc.nextInt();
String z=sc.next();
//可以从缓冲区中不断的按顺序读出，以空白字符分隔

sc.nextInt();//整数
sc.nextDouble();//小数
sc.next();//根nextInt差不多，类型不同，读到空白字符为止
sc.nextLine();//读取一整行字符串

26、延伸数组

Java中没有动态数组
方式一

 //例：
 char[ ] c={'a','b'};
 char[ ] temp=new char[c.length+1];
 for(int i=0;i<c.length;i++){
 temp[i]=c[i]
 }
 c=temp;
 c[2]='c';

方式2

char[] c={'a','b'};
char[] temp=new char [c.length+1];
System.arraycopy(c.0,temp,0,c.length);
c=temp;
c[2]='c';

27、Java.lang.NullPointer Exception

空指针异常

28、栈和堆

每个方法都有一个自己的栈
方法运行结束时释放栈
凡是new出来的东西都放到堆里
引用类型在栈中保存地址，然后指向堆中的数据
基本类型直接在栈中保存值

29、面试题：Java中方法是值传递还是引用传递？
Java中方法传递的是栈里的数据，两者都有可能，要根据具体情况来判断。

30、将一个数字插入到一个有序的数组中，数组最后空一位。

思路：从后往前依次比较，只要小于原数组中的数，就把原数组中的那个数往后移一位。

package exercise;

import java.util.Arrays;

public class Test03 {
	public static void main(String[] args) {
		int a[]=new int[5];
		a[0]=1;
		a[1]=2;
		a[2]=4;
		a[3]=5;
		
		int i=a.length-2;
		int num=3;
		while(i>=0&&a[i]>num) {
			a[i+1]=a[i];
			i--;
		}
		a[i+1]=num;
		System.out.println(Arrays.toString(a));
	}
	
}

31、插入排序

思路：在前者的基础上，每次往后多看一位即可。

package exercise;

import java.util.Arrays;

public class Test04 {
public static void main(String[] args) {
	int[] a= {45,23,65,87,1,34};
	for(int i=1;i<a.length;i++) {
		int j=i-1;
		int num=a[i];
		while(j>=0&&a[j]>num) {
			a[j+1]=a[j];
			j--;
		}
		a[j+1]=num;
	}
	System.out.println(Arrays.toString(a));
}
}

32、选择排序

思路：从第一个位置开始，与后面的每个位置进行比较，只要第一个位置上的数大于后面位置上的数，两者交换，一直到最后一个数。

package exercise;

import java.util.Arrays;

public class Test05 {
	public static void main(String[] args) {
		int[] a= {45,23,65,87,1,34};
		for(int i=0;i<a.length-1;i++) {
			for(int j=i+1;j<a.length;j++) {
				if(a[i]>a[j]) {
					a[i]=a[i]+a[j];
					a[j]=a[i]-a[j];
					a[i]=a[i]-a[j];
				}
			}
		}
		System.out.println(Arrays.toString(a));
	}
}

33、冒泡排序

思路：从第一个数开始，每次与相邻的后一个数比较，只要大于后一个数，两者位置交换

package exercise;

import java.util.Arrays;

public class Test06 {
	public static void main(String[] args) {
		int[] a= {4,68,34,90,87,54,89,56,22,9};
		for(int i=0;i<a.length-1;i++) {
			for(int j=0;j<a.length-i-1;j++) {
				if(a[j]>a[j+1]) {
					a[j]=a[j]+a[j+1];
					a[j+1]=a[j]-a[j+1];
					a[j]=a[j]-a[j+1];
				}
			}
		}
		System.out.println(Arrays.toString(a));
	}
}

34、排序

package exercise;

import java.util.Arrays;

public class Test07 {
	public static void main(String[] args) {
		int[] a= {5,7,3,9,6,33,76,12};
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
	}
}

35、将一个有序序列换位
例：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16 ----->

13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4

思路：循环不变，计算每个位置上的数原来所在的位置和现在所在的位置和i,j 之间的关系。

在这里插入图片描述

package exercise;

public class Test08 {
	public static void main(String[] args) {
		int[][] a=new int[4][4];
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<a[i].length;j++) {
				a[i][j]=i*a[i].length+j+1;
				System.out.print(a[i][j]+"\t");
			}
			System.out.println();
		}
		System.out.println("---------------------");
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<a[i].length;j++) {
				a[i][j]=a[a[i].length-j-1][i];
				System.out.print(a[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

在这里插入图片描述
36、十六进制字符串转十进制数字

int i=Integer.parseInt(m,16);//将16进制字符串m转换成十进制数字i

37、思路：

对于n 个情况的轮流执行，可设一计数参数让其对n取余，从而实现轮流进行。其中，如果n为2，我们还可以每次取反（f=-f）来实现两者交替。

38、面试题：优化，提升性能

//题目
for(int i=0;i<3;i++){
	for(int j=0;j<2;j++){
	}
}

在这里插入图片描述

//答案
int i=0;
int j=0;
for(j=0;j<2;j++){
	for(i=0;i<3;i++){
	}
}

在这里插入图片描述

考点：变量定义在循环外面，多层循环中，外层循环次数比内存循环次数小。
注意：只是作为面试题，在实际开发中逻辑是怎样的就怎么写，不要这么写。