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


package day1; // package -包  ， day1 就是包名


import java.util.Scanner; // import - 导入

//  class -  类 ， 类型   ， InputDemo就是类名
// public - 公开的 ，修饰类
public class InputDemo {
    // java程序的入口函数 ： 能直接运行的方法
    // static - 静态的 ，  void - 表示方法无返回值
    // String - 字符串  ， 是java中定义好的一种类型
    public static  void  main(String[] arg){
        // 从键盘输入名字
        Scanner scan = new Scanner(System.in);// - 定义了一个叫scan的变量

        System.out.println("请输入名字：");

        String  name = scan.next(); // 通过键盘输入一个名字 , 保存在变量name中。

        //  + 完成 字符串的拼接
        System.out.println(name + "， 早上好！");// “;”表示一句代码结束了。
    }
}

package day1;//package是Java中的关键字，有特殊功能，标志day1是关键字

import java.util.Scanner;

//输入用户信息，然后输出用户信息
//public是Java的关键字，标志类是一个公开类
public class InfoDemo {//class是一个关键字，这里表示InfoDemo是一个类
    //java的入口函数（方法）
    public static void main(String[]args){
        Scanner sc=new Scanner(System.in);//new是Java中的关键字，创建对象
        System.out.println("请输入你的名字：");//sout：就能输出System.out.println（）
        String name =sc.next();//用户只能输入字符串
        System.out.println("请输入你的年龄：");
        int age = sc.nextInt();
        System.out.println("请输入你的地址");
        String address =sc.next();//sc,name,age,address都是变量名
        System.out.println(name+"今年"+age+"岁，家住"+address);

    }

}

package day1;

import java.util.Scanner;

// 功能：  用户输入两个整数  ， 然后求和 ， 输出结果
public class SumDemo {
     // java的入口函数main
     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入一个整数：");
         // int  (integer) , 在java中表示整数
         int  a =  sc.nextInt(); // 输入整数
         System.out.println("请再输入一个整数：");
         int  b = sc.nextInt();
         System.out.println("和：" +(a+b));// (a+b) 提高优先级 ， 先算加法，然后再字符串拼接
     }
}

2.Java的变量

2.1 什么是变量

变量是指代在内存中的一块存储空间，用于存储程序运算过程中需要用到的数据。

2.2 变量的定义

变量声明的语法规则：变量类型变量名字

在变量声明时同时初始化:

变量类型变量名字 = 初始值;

先声明变量，在第一次使用变量之前再对变量赋初值
未经声明的变量不能使用
如果多个变量的类型相同，可以在一条语句中声明，中间用逗号分隔。
变量的命名需要符合Java标识符语法要求

-可以有字母，数字，”_”和”$”符组成

-首字符不能以数字开头

-Java是大小写敏感的语言，命名变量时需要注意

