华清远见-重庆中心-JAVA基础阶段技术总结/知识点梳理/个人总结

            int a;//  定义变量再赋值
            a = 100;
            int age = 20;//定义变量直接赋值
            int x,y,z;//一条语句定义多个变量
            x=1;    y=2;    z=3;

变量的命名

由字母，数字，"_"，"$"组成。

注意事项：1. 不能以数字开头。

2.区分大小写。

3.不能使用关键字作为变量名。

4。一般见名知意，采用驼峰命名法。

5.可以使用中文命名，但一般不推荐使用。

数据类型

整数类型

数据类型	取值范围
byte	1个字节【-128，127】
short	2个字节【-32768，32767】
int	4个字节【2147483648，2147483647】
long	8个字节【9223372036854775808，9223372036854775807】

int是整数类型的默认类型。

通常声明long类型的变量时要在变量值后面加L或者l

浮点类型

数据类型	取值范围
float	4个字节【-3.410(-38)，3.410(38)】
double	8个字节【-1.710(-308)，1.710(308)】

通常声明float类型时，要加F或者f

double是浮点类型的默认类型。

字符型

char ： 2个字节，16位。表示Unicode字符编码上的符号，前128个符号和ASCII表相同

布尔型

boolean：只有true和false这两个值，一般用于逻辑运算，不能和整数类型转换

数据类型的大小比较

byte<short=char<int<long<float<double(只是根据所占字节数来比较，short并不等同于char)

数据类型的转换

自动类型转换（隐式转换）

小的数据类型转换成大的数据类型（由系统自动转换）

        long a1 = 100;//自动类型转换： 直接量100是int类型，a1是long类型。

强制类型转换

大的数据类型转换成小的数据类型，可能会有精度的损失或溢出

//强制转换造成精度损失或溢出
        double d = 3.616565156156;
        float d1 = (float) d;
        System.out.println("精度损失："+d1);//3.6165652
        long data = 10000000000L;
        int data1 = (int)data;
        System.out.println("溢出:"+data1);//1410065408

运算符

算术运算符

+（加），-（减），*（乘），/（除）,%（取余），++（自增）,--(自减)。

++（自增），--（自减）运算是在自身值的基础上，增加或者减少1.

++，--写在变量的前面，先加减再运算。

++，--写在变量的后面，先运算再加减。

关系运算符

>（大于），<（小于），==（等于），>=（大于等于）, <=（小余等于），!=（不等于）。

运算结果为boolean类型，整数类型和浮点类型能做关系运算，boolean类型不能。

逻辑运算符

&& - 与， || - 或 , ! - 非

运算规则：与运算（全真为真，有假为假）

或运算（有真为真，全假为假）

非运算（真变假，假变真）

运算结果为boolean类型，只有boolean类型能做逻辑运算。

注意事项：短路逻辑： && ，|| 当我们能够判断出结果时，后续的表达式不再执行 (常用)

不短路逻辑： & ， | 每个参与运算的表达式都需要执行 (不常用)

//短路逻辑与，短路逻辑或
        int a=3,b=5;
        boolean b5 = a>b && a++>1;// a>b是false，那么&&运算的结果确定出来是false。这里用的是“&&”，所以后面的a++ >1 的表达式不会呗执行。因此最终啊还是3。
        System.out.println("b5:"+b5 + ",a:"+a);//a=3
        boolean b6 = a>b & a++>1;//"&"不短路与，整个运算的所有表达式都要执行
        System.out.println("b6:"+b6 + ",a:"+a);//a=4

        boolean b7 = a<b || a++>1;// a<b是true，"短路||运算"，后面的a++ >1 的表达式不会呗执行。因此最终啊还是3。
        System.out.println("b7:"+b7 + ",a:"+a);//a=4
        boolean b8 = a<b | a++>1;//"|"不短路或，整个运算的所有表达式都要执行
        System.out.println("b8:"+b8+ ",a:"+a);//a=5

赋值运算符

"="，将等式右边的值赋给左边，优先级很低。

扩展赋值运算符

在赋值运算符的前面，加上算数运算符。

运算符的优先级

！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

三目运算

运算格式： boolean表达式？表达式1：表达式2

