华清远见重庆中心—后端基础阶段技术总结/个人总结

Java概念

Java的历史

Oak（橡树）语言，由Green开发团队开发，主要用于微型嵌入式设备编程，第一次提出了开源协议 ，Java之父 詹姆斯.高斯林

发布时间

经历过Sun公司接手之后，最终由Oracle收购，1995年语言更名为Java，正式发布JDK1.0

1996年 Java（此时JDK1.2）应对发展需求

Java的分类

J2ME

微型嵌入式领域的编程（例如：塞班系统应用，但后来并没有普及）

J2SE

Java标准语法（这是学习Java开发体系的必备基础）

J2EE

企业级开发（使用Java语言开发服务器）

Java的变化

2006年 JDK1.6 开源所有的代码

（J2SE-->Java SE，J2ME-->Java ME,J2EE-->Java EE）

Java的定义

Java是一门跨平台、“半解释半编译”的“面向对象”语言。

什么是解释型语言

首先要了解两个概念：编译语言、解释语言

1、编译语言是指定文件，编译到指定位置，生成指定的二进制文件，特点：效率高、速度快 （C语言）

2、解释语言是指定文件，解释到任何位置，生成指定的二进制文件，特点：跨平台性好

JDK

JDK 全称是 Java Development Kits 的缩写，翻译过来为Java开发工具包

在JDK中有运行.java文件的虚拟机（解释器）

java的源文件 开发文件是以什么方式结尾 .java

虚拟机 解析 .java文件

虚拟机

指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统

比如：我们在电脑中用的手机模拟器，就是一个由软件模拟的虚拟机

在Java中的虚拟机，是指的专门为了解析.java文件存在的一种软件

虚拟机，英文为 Virtual Machine，而Java虚拟机被人成为JVM（即Java Virtual Machine）

JDK中除了虚拟机还有哪些内容

JRE： Java Runtime Envirment (Java运行时环境 ，运行.java文件的核心内容)

JDK 包含JRE，JRE中有JVM。

虚拟机运行 .java文件 的原理

Java11 之前

java命令：将.java文件编译成.class文件（这里的.class为字节码文件，机器是无法识别的）

javac命令：将.class文件解释成对应的二进制命令。

Java11 后

java命令：将.java文件直接解释成对应的二进制命令

所以我们既可以说Java是一门编译解释语言，也可以说是一门解释语言。（区别与编译语言）

JDK的安装

1、进入JDK的官网 找到JDK11 的下载地址，然后根据自己设备选择对应的版本（常用的电脑设备要注意32位的操作系统和64位的操作系统）从Oracle官网下载。

2、选中对应的系统以及下载版本

3、下载完成，直接安装就可以

4、安装后，我们可以在控制台查看是否已经安装好

WIN+R启动运行窗口

在运行窗口中输入cmd，并回车"确认"

在命令提示符窗口中输入java -version

说明java环境已经安装完成。

JDK卸载

1、在windows搜索中，找到控制面板

2、双击打开控制面板，在右上角启用类别 ，选择程序 中的卸载程序选项

3、在卸载程序页面中查看需要卸载的JDK文件，并双击

4、卸载完成后可以查看安装路径，是否卸载干净。

JDK版本切换

1、启动运行窗口，并输入regedit

2、在注册表中 逐一打开 HKEY_LOCAL_MACHINE,SOFTWARE,JavaSoft

3、在Java Plug-in中修改主体版本即可。

Java程序的运行过程及代码理解

简单的Java程序的组成

public class Hello{
    public static void main(String[] args){
        System.out.println("你好，中国");
    }

}

代码理解

public 公共的，公有的（可以被其他文件访问）
class 类（java代码的主要组成部分）
static 静态的
void 没有返回值（方法）
main 方法的名称``
() 方法的形参
(形式参数) 简称形参
String[] 形参的类型
args 形参的名称

重点： 1、main方法是整个程序的入口 （一旦运行整个项目，main方法就会执行）
      2、如何在没有IDEA的情况下，运行.java
      JDK (Java Development Kits)java开发工具包
      1) 打开IDEA最底部的控制台 Terminal

运行过程