-不能使用Java保留字(Java语言规定好的，有特殊含义的字符：public static void…

中文可以作为变量名字，但是不推荐使用。

Java变量命名最好能“见名知意”

Java编程规范要求：变量的命名需要采用“驼峰命名法”，即：如果Java变量名字由多个

英语单词组成，除第一个单词首字母小写外，其他的单词，需要首字母大写，其余的字母小写。

2.3 变量的访问

可以对变量中的值进行存取操作
变量在定义的时候，指定了类型。Java编译器会检测对该变量的操作是否符合定义的数据类型，如果对变量的赋值或操作不符合定义的数据类型，会产生编译错误。

2.4Java中的关键字

2.5变量相关代码

public class VarDemo {
    public static void main(String[] args) {
        // 1. 定义变量 ， 然后给变量赋值。
        int a  ;   // 定义了一个整形变量a。
        a = 100 ;//  “=”  ， 表示给变量赋值
        int b ;
       // b = 100 ； // 编译错误： 这里把.java的源文件， 编译为.class的字节码文件， 发现“；”是中文的。
        b = 100 ;
        int c = a + b ;
        System.out.println("c:" + c);
        // 2. 定义变量的时候，直接给变量赋值。
        String  birth = "2000-10-10";
       // int a = 22 ; // 编译错误： 同一个代码区域内部，不允许变量名重复。
        int age = 22 ;
        System.out.println("你出生于：" + birth + ",今年：" + age  + "岁");
        // 3. 未经声明的变量不能使用
       // address = "歇台子"; 编译错误， 未经声明的变量不能直接使用。
        String  address ; // 声明变量
        address = "歇台子";
        // 4. 一条语句声明多个变量
        int a1 , a2 , a3 ;
        //System.out.println( a1 + a2 + a3); // 编译错误： 没有初始化的变量，不能直接做加法运算。
        a1 = 5 ;
        a2 = 6 ;
        a3 = 7 ;
        System.out.println("和：" + (a1+a2+a3));
        int b1= 7 ,b2=8 , b3=9 ;
        System.out.println("和：" + (b1+b2+b3));
        // 5. 变量命名规则
        int $ = 100;
        int _ = 200;
       //  int * = 300;// 编译错误：变量命名只能包含数字，字符， _ , $ ,并且不能时纯数字。
        String  name = "alice";
        // System.out.println(Name); // 编译错误： 变量名严格区分大小写。
       // int int = 2022111;  // 编译错误：关键字不能作为变量名。
        String englishName = "张老师"; // 这里是不是驼峰命名法： 第一个单词首字母小写，后续单词首字母大写。

    }
}

3.Java中的基本数据类型

3.1 整型 int

int是最常用的整数类型。一个int类型占用4个字节（32位），

最大表示范围为：-2147483648 ~ 2147483647

整数类型的直接量(literal)默认是int类型。
两个int整数相除(/)，结果取整，舍弃小数部分（非四舍五入），结果还是整数
整数运算要防止溢出

-整数运算的过程中，运算结果，如果超过了整数能表示的最大范围，会发生溢出。

正数过大溢出，结果变为负数；负数过小溢出，结果变为正数。

与整型相关的代码：

//  int数据类型介绍
public class IntDemo {
    public static void main(String[] args) {
        // 1. int的数据是占4个字节
        int  a = 10000 ;
        System.out.println("a:" + a); // 输出变量a.
        //int a1 = 10000000000 ;// 100亿  , 编译错误。 超过了int的最大范围。
        int  b = 1500000000;
        int  c = 1500000000;
        int  sum = b + c ;  // 和超过了int的最大值
        System.out.println("sum:" + sum);// sum:-1294967296 ,  这里溢出了。
        //2 . 直接量
        int k  = 100 ;// 这里的100就是直接量
        System.out.println("k十进制：" + k);
        int k1 = 0x100;
        System.out.println("k1十六进制:" + k1);
        int k2 = 0100;
        System.out.println("k2是8进制：" + k2);
        // 3. int数据的运算：  +  , - , *  , /(取整) ， % （取余）
        int a1 = 9 ;  // 定义变量
        int a2 = 4 ;
        int c1 = a1 + a2 ; // c1 = 13
        int c2 = a1 - a2; // c2 = 5
        int c3 = a1 * a2; // c2 = 36
        int c4 = a1 / a2;// 取整: java程序中规定，两个整数的运算结果只能是整数(9/4 等于2)
                         //   , 数学中(9/4等于2.25)
        System.out.println("c4:" + c4);
        int c5 = a1 % a2;// 取余： 获取两个数相除的余数
        System.out.println("c5:" + c5);
        // 思考， 怎么判断一个数据是奇数还是偶数
        if(a1 % 2  == 0){ //a1 % 2  == 0 判断是否相等 , 结果是true或false.
            System.out.println(a1 + "是偶数");
        }else{
            System.out.println(a1 + "是奇数");
        }
        // 除法的练习 :计算百分比
        int  current = 33 ;
        int  total = 50 ;
        System.out.println("第一种：");
        System.out.println( current / total   * 100 + "%");
        System.out.println("第二种：");
        System.out.println( current  * 100 / total + "%");
    }
}

3.2 长整型 long

如果要表示的整数已经超过了int的范围，那么可以用long类型定义变量，保存数据。

long类型数据范围（8个字节，64位）：

-9223372036854775808~9223372036854775807

long类型直接量的表示，需要在数据后面加一个L或l;
通过long类型来存储系统当前毫秒数，jdk提供了一个方法（ System.currentTimeMillis() ）,来获取从1970.1.1日零时至今的毫秒数，返回结果为long。
对于较大的整数运算(超出int范围)，可以使用long型。

与长整型相关的代码：

// long : 长整形 ， 8个字节 ， 如果int数据范围不够，就选择使用long
public class LongDemo {
    public static void main(String[] args) {
        // 1. 定义long类型的变量
        long a1 = 100;
        // java中“直接量”默认为int类型。
       // long a2 = 10000000000;// 100亿超过了int的范围，所以导致编译错误。
        long a2 = 10000000000L ; // 在直接量后，添加"L 或 l "的标志，表示这个直接量是long类型。

        // 2. 时间毫秒数
        // 练习： 自己计算一年的毫秒数
       // long micro = 365 * 24 * 60 * 60 * 1000 ; //全部都是int类型参与运算，结果就是int类型，超过int范围，就溢出。
        long micro = 365L * 24 * 60 * 60 * 1000 ; // 把365转为long类型， 所以运算结果就是long类型。
        System.out.println("一年的毫秒数：" + micro);
        // 3. 获取系统的时间毫秒数：  起点为1970.1.1 0:0:0 距离此刻的时间毫秒数
        long  time = System.currentTimeMillis();
        System.out.println("距今的时间毫秒：" + time);


    }
}

3.3 浮点型 double & float

所谓的浮点类型就是小数类型，包含double 和 float。

浮点类型的默认直接量是double类型。

如果要使用float类型，需要在数据后面加F或f。

double类型的精度比float类型的精度高，因此，一般用double类型。

eg:

float f1 = 3.3F;

double money = 3.5;

double类型数据运算的时候，会有舍入误差。

由于舍入误差，导致浮点数不能精确运算。

二进制中无法表示1/10，就像十进制中无法精确表示1/3，所以二进制表示浮点数存在误差

相关代码：


// double - 双精度浮点型 （8个字节）
// float - 单精度浮点型 (4个字节)
public class DoubleDemo {
    public static void main(String[] args) {
        // 1. 定义变量
        double  a1 = 3.5 ;
        //float a2 = 3.5 ;// 编译错误： java中的浮点数直接量默认是double类型。 不能将double直接赋值给float.
        float a2 = 3.5F  ;//  直接量的好后面，使用“F 或 f” ，让直接量为float类型。

        // 2. double 用于计算： + ， - ， *  ,  /   , %
        double a3 = 1.5 ;
        System.out.println(a1 + a3); // 5.0
        System.out.println(a1 - a3); // 2.0
        System.out.println(a1 * a3); // 5.25
        System.out.println(a1/a3); // 2.3333333333333335
        System.out.println(a1%a3); // 0.5

        double a4 = 1.4 ;
        System.out.println(a3 - a4);//0.10000000000000009

        // 3. 练习： 计算自由落体运动的位移 ：  s = 1/2 * g * t * t;
        double g = 9.8 ;
        int  t = 5 ;
        double s ;
        s = 0.5 * g * t * t; // 运算数据有double类型，因此整体的结构时double类型。
        System.out.println("位移为:" + s ); // 位移为:122.5


    }
}

3.4 字符类型Char

字符类型实质上是一个16位的无符号整数，这是整数对应的字符编码

Java字符类型采用Unicode字符集编码。Unicode字符编码是国际上通用的定长字符集，所有字符都是16位。

字符直接量，可以采用字符的形式，比如‘中 ’；

或者采用Unicode编码的方式，比如：‘\u4e4d’

字符是整数可以参与运算，比如 char c = ‘A’ ; int a = 10 + c ;//75

字符直接量赋值

整数赋值(0~65535)

Unicode编码赋值

eg: char a = ‘A’;

char a = 65;

char a = ‘\u0045’;

转义字符（\）:对于不方便输出的字符，采用转义字符表示。

相关代码：

// char - 字符   ， 本质就是一个整数 , 占两个字节， 且无符号位。
public class CharDemo {
    public static void main(String[] args) {
        // 1. 定义字符类型的变量
        char a = 'A';
        System.out.println(a);
        // char b = 'AB';// 编译错误： 字符只能是单个
        // 2. 字符的本质就是整数
        // 字符和整数的对应关系，一般就称为编码表。
        // 比如ascii码表 ， utf-8编码表， gbk编码表
        int b = a ; // 这里把a的编码对应的整数，赋值给变量b .
        System.out.println(b); // 65
        int c = '中';  // ‘中’对应的编码，赋值给c。
        System.out.println(c);
        // 3.  字符的表达方式
        char  d = '0';
        char  d1 = 48 ;
        char  d2 = '\u0048';
        System.out.println(d  + ":" + d1 + ":" + d2);
        // 4. 字符的运算
        char  d3 = '0'; // 编码为48
        char d4 = '9'; // 编码为57
        System.out.println(d4 - d3); //  9
        //5 . 字符范围
       // char  c2 = -5 ; // 编译错误 ： 字符都是正整数 , 这里比最小值还小。
       //  char  c3 = 1000000; // 编译错误：超过了字符的最大值（65535）
        int  k = 100000;
        //char c4 = k ;  //编译错误： 只能把整数的直接量赋值给字符 ，不能把int变量赋值给字符。
        short k1 = 300;
       //  char c5 = k1;
        // 6. 转义字符：  程序中的特殊字符，如果要输出，可以选择使用 "\ + 字符"方式， 然后输出这个内容。
        System.out.println("孔子说:\"学而时习之。\"");
        System.out.println("3\t+\t5\t=\t8");


    }
}

3.5 布尔类型 Boolean

boolean类型,即布尔类型，适用于逻辑运算，一般在程序流程控制中作为条件判断。
boolean类型的值只有两个：true/false。不能用0或非0代替true/false.
boolean类型不能与整数类型做转换。

相关代码：

//boolean-布尔：true（真），false（假）
public class BooleanDemo {
    public static void main(String[] args) {
        //1.定义变量
        //java中规定boolean类只有两个值：true，false
        boolean a = true;//true就是一个直接量
        boolean b = false;//false就是一个直接量
        //boolean c = 1;//1不是布尔类型。不能赋值给变量c
        //2.运算，逻辑运算
        //&&与运算，||或运算，！非运算
        boolean c = a && b;//c=false
        System.out.println(c);
        c = a||b;//c=true
        c = !a;//c=false
        //3.Boolean类型只要用于条件判断
        int age=19;
        boolean d = age > 18 ;//age>18,结果是true。所以d=true
        if(d){
            System.out.println("成年人");
        }
        else{
            System.out.println("未成年人");
        }

    }
}

3.6 数据类型转换

自动数据类型转换（隐式转换）：小类型，自动转为大类型。

强制数据类型转换：从大类型，转到小类型，需要强制转化，可能会有精度损失或者溢出。

相关代码：

//数据类型转换
//自动类型转换
//强制类型转换
public class DataTypeDemo {
    public static void main(String[] args) {
        //1.自动类型转换
        long a1 = 100;//自动类型转换，直接量100是int类型.a1是long类型。说明这里就自动类型转换
        //int a2 = 3.6;//编译错误，3.6是double类型，a2是int，不能直接转换
        int a2 = (int)3.6;//强制数据转换，在数据3.6前面添加（int），告诉程序把3.6转换成int
        double a3 = 3.6;
        System.out.println("a1:"+a1);//100
        System.out.println("a2:"+a2);//3
        System.out.println("a3:"+a3);//3.6
        //3.强转造成精度损失或者溢出
        double d = 3.154654562515;
        float d1 = (float) d ;
        System.out.println("精度损失："+d1);

        long data = 10000000000L;
        int data1 = (int)data;
        System.out.println("溢出："+data1);
        //4.byte,short两种数据
        byte b1 = 100 ;
        //byte b2 = 200;//编译错误，超出了short的范围
        short s1 = 100;
        //short s2=10000000;//编译错误，超过了short的范围
        byte b2 = 5;
        //byte b3=b1+b2;//编译错误,数据类型不匹配，Java中的运算byte和short，都会转换为int的结果
        byte b3=(byte)(b1+b2);
        System.out.println("b3:"+b3);
        //5.面试题
        short c1 = 5;
        short c2 = 5;
        //short c3 = c1+c2;//编译错误，short参与运算的时候，转换为int，运算结果就是int，int类型不能直接赋值给short
        short c3 = (short)(c1+c2);
        System.out.println("c3:"+c3);
        short c4 = 5+5;//这里可以，是因为编译时，这里的5+5是直接量的运算，已经计算出结果为10，10可以赋值给short
        //一天的毫秒数
        long time = 24*60*60*1000;//这里全都是直接量，所以编译器会将结果算出来，赋值给time
        System.out.println(time);
        //6.练习
        //a.定义一个long类型的变量赋值给double类型的变量
        //b.定义一个char类型的变量赋值给short类型
        //c.定义一个float类型的变量，然后赋值给int类型
        //d.定义一个Boolean类型的变量，然后赋值给byte类型

        long h1 = 10;
        double h2 = h1;//自动类型转换
        System.out.println("h2:"+h2);
        char h3 = 'A';
        short h4 = (short)h3;//强制类型转换
        System.out.println("h4:"+h4);
        float h5 = 5.235641541F;
        int h6 = (int)h5;//强制类型转换
        System.out.println("h6:"+h6);
        boolean h7 = true;
        //byte h8 = (byte)(h7);//编译错误，Boolean类型不能转成任何类型的整数


    }
}

4.运算符

4.1算数运算符

Java中的算数运算符，包含：+（加），-（减），*（乘），/（除）,%（取余），++（自增）,--(自减)。

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

++，--写在变量的前面，运算的时候，需要先增加或者减少1，再参与运算。

++，--写在变量的后面，运算的时候，需要先参与运算，再增加或者减少1。

“+”,“-”,可以作为数据正负符号。

相关代码：

//算数运算符：+, - ,* ,/, %
//          ++ ,--
//          符号（+ -）
//能做算数运算的类型： byte，short，int，long，char，float，double
//不能做算术运算的类型：Boolean，其他复杂类型

public class SuanShuDemo {
    public static void main(String[] args) {
        //1.加法（减法，乘法）运算
        long data1 = 10;
        double data2 = 3.5;
        double data3=data1 + data2;//运算结果以大范围的数据为准
        System.out.println("data3:"+data3);
        //2.除法运算
        double data4 = data1/3*data2;//运算结果以大范围数据为准
        System.out.println("data4:"+data4);//10.5
        data4=1/2;//0.0:这里1，2都是int类型，所以运算结果是0，但是把int的数据类型赋值给double类型，所以最终值是0.0
        System.out.println("data4:"+data4);
        data4=1/2.0;
        System.out.println("data4:"+data4);//0.5
        //3.取余（%）运算
        long m = data1 % 3;//如果m是0，表示他能整除，如果m不是0，表示不能整除
        boolean k = m==0;//m==0,表示判断m是否为0，是结果为true，不是结果为false
        System.out.println("k:"+k);
        //4.++(--)运算:在原来的数据上增加1或者减少1
        int i = 5;
        i ++; //自增，i = i + 1;自己加1再赋值给自己
        System.out.println("i:"+i);
        i --;
        System.out.println("i:"+i);
        /*
        int j = ++ i;//前自增：先对i进行增加，然后把增加后的数据值，赋值给变量j
        System.out.println("i:"+i+",j:"+j);
        */
        int j =i ++;//后增加：先把i的数据值，赋值给变量j,然后在对i增加1
        System.out.println("i:"+i+",j"+j);//i=6,j=5

        /*int i1 = i++ + j++ + i--;
        System.out.println("i1:"+i1);//i1=18

         */
        int i2 = ++i + j++ + i--;
        System.out.println("i2:"+i2);

        //5.符号（+，-）
        int m1 = -5;//负号
        int m2 = +5;//正好
        int m3 = -5-5;
        System.out.println("m3:"+m3);
        int m4 = -5 + -10;
        System.out.println("m4:"+m4);
        int m5 = -5+ +10;
        System.out.println("m5:"+m5);

    }


}

4.2关系运算符

Java中的关系运算符，包含：>（大于），<（小于），==（等于），>=（大于等于）,<=（小余等于），!=（不等于）。
关系运算的结果为boolean类型。

相关代码

//关系运算
//大于(>) , 大于等于(>=), 等于(==) , 不等于(!=), 小于(<), 小于等于(<=)
//能进行关系运算：byte, short,char,int,float,double
//不能进行关系运算：Boolean，其他的引用类型

public class GuanXiDemo {
    public static void main(String[] args) {
        int a = 100;
        int b = 200;
        boolean r = a > b;//关系运算：r是false
        System.out.println("r:"+r);
        char c = '中';
        char c1 = '国';
        if(c>c1){ // c > c1 : 如果满足条件。那么就是true。否则就是flase
            System.out.println("中的编码值大于国的编码值");
        }
        else{
            System.out.println("中的编码值小于国的编码值");
        }
        //2.等于（==）
        int a1 = 10 ;
        int a2 = 20 ;
        //int a3 = a1==a2;//编译错误：a1==a2是条件运算，结果是Boolean类型，不能赋值给int类型
        int a3 = a2 = a1 ; //"="是赋值运算
        System.out.println("a1:"+a1+",a2:"+a2+",a3:"+a3);
        //3.练习：定义两个整数，找到两个整数中最大的那个值
        a1=30;
        a2=50;
        boolean b1 = a1 >= a2;//赋值的优先等级最低，先做其他运算，最后赋值
        if(b1){
            System.out.println("a1大："+a1);
        }
        else {
            System.out.println("a2大："+a2);
        }


        }
}

4.3逻辑运算符

&& “与”运算
|| “或”运算
！“非”运算
逻辑运算的结果为boolean类型。

相关代码：

//   逻辑运算： &&与,||或,！非
//   运算规则：与运算（全为真则结果为真，有一个假则结果为假）;
//           或运算（全为假则结果为假，有一个真则结果为真）;
//           非运算（真变假，假变真，本质就是取反）
//   能做逻辑运算的类型：Boolean
//   不能做逻辑运算的类型：除了Boolean类型，都不能做逻辑运算


//  短路逻辑： && , ||,当我们能判断出运算结果的时候，后续的表达式不再执行，——常用短路逻辑
//  不短路逻辑： & , | , 每个参与运算的表达式都需要执行。——不常用

public class LuoJiDemo {
    public static void main(String[] args) {
        boolean b1 = true ;
        boolean b2 = true ;
        boolean b3 = false;
        boolean b4 = b1 && b2 ;//true
        System.out.println(b4);
        b4 = b1 && b2 && b3 ;//false
        System.out.println(b4);
        b4 = b1 || b3 ;//true
        System.out.println(b4);
        b4 = b1 || b2 || b3 ;//true
        System.out.println(b4);
        b4 = ! b3 ;//true
        System.out.println(b4);
        b4 = !(b1||b2) ;//false
        System.out.println(b4);
        b4 = !(b1 && b3)|| b3 ;//true
        System.out.println(b4);

        //2.短路逻辑与，短路逻辑或
        int a = 3 , b = 5 ;
        /*boolean b5 = a > b && a++ > 1 ;//a>b是false，那么&&运算的结果确定出来是false，这里用的是”短路&&“，
                                       // 所以后面a++>1的语句不会被执行到，因此a的结果还是3
        System.out.println("a:"+a);//a是3

        boolean b5 = a > b & a++ > 1;//"&"不短路与，整个运算的所有表达式都要执行
        System.out.println("a:"+a);//a是4

        boolean b6 = a < b || a ++ > 0 ;//a<b 结果为true，“短路||运算”, 后面的a++>0不会判断。
        System.out.println("b6:"+b6+",a:"+a);

         */
        boolean b6 = a > b || a ++ > 0 ;//a>b结果为false,或运算结果不定，因此判断a++>0的情况。
        System.out.println("b6:"+b6+",a:"+a);

    }
}

4.4 赋值运算符和扩展赋值运算符

赋值运算符“=”是最常用的赋值运算。它将“=”右边的运算结果的值，赋给“=”左边的变量。
赋值运算符的优先级很低。（低于算数运算符）
在赋值运算符的前面，加入算数运算符，即为扩展赋值运算符。

+=，-=，*=，/=，%=

4.5 字符串拼接"+"

运算符“+”，用于数据类型，加法运算。
运算符“+”，用于字符串型，字符串拼接运算。
字符串（String）+ 数据，java中会自动将数据转为字符串，然后两个字符串相连，生成一个新的字符串。

4.6三目运算符

三目运算符格式:

X ? Y : Z; --?boolean表达式?表达式1 ：表达式2；

X为boolean表达式，如果X为true,在运算结果为Y的值，

如果X为false，则运算结果为Z的值。

4.7扩展赋值运算和三目运算和字符串拼接代码:

//1.= ，赋值运算
//2.+=,-=,*=,/=,%= 扩展的赋值运算符：表示变量的数据取出来和其他的数据进行运算，然后把运算结果赋值给变量。
//3.”+“用于字符串拼接
//4.三目运算： ？ ： , 语法规则：boolean表达式？表达式1：表达式2，boolean值为true，执行表达式1，否则执行表达式2

import java.util.Scanner;

public class OtherYunSuanDemo {
    public static void main(String[] args) {
        //1.扩展的赋值运算符
        int k = 10 ;
        k += 20;//k=? 这里k+=20等价于k=k+20.所以k=30
        System.out.println("k:"+k);

        k/=4;//k=?,k=k/4,所以k=7
        System.out.println("k:"+k);
        //2."+"做字符串拼接
        String str = "hello" ;
        System.out.println(k+k+str);//14hello
        System.out.println(k+str+k);//7hello7
        System.out.println(str+k+k);//hello77
        System.out.println(str+(k+k));//hello14
        System.out.println((str+k)+k+k);//hello777
        System.out.println(str+k+k);//hello77
        System.out.println(k+k+k+k);//28
        //3.三目运算
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的年龄：");
        int age1 = scanner.nextInt();
        int age = 19 ;

        String info = age1 >= 18?"成年人":"未成年人";//需要把三目运算的结果，赋值给一个变量保存起来
        System.out.println("你现在："+age1+"岁，你是："+info);
    }
}

5.Java程序的结构

5.1 顺序结构

按照由上到下的顺序依次执行的代码

5.2 分支结构

Java语法中的分支结构包含以下四种
分支结构可以嵌套使用

1.if //如果…

//介绍if的语法规则
//     if（boolean值）{//代码}，boolean值为true，那么执行if语句块，值为false，跳过这段代码，不执行这段代码
public class IfDemo {
    public static void main(String[] args) {
        //如果超过99，就打八折
        Scanner scanner = new Scanner(System.in);
        System.out.println("请用户输入单价和数量：");
        double price = scanner.nextDouble();
        int number = scanner.nextInt();
        double total = price * number;//有double类型参与运算，结果为double类型
        //判断total是否超过999，然后觉得是否需要打折
        if(total>=999){
            total*=0.8;
        }
        System.out.println("您需要支付："+total);

    }
}

2.if……else…… //如果…否则…

//用户输入1-7的整数，然后程序转换为：星期几
public class IfElseManyDemo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入1-7之间的整数：");
        int week = scanner.nextInt();
        if(week>=1 && week<=7){
            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("星期天");

            }
        }
        else {
            System.out.println("请输入1-7之间的整数");
        }
    }
}

