java基础语法--面向过程

1 、Java前置知识

1.1 认识Java

java是一款高级贬称语言计算机只认识（0和1）

编程语言即时人类和计算机沟通的桥梁，Java只是编程语言中的一种，我们可以编程语言操作计算机。

编程运行过程（重点）：编译期：Java源文件----编译------.class字节码文件运行期：jvm加载并运行.class字节码文件（0和1）
名词：JVM（Java Virtual Machine）：Java虚拟机，主要是用来加载运行.class字节码文件JRE（Java Runtime Environment）：Java运行环境，包含了JVM，还包含了运行程序的环境JRE= JVM + Java系统类库工具JDK（JAVA Development Kit）：Java开发工具包，包含了JRE，还包含了Java开发所需的工具JDK = JRE +编译，运行等命令如果运行一个Java程序，至少需要JRE
如果开发一个Java程序，至少需要JDK

1.2 编译器工具

Eclipse（手动档）和IDEA（自动档）

IDEA是JetBarins公司提供的提供两个版本：社区版（免费）终极版（收费）

开源：对用户开放细节

Java这款语言就是开源，Eclipse（开源的），IDEA社区版（开源的）

下载JDK和IDEA的方式：

doc.canglaoshi.org

Mac下载完JDK不需要配置环境变量

1.3 开发步骤

①新建一个Java项目或工程

②新建一个Java包

③新建一个Java类

1.4 Java中的注释（三种）

单行注释：//写上解释性文本

多行注释：/*写上解释性文本*/

文档注释：/**写上解释性文本*/

1.5 Java中的编译方式（三种）

Compile------对类进行编译（不管类中的内容是否修改过，一定会编译）

Rebuild-------对项目进行编译（不管项目是否修改过，一定会全部编译）

Make----------默认的编译方式（只编译修改过的文件）

package day01;// 包名  day01   ---------- 具体楼+单元

public class HelloWorld { //类名 HelloWorld  --------房子//main功能的快捷键   main回车即可自动生成//main 功能 ----程序的主入口 ：// 代码只能放在main的功能里面 才能运行//且代码是逐语句往下运行public static void main(String[] args) { //-------大门 入口/** 1.严格区分大小写！* 2.写代码期间,所用到的符号 全部都要保证英文状态下输入,否则也会报错* 3.每句话如果写完 要用分号结尾* *///想输出一句话  显示在屏幕// 输出的功能  快捷键 sout 回车//文本性的内容：如果要输出 需要加双引号！System.out.println("Hello Java!!");//双引号中的内容所见即所得System.out.println(3);System.out.println(2);System.out.println(1);}//执行到这里 就代表 出口(程序结束)
}

2、变量

早期的计算机----------算术（数字的加减乘除）

现在的计算机-----------算术（数字、文字、图片。音频、视频）

计算机处理的是数据，也就意味着离不开变量（就是存数的）

变量：可以变化的量

变量的作用：开一个账户

2.1 变量的声明

int a ;//声明一个int类型的变量 变量名为a
int b,c,d;//声明三个int类型的变量 变量名为 b,a,d
//int a;编译错误：因为已经声明过一个名为 a的变量了，不能重复声明

2.2 变量的初始化

int e = 300;//声明了一个int(整数) 变量 名为e e里面存了300
int f;//声明一个int(整数) 变量名 为f
f = 150;//为f这个变量里面存 150

2.3 变量的使用

对变量的使用，本质上就是变量里存的内容

使用变量前一定要先声明+初始化！否者会报错！

int b = 5;//声明一个int(整数) 的变量名为 b  为b里面存了5
int c = b + 10;//声明一个int(整数)的变量名为c 里面存了 b + 10 的和，b是5 + 10 最后15存到变量c里面去
System.out.println("c");//c   -----因为双引号 所见即所得
System.out.println(c);//15

2.4 变量的命名规范

①变量的命名只能包含数字、字母、_和$ 注意不能以数字开头！

②变量名是区分大小写的

③变量名不能以关键字来命名

④变量的命名要见名知意

 //2.4 变量的命名规范
//      int 1a; 编译错误：变量名不能以数字开头int _01$;int $abc_;//Java严格区分大小写int a = 1;System.out.println(a);
//        System.out.println(A); 此A非彼 a
//        int void;  不能以关键字进行命名   关键字就是蓝色的字！
//        int static;
//命名要见名知意int score = 100;//用英文单词的见名知意//int 分数 = 100;//不能用 中文的见名知意  ------行业规范！
//      int fenshu = 100;//不能用 拼音的见名知意//变量的命名 遵循 小驼峰命名法 :小驼峰命名法 多个单词之间 首字母小写 后续第二单词首字母大写....第三....int myScore = 100;//类名 遵循 大驼峰命名法: 每个单词首字母大写.

3、数据的基本类型

数据类型的作用：决定了变量可以存储的类型和存储的范围。

数据类型分为：基本数据类型和引用数据类型

常用的基本数据类型：

