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

Java技术以及重难点汇总：

基础理论知识：

1、JDK(Java开发工具包)包含JRE(Java运行时环境)，JRE中包含JVM(Java虚拟机)；

2、Java运行.Java文件的原理：

（1）Java11之前：将.Java文件通过Java命令编译成.class文件，再将.class文件通过Javac命令解释成对应的二进制命令；

（2）java11之后：将.Java文件直接通过Java命令解释成对应的二进制命令

所以Java是一门编译解释语言；

3、基本数据类型有：byte short int long float double char boolean

4、变量名称以及标识符名称：

标识符是用来为类、接口、变量、方法进行命名的；

（1）标识符和变量的开头只能以“_”、“￥”、英文字母大小写定义；

（2）标识符和变量的 中后部份只能以“_”、“￥”、英文字母大小写、数字定义；

（3）标识符不能以关键字、特殊字符进行命名，遵循长度适中、大小写严谨、不能换行的原则；

（4）命名得见明知意。

5、标识符的常见命名方法：驼峰法和下划线隔断法

基本数据类型

1、long类型数值后需要加上L或者l，不加会默认为int型，并且超过int的取值大小会报错；

2、浮点型：

float类型数值后需要加上F或者f，小数值默认为double型；

double型采用科学进制表达方式：E，如：double d=1.23E-7 //表示0.000000123，E10的负几次方；

3、char字符类型：只能用单引号且引号里只有一个字符或者数字，char后跟数字是ASCII码

char c=65

4、String 字符串类型：采用双引号

5、数据类型转换：大范围数值转小范围，强行转化；小范围转大范围，自动转化

数据类型大小比较：byte<short<int<long<float<double

强制转化：

byte a = 1; //-128 ~ 127
//byte b = 128;//128超出byte取值范围，红色下划线，编译出错
 short b = 150;//超出byte取值范围，存在精度丢失
 byte c = (byte)b;//强制转化
System.out.println(c);//丢失精度（值溢出，内存溢出）

运算优先级

重难点

自加自减++ --

重点是判断运算符在前，还是变量在前，如果运算符在前，则先对值进行自加，再将值赋值给左侧，如果是变量在前，则先把值赋值给左侧，再自加。

package com.fs.test;

public class Demo01 {
    //自加、自减++、--
    public static void main(String[] args) {
        int i=1;
        int b=i++;//i++是把i先赋值给b,所以b=1，再自加1，但是因为i++原本应该等于2，
        // 但是在这里没有i的出现了，所以不再执行，一旦出现下一个i，就会=2
        //System.out.println(b);
        //System.out.println(i);//先把i=1的值给b然后b再自加1，所以b=1,i=2
        System.out.println(i++   +  i++);//5 没懂  i=1,
        //                 i=2      i=3 （第一个i++先把i=2的值赋了后，在执行自加，由于i已经执行了，所以自加不显示，
        //自加的值将会在下一个i中体现出来，所以第二个i++中的i=3，再自加1，由于i执行完了，所以不再执行自加
        System.out.println(++i-++i);//-1
        //                 i=3 - 4（第一个i=2然后+1再赋值，所以第二个i=3再+1再赋值）
        System.out.println(i++-++i);//-2 没懂
    }//   i                )i=2  - 4 （第一个i=2,把i的值赋值后再自加，由于第一个i里面已经执行完了，
                        // 所以i原本等于3的要放在下一个i出现才会执行，所以第二个i=3然后自+1后再赋值）
}

字符串拼接+

“+”的任意一侧有字符串出现时，“+”就是拼接符，与加减运算的优先级一致

赋值运算符“=”

优先级别最低，从右往左运算，是将数值赋予给变量，扩展有：+=、-=、*=、/=、%=.......；如：a=10，是将10的数值赋给a，a现在就等于10了，而关系运算符中的“==”是用来判定“==”两边的关系是否相等

逻辑运算符

&&、||、！：逻辑运算符两侧必须是布尔表达式，表达式的值必须是true或者false。

&&（短路与）：一假即假，当有多个表达式时，如果条件1为false，后续将没必要继续执行判断，输出为false；