3.if…….else if……. //如果…否则如果…..

//if...else if...else if....   else的后面可以使用多个if语句
public class IfElseManyDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个分数：");
        double score = scanner.nextDouble();
        if(score>=0 && score<=100){
            if(score>=90){
                System.out.println("A等级");
            } else if (score>=80) {
                System.out.println("B等级");
            } else if (score>=70) {
                System.out.println("C等级");
            } else if (score>=60) {
                System.out.println("D等级");
            }
            else {
                System.out.println("E等级");
            }
        }
        else {
            System.out.println("你输入的分数不合理，应该是0-100之间的数据。");
        }
    }
}

4.switch……case…… //switch….情况1…情况2…..

//用户输入分数，计算出等级

import java.util.Scanner;

public class SwitchDemo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的分数（0-100的整数）：");
        int score = scanner.nextInt();
        score/=10;//score=score/10(目的是把0-100的整数转换为0-10的整数)
        switch (score){
            case 10:// 没有break就会执行到下一个case
            case 9:
                System.out.println("A");
                break;
            case 8:
                System.out.println("B");
                break;
            case 7:
                System.out.println("C");
                break;
            case  6:
                System.out.println("D");
                break;
            default:
                System.out.println("E");

        }
    }
}

5.3 循环结构

5.3.1 for循环