整数类型：int 、 long

小数类型：double

字符类型：char

布尔类型：boolean

不常用：byte（只是在io相关内容会用到）

short/float 保留c语言的类型，工作用不到

GB（吉字节） 1GB = 1024MB

MB（兆字节） 1MB = 1024KB

KB（千字节） 1KB = 1024b

b（字节） 1b = 8bit（位）

3.1 整数类型：

int在内存中占用4个字节，存储范围- 21亿~21亿多（2147483647）

① 整数的直接变量默认为int类型，直接变量是不能够超出当前类型所存储的范围，否则会报编译错误。

② 如果两个整数进行运算，结果是不会保留小数的（会截断删除，不会四舍五入）

③ 整数如果运算时，若超出范围则会溢出（溢出不是错误）但需要避免，溢出的数据没有参考价值

package day03;
/*** 数据类型的使用演示类:* 整数类型:*          int类型 占4个字节 可存储范围-2147483648  ~ 2147483647*         long类型* */
public class DateTypeDemo01 { //房子
public static void main(String[] args) {//大门//整数直接量 默认为int类型int a = 100;//声明一个int类型的变量 变量名为a  存了100;
//        int b = 2147483648; 编译错误:整数直接量超过了int 这个类型可存储的范围int c = 5;int d = 2;// System.out.println(c / d );//2    (整数运算时不会保留小数位)//--------------------------------int number = 2147483647;//number已经存储的int 最大值int result = number + 3;System.out.println(result);//溢出的数据   -2147483646/***  +1 -------------------(-2147483648)*  +1+1 -----------------(-2147483647)*  +1+1+1 ---------------(-2147483646)* */
}
}

3.2 long

在内存中占用八个字节，可存储范围-900万万亿~900万万亿

① 长整型类型的直接量需要在后面家上L

② 长整型类型在进行运算时，建议在第一个数据后面加上L即可，代表所有的结果都是long类型的

  //长整数直接量long a = 10000000000L;//100亿  需要明确加L表示是long类型的直接量// 10亿    * 2  * 10long b = 1000000000 * 2 * 10L;//System.out.println(b);//200亿//30亿 超出了int的范围long c = 1000000000 * 3 * 10L;// System.out.println(c);//溢出:-12949672960
long d = 1000000000L * 3L * 10L;System.out.println(d);//300亿

变量占多大内存,取决的是数据类型  而并不是装载的数据!
int a = 5;
int b = 2147483647;

3.3 小数类型

double（双精度）：占八个字节，可以存储的数据很大很大、、、

① 浮点型的直接量默认为double类型

② double类型的直接量也可以明确表示加上后缀d

③ double类型的数据在进行运算时，也能存在误差，Math.round()四舍五入的功能

/*** 小数类型的使用演示类:* double 占8个字节*/
public class DateTypeDemo02 {//房子
public static void main(String[] args) { //大门//小数直接量 默认为doubledouble a = 3.14;//声明一个double类型的变量 变量名为a  存了3.14
double b = 3.0;double c = 2.9;//System.out.println(b - c);// 0.10000000000000009  可能存在误差double e = 6.0;double f = 4.9;//System.out.println(e - f);//1.0999999999999996   可能存在误差 无限接近
double g = 6.0;double h = 1.9;System.out.println(g - h);//4.1   可能存在误差
double r = Math.round(4.5);//可以四舍五入System.out.println(r);}

}

3.4字符类型

① char占用两个字节，表示的是字符的意思

② 字符是什么？键盘上：字母、数字、汉字、特殊符号等...

③ Java提供特殊符号，如果想要存储的话，需要转义转换特殊含义（），转义符号 \

 char temp = 'a';//声明一个char类型的变量 名为temp 存了字符aSystem.out.println(temp);//aSystem.out.println((int)temp);//97char temp1 = '我';System.out.println(temp1);
//        char temp2 = 'ni'; 编译错误:char类型只能存单个值!char temp3 = '\'';//转义System.out.println(temp3);//   'char temp4 = '\\';//转义System.out.println(temp4);//   \

3.5 布尔类型

Boolean占用内存一个字节，要么存TRUE（真、成立）要么存FALSE（假、不成立）

