Java是什么？Java开发入门之Java编程基础_java基本开发是什么-CSDN博客

本文链接：https://blog.csdn.net/Auroriiina/article/details/120301636

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]);
        }


    }

}