循环是程序设计语言中反复执行某些代码的一种计算机处理过程，是一组相同或相似的语句被有规律地执行。

        循环三要素
        1.循环变量初始化
        2.循环条件（以循环变量为判断条件）
        3.循环变量的改变（向着循环结束变）

for循环是最经典的循环语法，也是使用最多的循环方式。

        for语法规则：
        for(表达式1；表达式2；表达式3){
        // 语句序列
        }
        表达式1：初始化表达式，负责完成循环条件的初始化
        表达式2：循环条件表达式，值为boolean的表达式，指定循环条件
        表达式3：循环后的操作表达式，负责修改变量，改变循环条件

for循环的执行步骤

        步骤1：先初始化控制变量，判断该控制变量是否满⾜循环条件，是则进⼊循环体，否则退出循环
        步骤2：更新控制变量，对控制变量进⾏增量或减量操作，再判断此时控制变量是否满⾜条件，满⾜条件则进⼊循环，否则退出循环
        步骤3：继续执⾏步骤2，知道超出条件，停止循环

相关代码：

public class ForDemo {
    public static void main(String[] args) {
        //1. 围绕操场跑步10圈
        for (int i = 1 ; i<=10 ; i++){
            System.out.println("第" + i + "圈");
        }
        //System.out.println(i);//编译错误，因为i是定义在for循环内部的变量，因此在for循环语句块外不能使用变量i
        //2.练习：输出名字100次
        for(int a=1 ; a<=100 ; a++){
            System.out.println(a+"：邹麟");
        }
    }
}