||（短路或）：一真即真，与上同理

&（逻辑与）：当有多个表达式时，如果条件1为false，后续仍将继续执行判断。

位运算

&（按位与）:对二进制进行比较，对位都为1输出为1；

|（按位或）：对二进制进行比较，对位都为0输出为0；

^（异或）：二进制比较，对位不相同输出为1；

~（非）：对二进制进行取反。

判断语句

（1）if语句

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

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

（2）if...else 语句

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

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

（3）if...else if 语句

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

描述：如果if中布尔表达式成立，就会执行if中的“执行语句”，如果else if中布尔表达式成立，就会执行else if中的“执行语句”，随着条件的增多，我们可以增加else if的数量。

在if ....else if语句中：else 对前面的条件取反条件 + if(布尔表达式的条件)

控制台输入

采用控制台输入：java.util.Scanner

（1）引入Scanner工具 ：import java.util.Scanner;

（2）新建Scanner的对象： Scanner scan = new Scanner(System.in);

（3）先使用System.out.println("请输入内容:");

（4）使用scan.nextXXX 定义输入值的类型。

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 m = 5;
        switch (m){
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;//通过break可以终止整个switch语句
            case 3:
                System.out.println("3");
                break;
            default://不存在前面所有条件的情况
                System.out.println("其它数字");
                break;
        }
System.out.println("switch语句执行完成");

for循坏指定次数的循环

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

初始化内容：int i = 0

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

变化方式: i++

死循环：循环没有结束条件

for(int i = 0;;i++){}

for(int i = 0;i < 5;){}

for(;;){}

   for(int i=0,j=10;i < 9 && j > 3;j--,i++){
            System.out.println(i + ":" + j);
        }

输出：

while循坏

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

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

for循环用于已知的循环次数，while循环用于结束条件（直到什么时候停止）。

public static void main(String[] args) {

        int a = 1;
        while (a < 10){
            a++;
            System.out.println(a);//输出2，3，4，5，6，7，8，9，10
        }

do while循坏

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

while 与do while 的区别：

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

int a = 10;
 while(a < 10){
     a++;
     System.out.println(a);//输出为空，a=10，不会进入循坏语句
}

int b = 10;
do{
    b++;
    System.out.println(b);//在do语句中先输出b++，即b=11后在结束
}while(b < 10);

关键字break 与continue的区别

break 在switch中，退出switch ，后续程序将不再执行。break 在循环中出现，退出循环，后续程序将不再执行。

continue 在switch中，跳过本次switch，继续执行下一个switch；continue在循环中出现，跳过本次循环，开始下一次循环

数组

简单定义：将一类数据放到一个整体中去；

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

数组定义的方式有：静态初始化、动态初始化

（1）静态初始化：在构建数组中就给予初始化的值。

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

基本格式：

数据类型 变量[ ]={数组元素1,数组元素2,............}

数据类型[ ] 变量 ={数组元素1,数组元素2,............}

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

数组集合都是有对应的下标位，下标位从0开始

int[] a = {1,2,3};//数组有3个元素长度 
int b[] = {1,2,3};//

（2）动态初始化：先构建数组的对象，然后在逐一赋值初始化

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

数据类型 变量名[ ]=new 数据类型 [数组的长度]

new: 对象创建

int[] c = new int[5];//数组有5位整数[0,0,0,0,0]

遍历数组

可以通过length属性（变量）获取数组的长度

int[] a = {1,2,3};//长度为3
System.out.println(a.length);//通过a.length属性输出数组a的长度3
for(int i = 0; i < a.length; i++ ){//0~2
   System.out.println(a[i]);
}

如何取出数组中的最后一个元素

System.out.println(a[a.length - 1]);

如何将数组全部输出：需要使用工具类Arrays (java.util.Arrays)

数组如果按照之前的输出格式将会输出地址I@5594a1b5

//System.out.println(a);//I@5594a1b5地址错误格式
 // 工具类 Arrays (java.util.Arrays)
 System.out.println(Arrays.toString(a));//输出数组[1,2,3]

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

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

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

对数组指定下标进行重新赋值，可以直接修改该数组：

int[] a = {1,2,3};
a[1] = 4;//即可将下标为1的值改为4

通过new创建新的对象，开辟新的空间，但是空间中是有指定类型的默认值

int[] b = new int[3];
System.out.println(b[0]);//输出默认值0
//其他类型数组的默认值
 float[] n1 = new float[3];//默认值0.0
 char[] n2 = new char[3];
 System.out.println(n2[0]);//空字符
 boolean[] n3 = new boolean[3];//新建一个长度为3的空数组[false,false,false]
 System.out.println(Arrays.toString(n3));//false
 //引用数据类型的默认值
 String[] n4 = new String[3];//新建一个长度为3的空数组[null,null,null]
 System.out.println(Arrays.toString(n4));//null 空对象

数组复制：System.arraycopy

没有采用System.arraycopy方法：

int[] a = {1,2,3,4,5,6};
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));//输出[3,4]