通过javac命令进行编译，生成同名的.class字节码文件，在虚拟机上解释该字节码文件运行。

变量

概念

一个可以装载”字面量“的容器

数据类型

数据类型 变量名称 = 数据值（字面量）

int a = 1;

变量的声明

数据类型 变量名称

int b;

变量的初始化

变量名称 = 数据值（字面量）

b = 2;

注意点

1、数据类型 要与数据值（字面量）保持一致

int c = "张三"; //编译错误

2、在方法内，如果一个变量仅仅只声明，那么它不可以被使用

(在方法内，一个变量需要被初始化后才能使用)

int m;
System.out.println(m); //错误代码演示，结果会报未初始化的错误

变量的相互赋值

int n1 = 1;
int n2 = n1;

变量的名称

规则（前、中后）：1、变量名称的开头只能以_或$(￥ 人民币),英文字母 定义

2、变量名称的中间只能以_或$(￥ 人民币),英文字母,数字 定义

        int _admin;
        int $admin;
        int admin;
        int Admin;
        int ￥admin;
        int ad_min;
        int ad$min;
        int admin01;
        int ad01min;

标识符

概念

为 ”变量、类（接口）、方法“ 进行命名的符号

1、标识符的开头只能以_、$、字母

2、标识符的中间和结尾以_、$、字母、数字为主要内容

3、不能以关键字或者特殊字符命名,(长度、大小写、换行)

4、见名知意(对变量进行特殊的名称定义，会帮助我们或者其他开发者理解程序功能,翻译软件)

标识符常见的命名方式

1、驼峰法 我的苹果 ==> my apple ==> myApple MyApple

首写字母小写 ：小驼峰法 主要用于变量、方法命名

首写字母大写 ：大驼峰法 主要用于类 或者接口命名

2、下划线隔断法 我的苹果 ==> my_apple

关键字

50个常见关键字

Java 由C/C++

其中有5个常见的保留字：goto const (true,false,null)

goto const 已经被弃用 true,false,null 作为值的类型存在java中

数据类型

基本数据类型的表示方式

整数类型

byte short

int

        int a1 = 10; //十进制
        int a2 = 010; //八进制（逢八进一） 在数值前加0
        int a3 = 0x10; //十六进制（逢十六进一）在数值前加0x或者0X

long （数值后需要加上L或者l）

(默认类型是int)

浮点数类型

float （定义浮点数类型时，需要加上F或者f）

double （科学进制表示方式 E:10的多少次方）

(默认类型是double)

字符类型

char

只能用单引号,单引号中只有一个字符或者数字

        char c1 = 'a';
        char c2 = '国';
        char c3 = 65; //ASCII码 65是一个计算机编码，对应'A'
        char c4 = '\u0000';//Unicode编码，空

转义字符

具有特殊的格式意义的字符

\n 换行 \t 制表符 \r 回车

引用类型

System.out.println("Hello")//字符串

基本数据类型转化

大范围的数值类型 ==> 小范围的数据类型 ：强制转化

小范围的数值类型 ==> 大范围的数据类型 ：自动转化

数值范围大小

byte < short < int < long < float < double

基本数据类型转化的原因

数值之间表示数值范围的大小关系

运算符

算术运算符

加、减、乘、除、取余（求模）

注意点

两数相除：

1、两数都是整数类型，求整数商

2、两数任意一个是浮点数，求浮点数的商

数据类型表达式：

运算表达式的最终类型，由运算表达式中的最大类型来决定。

特殊运算符

++ （自加一）

b++ 将b的值先给左侧n，再进行自加一

int b=1；
int n=b++
System.out.println(n)

++b b先进行自加一，再赋值给左侧的m

int b=1；
int n= ++b
System.out.println(m)

-- （自减一）

--运算 与 ++运算规则是一致的

判断依据

看运算符在前，还是变量在前。

如果运算符在前，则先对值进行自加，再将值赋值给左侧

如果是变量在前，则先把值赋值给左侧，再自加。

表达式

1、例如：a-b; b++; ++b :注意表达式最终都是以结果形式显示

b（变量）的值，与b++,++b （表达式）的值是有区别的