5.3.2 特殊的for循环

相关代码：

//特殊的for循环,把这些循环的初始条件，循环的判断，循环变量的变化，放在其他的位置

public class ForDemo1 {
    public static void main(String[] args) {
        //1.循环输出1-10
        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;//break关键字，在循环中，目的是结束循环
            }
            k=k+1;//初始数据的变化
        }

        int j = 1;
        for(;;j++){
            if(j<=10){
                System.out.println(j);
            }else {
                break;//break关键字，在循环中，作用是结束循环
            }
        }

        int m = 1;
        for(;m<=10;){
            System.out.println(m);
            m+=1;
        }
    }
}

5.3.3 while 循环

while语法规则：

        语句0 ；
        while(循环条件){
        语句1 ；//循环体
        }
        语句2 ；

相关代码：

//while循环的语法规则
//while（boolean）{
//  语句块
// }

public class WhileDemo {
    public static void main(String[] args) {
        //1.输出1*9=9到9*9=81
        int num = 1 ; //循环的初始变量
        while (num<=9){  // 循环的条件
            System.out.println(num+"*9="+(num*9)); // 循环执行的语句块
            num++; //循环初始变量的变化
        }
        //2.练习：输出名字20次
        int i= 1;
        while (i<=20){
            System.out.println(i+".zou");
            i++;
        }
        //3.练习：输出1-100中能被3整除的数据
        int n = 1;
        System.out.println("能被3整除的有：");
        while (n<=100){
            if(n%3==0){
                System.out.println(n);
            }
            n++;

        }
    }
}