如果boolean为true就执行表达式1，boolean为false就执行表达式2

程序的结构

顺序结构

从上往下依次运行

分支结构

if

if的语法规则：

if(boolean){

//code

}

boolean为true,执行code；如果boolean为false,跳过code

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入单价和数量");
        int number = sc.nextInt();
        double price = sc.nextDouble();
        double total = number*price;
        if (total>300) {
            int discount = (int) (total / 300)*50;
            total -= discount*50;
        }
        System.out.println("你需要支付："+total);
    }

if...else...

if...else...的语法规则：

if(boolean){

//code1

}else{

//code2

}

boolean为true,执行code1；boolean为false,执行code2

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入单价和数量");
        int number = sc.nextInt();
        double price = sc.nextDouble();
        double total = number*price;
        System.out.println("请输入支付的金额：");
        double pay = sc.nextDouble();
        //判断找零情况
        if (total>300) {
            int discount = (int) (total / 300)*50;
            total -= discount;
        }
        if (pay>total){
            System.out.println("找零："+(pay-total));
        }else {
            System.out.println("需要补交："+(total-pay));
        }
    }

if...else if...

if...else if...的语法规则：

if(boolean1){

//code1

}else if(boolean2){

//code2

}else if(boolean3){

//code3

}

.......

}else{

//code？

}

boolean1为true,执行code1；boolean2为true,执行code2.........直到code？

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个1~7的整数");
        int week = sc.nextInt();
        if (week < 1 || week > 7) {
            System.out.println("输入错误：请输入一个1~7的整数");
        } else {
            if (week == 1) {
                System.out.println("今天是星期一");
            } else if (week == 2) {
                System.out.println("今天是星期二");
            } else if (week == 3) {
                System.out.println("今天是星期三");
            } else if (week == 4) {
                System.out.println("今天是星期四");
            } else if (week == 5) {
                System.out.println("今天是星期五");
            } else if (week == 6) {
                System.out.println("今天是星期六");
            }else {
                System.out.println("今天是星期天");
            }
        }
    }

switch…case…

switch ... case的语法规则：

switch（变量）{

case 数值1：......break; //break 中断. Java中的关键字。这里表示执行完case后，整个switch语句块结束

case 数值2:.......

default:...... }

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据值1~7：");
        int week = sc.nextInt();
        switch (week) {//当不加break时 会发生穿透，执行到对应的case时会继续执行后面的case
            case 1:
                System.out.println("星期一");
                break;  // break 中断.  Java中的关键字。 这里表示执行完case后，整个switch语句块结束
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期天");
                break;
            default:
                System.out.println("数据不合理，请重新输入");
        }
    }

循环结构

循环：处理重复或者有某种规律操作时，让计算机帮忙完成的方法

循环三要素： 1.循环变量初始化

2.循环条件

3.循环变量的改变

for循环

for(初始化变量；循环条件；变量的改变)
{
code
}

初始化变量是循环定义的变量，通常用i表示，循环条件是判断循环是否继续下去的依据，随着循环不断的进行，变量不断改变使得循环条件不成立，结束循环。

注意：在括号内定义的变量i只能在for循环中使用

特殊的for循环

        // 变量的初始化在循环外面
        int i = 1;
        for (; i <= 10; i++) {
            System.out.println(i);
        }
        System.out.println("最后i的数据值：" + i);

        //括号里只有;;
        int k = 1;
        for (; ; ) {
            if (k <= 10) {
                System.out.println(k);
            } else {
                break;//结束循环
            }
            k += 1;
        }

        //括号里只有变化量
        int j = 1;
        for (; ; j++) {
            if (j <= 10) {
                System.out.println(j);
            } else {
                break;
            }
        }
        
        //括号里只有循环条件
        int l = 1;
        for (;l<=10;){
            System.out.println(l);
            l++;
        }

while循环

变量初始化；

while（循环条件）
{
code

变量变化
}

        //输出1*9=9  到  9*9=81
        int i = 1;
        while (i <= 9) {
            System.out.println(i + "*9" + "=" + i * 9);
            i++;
        }
        System.out.println("循环结束");

do...while

变量初始化；