++，--在变量”左侧“和“右侧”的区别

2、有运算符参与的运算公式

        //算数表达式
        int a = 2;
        int b = 1;
        System.out.println(a - b);

        //赋值表达式（赋值运算的优先等级最低，从右往左运算）
         a = 5 - b;
        System.out.println(a);

        //布尔表达式 （最终结果是boolean）
        System.out.println(a > b);

        //逻辑表达式 （结果是boolean）
        System.out.println(a > b && b != a);

拼接符

String a = "abc";
String b = "123";
System.out.println(a + b);

字符串拼接符的判断依据：+ 的任意一侧有字符串出现时，它就是拼接符

字符串拼接符 与普通的加减运算的优先级一致。

拼接符的使用会直接消耗内存，执行效率低。

赋值运算符

= 优先等级最低

比较运算符

== 等号

=== 恒等 引用数据类型

> , < , >= , <= ,!=

逻辑运算符

与 &&、&

或 ||、|

非 ！

逻辑运算符的左右两侧，必须是布尔表达式

布尔表达式：表达式的值必须是true或者false（boolean类型）

        int a = 1;
        int b = 2;
        int c = 3;

        //与：一假即假 （当所有布尔表达式中有为false的条件，结果必然为false）
        System.out.println(a < b && b < c);//true 真
        System.out.println(a > b && b < c);//false 假
        System.out.println(a > b && b > c);//false 假

        //或：可能
        //比如：明天下雨，或打雷

        //或：一真即真（当所有布尔表达式中有为true的条件，结果必然为true）
        System.out.println(a < b || b < c);//true 真
        System.out.println(a > b || b < c);//true 真
        System.out.println(a > b || b > c);//false 假

        //非：！取相反的布尔表达式的值
        // 注意：非的一侧必须是布尔表达式。
        System.out.println(!(a > b));//true

位运算

        //二进制 （八进制，十六进制）
        // 二进制与十进制之间的转化

        //& 按位与 ：二进制比较，对位都为1结果为1
        //| 按位或 ：二进制比较，对位都为0结果为0
        System.out.println(3 & 7);
        System.out.println(3 | 7);

        //^ 异或： 二进制比较，对位不相同结果为1
        System.out.println(3 ^ 7);

        //了解：（乘除法）
        //~ 非位： 把所有二进制位取反(包含了符号位)
        System.out.println(~6);
        //移位运算

运算符的优先级

条件语句

if语句

格式：if(布尔表达式){ 执行语句 }

描述：如果布尔表达式成立，就会执行“执行语句”，否则直接跳过这一次判断

       //案例： 大于等于60分：成绩及格
        double score = 90;
        if(score >= 60){
            System.out.println("成绩及格");
        }
        System.out.println("结束");

if.....else语句

格式：if(布尔表达式){ 执行语句 }else{ 执行语句 }

描述：如果布尔表达式成立，就会执行if中的“执行语句”，否则执行else中的“执行语句”

        //案例：大于等于60分：成绩及格 小于60分：不及格
        double score = 90;
        if(score >= 60){
            System.out.println("成绩及格");
        }else{
            System.out.println("不及格");
        }

if...else if 语句

格式：if(布尔表达式){ 执行语句 }else if(布尔表达式){ 执行语句 }

描述：如果if中布尔表达式成立，就会执行if中的“执行语句”

如果else if中布尔表达式成立，就会执行else if中的“执行语句”

随着条件的增多，我们可以增加else if的数量。

        //案例：大于等于90 :优秀
        //     80~90:良好
        //     60~80：合格
        //     ~60：差
       double score = 90;
       if(score >= 90){
            System.out.println("优秀");
        }else if(score >= 80 && score < 90){//score < 90
            System.out.println("良好");
        }else if(score >= 60 && score < 80) {
           System.out.println("合格");
        }else if(score < 60){
            System.out.println("差");
        }

else if(布尔表达式)

else 对前面的条件取反条件 + if(布尔表达式的条件)

       double score = 90;        
       if(score >= 90){
            System.out.println("优秀");
        }else if(score >= 80){
            System.out.println("良好");
        }else if(score >= 60) {
            System.out.println("合格");
        }else{
            System.out.println("差");
        }