 boolean a = true;System.out.println(a);//trueboolean b = false;System.out.println(b);//false

3.6 类型转换

分为两种：

自动类型转换：将小的类型装载到大的类型的过程。

从小到大顺序：byte-->short-->int-->long-->float-->double

强制类型转换：将大的类型装载到小的类型的过程（强转有风险，使用需谨慎）

//自动类型转换:
//        int a = 100;//没有发生!
//        long b = a ;//发生自动类型转换
//        double c = b;//发生自动类型转换
//强制类型转换:long a = 1000000000L;//10亿int b = (int)a;//使用强制语法:在需要强制转换的变量前面加上小括号 填上要强转的类型即可System.out.println(b);//10亿long c = 100000000000000000L;int d = (int)c;System.out.println(d);//一定会溢出!!
double e = 3.1415926;int f = (int)e;//将小数强制转换为整数时  截断删除小数System.out.println(f);//3

规则：

1.整数直接量是可以直接赋值给byte short char类型的！但是不能超过当前类型的范围!

2.byte short char 如果进行运算时，系统会自动将其结果转换为int类型。

3.小类型与大类型进行运算时，系统会自动将类型个结果转换成大类型

byte a = 1;
byte b = 2;
byte c = (byte) (a + b);//byte运算 其结果会自动转换为int类型


char d = '2'; //50
char e = '2'; //50
int f = d + e; //char运算时 本质上 运算的是字符对应的码
System.out.println(f);
char d1 = 50;//也可以存整数直接量的码
System.out.println(d1);//   ‘2’

byte b1 = 100;
int r = b1 + 20;//byte(小类型)  与 int(大类型) 运算 结果为   大类型

4、运算符

4.1 数学算术运算符

符号：加（ + ）减（ - ）乘( * )除 ( / )取余（%）

package day04;

/*** 数学运算符：* 自增自减运算符：*/
public class OperationDemo01 {public static void main(String[] args) {int a = 10;int b = 5;System.out.println(a + b);//15System.out.println(a - b);//5System.out.println(a * b);//50System.out.println(a / b);//2//10 取余 5System.out.println(10 % 5);//10除以5 的余数为 0System.out.println(5 % 2);//---------------------------//取余操作时，若左边的数据小于右边的数据  其取余结果还是左边的数据System.out.println(1 % 3);//1System.out.println(2 % 3);//2System.out.println(3 % 3);//0System.out.println(8 % 15);//8}
}

4.2 自增自减运算符

自增：在自身的基础上增加1 符号用：++

自减：在自身的基础上减少1 符号用：--

作用于变量身上。

① 单独运算时（只有当前的变量被运算），符号在前在后都一样

② 参与运算时（赋值也算运算），符号在前在后不一样！

符号如果在前，就先执行符号自增或自减，然后再参与其他运算

符号如果在后，就会先参与其他运算，然后再进行自增或自减

//1.自增自减  单独运算时在前在后都一样。
//        int a = 5;
//        a--;
//        System.out.println(a);
//2.参与运算时，自增自减在前在后不一样。/** 符号如果在前,就先执行符号自增或自减，然后再参与其它运算。符号如果在后,就会先参与其它运算，在下次使用变量时 则变为自增或自减的后的值* */
//        int a = 5;
//        int b = 5;
//        int c = a++;
//        int d = ++b;
//        System.out.println(a);
//        System.out.println(b);
//        System.out.println(c);
//        System.out.println(d);
//        int a = 5;
//        int b = 5;
//        int c = a--;
//        int d = --b;
//        System.out.println(a);
//        System.out.println(b);
//        System.out.println(c);
//        System.out.println(d);//
//        int a = 5;
//        int b = 5;
//        int c = --a - b--;
//        System.out.println(a);//4
//        System.out.println(b);//4
//        System.out.println(c);//-1


//面试题：
//        int a = 1;
//        a = a++;  //相当于没有进行自增过  a值还是原来的数据
//        System.out.println(a);//1

4.3 关系运算符

关系运算符指的就是大于（>）小于（<）大于等于（>=）小于等于（<=）

等于（==）不等于（!=）

关系运算符的结果一定是Boolean类型，要么成立（TRUE）要么不成立（FALSE）

int a = 50;   int b = 40;
boolean result =  a > b;
a的数据 大于 b的数据吗？----------------true

int c = 50;  int d = 50;
boolean result1 = c >= d;
c的数据 大于等于 d的数据吗？------------trueint e = 100; int f = 99;
f++;
boolean result2 =  e == f;
e的数据 等于 f的数据吗？----------------trueint a = 50;int b = 40;boolean result = a > b;System.out.println(result);//trueSystem.out.println(a >= b);//trueSystem.out.println(10 < 10);//falseSystem.out.println(10 != 10);//falseSystem.out.println( 5 == 4);//false

4.4 逻辑运算符

逻辑运算符的结果一定是Boolean类型

Java中的逻辑运算符分为三种：

4.4.1 与（并且）符号用：&&

逻辑与(并且)   现象：在逻辑与(并且)的关系中，两个或多个条件 有一个条件不成立，其结果一定不成立一假俱假 ----- 见 false 即 false
能毕业吗?    条件一:课程学完了吗?    true       false     false    true       并且&&条件二:考试及格了吗?    false      true      false    true结果：    false      false     false    true

4.4.2 或（或者）符号用：||

逻辑或(或者)     现象：在逻辑或(或者)的关系中,两个或多个条件 有一个条件成立，其结果一定成立一真俱真  ------ 见 true 即 true
能结账吗?条件一：微信有钱吗?    false     true      true      false       或者 ||条件二：带现金了吗?    true      false     true      false   结果：   true      true      true      false

4.4.3 非（取反）符号用：！

逻辑非(取反)true： !true  非真即假结果:  falsefalse: !false 非假即真结果:  true

测试案例：

//逻辑运算符int a = 5;int b = 10;int c = 5;boolean result = a > b && b > c;// fasle && true  ---->并且关系中见fasleSystem.out.println(result);//false      即是false
System.out.println(a > b || b > c);//false || true --->或者关系中见true即trueSystem.out.println(a == ++c && c >5);// fasle && true  ---->并且关系中见fasle即是falseSystem.out.println(c);//6
System.out.println(!true);//false    ----结果取反System.out.println(!false);//true    ----结果取反//判断年份是否为闰年案例：/***  闰年的判定条件：*              条件一：年份能被4 整除   并且  年份不能被100整除*                 或者*              条件二：年份能被400 整除* */Scanner s = new Scanner(System.in);//创建一个扫描器System.out.println("请输入要判断的年份");int year = s.nextInt();//使用扫描器读取控制台输入的int数据的功能boolean r1 = year % 4 == 0 && year % 100 != 0;  //闰年条件一boolean r2 = year % 400 == 0;//闰年条件二boolean result = r1 || r2;//条件1 或 条件2 的结果 只要有一个成立 结果则成立System.out.println(result);//2000年是闰年//方式二：
//        boolean result1 = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
//        System.out.println(result1);

4.5 短路逻辑

短路与(并且)：相亲成功的两个条件！1.相亲对象是女生       true        false并且2.勤俭持家             true结果：       true        false短路与现象：如果前面条件不成立,程序则立刻返回不成立的结果，根本不去再执行判断后面的条件了。

短路或 (或者)相亲成功的两个条件！1.长得好看      true或者2.勤俭持家短路或现象：如果前面条件成立，程序立刻返回成立的结果，根本不去再执行判断后面的条件了。         int a = 5;int b = 20;//发生短路与
//        System.out.println(a > b && ++b > a ); // false
//        System.out.println(b);//20
//发生短路或System.out.println( ++a < b || ++b >19 );//trueSystem.out.println(b);//20
//未发生短路System.out.println(a < b && ++a > 19 );//false
System.out.println(a);//7

4.6 赋值运算符

赋值号：= 赋值顺序从右向左赋值的过程。

拓展赋值号：+= -= *= %=

在自身的基础上快速进行四则运算然后将结果赋值给自己