do
{
code

变量变化
}while（循环条件）;

        //练习：输入密码(123456)，解锁手机。只能输入5次，超过5次就提示半个小时后在尝试
        int count = 1;  //记录次数
        int pwd;
        do {
            if (count == 6) {
                System.out.println("输入次数超过最大限度，请半个小时后在尝试");
                // break;  结束循环
                return;//结束整个程序的运行
            }
            System.out.println("请输入密码：");
            pwd = scanner.nextInt();
            count += 1;//改变输入次数
            System.out.println("密码错误，请重试");

        } while (pwd != 123456);
        System.out.println("手机解锁成功");

while和do...while的区别

while先判断条件，条件为真，执行语句

do...while先执行语句，再判断条件（至少执行一次）

for、while、do...while各自适用的场合

for循环适用于循环次数固定的场景

while循环适用于不知道循环次数，只知道某个循环执行或终止的条件时

do...while与while类似，适用于知道循环肯定会执行一次的场合

break 、continue 、return

break可用于循环语句或者switch语句。

break用于循环会使当前循环中断跳出。

continue 只能在循环语句中使用。

continue 用于循环会使continue不会执行，继续下一次循环。

关键字	用法
break	用于switch或循环语句中，使循环中断，跳出循环
continue	用于循环语句中，使continue下方的循环中的语句不再执行，继续下一次循环
return	终止return后面的语句

循环的嵌套

相同或不同的循环的内部可以在有循环，外部循环一次，内部循环所有。

循环的层数越少越好（减少计算量），最好不要超过3层

死循环

没事终止循环条件的循环，一直执行下去。

数组

相同类型数据组成的集合

数组用下标来操作，元素个数从1开始，下标数从0开始

数组的声明

声明数组的语法：

数据类型[ ] 数组名 = new 数据类型[大小]；

声明之后根据数据类型不同会有不同的默认值

int,long默认值为0，double默认值为0.0，boolean 默认值为false,char默认值为空字符。

声明的要点：

int [ ] arr 与 int arr [ ] 两种写法均可

//数组的初始化
        int[] arr1 = new int[5];//arr1的长度是5, 这里的每个元素都是int类型的默认值：0
        char[] arr2 = {'a', 'b', 'c', 10, 8};//arr2的长度是5，  每个位置的元素已经指定了。
        double[] arr3 = new double[]{1.5, 2.3, 25.5};//arr3的长度是4. 每个位置都有具体的数据。

数组相关的函数

相关函数	演示方法	解释
Arrays.sort()	Arrays.sort(数组名)	排序的方法（将数组升序排列）
System.arraycopy()	System.arraycopy(复制数组名，起始位置，目标数组名，起始位置，复制元素个数)	将一个数组中的某一段元素复制到另一个数组的某一段位置中
Arrays.copyOf()	Arrays.copyOf（需要扩容的数组，扩容后的长度）	将一个数组放进另一个更大的数组当中实现数组长度的增加
Arrays.toString()	Arrays.toString(数组名)	将数组转换成String类型输出
Arrays.equals ()	Arrays.equals (数组1，数组2)	比较两个数组内容是否相等

练习

public static void main(String[] args) {
        //练习1 判断正负数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num = sc.nextInt();
        if (num == 0){
            System.out.println("该用户输入的是0");
        }else {
            String compare = num>0?"该用户输入的是正数":"该用户输入的是负数";
            System.out.println(compare);
        }

        //练习2 收银台程序
        Scanner cashier = new Scanner(System.in);
        System.out.println("请输入商品的单价");
        double price = cashier.nextDouble();
        System.out.println("请输入商品的数量");
        int count = cashier.nextInt();
        System.out.println("请输入收款金额");
        double pay = cashier.nextDouble();
        double cash = price*count;
        double change = pay-cash;
        System.out.println("应收："+cash/*(price*count)*/+"元"+" "+"找零："+change/*(pay-(price*count))*/);

        //练习3 判断是否为闰年
        Scanner y= new Scanner(System.in);
        System.out.println("请输入一个年份");
        int year = y.nextInt();
        if (year%4==0 && year%100!=0 || year%400==0){
            System.out.println("该年为闰年！");
        }else {
            System.out.println("该年不是闰年");
        }
    }

