JAVA学习笔记

最新推荐文章于 2024-10-01 18:51:18 发布

你品品细品

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量74

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44215543/article/details/115431028

版权

本文详细介绍了Java的基础知识，包括JDK、JRE和JVM的组成及作用，以及程序计数器、虚拟机栈等内存区域。讲解了变量、数据类型、运算符、流程控制和字符串等内容，并探讨了面向对象的特性如封装、继承和多态。此外，还阐述了数组、排序算法和内存管理，特别是对象在堆和栈中的分配。最后提到了抽象、抽象类和抽象方法的概念。

摘要由CSDN通过智能技术生成

JDK

JRE
	JVM
		程序计数器
			记录程序运行的情况，记录运行到了第几行
		虚拟机栈
		本地方法栈
		堆
		方法区
		JVM是一个虚拟机，只能运行Java语言所写的程序
	JRE包括Java虚拟机（jvm）、Java核心类库和支持文件。                                                               
                                                                          JRE不包含开发工具(JDK)--编译器、调试器和其它工具。
JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。

没有JDK的话，无法编译Java程序（指java源码.java文件），如果想只运行Java程序（指class或jar或其它归档文件），要确保已安装相应的JRE。
JRE

命名规则

每个单词首字母大写
不能以数字开头
名字只可以包含大小写字母，数字，下划线和$
文件名要和public类相同，文件名和类之间名字可以重复。可以有多个类，但是不可以拥有多个public类，一个class文件中public类只能有一个
不要使用中文作为类名
类名最好不要超过15个字符，如果单词过长，使用缩写
类命名遵循大驼峰命名法

截断符