采用System.arraycopy方法：

格式：System.arraycopy(src,srcPos,deatPos,length)

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

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

deat:粘贴到哪个数组

deatPos：从deat粘贴的数组的哪一个下标开始粘贴

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

int[] c = {7,8,9,10,11,12};
System.arraycopy(a,2,c,2,2);

如何将一个数据完成的复制给另一个数组

System.Arraycopy(a,0,c,0,a.length)
System.out.println("c数组：" + Arrays.toString(c));

数组扩容Arrays.copyOf

格式：Arrays.copyOf(src,length)

src:需要扩容的数组

length:扩容的长度

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

没有使用Arrays.copyOf();

 int[] a = {1,2,3};
 int[] b = new int[a.length + 1];
 System.arraycopy(a,0,b,0,a.length);
 b[3] = 4;
 System.out.println(Arrays.toString(b));
 a = b; //引用地址的赋值。
 System.out.println(Arrays.toString(a));//a输出=[1，2，3，4]

使用Arrays.copyOf();

int[] c = {1,2,3};
c = Arrays.copyOf(c,4);
c[3]=4;
System.out.println(Arrays.toString(c));//输出c=[1,2,3,4]

二维数组

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

格式：int [] [] 变量名={{元素1}，{元素2}.......}

二位数组定义方式：

静态初始化：

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

动态初始化：

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

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

int[][] n2 = new int[3][3];

静态初始化的特殊形式：

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

求二维数组的长度：

int[][] n4 = {{1,2,3},{5},{6,7}};
System.out.println(n4.length);//有多少个一维数组 3个
System.out.println(n4[n4.length - 1].length);//2个指定一维数组中的元素个数

二维数组的遍历

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

作业答疑

要求用户分别输入年月日（考虑闰年），算出这是这一年的第几天年

package com.fs.test;

import java.util.Scanner;
public class Demo6 {
    //要求用户分别输入年月日（考虑闰年），算出这是这一年的第几天
    public static void main(String[] args) {
        //要求1：用户输入年月日
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入年份：");
        int year=scan.nextInt();
        System.out.println("请输入月份：");
        int month =scan.nextInt();
        System.out.println("请输入天数：");
        int day_month =scan.nextInt();
        //计算闰年 四年一闰、百年不闰、四百年再闰
        //闰年
        int day_year =0;//定义一年中的第几天
        int fer=28;

        if(year%4==0 &&year%100!=0 || year%400==0){
             fer=29;
            System.out.println("输入的年份为闰年");
         }else if(year%4!=0 &&year%100==0 || year%400!=0){
            fer=28;
            System.out.println("输入的年份不是闰年");
        }
        /*
        //第一种方法：
        if(month>1) day_year+=31;
        if(month>2)  day_year+=fer;
        if(3 < month) day_year += 31;
        if(4 < month) day_year += 30;
        if(5 < month) day_year += 31;
        if(6 < month) day_year += 30;
        if(7 < month) day_year += 31;
        if(8 < month) day_year += 31;
        if(9 < month) day_year += 30;
        if(10 < month) day_year += 31;
        if(11 < month) day_year += 30;
        //为什么只有11，是因为1计算几月是，假如计算12月，那么是将1-11月的天数加起来之后在家天数day_month的数字
*/
        //第二种方法：使用switch语句
        switch (month-1){
            case 11://采用从大到小是因为如果输入为7月，那么从上往下执行，11-7都不执行，执行1-6并加起来
                day_year+=30;
            case 10:
                day_year+=31;
            case 9:
                day_year+=30;
            case 8:
                day_year+=31;
            case 7:
                day_year+=31;
            case 6:
                day_year+=30;
            case 5:
                day_year+=31;
            case 4:
                day_year+=30;
            case 3:
                day_year+=31;
            case 2:
                day_year+=fer;
            case 1:
                day_year+=31;

        }

        //以下部分通用
        day_year+=day_month;
        System.out.println("您输入的日期："+year+"年"+month+"月"+day_month+"日");
        System.out.println("这是该年的第"+day_year+"天");
    }
}