//手动输入9的个数计算9+99+999+9999+....
public static void sum() {
        //复杂
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入9的个数");
        int t = sc.nextInt();
        int k = 9;
        int s = 9;
        for (int i = 1; i <= t - 1; i++) {
            k = k + (9 * (int) (Math.pow(10, i)));
            s += k;
            System.out.println(s + "  " + k);
        }
        //简单
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入9的个数");
        int num = sc.nextInt();
        double sum = 0 ;
        for(int i = 1; i <=num  ; i ++){
            double data = Math.pow(10 , i ) -1 ;//
            sum += data;
        }
        System.out.println("sum:" + sum);
    }

//个人所得税
public static void tax() {
        Scanner sc = new Scanner(System.in);
        System.out.println("工资收入(整数)" + "  " + "社保（整数）");
        int salary = sc.nextInt();
        int insurance = sc.nextInt();
        double tax = salary - insurance - 3500;
        if (tax < 0) {
            tax = 0;
        } else if (tax <= 1500) {
            tax = tax * 0.03;
        } else if (tax <= 4500) {
            tax = tax * 0.1 - 105;
        } else if (tax <= 9000) {
            tax = tax * 0.2 - 555;
        } else if (tax <= 35000) {
            tax = tax * 0.25 - 1005;
        } else if (tax <= 55000) {
            tax = tax * 0.3 - 2755;
        } else if (tax <= 80000) {
            tax = tax * 0.35 - 5505;
        } else {
            tax = tax * 0.45 - 13505;
        }
        System.out.println("你的个人所得税是："+tax);
    }

//计算2~100的质数
public static void f1() {
        for (int i = 2; i <= 100; i++) {
            for (int j = 2; j < Math.sqrt(i); j++) {
                if (i % j == 0) {
                    break;
                }
                if (j == (int) Math.sqrt(i)) {
                    System.out.println(i);
                }
            }
        }
    }

//彩票
public static void f2() {
        Scanner sc = new Scanner(System.in);
        int red[] = new int[6];//红球
        int blue[] = new int[1];//蓝球
        int color[] = new int[7];//你输入的彩票
        int ck[] = new int[7];//实际产生的彩票
        int w = 0;//校验位
        //你输入的彩票号码
        System.out.println("请输入7位数的号码");
        for (int i = 0; i < color.length; i++) {
            color[i] = sc.nextInt();
        }
        //验证红球输入的数据是否合理
        for (int i = 0; i < red.length - 1; i++) {
            for (int j = i + 1; j < red.length; j++) {
                if (red[i] != red[j]) {
                    System.out.println("数据重复输入(红)");
                    return;
                }
            }
        }
        for (int i = 0;i<red.length;i++){
            if (color[i]>33||color[i]<0){
                System.out.println("数值过大或过小(红)");
                return;
            }
        }
        //验证蓝球输入的数据是否合理
        if (color[6] >= 8||color[6]<0) {
            System.out.println("数据无效请重新输入（蓝）");
            return;
        }
        //产生红球
        for (int i = 0; i < red.length; i++) {
            red[i] = (int) (Math.random() * 32 + 1);
        }
        for (int i = 0; i < red.length; i++) {
            for (int j = 1; j < i; j++) {
                if (red[i] == red[j]) {
                    for (int k = 0; k < red.length; k++) {
                        red[i] = (int) (Math.random() * 32 + 1);
                    }
                }
            }
        }
        System.out.print("红球：");

        System.out.println(Arrays.toString(red));
        //产生蓝球
        System.out.print("蓝球：");
        System.out.println(Arrays.toString(blue));
        //彩票
        System.out.print("彩票:");
        System.arraycopy(red, 0, ck, 0, 6);
        System.arraycopy(blue, 0, ck, 6, 1);
        System.out.print(Arrays.toString(ck));
        System.out.println();
        System.out.print("你的号码为：");
        System.out.print(Arrays.toString(color));
        System.out.println();
        //校验
        for (int i = 0; i < color.length; i++) {
            if (color[i] == ck[i]) {
                 w +=1;
            }
        }
        //判断
        if (w==7){
            System.out.println("恭喜你中奖了");
        }else {
            System.out.println("谢谢惠顾");
        }
    }