   //扩展赋值号的使用：int a = 10;a += 10;  // 等价于： a = a + 10;System.out.println(a);//20a -= 10;  // 等价于： a = a - 10;System.out.println(a);//10a *= 2;   // 等价于： a = a * 2;System.out.println(a);//20a /= 5;  // 等价于： a = a / 5;System.out.println(a);//4a %= 2;  // 等价于  a  = a % 2;System.out.println(a);//0

4.7 三目运算符

Boolean？值1：值2；

判断逻辑？若为true 返回值1：若为false 返回值2；

    //三元表达式的写法int number1 = 10;int number2 = 20;//      判断的逻辑 ?  若为true 返回值1  ：若为false 返回值2；int max = number1 > number2 ? number1 : number2;System.out.println(max);//最大值：20
//使用三元表达式，用什么类型来接收结果 主要看值1 和值2的 类型int num = 10;boolean result = num % 2 == 0 ? true : false;System.out.println(result);//是偶数： true

4.8 字符拼接符

字符是char类型，要用单引号存储1个字符

字符串是String类型要用双引号存储一串字符

使用+号是，若两边都是数值类型，则会进行运算操作

使用+号时，若两边有一方为字符串类型，则会进行拼接操作，变成一个字符串整体

  int num = 10;boolean result = num % 2 == 0 ? true : false;System.out.println("num是否是偶数:" + result);//是偶数： true
int age = 30;String name = "张三";System.out.println("我叫:"+name + "我的年龄是:"+age);
System.out.println(10+10+""+30);//2030System.out.println(""+10+10+30);//101030System.out.println(10+10+30+"");//50

---------------------------------------------------------byte b = 5;
//        b = b + 5;//编译错误：小类型+大类型 系统会自动将结果转换为大类型b += 5;//使用扩展赋值 系统会自动进行强转 等价于  b = (byte)(b + 5);

5、流程控制

Java中流程控制有三种结构，任何复杂的业务逻辑都可以通过这三种方式来实现

①顺序结构：代码逐语句顺序执行，每句代码都走

②分支结构：有条件的执行某个语句，并非每句都走

③循环结构：有条件的重复执行某个语句，并非每句都走

5.1 分支结构



import java.util.Scanner;

/*** 单路分支结构的使用演示类：*/
public class IFDemo {public static void main(String[] args) {/**  语法结构*          条件*      if(boolean){*          //条件成立执行的代码块*      }*      执行过程：*      判断if小括号中的boolean 值*      若为true 则执行条件成立执行的代码块*      若为false 代码跳过if的代码块... 继续往后执行* */Scanner s = new Scanner(System.in);System.out.println("请输入购物的金额..");double price = s.nextDouble();//金额 500if (price >= 500) { //如果金额 大于等于 500price *= 0.8; // price = price * 0.8;System.out.println("打完8折后应付金额:" + price);}System.out.println("已付款:" + price);
}
}

5.2 双路分支

package day05;

/*** 双路分支的使用演示类：*/
public class IFElseDemo {
public static void main(String[] args) {/** 双路分支的语法结构：*      if(boolean){*             //成立执行的代码块*      } else{ 否则*             // 不成立执行的代码块*      }*      执行过程：*      先去判断if小括号中的条件 是否成立*      若成立 执行 --成立执行的代码块*      若不成立 执行 --不成立执行的代码块* *///购物满500 打8折 不满打9折double price = 900;//金额if (price >= 500) {price *= 0.8;System.out.println("打完8折应付:" + price);} else { //否则price *= 0.9;System.out.println("打完9折应付:" + price);}System.out.println("已付款:" + price);

}

}

5.3 多路分支

5.3.1 多路分支一

多路分支的语法结构：
   if(条件1){
   //若条件1成立则执行的代码块
   } else if(条件2){
   //若条件2成立则执行的代码块
   }
   else if(条件3){
   //若条件3成立则执行的代码块
   }
* 执行过程：
* 先判断条件1 若条件1满足则执行条件1的代码块否则
* 再判断条件2 若条件2满足则执行条件2的代码块否则
* 再判断条件3 若条件3满足则执行条件3的代码块....

package day05;

import java.util.Scanner;

/*** 多路分支的使用演示类：*/
public class IFElseIFDemo {public static void main(String[] args) {* 需求： 根据用户输入的分数  来判断分数的等级。*      A. 分数 大于等于 90   输出优秀！*      B. 分数 小于90 并且 分数大于等于 80  输出良好！*      C. 分数 小于80 并且 分数大于等于 70  输出一般！*      D. 分数 小于70 并且 分数大于等于 60  输出及格！*      E. 分数小于 60   输出  不及格！* */Scanner s = new Scanner(System.in);int score = s.nextInt();//分数if (score >= 90) { //如果分数 大于等于 90System.out.println("优秀！");} else if (score >= 80) {//否则 如果分数大于等于80System.out.println("良好");} else if ( score >= 70) {//否则 如果分数大于等于70System.out.println("一般");} else if (score >= 60) {// 否则 如果分数大于等于60System.out.println("及格");} else {//否则 如果能执行到这里 说明上述条件没有一个 成立  则表示不及格System.out.println("不及格！");}System.out.println("程序继续往后执行.....");/**  练习： 通过控制台的方式 获取用户输入的年龄 根据年龄判断人生阶段*      int age = ?;*      A. 如果 age 大于等于 0 并且小于 5   输出幼年！*      B. 如果 age 大于等于 5 并且小于18   输出青年！*      C. 如果 age 大于等于 18 并且小于 35 输出成年！*      D. 如果 age 大于等于 35 并且小于 50 输出中年！*      E. 如果 age 大于等于 50 并且小于 65 输出中老年！*      F. 如果 age 大于等于 65 并且小于 150 输出老年！*      否则 年龄不合法！* */}
}

5.3.2 多路分支二

switch case 结构

适用性：对数值的数据进行匹配判断是否相等，不能使用逻辑预算和关系运算，JDK1.7 版本以后支持对String类型判断是否相等

主要判断传递的内容与程序设计的值是否相等

优点：如果只对单个整数数据判断是否匹配某个数值时，用switch case结构做分支效率更高

break //退出switch结构的代码块

default //代表默认的意思上述case都没匹配上则会走到default