截断符：{}；
{}：代表多行代码，统一成一个代码块，以{开始统计，以}结束统计
;：代表一行代码的结束，如果之前的内容不是{，那么就应该以;结束这一行

变量

局部变量
	局部变量在使用前必须赋值
变量的声明
	变量的声明需要符合一种条件
	类型 标志符;
	类型：JAVA之所以被称为语言，是因为它和自然语言很相似，我们去了解一下自然语言，比如说：英语
	对于变量的使用过程，必须先声明在使用，如果是局部变量，还需要一个赋值的过程，同时我们有一个在声明的同时赋值的过程，其格式：类型 标识符 = 字面量；
		long b = 127;声明的同时并赋值
整型
	byte short int long(1,2,4,8)
类型的强制转换
	默认是int型，可以将其强制转换成其他类型
		byte = (byte)128;
浮点型
	float（4）
	double（8）
	float f = 4.5f;

(默认浮点型是double，这里强制转换成float）
字符型
char（2）
char c = ‘1’;
char b = 49;
System.out.println(b);
每一个字符都有相对应ASCLL，所以这里c和b是相同的
布尔类型
boolean只有两个值false和true
boolean（4），在数组中占（1）个字符
不可以使用0和1代替false和true

ASCLL码

编码集合（汉字）

表达式

表达式是通过将标识符，运算符和字面量按照一定规则，结合到一起得到一个结果的式子，叫做表达式
运算符
	1.算数运算符
		+，—，*，/
			" / "：int/int得到还是int（如果想得到浮点数，可以强制将除数与被除数转换成浮点型，那样运算出来就是浮点型）
			加减乘就是正常用法
		%  取余
			两个数相除，只取余数
		++，--，+=，-=，*=，/=
			++：在原来的地址上进行运算
				a++：先赋值在运算
				++a：先运算在赋值
			--
			+=：相当于a=a+1
			-=
			*=
			/=
	2.位运算符
		>>:：字节右移一位，符号位是啥补啥
		<<：字节左移一位
		>>>：字节向右移一位，不管原来符号位是啥，都补0
		&：两边同时为真，才是真
		|：两边只有一个为真，就是真
		~：按位取反
		^：异或（异或的规则是转换成二进制比较，相同为0，不同为1.）
	3.关系运算符
		==：等于
		！=：不等于
		>
		<
		>=
		<=
	4.逻辑运算符
		&：两边同时为true，才为true
		|：两边只有一个为true，就为true
		&&：短路与，只要前边为true就不判断后边的，同时输出true
		||：短路或，只对前边进行判断，不管值是true还是false，都输出true
		！：非，结果为true输出false，结果为false输出true，反向输出结果
	特殊运算符
		特殊运算符是一般这种运算符，只有一个这样的运算符
		优先级运算符：（）
		赋值运算符：=
		三目运算符：boolean ? 分之1:分支2
			优先级最低的
		目数越小优先级越高

流程控制

局部变量不赋初值不能使用
在没有流程控制之前，代码的执行顺序依次是从上到下，从左到右执行的。
流程控制，可以在一定程度上，改变代码的执行顺序，跳过部分代码或者重复部分代码都是流程控制的作用
常见的流程控制有，if for switch while do...while
	我们把常见的流程控制，分成两个大类，分别是分支和循环
	分支类，就是遇到了某个条件成立，那某就可以选择一个分支去执行，当然也可以认为某些条件不成立。就选择，或者跳过一个分支去执行
		分支使用的关键字有两个：if switch
			if分支，其格式是：if(boolean){code}
				上面的格式可以省略，但是如果没有大括号，那么code只能有一行代码，第二行就不归if管，不认为在if过程中
				if适合连续性区间判断，也适合离散型区间
			switch分支流程
				switch的格式 switch（标志符）{
		case 目标值：
			code；
		case 目标值：
			code;
			……
			:
			code;
	}
				switch 只适合离散型区间	
				标志符不是都可以传进来 long float double boolean 就传不进来
	循环
		当条件被满足时，重复执行某一个部分代码
		for while do……while 递归
		for循环的格式：for(1;2;3){4}
			1.初始化部分，可以省略，含义是只有在for循环第一次开始时，才会执行1部分代码
			2，条件判断部分，默认是必然成立的，每一部分循环完成，准备开始下一次循环之前必然要执行一遍2部分代码
			3，条件改变部分，每次循环的代码块执行完成后，先执行3部分的代码，来改变循环条件
			4，循环代码块
		循环可以嵌套循环，也可以嵌套if
		while循环
			while循环格式：while(boolean) {code}
			知道循环退出的条件
		增强for循环
			for each循环，只对容器生效
			用来提取数组中的值，从数组的第一个值开始
		do……while

字符串

任何的值加上字符串，就是字符串

数组

数组是一个连续不断的内存空间，用来保存相同类型内容的一个容器
数组的大小在声明后，就不可以改变
	重新赋值，需要重新更改数组的地址
数组的格式：类型[ ]：标识符；
数组的动态赋值
	int[ ] array = new int[6];
静态赋值（静态初始化）
	int[] array = {1,2,3,4,5};
容器的三大操作：定位，求长和替换
获取数组的长度
	System.out.println(array.length);
获取数组中所有6所在的位置
	for(int i = 0;i<array.length;i++){
		if(array[i] == 6){
			//System.out.println("6在第"+i+"位上");
		}
	} 
排序

斐波那契数列
			int[] array = new int[20];
		array[0] = 0;
		array[1] = 1;
		for(int i = 2;i<array.length;i++){
			array[i] = array[i-1] + array[i-2];
		}
		for(int i = 0;i<array.length;i++){
			System.out.println(array[i]);
		}

直接排序
			int[] array = {8,2,6,4,9,1,5};
		for(int i = 0;i<array.length;i++){
			//每一次循环都在确定第一个位置的最小值是谁
			for(int j = i;j < array.length;j++){
				if(array[i]>array[j]){
					int temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
		for(int i = 0;i<array.length;i++){
				System.out.print(array[i] + "  ");
	}

选择排序
		int[] array = {8,2,6,4,9,1,5};
for(int i = 0;i < array.length; i++){//记录当前遍历的角标
	int minIndex = i;
	int minValue = array[i];
	for(int j=i;j<array.length;j++){//记录当前数组中最小的值
		if(minValue > array[j]){
			minIndex = j;
			minValue = array[j];
		}
	}
	int temp = array[i];
	array[i] = array[minIndex];
	array[minIndex] = temp;
}

增强for循环
for each循环，只对容器生效

for(int item : array){
System.out.print(item + " ");
}
冒泡排序

int[] array = {5,3,7,2,1,8,9,6};
for(int i=0;i<array.length;i++){
for(int j =0;j<array.length-i-1;j++){
if(array[j]>array[j+1]){
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
for(int item : array){
System.out.print(item+" “);
}
二维数组
int[][] array = new int[10][10];
for(int i=0;i<array.length;i++){
//遍历一共有几行
for(int j=0;j<array[i].length;j++){
//遍历一共有几列
//行加列，我们就可以定位一个元素
System.out.print(array[i][j]+” ");
}
System.out.println();
}
多维数组

关键字

关键字是java中具有一定含义的描述词
	这些描述词，不能当作变量名出现，所以我们叫这些词,关键字
	其中之前我们学习的循环分支，中的if，for，while，do，switch等等，都是关键字
	关键字在代码中的特点是，写完后会变成高亮
访问控制
	访问控制：访问控制，就是在创建了一个对象后，这个对象的属性或者方法是否可以被读取到（有些属性可能是你具有，但别人是获取不到的）
		private int length;//私有属性
		public int height;//公有属性
构造方法
	1,方法名称必须和类名一致，大小写敏感
	2,方法不能有返回值，void也不行
	3,这个方法一般在new这个关键字后调用的，使用用来创建这个类的对象
	4,如果我们不写这个方法，那么JAVA会输出一个没有参数，没有方法的默认的构造方法
	5,也就是说，任何的类中，都有构造方法

面向对象

1.首先，我们要了解面向对象，必须要了解第一件事情，Java面向对象说，万物皆对象
2.我们认知对象，是通过自己对这个世界的统一认识出发的，其中包括提前对于某个对象归属于那个类型的定义
比如，当我们看到一个手机，由于这个手机符合我们对手机类型的全定义，所以叫这个东西是手机
3.而我们创建一个相似对象的分类时，使用的“工具”叫做抽象 ，就是讲述这一类对象的名词，当作对象的属性，将描述
这一类对象的动词，当作方法来提取一个模板，任何符合这个模板定义的对象都属于这个类型的对象
4.这个模板，在java中，叫做类
面向对象三大属性
	里氏替换原则
		在任何使用父类的地方，都可以使用子类代替
	封装
	继承
		java在类里面只支持单继承
	多态
		在子类中重新定义父类已经定义的方法过程叫做堕胎
重写和重载
	重写
		1,父类的成员方法只能被它的子类重写
		2,参数列表必须完全与被重写方法的相同。返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类
		3,访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected
		4,构造方法不能被重写,如果不能继承一个方法，则不能重写这个方法
		5,子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重载
重载过程是方法名一样，但是方法的参数列表，类型，个数，顺序三个方向考量，是不一致的的这个时候，我们将这两个同名方法叫做重载
父类和子类的别称
父类=基类=超类
子类=延展类=SUB类
抽象：abstract
这个东西是一个关键字，它可以用来修饰类型和方法
它的意思是，指这个类型或者方法是抽象的，是不知道里面如何实现的，
也不知道如何实现
抽象类：被abstact修饰的类型，抽象类是具有承载抽象方法的类型
抽象类存在的意义就是被别人继承，抽象方法就是要被重写
抽象方法：只知道方法的特征（方法名，返回值类型，参数列表），
但不知道方法应该如何实现，叫做抽象方法。抽象方法应该使用abstract修饰

JAVA的内存

程序计数器：记录程序当前执行的行数
本地方法栈：记录Native方法的执行流程
虚拟机栈：记录JVM虚拟机的执行流程
堆：保存实际对象的位置
方法区：静态变量和常量以及类的模型等内容所在位置
什么时候在堆里面创建对象？什么时候，在栈里面申请引用呢？
	我们把JAVA代码中的，这一行，拆解一下：

Item item = new item();
这一行，其实是两个动作简写的，分别是声明和赋值
声明：Item item,当代码被执行在声明时，JVM会在栈中一个叫栈帧的东西里面创建一个
指向空白的引用（就是C语言的指针），这个空白的引用，它指向null
赋值：当我们写了item = new Item();这个动作又能分成两个部分，第一个部分叫做对象的创建就是new Item();
new 这个关键字，最主要的行为，就是在堆里面，划分一片合理的内存空间，用来保存创建的对象
当我们写了 = 号时，这个时候，栈里面的引用，就可以和在堆里面的内存空间，关联上了