商店找零，输入单价、数量、用户支付的金额，然后输出找零的数值

package com.fs.test;

import java.util.Scanner;

public class Demo09 {
    //商店找零，输入单价、数量、用户支付的金额，然后输出找零的数值
    public static void main(String[] args) {

       Scanner scan=new Scanner(System.in);
        System.out.println("请输入单价（元）：");
        float price=scan.nextFloat();
        System.out.println("请输入数量（个）：");
        int num =scan.nextInt();
        System.out.println("请输入金额（元）：");
        float pay =scan.nextFloat();

        float money=pay-num*price;//找零=用户给的金额-单价*数量
        if (money>=0){
            System.out.printf("找零的钱数为：%.2f",money);
        } else{
            System.out.println("支付失败，请继续支付");
        }
    }

}

分解质因数

package com.fs.test;

import java.util.Scanner;

public class Work01 {
    public static void main(String[]args){
/*
* 1、分解质因数 (质数：只能被1或者自身整除的数)
 *  因数：乘法的各参数。
 *  例如：输入 6  输出 6 = 3 x 2
 *       输入 12 输出 12 = 3 x 2 x 2
* */    //输入数字
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入一个数");
        int num= scan.nextInt();
        System.out.println(num+"=");
        int i;//定义一个质数
        while(true){
            for(i=2;i<=num;i++){
                if(num%i==0){
                    System.out.print(i);
                    num=num/i;
                    break;
                }
            }
           if(num==1)
                break;
               System.out.print; //123.6/2=hight;  sum=sum+hight=123.6+123.6/2
        }
        System.out.println("小球弹了"+num+"次后距离地面为:"+hight);
        System.out.println(sum);
    }
  }

1000以内回文数

class Work02 {
    public static void main(String[] args) {
        for(int a=1;a<=9;a++){
            for(int b=0;b<=9;b++){
                if(a==b)
                    System.out.println(a*10+b);
            }
        }
        for(int a=1;a<=9;a++) {
            for (int b = 0; b <= 9; b++) {
                for (int c = 0; c <= 9; c++) {
                    if (a == c) {
                        System.out.println(a * 100 + b * 10 + c);
                    }
                }
            }
        }
    }
}

抛小球

以一个高度抛出小球，小球弹起高度的一半后，再次下落 当小球弹了n次，它距离地面的距离为多少。

class Work05{
    public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入一个高度:");
        double hight= scan.nextDouble();//定义高度
        System.out.println("请输入弹跳次数:");
        int num= scan.nextInt();//定义次数
        double sum=0;
        for(int i=1;i<=num;i++){
          //  hight/=2;
            sum+=hight;// sum=sum+hight=0+123.6
            hight/=2;
            sum+=hight; //123.6/2=hight;  sum=sum+hight=123.6+123.6/2
        }
        System.out.println("小球弹了"+num+"次后距离地面为:"+hight);
        System.out.println(
sum);
    }
 

基础总结

由于个人基础很差，大学基础没有打好，对于现在所学的基础课前期没有进入循坏时还能跟得走，后期进入循坏和数组后，就比较困难，需要花更多的时间去消化课上所讲的内容，经过这一周的课程，给我的感觉是，建立逻辑思维非常重要，其次在写代码毫无头绪时可以上网查询一下，先建立解题逻辑，最后对于不懂得一定要多问一下。