switch语句

switch语句格式：switch(数据值或变量){ case 值1:...; case 值2 :...;... }

注意

1、switch括号中一般是变量，变量需要指定特殊的数据类型(byte short int char String(Character))

switch不可以设置的类型有：long,double,float

2、有无break的情况（break 跳出（停止）switch语句）,没有break情况，程序会继续往后执行。

3、关于if语句与switch的区别：switch不能判断范围条件.

4、default 除了case之外的其他条件，（default为了程序健壮性）

        int n = 2; //选择的数据变量
        switch (n){
            case 1:
                System.out.println("n为1");
                break;//通过break可以终止整个switch语句
            case 2:
                System.out.println("n为2");
                break;//通过break可以终止整个switch语句
            case 3:
                System.out.println("n为3");
                break;//通过break可以终止整个switch语句
            default://不存在前面所有条件的情况
                System.out.println("其它数字");
                break;
        }
        System.out.println("switch语句执行完成");

循环

for循环

for循环格式 for(初始化内容;结束循环条件;变化方式){...}

初始化内容：int i = 0

结束循环条件: i < 5 (布尔表达式)

变化方式: i++

        //举例：重复打印Hello World 50遍
        for(int i = 0; i < 50; i++){
            System.out.println(i);
        }

for循环用于，已知的循环次数。

while 循环

while循环格式 while(布尔表达式){ ... }

        int a = 1;
        while (a < 10){
            a++;
            System.out.println(a);
        }

while循环用于，结束条件（直到什么时候停止）。

do-while 循环

格式： do{ 执行代码 }while(布尔表达式);

        int a = 10;
        while(a < 10){
            a++;
            System.out.println(a);
        }

        int b = 10;
        do{
            b++;
            System.out.println(b);
        }while(b < 10);

while 和 do-while的区别

do-while 是先执行再判断 while是先判断再执行

break 和 continue关键字

break 在switch中，退出switch

break 在循环中出现，退出循环

        for(int i = 0; i < 10; i++){//循环次数，循环过程i的变化
            if(i == 5){
                break;//退出循环，后续程序将不再执行。
            }
            System.out.println(i);
        }

continue 在循环中出现，跳过本地循环，开始下一次循环(本质：continue 到 i++ 开始下一次循环)

        for(int i = 0; i < 10; i++){//循环次数，循环过程i的变化
            if(i == 5){
                continue;//阻止后续程序的执行，但不会退出循环。
            }
            System.out.println(i);
        }

循环的特殊结构

          //for死循环:循环没有结束条件
          for(int i = 0;;i++){}
          for(int i = 0;i < 5;){}
          for(;;){}

         //while死循环
          while(true){}

数组

简单定义将一类数据方到一个整体中

专业定义：将数据类型相同的数据，放到一个集合中

数组的定义方式

静态初始化

在构建数组时就给予初始化的值

数组类型： 数据类型[]、变量[]

数组初始化 {数组元素,数组元素,....}

        int[] a = {1,2,3};//1、数组有3个元素长度 2,里面的元素有哪些
        int b[] = {1,2,3};

动态初始化

先构建数组的对象，然后在逐一赋值初始化

基本格式： 数据类型[] 变量名 = new 数据类型[数组的长度]

 int[] c = new int[3];//数组有多长

数组元素

取出指定的数组元素：

数组元素都具有下标值，下标值从0开始

通过”数组变量[下标值]“将数组元素取出

 int[] a = {1,2,3};
 System.out.println(a[1]);

例如：数组a下标为1的元素是”2“

遍历数组

可以通过length这个属性(变量)获取数组的长度

        int[] a = {1,2,3};
        System.out.println(a.length);//3
        for(int i = 0; i < a.length; i++ ){//0~2
            System.out.println(a[i]);
        }
        //取出数组中的最后一个元素
        System.out.println(a[a.length - 1]);

        //将数组内容全部输出到打印语句 [I@5594a1b5地址
        //System.out.println(a);
        // 工具类 Arrays (java.util.Arrays)
        System.out.println(Arrays.toString(a));

数组空间