5.3.4 do...while 循环

do…while语法规则：

        语句0 ;
        do{
        语句1;//循环体
        语句2;//
        }while (循环条件);
        语句3 ;

对比while循环

        while循环先判断，再执行；
        do…while先执行一次，再判断。
        While循环比do…while循环用得多。

相关代码：

//do {语句}   while(条件) , 特点循环体至少执行一次

public class DoWhileDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        int num;
//        do{
//            System.out.println("请输入一个数据：");
//            num = scanner.nextInt();
//        }while (num!=30);

        //练习：输入密码(123456)解锁手机，只能输入5次，超过五次提示过半小时再输入
        int count = 1 ;//记录次数
        int pwd;
        do{
            if (count==6){
                System.out.println("输入次数过多，请半小时后尝试！");
                //break; //结束循环

                return;//结束整个程序的运行
            }
            System.out.println("请输入密码：");
            pwd =scanner.nextInt();
            count++;//改变输入的次数
        }while (pwd!=123456);
        System.out.println("手机解锁成功");


    }
}

5.3.5 死循环

循环没有指明结束条件的情况会造成死循环

while(true){
循环体
}
//循环条件恒为true

do{
循环体
}while(true);
//循环条件恒为true

for(;;){
循环体
}
//表达式1，2，3均为空