 Scanner s = new Scanner(System.in);System.out.println("1 取款  2 存款 3 转账 请输入指令");int userInput = s.nextInt();//接收用户再控制台输入的指令//判断的变量类型 需要是整数类型(不包括long) 或 String类型switch (userInput){case 1:System.out.println("取款业务开始办理中...");break;//退出switch 结构的代码块case 2:System.out.println("存款业务开始办理中...");break;//退出switch 结构的代码块case 3:System.out.println("转账业务开始办理中...");break;default://默认..走到这里 代表上述没有一个匹配上。System.out.println("输入指令有误");}
System.out.println("代码继续往后执行....");

5.4 循环结构

循环：字面意思指的就是重复执行某个事情（代码），反反复复的过程，称之为循环

Java中循环分为三种：1.while 2.do while 3.for（常用）

循环的三要素：1.循环变量的初始换 2.基于循环变量的条件 3.循环变量的改变（朝着目标改变）

三要素：1. int count = 0; //循环变量初始值2. count < 3;     //基于循环变量的条件3. count++;       //循环变量的改变

5.4.1 while

while 循环语法结构：
* 循环变量初始值
* while(2.boolean){
* //若条件成立则循环的代码块
* //3.循环变量的自增
* }
* 执行过程
* 先去判断while小括号中的条件是否成立
* 若成立则执行循环的代码块
* 再去判断while小括号中的条件是否成立
* 若成立则执行循环的代码块
* .....
* 若不成立
* 代码逐语句往后执行....

package xunhuan;
/*** while 循环的使用演示类：* */
public class WhileDemo {
public static void main(String[] args) {//循环的三要素：1. 循环变量的初始化  2.基于循环变量的条件  3.循环变量的改变
//        int count = 0;//1
//        while (count < 3){//2
//            System.out.println("行动是成功的阶梯!我们都是最棒的！！");
//            count++;
//        }
//        System.out.println("写一个很重要程序....");//   使用while循环  让小明同学 跑10圈int count = 1;//初始值
while (count <= 10){//循环条件System.out.println("小明同学跑第"+count+"圈了！" );count++;//循环变量自增}System.out.println("跑完了 歇歇.....");
}
}

5.4.2 do while

do .. while 循环结构：
* //循环的三要素：1. 循环变量的初始化 2.基于循环变量的条件 3.循环变量的改变
* 1.循环变量的初始化
* do{
* //循环的代码块
* //3.
* }while(2.条件);
* 执行过程：
* 先去做do 的循环代码块然后再判断while小括号中的条件
* 若条件成立则再次执行 do的循环代码块再判断while小括号中的条件
* 若条件成立则再次执行 do的循环代码块再判断while小括号中的条件
* ....
* 若条件不成立则代码代码继续往后执行...

package xunhuan;
/***  do ..while 循环的使用演示类：* */
public class DoWhileDemo {
public static void main(String[] args) {int count = 0;//1do {System.out.println("大家非常棒！ ！奥里给！");count++; //3.}while (count < 3); //2.}
}

5.4.3 随机数

Java提供了可以获取随机数的功能

Math.random();返回给一个double类型，从0~1区间的小时可取到0 取不到1

//---------随机数的使用double r = Math.random();//返回给一个double类型 从 0 ~ 1 区间的小数 可取到0  取不到1//System.out.println(r);double r1 = Math.random() * 100;//返回给一个double类型 从 0 ~ 100 区间的小数 可取到0  取不到100//System.out.println(r1);int r2 = (int) (Math.random() * 100);//返回的随机数强制int 类型// System.out.println(r2);//  (int)(随机数  * (最大值 - 最小值 ) +最小值); //500 ~ 1500 的随机数int r3 = (int)(Math.random() * (1500 - 500 ) +500);System.out.println(r3);

猜大小的案例：
运行产生一个随机数 ,提示用户在控制台中输入数据来进行猜大小

int random = (int) (Math.random() * 100);//随机生成0 ~ 100 的整数Scanner s = new Scanner(System.in);//创建一个扫描器int user;do {System.out.println("开始猜大小 区间0~99");//需要user = s.nextInt();//接收用户输入的猜的数据  需要if (user > random) { //如果用户输入的数据 大于 系统产生的数据System.out.println("猜大了");} else if (user < random) {//如果用户输入的数据 小于 系统产生的数据System.out.println("猜小了");}} while (user != random);//用户猜的数据 不等于 系统产生的数据//如果 代码能执行到这里 那么一定是猜对了！System.out.println("猜对了");

while 和 do while 的区别

相同点：当不明确循环次数的时候，但是一直循环条件，可以进行选择。

不同点：while 循环先去判断循环条件，再决定是否循环！有可能一次循环都不做

do while 循环先去做一次循环，再去决定是否循环！至少做一次循环体

5.5 for（）循环

当已知循环次数就使用for循环

循环关键字：

continue 作用：跳过当次循环直接到达第三步（直接进入下次的循环的过程）

break 作用：再循环体中，代表退出当前循环（即使循环没做完也不做了

5.5.1 for循环使用演示类

package xunhuan;

public class ForDemo {
public static void main(String[] args) {/**   for 循环的语法结构  当已知循环次数 就使用 for*   循环的三要素：①循环变量的初始化  ② 基于循环变量的条件   ③ 循环变量的改变*                ①            ②       ③*      for(int count = 0; count < 3; count++){*           //循环的代码块 ④*      }**      执行过程：*      先去执行  ①   ②   ④*      然后执行  ③   ②   ④ ------- ③   ②   ④------- ③   ②   ④*      直到 ② 不满足 循环则结束  代码继续往后执行了....* *///同学们继续加油！！  x3
for (int count = 0; count < 3; count++) {//System.out.println("同学们加油666！");}//  continue  循环中可使用的关键字  作用：跳过当次循环 直接到达第 ③步 (直接进入下次的循环执行过程)
for (int i = 1; i <= 10; i++) {if (i % 2 == 0) { //如果成立 则为偶数System.out.println(i + ":是偶数");continue;//跳过当次循环,直接执行下次循环过程}System.out.println(i + ":是奇数");}//---------break 关键字  作用在循环体中，代表退出当前循环(即使循环没做完也不做了...)
for (int i = 1; i <= 10; i++) {if(i > 5){System.out.println("马润同学肚子疼...剩下圈数不能跑了..");break;//退出循环}System.out.println("马润同学跑第" + i + "圈了");}System.out.println("不跑了 让孩子歇歇吧...");}
}

for循环小括号中声明的变量，作用域只在当前的for中可用，其他视为看不见

5.5.2 双重for循环

for循环嵌套：for里套个for

99乘法表的实现

外层for循环控制轮数，或者叫做行数

内层for循环控制次数，或者叫做列数

 // 双重for  九九乘法表
for (int num = 1; num <= 9; num++) { //外层走一轮
for (int i = 1; i <= num; i++) {//内层走多次 (具体看循环条件)// 删除ln 代表不换行                                   //tab键System.out.print(i + " * " + num + " = " + (i * num)+"\t");}System.out.println();//换行}

6、数组

定义：代表一组相同数据元素的集合，数组是一种数据类型（引用数据类型）

① 数组的定义和初始化

② 数组的使用

③ 数组名.length 代表数组的总长度，通常用于for遍历数组时的条件

int a;//声明一个int类型的变量名为a         ---------------里面只能放整数
int[] b;//声明一个int类型的数组  数组名为b  ---------------里面可以放多个整数
double[] c;//声明一个double类型的数组 数组名为c -----------里面可以放多个小数
int score1 = 100;
int score2 = 99;
int score3 = 60;....
int score174 = 88;       //1.数组的定义int[] arr;//定义: 声明一个int类型的数组  数组名为arr//初始化方式动态初始化写法：//未知数组中每个格子存的数据是多少，但是已知存储的数据个数int[] arr1 = new int[3];//声明一个int类型的数组 名字为arr1 在内存中开了3个格子 分别存了默认0//初始化方式静态初始化写法：//已知数组中每个格子的具体数据，已知存储的个数int[] arr2 = {100,60,20};//声明一个int类型的数组 名字为arr2 在内存中开了3个格子，分别存100,60,20//int[] arr3 = new int[]{100,60,20}; 写法2//2.数组的使用int[] arr4 = new int[3];//声明一个int类型的数组 名字为arr4 在内存中开了3个格子 分别存了默认0arr4[1] = 666;//访问数组下标为1的这块地 存了666System.out.println(arr4[0]);//访问arr4数组第一块内容System.out.println(arr4[1]);//访问arr4数组第二块内容System.out.println(arr4[2]);//访问arr4数组第三块内容//System.out.println(arr4[3]);//ArrayIndexOutOfBoundsException：访问数组下标越界的异常

int[] scores = new int[7];//创建数组 开了 5块地 数组名scoresscores[0] = 100;//访问下标为0 的这块地 存了100scores[1] = 99;//访问下标为1 的这块地 存了99scores[2] = 88;scores[3] = 77;scores[4] = 66;scores[5] = 66;scores[6] = 0;for (int i = 0; i < scores.length; i++) {System.out.println(scores[i]);}

数组内存图示：

7、方法

方法称之为函数，方主要用来表示功能

适用性:当有一些重复性的逻辑代码时，我们可以用方法来进行复用，减少代码冗余

方法语法：[访问修饰符] 返回值类型方法的名称（[参数列表]）{方法的代码块}

① 访问修饰符：控制当前方法的可见范围

②返回值类型：没有返回值类型用void表示没有返回值，如果有返回值的话定义的时候要写上返回值类型，其次在方法体的最后一行代码要写上return 关键字代表返回然后再在后面写写上要返回的数据，返回的数据要与返回值类型匹配

③方法名：（遵循小驼峰命名法）见名知意

④参数列表：又叫做形式参数，定义方法时占一个坑，供外部使用时参入具体的数据内容

⑤方法体：用来存放该方法的功能逻辑

7.1 方法（函数）类型

7.1.1 无参无返回值

仅仅只是想优化重复性的代码并没有其他的逻辑

public class MethodDemo {public static void main(String[] args) {//多次定义 多次使用//一旦发生修改  都要变!
//        System.out.println("直拳");
//        System.out.println("摆拳");
//        System.out.println("上勾拳");
//        System.out.println("侧踹");
//
//        System.out.println("直拳");
//        System.out.println("摆拳");
//        System.out.println("上勾拳");
//        System.out.println("侧踹");
//
//        System.out.println("直拳");
//        System.out.println("摆拳");
//        System.out.println("上勾拳");
//        System.out.println("侧踹");
attack(); //调用方法 从哪里来回哪去System.out.println("程序继续往后执行");}
//方法的语法:  没有返回值 方法的名称 () { 方法的代码块  }//定义了一个无参数无返回 名为attack 的方法//加static 是为了能在main中调用 否则main不可访问attack方法static void attack() { //定义方法System.out.println("直拳");System.out.println("摆拳");System.out.println("上勾拳");System.out.println("侧踹");System.out.println("下勾拳");}

}

7.1.2 有参无返回值

public class MethodDemo02 {public static void main(String[] args) {//传递实际参数:具体的数据   注意,具体的数据要与该功能需要的类型匹配//注意:name: 是属于编译器的提示 不需要写!!sayHi("Hello！");//调用功能}//方法表示的是功能//做一个问好的功能//返回值类型 方法的名称 () { 方法的代码块  }//定义功能//目标是希望谁调用这个问好功能,可以自己选择到底问谁好!//可以给方法加        形式参数:定义功能时占一个坑 但是具体坑里面是什么,要看使用者传递什么数据//程序设计中的一个要求: 对修改关闭 就是设计好一个功能后尽量不要修改它了static void sayHi(String name){System.out.println(name + "同学你好!");}
}

7.1.3 无参有返回值

import java.util.Scanner;

/*** 无参数有返回值的使用演示:*/
public class MethodDemo03 {public static void main(String[] args) {//方法有返回值 才可以接收!!double pi = getPI();//调用方法System.out.println(pi);// 3.1415926
//只有方法有返回值类型 才可以放到打印语句中! 也就是下面这种写法System.out.println(getPI());//调用getPI方法并将返回值打印出来
//        //用随机数的功能
//        double r = Math.random();//返回一个0~1的double类型的小数!
//        System.out.println(r);}
//做一个功能 别人调用时 返回 PIstatic double getPI() {//3.1415926  ----PI//返回   数据的类型要与方法的返回值类型 匹配!return 3.1415926;}

}

7.2 方法的重载

好处：当方法参数个数和方法参数类型发生变化时，我们在定义对应的功能时，可以不需要气不通的方法名称，可以共用一个方法名。对于调用者而言，非常友好，只需要传递要九三的内容即可，不需要区分使用的哪一个功能，系统会根据调用者传入的数据来自动匹配对应的功能实现。

重载的条件：当方法参数个数或者参数类型不一样时，则可以构建成重载！我们可以共用一个方法名。

不能重载的条件：参数个数和参数参数类型都一样，则不可构成重载。

public class MethodDemo {public static void main(String[] args) {/**  需求是多变的!*   做程序:*    做一个 10 + 20 的 运算*    做一个 100 + 1000 的运算*    做一个程序 5000000+ 50000 的运算*    做一个 50 + 50 +100 的运算*    做一个 1.5 + 4.5 的运算*    使用方法来实现:* */  //从需求的角度:数据是多变的! 数据的个数  数据的类型
//        int a = 10;
//        int b = 20;
//        int r = a + b;
//        System.out.println(r);//30
//        int c = 100;
//        int d = 1000;
//        System.out.println(c+d);//1100//.....int result = sum(10, 20);//调用功能//----------重载的使用System.out.println( sum(100,1000));System.out.println( sum(10,10,10));System.out.println(sum(1.5,4.5));//println 打印功能实现了重载System.out.println(10);System.out.println(1.1);System.out.println("hello");System.out.println(true);System.out.println('a');}
//有参有返回值:就是当一个功能 需要外部传递数据 进行计算 然后需要计算结果返回给使用者的时候// 两个int的数据求和运算的功能//       形式参数:占两个坑  供调用者传递具体运算的两个数据static int sum(int a, int b) {int r = a + b;//求 a + b的和return r;}
static int sum(int a, int b, int c) {return a + b + c;}
static double sum(double a, double b) {return a + b;}
}

7.3 方法强化

* 数组和方法结合的案例

public class MethodDemo {
public static void main(String[] args) {/***  需求: 写一个程序,求出数组中最大值!//      运行打印出数组的最大值.* */int[] array = {100, 60, 30, 20, 1000};int max = getArrayMax(array);//调用功能 传入要求最大值的数组System.out.println(max);
int[] arr1 = {10000,500,30000,40000};int max1 = getArrayMax(arr1);//调用功能 传入要求最大值的数组System.out.println(max1);//        //思路:假设数组第一个元素是最大值,然后存给max变量
//        //    在遍历的过程中 需要用max 与 后面的内容 依次作比较 (始终保持max是数组中最大值)
//        int max = array[0];//把第一个元素 存给了max
//        for (int i = 0; i < array.length; i++) {
//             if(max < array[i]){//判断max 是否小于当前数组的元素
//                max = array[i];//则将当前数组元素的数据 给max
//             }
//        }
//        System.out.println("数组中最大值为:"+max );}//写一个功能 , 通过外部传入一个数组 求出数组中最大值 并返回出去!//                      占一个坑 具体什么数组由调用者传入static int getArrayMax(int[] array) {int max = array[0];//把第一个元素 存给了maxfor (int i = 0; i < array.length; i++) {if (max < array[i]) {//判断max 是否小于当前数组的元素max = array[i];//则将当前数组元素的数据 给max}}return max;}

}

注：整理来自达内张老师的课堂笔记，手打一遍是为了加深记忆，不要转载和他用！