一、环境搭建
下载和安装jdk(车油)和idea(车):------------------装好的同学,不需要重装
-
下载:
- 打开浏览器,在地址栏中输入doc.canglaoshi.org,回车
- 找到常用下载,找到Windows/Mac OS必备,下载jdk 8和idea社区版
-
安装:
-
JDK的安装:一路下一步,直到显示完成为止-----------不要企图去运行它
-
idea的安装:一路下一步,直接安装结束为止----------保证在桌面上有一个快捷方式
-
-
java开发环境:
-
java编译运行过程:
-
编译期:.java源文件,经过编译,生成.class字节码文件
-
运行期:JVM加载并运行.class(0和1)
特点:跨平台、一次编译到处使用
-
-
名词解释:
-
JVM:java虚拟机
加载.class并运行.class
-
JRE:java运行环境
除了包含JVM以外还包含了运行java程序所必须的环境
JRE = JVM+java系统类库(小零件)
-
JDK:java开发工具包
除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK = JRE+编译、运行等命令工具
注意:
- 运行java程序的最小环境为JRE
- 开发java程序的最小环境为JDK
-
-
-
idea:
-
JetBrains公司的,分为社区版(免费)和终级版(收费的)
-
开发步骤:
-
新建Java项目/工程--------------------------小区
-
新建Java包-------------------------------------楼+单元
-
新建Java类-------------------------------------房子
main中:System.out.println(“hello world”);
package day01; //声明包day01(楼+单元) public class HelloWorld { //声明类HelloWorld(房子) //主方法,为程序的入口(大门口),程序的执行从main开始,main结束则程序结束 public static void main(String[] args) { //输出hello world //1)严格区分大小写 //2)所有符号必须是英文模式的 //3)每句话必须以分号结尾 System.out.println("hello world"); //双引号中的原样输出 System.out.println("欢迎大家来到达内"); } }
-
-
注释:解释性文本(计算机不执行)
- 单行注释://
- 多行注释:/* */
- 文档注释:/** */
-
补充知识
-
IDE:集成开发环境,一整套带图形界面的功能强大的工具,目前最流行的IDE叫Idea
-
单词
内存单位换算:-----------------背下来 1G=1024M(兆) 1M=1024KB(千字节) 1KB=1024B(字节) 1B=8bit(位)
二、基本数据类型
-
变量:存数的
-
声明:---------------在银行开了个帐户
int a; //声明一个整型的变量,名为a int b,c,d; //声明三个整型的变量,名为b,c,d //int a; //编译错误,变量不能同名
-
初始化:--------------给帐户存钱
int a = 250; //声明整型变量a并赋值为250------开户的同时存了个250 int b; //声明整型变量b b = 250; //给变量b赋值为250---------先开户再存了个250 b = 360; //修改变量b的值为360
-
使用:---------------使用的是帐户里面的钱
-
对变量的使用就是对它所存的那个数的使用
int a = 5; int b = a+10; //取出a的值5,加10后,再赋值给整型变量b System.out.println(b); //输出变量b的值15 System.out.println("b"); //输出b,双引号中的原样输出 a = a+10; //在a本身基础之上增10 System.out.println(a); //15
-
变量在使用之前必须声明并初始化
System.out.println(i); //编译错误,变量i未声明 int i; System.out.println(i); //编译错误,变量i未初始化
-
-
命名:
-
只能包含字母、数字、_和$符,并且不能以数字开头
-
严格区分大小写
-
不能使用关键字
-
允许中文命名,但不建议,建议"英文的见名知意"、“小驼峰命名法”
int a1,a_5$,_3c,$_5; //int a*b; //编译错误,不能包含*号等特殊符号 //int 1a; //编译错误,不能以数字开头 int aa = 5; //System.out.println(aA); //编译错误,严格区分大小写 //int class; //编译错误,不能使用关键字 //int j; //不直观,不建议 //int 年龄; //允许中文,但不建议 //int nianLing; //必须杜绝,既不直观也不专业,不建议 int age; //建议"英文的见名知意" int score,myScore,myJavaScore; //建议"小驼峰命名法"
-
-
-
八种基本数据类型:byte、short、int、long、float、double、boolean、char
-
int:整型,4个字节,-21个多亿到21个多亿
int:整型,4个字节,5,25,250...... long:长整型,8个字节,5L,100000000000L...... double:浮点型,8个字节,3.14,25.678...... boolean:布尔型,1个字节,true,false char:字符型,2个字节,'你','y','5','*'......
-
整数直接量默认为int类型,但不能超出范围,若超范围则发生编译错误
int a = 25; //25为整数直接量,默认为int类型 //int b = 10000000000; //编译错误,100亿默认为int类型,但超出范围了 //int c = 25.678; //编译错误,数据类型不匹配
-
两个整数相除,结果还是整数,小数位无条件舍弃(不会四舍五入)
System.out.println(5/2); //2 System.out.println(2/5); //0 System.out.println(5/2.0); //2.5
-
运算时若超范围会发生溢出,溢出不是错误,但需要避免
int c = 2147483647; //int的最大值 c = c+1; System.out.println(c); //-2147483648(int的最小值),发生溢出了
-
-
long:长整型,8个字节,很大很大很大
-
长整型直接量需要数字后加L或l
long a = 25L; //25L为长整型直接量 //long b = 10000000000; //编译错误,100亿默认为int型,但超出int范围了 long c = 10000000000L; //100亿L为长整型
-
运算时若有可能溢出,建议在第1个数字后加L
long d = 1000000000*2*10L; System.out.println(d); //200亿 long e = 1000000000*3*10L; System.out.println(e); //不是300亿 long f = 1000000000L*3*10; System.out.println(f); //300亿
-
-
double:浮点型,8个字节,很大很大很大
-
浮点数直接量默认为double型,若想表示float则需在数字后加F或f
double a = 25.678; //25.678为浮点数直接量,默认double型 float b = 25.678F; //25.678F为float型
-
double或float型数据运算时,有可能会发生舍入误差,精确场合不能使用
double c=3.0,d=2.9; System.out.println(c-d); //0.10000000000000009,有可能发生舍入误差
-
-
boolean:布尔型,1个字节
-
只能取值为true或false
boolean a = true; //true为布尔型直接量 boolean b = false; //false为布尔型直接量 //boolean c = 250; //编译错误,数据类型不匹配
-
-
char:字符型,2个字节
-
采用Unicode编码格式,一个字符对应一个码
表现的形式是字符char,但本质上是码int(0到65535之间)
ASCII码:‘a’—97 ‘A’—65 ‘0’—48
-
字符直接量必须放在单引号中,只能装1个
char c1 = '女'; //字符女 char c2 = 'f'; //字符f char c3 = '6'; //字符6 char c4 = ' '; //空格符 //char c5 = 女; //编译错误,字符直接量必须放在单引号中 //char c6 = ''; //编译错误,必须有字符 //char c7 = '女性'; //编译错误,只能有1个字节 char c8 = 97; //0到65535之间 //println()时会依据c8的数据类型来输出数据 System.out.println(c8); //A,c8为char类型,所以会以字符的格式来输出
-
特殊符号需要通过\来转义
char c9 = '\\'; //\为转义符 System.out.println(c9); //\
-
-
-
类型间的转换:
数据类型由小到大依次为:byte,short,int,long,float,double
char
-
两种方式:
-
自动/隐式类型转换:小类型到大类型
-
强制类型转换:大类型到小类型
语法:(要转换成为的数据类型)变量
注意:强转有可能溢出或丢失精度
int a = 5; long b = a; //自动类型转换 int c = (int)b; //强制类型转换 long d = 5; //自动类型转换 double e = 5; //自动类型转换 //练习-----------4:41继续 long f = 10000000000L; int g = (int)f; System.out.println(g); //1410065408,强转有可能发生溢出 double h = 25.987; int i = (int)h; System.out.println(i); //25,强转有可能丢失精度
-
-
两点规则:
-
整数直接量可以直接给byte,short,char赋值,但不能超范围
-
byte,short,char型数据参与运算时,系统会自动将其统一转换为int再运算
byte b1 = 5; byte b2 = 6; byte b3 = (byte)(b1+b2); System.out.println(2+2); //4 System.out.println(2+'2'); //52,2加上'2'的码50 System.out.println('2'+'2'); //100,'2'的码50,加上,'2'的码50 System.out.println('2'); //2,只有运算时才会转换为int类型
-
-
补充知识
-
标识符命名法:
-
小驼峰命名法:第1个单词首字母小写,其余单词首字母大写
score,myScore,myJavaScore------------变量
-
大驼峰命名法/帕斯卡命名法:所有单词首字母大写
Score,MyScore,MyJavaScore-------------类
-
-
数据类型分类:基本数据类型和引用数据类型
-
内存单位换算:
1G=1024M(兆) 1M=1024KB(千字节) 1KB=1024B(字节) 1B=8bit(位)
-
Unicode:万国码、统一码、通用码,世界级通用的定长(固定16位)字符集
三、运算符及分支结构:
-
运算符:
-
算术:+、-、*、/、%、++、–
-
%:取模/取余,余数为0即为整除
System.out.println(5%2); //1,商2余1 System.out.println(8%2); //0,商4余0----整除 System.out.println(2%8); //2,商0余2
-
++/–:自增1/自减1,可在变量前也可在变量后
- 单独使用时,在前在后都一样
- 被使用时,在前在后不一样
- a++的值为a----------(a–的值为a)
- ++a的值为a+1--------(–a的值为a-1)
//演示++单独使用 int a=5,b=5; a++; //相当于a=a+1 ++b; //相当于b=b+1 System.out.println(a); //6 System.out.println(b); //6 //演示++被使用 int a=5,b=5; int c = a++; //1)将a++的值5赋值给c 2)a自增1变为6 //----a++的值为a(5),所以c的值就是5 int d = ++b; //1)将++b的值6赋值给d 2)b自增1变为6 //++b的值为b+1(6),所以d的值就是6 System.out.println(a); //6 System.out.println(b); //6 System.out.println(c); //5 System.out.println(d); //6 //演示--单独使用: int a=5,b=5; a--; --b; System.out.println(a); //4 System.out.println(b); //4 //演示--被使用: int a=5,b=5; int c = a--; //1)将a--的值5赋值给c 2)a自减1变为4 int d = --b; //1)将--b的值4赋值给d 2)b自减1变为4 System.out.println(a); //4 System.out.println(b); //4 System.out.println(c); //5 System.out.println(d); //4
-
-
关系:>、<、>=、<=、==、!=
1)>(大于)、<(小于) >=(大于或等于)、<=(小于或等于) ==(等于)、!=(不等于) 2)关系运算的结果为boolean型, 关系成立则为true,关系不成立则为false
int a=5,b=10,c=5; boolean b1 = a>b; System.out.println(b1); //false System.out.println(c<b); //true System.out.println(a>=c); //true System.out.println(a<=b); //true System.out.println(a==c); //true System.out.println(a!=c); //false System.out.println(a+c>10); //false System.out.println(a%2==0); //false System.out.println(a++>5); //false--------a自增1变为6 System.out.println(a++>5); //true---------a自增1变为7
-
逻辑:&&、||、!
-
逻辑运算是建立在关系运算的基础之上的
逻辑运算的结果也是boolean型 -
&&:短路与(并且),两边都为真则为真,见false则false
int a=5,b=10,c=5; boolean b1 = b>=a && b<c; System.out.println(b1); //true&&false=false System.out.println(b<=c && b>a); //false&&true=false System.out.println(a==b && c>b); //false&&false=false System.out.println(b!=c && a<b); //true&&true=true //演示短路 boolean b1 = a>b && c++>2; System.out.println(b1); //false System.out.println(c); //5,发生短路了
-
||:短路或(或者),有真则为真,见true则true
int a=5,b=10,c=5; System.out.println(b>=a || b<c); //true||false=true System.out.println(b<=c || b>a); //false||true=true System.out.println(b!=c || a<b); //true||true=true System.out.println(a==b || c>b); //false||false=false //演示短路 boolean b2 = a<b || c++>2; System.out.println(b2); //true System.out.println(c); //5,发生短路了
-
!:逻辑非(取反),非真则假,非假则真
int a=5,b=10,c=5; boolean b2 = !(a<b); System.out.println(b2); //!true=false System.out.println(!(a>b)); //!false=true
-
-
赋值:=、+=、-=、*=、/=、%=
-
简单赋值运算符:=
-
扩展赋值运算符:+=、-=、*=、/=、%=
—注意:扩展赋值运算符自带强转功能int a = 5; a += 10; //相当于a=(int)(a+10) System.out.println(a); //15 a *= 2; //相当于a=(int)(a*2) System.out.println(a); //30 a /= 6; //相当于a=(int)(a/6) System.out.println(a); //5 //小面试题: short s = 5; //s = s+10; //编译错误,需强转: s=(short)(s+10); s += 10; //相当于: s=(short)(s+10);
-
-
字符串连接:+
-
若两边为数字,则做加法运算
-
若两边出现了字符串,则做字符串连接
-
任意类型的数据只要和字符串连,结果都会变为字符串类型—同化作用
int age = 38; System.out.println("age="); //age= System.out.println(age); //38 System.out.println("age="+age); //age=38 System.out.println("我的年龄是"+age); //我的年龄是38 System.out.println("我今年"+age+"岁了"); //我今年38岁了 String name = "WKJ"; System.out.println("name="+name); //name=WKJ System.out.println("大家好,我叫"+name); //大家好,我叫WKJ System.out.println("大家好,我叫"+name+",今年"+age+"岁了"); //大家好,我叫WKJ,今年38岁了 System.out.println(10+20+""+30); //3030--------String System.out.println(""+10+20+30); //102030------String System.out.println(10+20+30+""); //60----------String
-
-
条件/三目:
-
语法:
boolean?数1:数2
-
执行过程:
- 整个表达式是有值的,它的值要么是问号后的数1,要么是冒号后的数2
- 判断boolean的值:
- 若为true,则整个表达式的结果为?号后的数1
- 若为false,则整个表达式的结果为:号后的数2
int num = 0; int flag = num>0?1:-1; System.out.println(flag); //-1 int a=8,b=55; int max = a>b?a:b; System.out.println("max="+max);
-
-
-
分支结构:基于条件执行的语句
-
if结构:1条路
1)语法: if(boolean){ 语句块-------------基于条件执行的语句 } 2)执行过程: 判断boolean的值: 若为true,则执行语句块(整个结束) 若为false,则直接结束
//1)偶数的判断: int num = 6; if(num%2==0){ //带数(6,5) System.out.println(num+"是偶数"); } System.out.println("继续执行..."); //1)满500打8折 double price = 300.0; //消费金额 if(price>=500){ //满500 带数(600.0,300.0) price = price*0.8; //打8折 } System.out.println("最终结算金额为:"+price);
-
if…else结构:2条路
1)语法: if(boolean){ 语句块1 }else{ 语句块2 } 2)执行过程: 判断boolean的值: 若为true,则执行语句块1(整个结束) 若为false,则执行语句块2(整个结束) 3)说明: 语句块1和语句块2,必走其中之一----------2选1
//1)偶数、奇数的判断: int num = 5; //带数(6,5) if(num%2==0){ System.out.println(num+"是偶数"); }else{ System.out.println(num+"是奇数"); } System.out.println("继续执行..."); //2)满500打8折,不满500打9折: double price = 300.0; //带数(600.0,300.0) if(price>=500){ price = price*0.8; }else{ price = price*0.9; } System.out.println("最终结算金额为:"+price);
-
补充知识
-
任何复杂的程序逻辑都可以通过三种结构来实现:
- 顺序结构:从上往下逐行执行,每句必走
- 分支结构:有条件的执行某语句,并非每句必走
四、分支结构及循环:
-
Scanner接收用户输入的数据:共3步-----------不需要理解,先记住它,面向对象第五天才能理解
package day04; import java.util.Scanner; //1.导入扫描仪 //Scanner的演示 public class ScannerDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); //2.新建一个扫描仪叫scan System.out.println("请输入年龄:"); int age = scan.nextInt(); //3.用扫描仪扫描一个整数赋值给age System.out.println("请输入商品价格:"); double price = scan.nextDouble(); //3.用扫描仪扫描一个小数赋值给price System.out.println("年龄为:"+age+",商品价格为:"+price); } }
-
分支结构:
-
if…else if结构:多条路
1)语法: if(boolean-1){ 语句块1 }else if(boolean-2){ 语句块2 }else if(boolean-3){ 语句块3 }else{ 语句块4 } 2)执行过程: 判断boolean-1,若为true则执行语句块1(结束),若为false则 再判断boolean-2,若为true则执行语句块2(结束),若为false则 再判断boolean-3,若为true则执行语句块3(结束),若为false则执行语句块4(结束) 3)说明: 语句块1/2/3/4,必走其中之一-------多选1
package day04; import java.util.Scanner; //成绩等级判断 public class ScoreLevel { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("请输入成绩:"); double score = scan.nextDouble(); //带数(888,-45,95,85,65,40) if(score<0 || score>100){ System.out.println("成绩不合法"); }else if(score>=90){ //成绩合法 System.out.println("A-优秀"); }else if(score>=80){ System.out.println("B-良好"); }else if(score>=60){ System.out.println("C-中等"); }else{ System.out.println("D-不及格"); } } }
-
switch…case结构:
-
优点:效率高、结构清晰
-
缺点:只能对整数判断相等
-
break:跳出switch
面试题:switch后数据的类型可以为:byte,short,char,int,String,枚举类型
package day04; import java.util.Scanner; //命令解析程序 public class CommandBySwitch { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("请选择功能: 1.存款 2.取款 3.查询余额 4.退卡"); int command = scan.nextInt(); switch(command){ case 1: System.out.println("存款操作..."); break; case 2: System.out.println("取款操作..."); break; case 3: System.out.println("查询余额操作..."); break; case 4: System.out.println("退卡操作..."); break; default: System.out.println("输入错误"); } } }
-
-
-
循环:反复多次执行一段相同或相似的代码
-
循环三要素:
-
循环变量的初始化
-
循环的条件(以循环变量为基础)
-
循环变量的改变(向着循环的结束变)
循环变量:在整个循环过程中所反复改变的那个数
案例一: 输出5次"行动是成功的阶梯" 行动是成功的阶梯 行动是成功的阶梯 行动是成功的阶梯 行动是成功的阶梯 行动是成功的阶梯 循环变量:次数times 1)int times=0; 2)times<5 3)times++; times=0/1/2/3/4/ 5时结束 案例二: 输出9的乘法表: 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 循环变量:因数num 1)int num=1; 2)num<=9 3)num++; num=1/2/3/4/5/6/7/8/9/ 10时结束 1*9=9 3*9=27 5*9=45 7*9=63 9*9=81 循环变量:因数num 1)int num=1; 2)num<=9 3)num+=2; num=1/3/5/7/9/ 11时结束
-
-
循环结构:
-
while结构:先判断后执行,有可能一次都不执行
1)语法: while(boolean){ 语句块/循环体----------反复执行的代码 } 2)执行过程: 判断boolean的值,若为true则执行语句块, 再判断boolean的值,若为true则再执行语句块, 再判断boolean的值,若为true则再执行语句块, 如此反复,直到boolean的值为false时,while循环结束
//2)输出9的乘法表: //3*9=27 int num = 1; while(num<=9){ System.out.println(num+"*9="+num*9); num+=2; //num++; } System.out.println("继续执行..."); //1)输出5次"行动是成功的阶梯": int times = 0; //1)循环变量的初始化 while(times<5){ //2)循环的条件 System.out.println("行动是成功的阶梯"); times++; //3)循环变量的改变 } System.out.println("继续执行..."); */ /* 执行过程: times=0 true 输出 times=1 true 输出 times=2 true 输出 times=3 true 输出 times=4 true 输出 times=5 false while循环结束 输出继续执行... */
package day04; import java.util.Scanner; //猜数字小游戏 public class Guessing { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int num = (int)(Math.random()*1000+1); //1到1000之内的随机数 System.out.println(num); //作弊 //300(大),200(小),250(对) System.out.println("猜吧!"); int guess = scan.nextInt(); //1. while(guess!=num){ //2. if(guess>num){ System.out.println("太大了"); }else{ System.out.println("太小了"); } System.out.println("猜吧!"); guess = scan.nextInt(); //3. } System.out.println("恭喜你猜对了!"); } }
-
do…while结构:先执行后判断,至少执行一次
当第1要素与第3要素的代码相同时,首选do…while
package day04; import java.util.Scanner; //猜数字小游戏 public class Guessing { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int num = (int)(Math.random()*1000+1); //1到1000之内的随机数 System.out.println(num); //作弊 //假设num=250 //300(大),200(小),250(对) int guess; do{ System.out.println("猜吧!"); guess = scan.nextInt(); //1+3 if(guess>num){ System.out.println("太大了"); }else if(guess<num){ System.out.println("太小了"); }else{ System.out.println("恭喜你猜对了"); } }while(guess!=num); //2 } }
-
补充知识
-
任何复杂的程序逻辑都可以通过三种结构来实现:
- 顺序结构:从上往下逐行执行,每句必走
- 分支结构:有条件的执行某语句一次,并非每句必走
- 循环结构:有条件的执行某语句多次,并非每句必走
-
生成随机数: 1到1000
Math.random()-------------0.0到0.999999999999999... *1000---------------------0.0到999.9999999999999... +1------------------------1.0到1000.999999999999... (int)---------------------1到1000
-
变量的作用域/范围:
- 从变量的声明开始,到包含它最近的大括号结束
五、循环及数组:
-
循环结构:
-
for结构:应用率高、与次数相关的循环
1)语法: // 1 2 3 for(要素1;要素2;要素3){ 语句块/循环体---------------反复执行的语句 4 } 2)执行过程: 1243243243243243...2
for(int times=0;times<5;times++){ System.out.println("行动是成功的阶梯"); } //特殊的: for中的循环变量num的作用域---仅在当前for中 for(int num=1;num<=9;num++){ System.out.println(num+"*9="+num*9); } for(int num=1;num<=9;num+=2){ System.out.println(num+"*9="+num*9); } /* 执行过程: num=1 true 1*9=9 num=3 true 3*9=27 num=5 true 5*9=45 num=7 true 7*9=63 num=9 true 9*9=81 num=11 false for循环结束 */ //演示for的特殊语法格式: int num=1; for(;num<=9;num++){ System.out.println(num+"*9="+num*9); } for(int num=1;num<=9;){ System.out.println(num+"*9="+num*9); num++; } for(;;){ //没有条件的循环就是一个死循环 System.out.println("我爱Java"); } for(int i=1,j=5;i<=5;i+=2,j-=2){ } /* i=1,j=5 i=3,j=3 i=5,j=1 i=7,j=-1 */
//随机加法运算器 package day05; import java.util.Scanner; //随机加法运算器 public class Addition { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int score = 0; //总分 for(int i=1;i<=10;i++){ //10次 (1)25+65=? int a = (int)(Math.random()*100); //加数a--0到99的随机数 int b = (int)(Math.random()*100); //加数b--0到99的随机数 int result = a+b; //存正确答案 System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题 System.out.println("算吧!"); int answer = scan.nextInt(); //2)答题 if(answer==-1){ //3)判题 break; } if(answer==result){ System.out.println("答对了"); score += 10; //答对1题,加10分 }else{ System.out.println("答错了"); } } System.out.println("总分为:"+score); } }
-
-
三种循环结构如何选择:
- 先看循环是否与次数相关:
- 若相关-------------------------------------直接上for
- 若无关,再看第1要素与第3相互的代码是否相同:
- 若相同--------------------------------直接上do…while
- 若不同--------------------------------直接上while
- 先看循环是否与次数相关:
-
break:跳出循环
for(int num=1;num<=9;num++){ if(num==4){ //在某种特定条件下,提前结束循环 break; //跳出循环 } System.out.println(num+"*9="+num*9); } /* 执行过程: num=1 1*9=9 num=2 2*9=18 num=3 3*9=27 num=4 */
continue:跳过循环体中剩余语句而进入下一次循环
//输出9的乘法表,只要不能被3整除 for(int num=1;num<=9;num++){ if(num%3!=0){ System.out.println(num+"*9="+num*9); } } //输出9的乘法表,跳过能被3整除的 for(int num=1;num<=9;num++){ if(num%3==0){ continue; //跳过循环体中剩余语句而进入下一次循环 } System.out.println(num+"*9="+num*9); } /* num=1 1*9=9 num=2 2*9=18 num=3 num=4 4*9=36 num=5 5*9=45 num=6 num=7 7*9=63 num=8 8*9=72 num=9 num=10 false */
-
嵌套循环:
-
循环中套循环,常常多行多列时使用,一般外层控制行,内层控制列
-
执行规则:外层循环走一次,内层循环走所有次
-
建议:嵌套层数越少越好,能用一层就不用两层,能用两层就不用三层
-
break只能跳出当前一层循环
//九九乘法表 public class MultiTable { public static void main(String[] args) { for(int num=1;num<=9;num++){ //控制行 for(int i=1;i<=num;i++){ //控制列 System.out.print(i+"*"+num+"="+i*num+"\t"); } System.out.println(); //换行 } /* 执行过程: num=3 i=1 1*3=3 i=2 2*3=6 i=3 3*3=9 i=4 false 换行 num=2 i=1 1*2=2 i=2 2*2=4 i=3 false 换行 num=1 i=1 1*1=1 i=2 false 换行 */ } }
-
-
数组:
-
是一种数据类型(引用类型)
-
相同数据类型元素的集合
-
定义:
//声明整型数组arr,包含10个元素,每个元素都是int型,默认值为0 int[] arr = new int[10];
-
初始化:------------------初始化的是数组中的元素
int[] arr1 = new int[3]; //0,0,0 int[] arr2 = {2,5,8}; //2,5,8 int[] arr3 = new int[]{2,5,8}; //2,5,8 int[] arr4; //arr4 = {2,5,8}; //编译错误,此方式只能声明同时初始化 arr4 = new int[]{2,5,8}; //正确
-
访问:--------------访问的是数组中的元素
-
通过(数组名.length)可以获取数组的长度(元素个数)
int[] arr = new int[3]; System.out.println(arr.length); //3,输出数组的长度
-
通过下标/索引来访问数组中的元素,下标从0开始,最大到(数组的长度-1)
int[] arr = new int[3]; System.out.println(arr[0]); //0,输出第1个元素的值 arr[0] = 100; //给第1个元素赋值为100 arr[1] = 200; //给第2个元素赋值为200 arr[2] = 300; //给第3个元素赋值为300 arr[3] = 400; //运行时会发生数组下标越界异常 System.out.println(arr[arr.length-1]); //输出最后一个元素的值
-
-
遍历/迭代:从头到尾挨个走一遍
int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ //遍历arr数组 arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的之间的随机数 System.out.println(arr[i]); //输出每个元素的值 }
-
补充知识
-
变量的重名问题:
- 作用域重叠时,变量不能同名
-
\t:水平制表位,固定占8位
-
数组元素的默认值:
byte,short,int,long,char----------------0 float,double----------------------------0.0 boolean---------------------------------false
-
异常:
- ArrayIndexOutOfBoundsException:数组下标越界异常
- 数组下标为0到(数组长度-1),若超出这个范围则发生数组下标越界异常
- ArrayIndexOutOfBoundsException:数组下标越界异常
六、数组及方法:
-
数组:
-
复制:
-
System.arraycopy(a,1,b,0,4);
int[] a = {10,20,30,40,50}; int[] b = new int[6]; //0,0,0,0,0,0 //a:源数组 //1:源数组的起始下标 //b:目标数组 //0:目标数组的起始下标 //4:要复制的元素个数 System.arraycopy(a,1,b,0,4); //灵活性好 for(int i=0;i<b.length;i++){ System.out.println(b[i]); }
-
int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1); //数组的扩容int[] a = {10,20,30,40,50}; //a:源数组 //b:目标数组 //6:目标数组的长度 //----若目标数组的长度>源数组长度,则在末尾补默认值 //----若目标数组的长度<源数组长度,则将末尾的截掉 int[] b = Arrays.copyOf(a,6); for(int i=0;i<b.length;i++){ System.out.println(b[i]); } //数组的扩容 int[] a = {10,20,30,40,50}; //数组的扩容(创建了一个更大的新的数组,并将数据复制进去了) a = Arrays.copyOf(a,a.length+1); for(int i=0;i<a.length;i++){ System.out.println(a[i]); }
package day06; import java.util.Arrays; //求数组元素的最大值,并将最大值放在数组最后一个元素的下一个位置 public class MaxOfArray { public static void main(String[] args) { int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ //遍历arr数组 arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的之间的随机数 System.out.println(arr[i]); //输出每个元素的值 } int max = arr[0]; //假设第1个元素为最大值 for(int i=1;i<arr.length;i++){ //遍历剩余元素 if(arr[i]>max){ //若剩余元素大于max max = arr[i]; //修改max为较大的 } } System.out.println("最大值为:"+max); arr = Arrays.copyOf(arr,arr.length+1); //扩容 arr[arr.length-1] = max; //将max赋值给arr的最后一个元素 for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } } }
-
-
排序:
-
Arrays.sort(arr);
int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ arr[i] = (int)(Math.random()*100); System.out.println(arr[i]); } Arrays.sort(arr); //对arr进行升序排列 System.out.println("排序后数据:"); for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } System.out.println("倒序输出"); //只是倒着显示,但数组中数据没有改变 for(int i=arr.length-1;i>=0;i--){ System.out.println(arr[i]); }
-
-
-
方法:函数、过程
- 封装一段特定的业务逻辑功能
- 尽可能独立,一个方法只干一件事
- 方法可以被反复调用多次
- 可以减少代码重复,有利于代码维护
-
方法的定义:五要素
修饰词 返回值类型 方法名(参数列表) { 方法体 }
//无参无返回值 public static void say(){ System.out.println("大家好,我叫WKJ,今年38岁了"); } //有参无返回值 public static void sayHi(String name){ //形参 System.out.println("大家好,我叫"+name+",今年38岁了"); } //有参无返回值 public static void sayHello(String name,int age){ //形参 System.out.println("大家好,我叫"+name+",今年"+age+"岁了"); } //无参有返回值 public static double getNum(){ /* java规定: 1)有返回值的方法中,必须得通过return来返回数据 2)并且return后数据的类型,必须与返回值类型匹配 */ //return "abc"; //编译错误,返回值类型必须匹配 return 8.88; //1)结束方法的执行 2)返回结果给调用方 } //有参有返回值 public static int plus(int num1,int num2){ int num = num1+num2; return num; //返回的是num里面的那个数 //return num1+num2; //返回的是num1与num2的和 } //无参有返回值 public static int[] testArray(){ int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ arr[i] = (int)(Math.random()*100); } return arr; }
-
方法的调用:
-
无返回值:方法名(有参传参);
public class MethodDemo { public static void main(String[] args) { say(); //调用say()方法 //sayHi(); //编译错误,有参则必须传参 //sayHi(250); //编译错误,参数类型必须匹配 sayHi("zhangsan"); //String name="zhangsan" //实参 sayHi("lisi"); //String name="lisi" //实参 sayHello("zhangsan",25); //实参 String name="zhangsan",int age=25 sayHello("lisi",24); //实参 } }
-
有返回值:数据类型 变量 = 方法名(有参传参);
//方法的演示 public class MethodDemo { public static void main(String[] args) { double a = getNum(); //getNum()的值就是return后的那个数 System.out.println(a); //8.88,模拟对返回值的后续操作 int b = plus(5,6); //plus(5,6)的值就是return后的那个数 System.out.println(b); //11,模拟对返回值的后续操作 int m=5,n=6; int c = plus(m,n); //传递的是m和n里面的数 System.out.println(c); //11,模拟对返回值的后续操作 int[] d = testArray(); System.out.println("长度为:"+d.length); //10---模拟对返回值的后续操作 for(int i=0;i<d.length;i++){ //---模拟对返回值的后续操作 System.out.println(d[i]); } } }
-
-
return:
- return 值; //1)结束方法的执行 2)返回结果给调用方-------------此方式用在有返回值的方法中
- return; //1)结束方法的执行------------------------此方式用在无返回值的方法中
补充知识
-
形参:定义方法时的参数叫形参
实参:调用方法时的参数叫实参
public static void main(String[] args){
say();
sayHi("zhangsan");
sayHello("zhangsan",35);
double a = getNum(); 输出a(模拟对返回值的后续操作)
int b = plus(2,4); 输出b(模拟对返回值的后续操作)
int m=2,n=4; int c = plus(m,n); 输出c(模拟对返回值的后续操作)
int[] d = testArray(); 输出d的长度(模拟对返回值的后续操作) 遍历输出元素(模拟对返回值后续操作)
}
public static void say(){ ... }
public static void sayHi(String name){ ... }
public static void sayHello(String name,int age){ ... }
public static double getNum(){ return 8.88; }
public static int plus(int num1,int num2){ int num=num1+num2; return num; }
public static int[] testArray(){
int[] arr = ...; for(...){...}
return arr;
}