5.4 break & continue

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

break用于循环，可使程序终止循环从而执行循环后面的语句。常常与条件语句一起使用。

continue 用于循环语句中，表示跳过循环体剩余语句，继续执行下一次循环。

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

相关代码：

//随机出10道题，记录用户考试分数
public class TestDemo {
    public static void main(String[] args) {
        int score=0;//用于记录分数
        Scanner scanner = new Scanner(System.in);
        for(int i=1;i<=10;i++){
            int a = (int)(Math.random()*10);//强制转换
            int b = (int)(Math.random()*10);
            System.out.println("题目："+a+"+"+b+"=");
            System.out.println("请输入你的答案：");
            int answer = scanner.nextInt();
            if(answer==-1){  //表示用户跳过这道题
                continue;//java中的关键字，用于跳过本次循环，进行下一次循环
            } else if(answer==-2){
                break;//结束for循环
            }
            else {
                if (answer == a + b) {
                    score = score + 10;//记录分数
                    System.out.println("答对啦");
                }
                else {
                    System.out.println("很遗憾，回答错误");
                }
            }

        }
        //for循环结束，考试结束，显示最终得分
        System.out.println("最后得分："+score);
    }
}

5.5 循环的阿嵌套

循环的内部再有其它循环，就是循环的嵌套。
外层走一次，内层走所有次
建议循环层数越少越好

6. 数组

6.1 什么是数组

数组：相同数据类型的元素组成的集合
元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”）,可以通过元素所在位置的顺序号（下标）做标识来访问每一个元素（下标从0开始，最大到元素的个数-1）。

6.2 数组的使用

声明数组的语法：

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

数组声明后的默认值

-数组new之后，每个元素都有默认值。int,long默认值为0，double默认值为0.0，boolean默认值为false，char默认值为空字符。

相关代码：

// array --数组
//当我们由一组数据需要保存在一个变量中的时候，一般可以声明一个对应长度和对应数据类型的数组，然后把这组数据存储在数组中

public class ArrayDemo {
    public static void main(String[] args) {
        //1.定义一个数组
        //int a=1,b=10,c=20,d=30,e=50;//定义了五个变量，存储5个数据
        int [] arr ;
        //arr = new int[];//编译错误，在创建数组对象的时候，必须指定数组的长度
        arr = new int[6];//内存空间会分配长度为6个整型数据空间
        //2.数据的初始化
        int[] arr1 = new int[5];//arr1的长度是5，这里的每个元素都是int类型的默认值：0
        char[] arr2 = {'A','B','A',10};//arr2的长度时4，每个位置的元素值已经指定了
        double[] arr3 = new double[]{1.5,2.5,3.5,4.5};//arr3的长度是4，每个位置都有具体的数据

        //3.通过数组的下标（从0开始，到元素个数-1结束） 访问数组中的元素
        /*System.out.println(arr1[0]);//arr1[下标]
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr1[3]);
        System.out.println(arr1[4]);//数组长度是5，下标值：0，1，2，3，4  其他数据发生异常
         */
        for (int i=0 ;i<5;i++){
            System.out.println(arr1[i]);
        }
    }
}

数组的交换位置：