//验证身份证号码的合法性
public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String next = scanner.next();
        char id[] = next.toCharArray();//toString-转为字符串，toCharArray-转为字符数组
//        int id17[] = {5, 2, 0, 2, 0, 3, 2, 0, 0, 1, 0, 2, 0, 7, 0, 2, 1};//身份号码的前17位
//        char id18 = 'X';//最后一位
        int id17 []= new int[17];
        for (int i=0;i<id17.length;i++){
            id17[i] = id[i]-48;//比如：字符‘5’，如果直接赋值int，那么是把字符‘5’的编码赋值给int，导致最后计算结果错误
                                // 这里利用： ascii码表的数据值，比如‘5'对应的编码整数为53，‘0’对应的整数位48
                                //得到的就是正好是整数5

        }
        char id18 = id[id.length-1];//身份证号码的最后一位
        int datas[] = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};//系数
        char valids[] = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'};//校验位
        //累加算法
        int sum = 0;
        for (int i = 0; i < id17.length; i++) {
            sum += id17[i] * datas[i];
        }
        //计算余数
        int y = sum % 11;
        //把余数作为valids的下标，获取数组元素
        char data = valids[y];
        if (data == id18) {
            System.out.println("身份证合法");
        } else {
            System.out.println("身份证不合法");
        }
    }

错题分析

1.Java语言是1995年发布的，发布该语言的公司是：（ A ）D

A.Oracle B. Borland C. Microsoft D.Sun

2.编译和运行以下代码的结果为：B D
  public class Hello{
  public static void main(String s){ //java对于main函数的创建有着严格的格式要求
  System.out.println("Hello");
  }
}

A. 编译错误                    B.运行输出 "Hello"

C.编译无错，但运行时指示没有定义构造方法

D.编译无错，但运行时指示没有正确定义main方法

12.编译和运行以下代码的结果为：A?B
   public static void main(String args[]){
     byte b=(byte)4096;
     if(b==4096)
        System.out.println("Equal");

//System.out,println("Equal");这句不会执行，因为if-else的用法如果不加{}，那么只能作用于if-else下方的第一句代码

    else
        System.out.println("Not Equal");
   }

A.在第3行出现转换丢失精度的编译错误

B.输出“Not Equal”

C.输出“Equal”

D.在第四行出现编译错误

14.编译运行以下程序后，关于输出结果的说明正确的是:B C
       public static void main(String args[ ]){
             int x=4;
             System.out.println(“value is “+ ((x>4) ? 99.9 :9));
       }

A.输出结果为：value is 99.99       B.输出结果为：value is 9

C.输出结果为：value is 9.0         D.编译错误

//三目运算表达式的最后结果数据类型为：整个表达式中数据类型最高的那个

16.Java语言中字符串“学Java”所占的内存空间是:A C

//Unicode当中一个字符占两个字节

A. 6个字节 B. 7个字节 C. 10个字节 D.11个字节

17.下列代码段的输出结果是：A D
public static void main(String[] args) {
int x = 5;
boolean b1 = true;
boolean b2 = false;
if ((x == 4) && !b2)
    System.out.print("l ");
System.out.print("2 ");
if ((b2 = true) && b1) //b2=true是赋值运算，恒为真
    System.out.print("3");
}

A. 2     B. 3     C. 1 2           D. 2 3

18.请看看列代码： C?B
public void testIfA() {
if (testIfB("True")) {
    System.out.println("True");
} else {
    System.out.println("Not true");
}
}
public Boolean testIfB(String str) {
   return Boolean.valueOf(str); //将字符串类型转换成boolean类型，字符串“True”能够被转换成boolean类型的true

}
在JDK1.6版本中，调用执行testIfA方法，程序的结果是：

A.输出Not true                     B.输出True

C. if (testIfB("True")) { 行，编译错误

D. return Boolean.valueOf(str); 行，编译错误

22.下列代码段编译和运行的结果是：B D
public static void main(String[] args) {
for (int i = 0; i <= 10; i++) {

if (i > 6)
break;
}
System.out.println(i); //变量i已经超出它的作用域
}

A.输出 6 B.输出 7 C.输出 10 D.编译错误