1)数组a的地址，指向了1，2，3元素所在的堆内存空间

2)而数组a的地址等于 1元素所在空间的地址。

3)1，2，3元素所在的堆内存空间的地址是连续的

 int[] a = {1,2,3};
 //对指定下标的数组元素赋值，可以直接修改该数组
 a[1] = 4;

动态初始化过程

new: 对象创建

虽然new int[3] 开辟了三个空间，但是空间中是有指定类型的默认值

       int[] b = new int[3];
        System.out.println(b[0]);//输出默认值0
        b[0] = 1;
        System.out.println(b[0]);

其他类型数组的默认值

        float[] n1 = new float[3];//默认值0.0
        char[] n2 = new char[3];
        System.out.println(n2[0]);//空字符
        boolean[] n3 = new boolean[3];
        System.out.println(n3[0]);//false
        //引用数据类型的默认值
        String[] n4 = new String[3];
        System.out.println(n4[0]);//null 空对象

数组复制

传统复制

        int[] a = {1,2,3,4,5,6};

        //问：如实现数组复制 从哪里开始复制（start），到哪里停止复制（end）
        //   数组 ===> 新的数组 （数组长度要确认） length = end - start + 1
        int start = 2;
        int end = 3;
        int[] b = new int[end-start+1];

        int m = 0;//b数组的下标
        for(int i = 0; i < a.length; i++){
            if(i >= start && i <= end){
                b[m] = a[i];
                m++;
            }
        }
        System.out.println(Arrays.toString(b));

简便复制

System.arraycopy

System.arraycopy(src,srcPos,dest,destPos,length)

src : 被复制的数组（从哪个数组复制）

srcPos : 从src的哪个下标开始复制

dest : 粘贴到的数组

destPos : 从dest的哪个下标开始粘贴

length : 复制的数据元素的长度

数组扩容

注意：数组本身在定义之后，不可以增减长度

传统扩容

简便扩容

Arrays.copyOf(src,length)

src:需要扩容的数组

length:扩容的长度

冒泡排序

        int[] a = {5,4,3,2,1};
        //通过推理,总共有a.length - 1 次排序
        for(int j = 0; j < a.length - 1; j++){
            //一次排序
            //1.考虑倒数的第二位元素结束: i < a.length - 1
            //a.length - 1 - j : 考虑到不用比较的次数
            for (int i = 0; i < a.length - 1 - j; i++){
                //2.前面的数和后面的数比较大小
                if(a[i] > a[i+1]){
                    //3.交换
                    int tmp;
                    tmp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = tmp;
                }
            }
            System.out.println(Arrays.toString(a));
        }

        System.out.println(Arrays.toString(a));

二维数组

二维数组的元素是一维数组

定义方式

int[][] 数组名称

int[][] d = {a,b,c};

静态初始化

int[][] n1 = {{1,2,3},{3,4,5}};

动态初始化

理解方式一: new int[行][列]

理解方式二: new int[有几个一维数组][这些一维数组中有几个元素]

        int[][] n2 = new int[3][3];
        int[][] n3 = new int[3][];// = {[],[],[]};//元素是三个空的一维数组

特殊形式

每个元素中数组是不同的长度

int[][] n4 = {{1,2,3},{5},{6,7}};

二维数组的遍历

        for(int i = 0; i < n4.length; i++){
            for(int j = 0; j < n4[i].length; j++){
                System.out.println(n4[i][j]);
            }
        }

注意

数组的类型决定了元素是什么样的类型

本阶段个人心得总结

在以前大学的课程学过许多门程序语言，所以在有一定的程序语言的基础后，再来系统且细致的学习Java语言，感触颇多。明白在每个基础点，注意的是逻辑思维的锻炼，以前可能不是很注意的点，很可能就是容易出错的点。还有一方面是，自身有一定的前端基础且学得不错，所以对于后端知识以前学习就不太够，以至于在编程开发方面没有一个大致的范围的概念。最重要的一点还是不要心浮气躁，枯燥是代码，但有趣的是思维，不做没有感情的敲代码工具，编程开发的学习讲究的是扎实的基础和丰富的实践开发能力，不断坚持完成每天的小目标。