public class ArrayDemo2 {
    public static void main(String[] args) {
        //1.创建整型数组
        int[] arr = new int[ ]{10,15,8,40,25,5};
        //2.把数组中最大的数据移动到末尾
        for(int i= 0 ;i<arr.length-1;i++){
            if (arr[i]<arr[i+1]){ //当前元素小于下一个元素不交换位置，反之交换位置
                continue;//退出本次循环
            }else {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        //3.遍历出数组的元素
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();

        //4.练习：把最小值移动到末尾
        for (int i = 0;i<arr.length-1;i++){
            if(arr[i]<arr[i+1]){
                int temp=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=temp;
            }
        }
        //遍历数组
        System.out.println("末尾是最小的");
        for (int i=0 ;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }

    }
}

6.3 数组的排序

冒泡排序:所谓的冒泡算法就是从左往右依次比较两个数大小，若前一个数大于后一个数，则两个数交换位置

//bubble ：泡
// 冒泡排序：双重for循环，waicengfor循环走一次，内存循环n次，就能把数组中的每一个元素的位置排好

public class BubbleDemo {
    public static void main(String[] args) {
        int[] arr = new int[ ]{10,15,8,40,25,5};
        //1.升序排序
        for(int i = 0;i<arr.length-1;i++){
            for (int j = 0 ;j<arr.length-1;j++){ //j=0,1,2,3,4,5
                if(arr[j]>arr[j+1]){
                    continue;
                }else {  //下一个小就交换位置
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        //2.输出升序数组
        for (int i =0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();

        //3.降序排序
        for(int i = 0;i<arr.length-1;i++){
            for (int j = 0 ;j<arr.length-1;j++){ //j=0,1,2,3,4,5
                if(arr[j]<arr[j+1]){
                    continue;
                }else {  //下一个小就交换位置
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        //4.输出降序数组
        for (int i =0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }

    }
}

数组的排序函数sort（Arrays.sort()——jdk提供的排序方法。）

String[] names ={"tom","cat","jerry"};
      Arrays.sort(names);
 
     System.out.println( Arrays.toString(names) );   // import
java.util.Arrays;

7. 案例题

7.1 bmi指数计算

// BMI的公式=体重(kg)/身高(m) * 身高(m) ， 先算身高的平方，然后再算除法 。
public class BMIDemo {
    public static void main(String[] args) {
        // 要求 ： 让用户输入姓名， 体重   ， 身高  , 然后根据用户输入的数据，计算bmi指数 , 然后输出bmi指数
        Scanner scanner = new Scanner(System.in);
        double  bmi , h  , w ;
        System.out.println("请输入你的姓名：");
        String  name = scanner.next() ;  // 输入字符串
        System.out.println("请输入身高(m):");
        h = scanner.nextDouble() ;// nextDouble: 用于输入double类型数据
        System.out.println("请输入体重(kg):");
        w = scanner.nextDouble() ; //
        // 计算bmi
        bmi =  w / (h * h);
        System.out.println(name + ",你的bmi:" + bmi);
    }


}

7.2 随机字符

//产生 A~Z的随机字符
// 练习： 0~9随机整数
// 练习：  a~z的随机字符
public class AZDemo {
    public static void main(String[] args) {
        // 1. 产生随机数
         double random = Math.random();  // Math.random() 产生一个随机数 , [0,1)区间的浮点数
         double data = random * 26 ;
         int  a  = (int) data ; // java的强制数据类型转换
         System.out.println("0~26:" + a);
         // 2.  得到随机字符
         char c = (char)(a  +  65);// java的强制数据类型转换
         System.out.println("随机字符：" + c);
    }
}

7.3 三目运算找最大值

//用三目运算。判断出用户输入的两个数据中最大的那个
public class MaxData {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数：");
        int a1= scanner.nextInt();
        //Scanner scn = new Scanner(System.in);
        System.out.println("请输入第二个数：");
        int a2 = scanner.nextInt();
        int max = a1>a2 ? a1 : a2;
        System.out.println("两个数据中较大的是"+max);

    }
}

7.4 判断年龄的区间

public class AgeDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的年龄：");
        int age = scanner.nextInt();
//        int a=18,b=30;
//        boolean age1 = age >= a && age <= b;
//        if(age1){
//            System.out.println("年龄18到30岁之间");
//        }
//        else{
//            System.out.println("年龄不在18到30岁之间");
//        }
        if(age < 18 || age > 30){
            System.out.println("不在18~30之间");
        }
        else{
            System.out.println("在18~30之间");
        }


    }

}

7.5 猜数字

import java.util.Scanner;
// 猜数字： 随机产生一个整数， 让用户输入一个数据，然后对比大小，直到用户猜正确
public class GuessData {
  public static void main(String[] args) {
    // 1. 产生一个随机整数[0,100)
    int data = (int)(Math.random()*100);
    System.out.println("data:" + data);
    // 2. 输入数据的功能
    Scanner sc = new Scanner(System.in);
    // 3. 循环让用户输入数据，然后对比大小，直到用户输入正确
    while(true){ // while的条件为true的时候， 表示这个while循环会一直执行。一般称这种情况为”死循环“
          // 我们可以循环代码块中，做条件判断， 符合某种条件的时候 ，就利用break， 结束循环。
      System.out.println("请输入一个整数[0,100):");
      int input = sc.nextInt();
      if(input > data){
         System.out.println("太大了， 小一点。");
       }else if(input < data){
          System.out.println("太小了， 大一点");
       }else{
          System.out.println("恭喜你，猜对了。");
          break; // 结束循环
     }
   }
 }
}

7.6 身份证验证

public class IDDemo {
    public static void main(String[] args) {
        //0.键盘输入一个字符串类型的身份证号码
        Scanner scanner=new Scanner(System.in);
        String next = scanner.next();//字符串输入
        char[] id = next.toCharArray();//toCharArray--转为字符数组 toString--转为字符串
        //1.身份数据
       
        int [] id17 = new int[17];
        for (int i = 0;i<id17.length;i++){
            id17[i]=id[i]-48;

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

    }
}