Java是什么?Java开发入门
Java成长之路
java基础+进阶,记录自己的java学习之路,用来记录自己的笔记,复盘,充实。
什么是Java
Java是一种高级计算机语言(计算机语言总的来说分为机器语言,汇编语言,高级语言三大类),针对不同的开发市场,sun公司将Java划分为三个技术平台,分别是Java SE,Java EE和Java ME。
Java SE:是三个平台中的核心部分,是为开发普通桌面和商务应用程序提供的解决方案。
Java EE:为开发企业级应用程序提供的解决方案。
Java ME:是为开发电子消费产品和嵌入式设备提供的解决方案。
Java语言特点:简单易用,安全可靠,跨平台,面向对象,支持多线程
sun公司提供了一套Java开发环境,简称JDK,它是整个Java的核心。还提供了Java运行环境JRE。
JDK,JRE,JVM三者关系
JDK安装 环境变量配置 掌握
进制之间的转换
计算机的世界只能处理二进制,0和1.
1.十进制与二进制之间的转化。
十进制数我们日常生活中用到的,0~9.
二进制只有0和1.
十进制与二进制之间相互转化
还有八进制,十六进制,整数,小数等这几类之间转化机制。
计算机存储单元
位(bit)一个数字0或者一个数字1,代表一位
字节(Byte),每逢八位是一个字节,这是数据存储的最小单位。
1 Byte =8 bit
1KB = 1024 字节
1GB= 1024 KB
1TB= 1024 GB
1PB=1024TB
1EB=1024 PB
1ZB=1024EB
常用的DOS命令
命令行操作
命令提示符(cmd)
win开始键+R 打开
输入cmd
命令:
切换盘符: 盘符名称+:
打开文件夹:cd 文件夹名 tab键可以来回切换
进入多级文件: cd 文件夹1\文件夹2
返回上一级: cd…
直接回根路径: cd
文件夹目录:dir
清屏 cls
Java中的关键字
在java编写时
完全小写的英文字母,有颜色的
都是关键字
Java中的标识符
我们自己命名的用来标记一些名称,如包名,类名,方法名,参数名,变量名等
命名规则:
1.标识符可以包含 英文字母,数字,美元符$,和下划线_
2.标识符不能以数字开头
3.标识符不能是关键字
规范:
类名规范:首字母大写,后面每个单词首字母大写
变量名规范:首字母小写,后面每个单词首字母大写
方法名规范:同变量名
Java中的常量,在程序运行期间,固定不变的量
常量就是在程序中固定不变的值,是不能改变的数据,常量包括整型常量,浮点型常量,布尔常量,字符常量等。
1.字符串常量,双引号
2.整数常量 二进制,八进制,十进制,十六进制
3.浮点数常量 单精度 双精度
4.字符常量 单引号单个字符
5.布尔常量 true or false
6.空常量 null 代表没有任何数据
定义常量必须用final关键字修饰,来声明是一个不可改变的量。
*扩展:转义符——反斜杠*
Java中的数据类型
基本数据类型
整数型 关键字 byte short int long
浮点型 float double
字符型 char
布尔型 boolean
引用数据类型
字符串,数组,类,接口,Lambda
Java中的变量
创建一个变量
数据类型 变量名称
1.如果创建多个变量,那么变量之间的名称不可以重复。
2.对于float和long类型来说,后面的F和L不能丢。
变量的类型转化
数据类型转换
java中整数类型默认的int类型;小数类型默认的double;
当数据类型不一样时,将会发生数据类型转换
自动类型转换
java中数据类型转换的顺序 按照范围从小到大:
byte->short->int->long->float->double
范围大的数据类型 变量 = 范围小的数据
eg:double d = 1000;
1.特点:自动转换
2.规则:数据范围从小到大
强制类型转换
范围小的数据类型 变量 = (范围小的数据类型)范围大的数据
eg:int i = (int)6.826
1.特点:代码需要特殊的格式处理,不能自动完成
2.格式:范围小的类型 范围小的变量名 = (范围小的类型)原本范围大的数据
注意事项
强制类型转换一般不推荐使用,可能发生精度损失,数据溢出
byte、short、char都可以发生数学运算,都会被首先提升后int类型,然后在计算。
**扩展:**表达式类型自动提升
Java中的运算符
四则运算
正负
加 +
减 -
乘 *
除 / (只看商,不看余数)(即算术中整除的结果)
取模(取余数)%(即算术中的求余数)
自增自减运算符
自增:++
自减:–
自增、自减运算符的作用是将变量的值增加1或者减少1。
只能对变量使用,不能用于常量和表达式
作前缀时是先运算、后引用
作后缀时是先引用、后运算
自增分为两种 a++,++a
(1)a++
eg: a = 123;
b = a++;
输出a=
输出b=
结果是:a=124 b=123
(1)++a
eg: a = 123;
b = ++a;
输出a=
输出b=
结果是:a=124 b=124
自减同上
注意事项:
1.一旦运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种
赋值运算符
基本赋值运算符:=,代表将右侧的数据交给左侧的变量
复合赋值运算符:
+= a+=3 相当于 a=a+3
-= a-=3 相当于 a=a-3
= a =3 相当于 a=a3
/= a/=3 相当于 a=a/3
%= a%=3 相当于 a=a%3
比较运算符
比较运算符,是两个数据之间进行比较的运算,运算结果都是布尔值true或者false
==(相等) ,
!=(不相等),
<(小于),>(大于),
<=(小于等于),>=(大于等于)
逻辑运算符
与(并且)&&
或(或者)||
非(取反)!
^(异或)
与运算和或运算具有短路效果,如果根据左边已经可以判断得到最终结果,那么右边的代码将不再执行,从而节省一定的性能。
三元运算符
一元运算符:只需要一个数据就可以操作的运算符,例如取反,自增,自减
二元运算符:需要两个数据才可以进行操作的运算符。例如:加法,赋值=…
*三元运算符:需要三个数据才可以操作的运算符
格式: 数据类型 变量名称 = 条件判断? 表达式A:表达式B
流程:首先判断条件是否成立:
如果成立为true,那么将表达式A的值赋值给左侧的变量
如果不成立为false,那么将表达式B的值赋值给左侧的变量
二者选其一
注意事项:
1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2.三元运算符的结果必须被使用
位运算符
运算符的优先级
方法入门
方法:就是将一个功能抽取出来,把代码单独定义在一个大括号内,形成一个单独的功能。当我们需要这个功能的时候,就可以去调用。这样既实现了代码的复用性,也解决了代码冗余的现象。
方法的定义:
定义格式
修饰符 返回值类型 方法名 (参数列表){
代码...
return;
}
定义格式解释:
修饰符:目前固定写法 public static
返回值类型:目前固定写法void,其他返回值类型后续
方法名:为我们定义的方法起名,满足标识符的规范,用来调用方法。
调用方法,格式:
方法名称();
方法的重载
对于功能类似的方法来说,因为参数列表的不一样,却需要记住那么多不同的方法名称,太麻烦。
方法的重载(Overload),多个方法的名称,但是参数列表不一样。好处,只需要记住唯一方法名称,就可以实现类似的多个功能。
编译器的两点优化:
一对于byte/short/char三种类型来说,如果右侧赋值的数值没有超过范围,那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char).
1.如果没有超过左侧的范围,编译器补上强制转换
2.如果右侧超过了左侧的范围,那么直接编译器报错。
int -->char,65没有超过范围
eg:char zifu = 65;
输出zifu为:A
二前面讲了byte/short/char/进行运算时会被首先转换为int
流程控制
什么是流程?这么多代码,先执行哪一行,后执行哪一行。执行的顺序。
程序中流程有三种。顺序,判断,选择
选择结构语句
作出判断进行选择
1.if语句
格式
if(关系表达式){
语句体;
}
执行流程
首先判断关系表达式看其结果是true还是false
如果是true,则执行语句体
如果是false,则不执行语句体
2.if…else语句
格式
if(关系表达式){
语句体1;}
else{
语句体2;
}
执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2
3.if…else if…else语句
格式
if(判断条件1){
执行语句1;
}else if(判断条件2){
执行语句2;
}
...
}else if(判断条件n){
执行语句n;
}else {
执行语句n+1;
}
执行流程
首先判断关系表达式1,看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式,看其结果是true还是false
练习:使用三元运算符合标准的if-else语句分别实现,取两个数字中最大的值。
int a = 10;
int b = 20;
//首先使用三元运算符
int max = a > b ? a : b ;
//使用if-else语句实现
int max;
if(a > b){
max=a;
}else{
max= b;
}
switch
格式:
switch(表达式){
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
....
default:
语句体n=1;
break;
}
执行流程:
首先计算出表达式的值
其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束。
最后,如果所以的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉。
注意事项:
1.多个case后面的数据不可以重复。
2.switch后面小括号当中只能是下列数据类型:
基本数据类型:byte、short、char、int
引用数据类型:String字符串,enum枚举
3.switch语句格式可以很灵活,前后顺序可以颠倒,而且break语句还可省略。case的穿透性。如果break省略了,会向下穿透case.
循环结构语句
循环皆归于的基本组成部分,一般分为四部分
1.初始化语句,在循环开始最初执行,而且只做唯一一次。
2.条件判断,如果成立,则循环继续,如果不成立,则循环退出。
3.循环体:重复要做的事情内容,若干语句。
4.步进语句:每次循环之后都要进行的扫尾工作,每次循环结束之后都要执行一次。
1.for语句
格式:
for(初始化表达式1;布尔表达式2;步进表达式4){
循环体3
}
执行流程:
-执行顺序:1234>234>234…2不满足为止
-1负责完成循环变量初始化
-2负责判断是否满足循环条件,不满足则跳出循环
-3具体执行的语句
-4循环后,循环条件所涉及变量的变化情况
2.while
while循环标准格式:
while(条件判断){
循环体
}
扩展格式:
初始化表达式1
while(布尔表达式2){
循环体3
步进表达式4
}
执行流程:
执行顺序:1234>234>234…2不满足为止。
1负责完成循环变量初始化
2负责判断是否满足循环条件,不满足则跳出循环。
3具体执行的语句
4循环后,循环变量的变化情况
3.do…while…
标准格式:
do{
循环体
}while(条件判断);
扩展格式:
初始化语句1
do{
循环体3
步进表达式4
}while(布尔表达式2);
执行流程:
执行顺序:134>234>234…2不满足为止。
1负责完成循环变量初始化
2负责判断是否满足循环条件,不满足则跳出循环。
3具体执行的语句
4循环后,循环变量的变化情况
三种循环的区别:
1.如果条件判断从来没有满足过,那么for循环和while循环将会执行0次,但是do-while循环会执行至少一次
2.for循环的变量在小括号当中定义,只有循环内部才可以使用,while循环和do-while循环初始化语句本来就在外面,所以出来循环之后还可以继续使用。
跳出语句
break关键字:
1.用在switch语句当中,一旦执行,整个switch语句立刻结束
2.还可以用在循环语句中,一旦执行,整个循环句立刻结束,打断循环
continue关键字:
一旦执行,立刻跳过当前次循环剩余内容,马上开始下一次循环
扩展知识点:
死循环:永远停不下来的循环,叫做死循环
死循环标准格式:
while(true){
循环体
}
故意写的死循环
注意事项:死循环后面写什么都执行不了,会报错。
嵌套循环
总共循环次数=外循环次数*内循环次数
格式:
for(初始化表达式1;循环条件2;步进表达式7){
for (初始化表达式3;循环条件4;步进表达式6){
执行语句3;
}
}
执行流程:
执行顺序:123456>456>723456>456
外循环一次,内循环多次
java的内存
java的内存要划分为5个部分
1.栈(Stack):存放的都是方法中的局部变量。方法的运行一定要在栈当中运行
局部变量:方法的参数,或者是方法{}内部的变量
作用域:一旦超出作用域,立刻从栈内存当中消失
2.堆(Heap):凡是new出来的东西,都在堆当中
堆内存里面的东西都有一个地址值:16进制
堆内存里面的数据,都有默认值,规则
如果是整数类型,那么默认值为0;
如果是浮点类型,默认值为0.0;
如果是字符类型,那么默认为’\u0000’
如果是布尔类型,那么默认为false;
如果是引用类型,那么默认为null
3.方法区(Method Area)
4.本地方法栈(Native Method Stack)
5.寄存器(pc Register):与CPU相关
数组
初始化数组
/*
数组,是一种容器,可以同时存放多个数据
数组特点:
1.数组是一种引用数据类型
2.数组当中的多个数据,类型必须统一
3.数组的长度在程序运行期间不可改变
数组的定义:
在Java中,数组的定义有三种方法,其基本语法格式如下:
数组类型 [ ] 数组名 = new 数组类型 [数组长度];
数组类型 [ ] 数组名 = new 数组类型 [ ]{数组元素0,数组元素1,…};
数组类型 [ ] 数组名 = {数组元素0,数组元素1,…};
数组的初始化,在内存当中创建一个数组,并且向其中一些默认值
动态初始化(指定长度)
静态初始化(指定内容)
动态初始化数组格式
数据类型[] 数组名称 = new 数组类型[数组长度]
动态初始化,在创建数组的时候,直接指定数组当中的数据元素个数
静态初始化基本格式
标准
数据类型[] 数组名称 = new 数据类型[] {元素1,元素2,…};
在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定
省略格式
数据类型[] 数组名称 = {元素1,元素2,…};
注意事项:
1.静态初始化没有直接指定长度,但是仍然会自动推算得到长度
2.静态初始化标准格式可以拆分为两个步骤
3.动态也可以拆分成两个步骤
4.静态初始化省略格式不可以拆分
*/
public class Demo01Array {
public static void main(String[] args) {
//动态数组
int[] arrayA = new int[300];
double[] arrayB = new double[10];
String[] arrayC = new String[5];
//静态初始化
int[] arrayD = new int[] {5,15,25};
String[] arrayE = new String[] {"hello","world"};
//拆分
int[] arrayF ;
arrayF = new int[] {1,2,3};
}
}
访问数组元素的获取与赋值
/*
访问数组元素进行获取
访问数组元素的格式:数组名称[索引值]
索引值:数组下标
使用动态初始化数组的时候,其中的元素将会自动拥有默认值。
规则如下:
如果是整数类型,那么默认值为0;
如果是浮点类型,默认值为0.0;
如果是字符类型,那么默认为’\u0000’
如果是布尔类型,那么默认为false;
如果是引用类型,那么默认为null
访问数组元素进行赋值
*/
public class Demo02Array {
public static void main(String[] args) {
//静态初始化
int[] array = {10,20,30};
System.out.println(array);//[I@4554617c
//直接打印数组名称,得到的是数组对应的,内存地址哈希值。
System.out.println(array[0]);//10
System.out.println(array[1]);//20
System.out.println(array[2]);//30
//动态初始化
int[] arrayA = new int[3];
System.out.println(arrayA);
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
System.out.println("==========");
arrayA[1]=123;
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//123
System.out.println(arrayA[2]);//0
}
}
数组常见问题
数组索引越界异常
ArrayIndexOutOfBoundsException
访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常
空指针异常
数组必须进行new初始化才能使用其中的元素
如果智慧树赋值了一个null,没有进行new创建
那么将会发生空指针异常 NullPositionException
练习
求数组中的最大值
1数组元素翻转,其实就是对称位置的元素交换
2通常遍历数组用的是一个索引:
int i=0;
现在表示对称位置需要两个索引
int min = 0;
int max = array.length-1;
3交换两个变量的值
引入一个一个temp;
4.什么时候停止交换
当min == max
或者min>max
*/
public class Demo06Array {
public static void main(String[] args) {
int[] array ={5,15,30,20,10000};
int max;
max = array[0];
for (int i = 0; i < array.length; i++) {
if(array[i]>max){
max = array[i];
}
}
System.out.println("最大值:" + max);
System.out.println("===============");
//遍历打印数组本来的样子
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("===============");
//翻转
for(int left = 0,right = array.length-1;left < right; left++, right--){
int temp = array[left];
array[left] = array[right];
array[right] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
数组作为方法参数–传递的是数组的地址
数组作为方法返回值–返回地址
一个方法可以有0,1,多个参数,但是只能有0或者1个返回值,不能有多个返回值
如果希望一个方法当中产生了多个结果数据进行返回,怎么办?
可以使用一个数组作为返回值类型即可。
扩展:多维数组