本文详细介绍了Java语言的基础知识，包括开发环境（JDK、JRE、JVM）、集成开发环境Idea的使用、数据类型（八大基本类型及其转换）、运算符、Scanner类的使用、分支结构（if、if...else、switch...case）以及循环结构（while、do...while、for）。此外，还讨论了数组的概念、操作和异常处理，以及方法的定义和调用。
Java语言基础
1.Java开发环境
编译运行过程
-
编译期:
.java源文件,经过编译,生成.class字节码文件 -
运行期:
JVM加载.class并运行.class(0和1)特点:跨平台,一次编译到处使用
名词(JDK,JRE,JVM)
-
JDK:java开发工具包,是java的核心,包括JRE+编译,运行等命令工具 -
JRE:java运行环境，是运行java程序所必须的环境的集合，包括:JVM+java系统类库(小零件) -
JVM:java虚拟机，是java实现跨平台的最核心部分，能够运行java语言所开发的程序.加载.class并运行.class总结:
1.运行
Java程序的最小环境为:JRE 2.开发
Java程序的最小环境为:JDK
2.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("欢迎大家来到达内"); } }
-
-
注释：解释性文本(计算机不执行)
- 单行注释：//
- 多行注释：/* */ ---------------------明天用
- 文档注释：/** */ -------------------面向对象阶段讲
-
java是Oracle公司的，开源的，免费 -
内存单位换算:-----------------背下来 1G=1024M(兆) 1M=1024KB(千字节) 1KB=1024B(字节) 1B=8bit(位)
3.变量
命名法
-
小驼峰命名法：第1个单词首字母小写，其余单词首字母大写-------------变量、方法、包名
score,myScore,myJavaScore -
帕斯卡命名法/大驼峰命名法：所有单词首字母大写---------------------------类
Score,MyScore,MyJavaScore -
常量所有的字母都大写,单词之间用"_"隔开
SCORE,MY_SCORE,MY_JAVA_SCORE
声明
-
相当于在银行开账户
int a; //声明了一个整型的变量，名为a int b,c,d; //声明了三个整型的变量，名为b,c,d //int a; //编译错误，变量不能同名
初始化:
-
相当于给账户存钱
int e = 250; //声明整型变量e并赋值为250------开户的同时存钱 int f; //声明整型变量f--------先开户 f = 250; //给变量f赋值为250-----后存钱 f = 360; //修改f的值为360
访问:
-
访问的是账户里边的钱
-
对变量的访问就是对它所存的的那个数的访问
int g = 5; int h = g+10; //取出g的值5，加10后，再赋值给变量h System.out.println(h); //输出h的值15 System.out.println("h"); //输出h，双引号中的原样输出 g = g+10; //在g本身基础之上增10 System.out.println(g); //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 m; //不建议，不直观 int 年龄; //不建议，直观但不专业 int nianLing; //不建议，既不直观也不专业 int age; //建议"英文的见名知意" int score,myScore,myJavaScore; //建议"小驼峰命名法"
-
变量的作用域/范围
从变量的声明开始，到包含它最近的大括号结束
变量的同名
作用域重叠时，变量不能同名
4.八大基本类型
byte字节型
- 用于存储整数的，占用1个字节，范围-128到127
short短整形
- 用于存储整数的，占用2个字节，范围-32768到32767
int整型(字面默认值)
-
4个字节，范围-231 到231-1(-21个多亿到21个多亿)
-
整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误
int a = 250; //250为整数直接量，默认为int类型 int b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了 int c = 3.14; //编译错误，数据类型不匹配
-
两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
System.out.println(5/2); //2 System.out.println(2/5); //0 System.out.println(5/2.0); //2.5 -
运算时，若超范围则发生溢出，溢出不是错误，但是需要避免
int d = 2147483647; //int的最大值 d = d+1; System.out.println(d); //-2147483648，发生溢出了，溢出需要避免
long长整型
-
用于存储较大的整数，占用8个字节，范围-263 到263-1(-900万万亿多到900万万亿多)
-
长整型的直接量需在数字后加L或l
long a = 125L; //125L为长整型直接量 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亿
float单精度浮点型
- 用于存储小数的，占用4个字节，不能表示精确的值
double双精度浮点型(字面默认值)
-
最常用的存储小数的类型，占用8个字节，不能表示精确的值
在内存当中保存的位数是有限的
-
小数直接量默认为
double型，若想表示float，需在数字后加F或fdouble a = 3.14; //3.14为小数直接量，默认为double类型 float b = 3.14F; //3.14F为float直接量 -
不能表示精确数字，运算时有可能会发生舍入误差，精确场合不能使用
double c=3.0,d=2.9; System.out.println(c-d); //0.10000000000000009，有可能发生舍入误差
boolean布尔型
-
存储true或false，占用1个字节,只能存储true或false
boolean a = true; //true为布尔型直接量 boolean b = false; //false为布尔型直接量 boolean c = 250; //编译错误，布尔型只能存储true或false
char字符型(Unicode字符编码格式)
-
采用
Unicode字符编码格式，Unicode：万国码、统一码、通用码，是世界级通用的定长(16位)字符集 -
存储单个字符，占用2个字节
-
一个字符对应一个码.表现的形式是字符
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 = '10'; //编译错误，只能有一个字符 char c8 = 65; //0到65535之间 System.out.println(c8); //println()输出时会依据c8的类型来输出展示 //若c8是char型，则以字符形式输出 //若c8是int型，则以数字形式输出 -
特殊符号需要通过\来转义
char c9 = '\''; System.out.println(c9); //'
5.类型之间的转换
大小次序
- 数据类型由小到大依次为：
byte<short<int<long<float<double
char<
-
char在short和int之间
-
char类型里边的是Unicode字符编码格式,本质上是码int(0到65535),所以最大值比short大,但是范围比short小
两种方式
-
自动/隐式类型转换：小类型转为大类型
-
强制类型转换：大类型转为小类型
- 语法：(要转换成为的数据类型)变量
- 注意：强转有可能溢出或丢失精度
int a = 5; long b = a; //自动类型转换(小到大) int c = (int)b; //强制类型转换(大到小) long d = 5; //自动类型转换 double e = 5; //自动类型转换 double f = 25.987; int g = (int)f; System.out.println(g); //25，强转有可能丢失精度 long h = 10000000000L; int i = (int)h; System.out.println(i); //1410065408，强转有可能发生溢出
两点规则:
-
整数直接量可以直接赋值给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 int a = '我'; System.out.println(a); //25105，'我'所对应的码
6.运算符
算数
-
算数:
+、-、*、/、%、++、---
%:取模/取余，余数为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 int d = ++b; //1)将++b的值6赋值给d 2)b自增1变为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--; //相当于a=a-1 --b; //相当于b=b-1 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，关系不成立则为falseint 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>b); //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变为
逻辑
-
逻辑：
&&、||、!-
逻辑运算是建立在关系运算的基础之上的
逻辑运算的结果也是boolean型 -
&&：短路与(并且)，两边都为真则为真，见false则false- 当第1个条件为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 b3 = a>b && c++>2; System.out.println(b3); //false System.out.println(c); //5，发生短路了 -
||：短路或(或者)，有真则为真，见true则true- 当第1个条件为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 b4 = a<b || c++>2; System.out.println(b4); //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
-
条件/三目
- 在**纳秒级运算速度:三目运算>switch…case结构>if函数**
-
语法：
-
boolean?数1:数2
?后边可以是表达式1和表达式2
-
-
执行过程：
-
整个条件运算是有值的，它的值要么是?号后的数1，要么是:号后的数2
-
计算boolean的值:
-
若为true，则整个表达式的值为?号后的数1
-
若为false，则整个表达式的值为:号后的数2
int num = 5; 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); //max=55
-
-
7.Scanner
-
Scanner接收用户输入的数据：分三步，不需要理解，需要背下来
1.在package下:
import java.util.Scanner;
2.在main中:
Scanner scan = new Scanner(System.in);
3.在第2步之下:System.out.println("请输入年龄:"); int age = scan.nextInt(); System.out.println("请输入商品价格:"); double price = scan.nextDouble();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); } }
8.随机数
- random随机
Math.random()--------------0.0到0.9999999999999...
*1000----------------------0.0到999.99999999999...
+1-------------------------1.0到1000.9999999999...
(int)----------------------1到1000
9.分支结构
基于条件执行的语句
if结构
任何复杂的程序逻辑都可以通过三种结构来实现：
顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句，并非每句必走
循环结构：有条件的执行某语句多次，并非每句必走
-
一条路
1)语法: if(boolean){ 语句块--------------基于条件执行的语句 } 2)执行过程: 判断boolean的值: 若为true，则执行语句块(整个结束) 若为false，则直接结束//1)偶数的判断: int num = 5; //带数(6,5) if(num%2==0){ System.out.println(num+"是偶数"); } System.out.println("继续执行..."); //2)满500打8折: double price = 300.0; //消费金额 带数(600.0,300.0) if(price>=500){ //满500 price *= 0.8; //打8折 } System.out.println("最终结算金额为:"+price); //3)判断年龄是否在18到50之间(包含)，若在范围内则输出:满足条件 int age = 88; //带数(38,8,88) if(age>=18 && age<=50){ System.out.println("满足条件"); } System.out.println("继续执行...");
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*=0.8; }else{ price*=0.9; } System.out.println("最终结算金额为:"+price); //3)判断年龄是否在18到50之间(包含)，在范围内输出:满足条件，不在范围内输出:不满足条件 int age = 88; //带数(38,8,88) if(age>=18 && age<=50){ System.out.println("满足条件"); }else{ System.out.println("不满足条件"); }
if…else if结构:
-
多条路-------------------多选1
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，必走其中之一-------------多选1package 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,-88,95,85,65,45) 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("输入错误"); } } }
10.循环
反复多次执行一段相同或相似的代码
循环三要素
-
循环变量的初始化
-
循环的条件(以循环变量为基础)
-
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
案例一： 输出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循环结束
-
输出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循环结束 输出继续执行... -
输出9的乘法表
int num = 1; while(num<=9){ System.out.println(num+"*9="+num*9); num+=2; //num++; } System.out.println("继续执行..."); -
猜数字小游戏
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)语法:
do{
语句块-------------------反复执行的代码
}while(boolean);
2)执行过程:
先执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，如此反复，直到boolean的值为false时，循环结束
-
猜数字小游戏
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=373 //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 } }
for循环结构
应用率最高、与次数相关的循环
1)语法:
// 1 2 3
for(要素1;要素2;要素3){
语句块/循环体---------------反复执行的代码 4
}
2)执行过程:
1243243243243243...2为false时，for循环结束
-
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); } for(int num=9;num>=1;num--){ System.out.println(num+"*9="+num*9); } for(int times=0;times<5;times++){ System.out.println("行动是成功的阶梯"); } System.out.println("继续执行...");带数
执行过程:-----带数 times=0 true 输出 times=1 true 输出 times=2 true 输出 times=3 true 输出 times=4 true 输出 times=5 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("我要学习..."); } for(int i=1,j=5;i<=5;i+=2,j-=2){ System.out.println(i+","+j); }输出结果
i=1,j=5 i=3,j=3 i=5,j=1 i=7,j=-1 -
随机加法运算器
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+36=? 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==5){ //在某种特定条件下，提前结束循环
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 4*9=36
num=5
*/
continue
跳过循环体中剩余语句而进入下一次循环,并没有跳出该循环函数
-
输出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 -
输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){ if(num%3!=0){ System.out.println(num+"*9="+num*9); } }
嵌套循环
-
循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
-
执行过程：外层循环走一次，内层循环走所有次
-
建议：嵌套层次越少越好，能用一层就不用两层，能用两层就不用三层
-
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 换行
11.数组
基础介绍
- 是一种引用数据类型,默认值是0
- 相同数据类型元素的集合
数组的概念
把有限个相同类型元素变量放在一个整体， 这个整体就叫做数组。数组中的每一个元素被称为数组元素，通常可以通过数组元素的索引(也叫下标，可以理解为一种编号，从0开始)来访问数组元素，包括数组元素的赋值(set)和取值(get)。
在Java中数组属于引用类型，也是一种类型，Java中的数组要求所有的数组元素必须具有相同的数据类型，因此在一个数组中，数组元素的类型是唯一的，一个数组只能存储一种数据类型的数据，而不能存储多种数据类型的数据。
一旦数组初始化完成,数组内存所在的空间也就被固定,因此数组的长度是不可改变的.即使把某个数组中所有元素的数据全部清空，其所占的空间仍然会被保留，该空间依然属于该数组，数组长度依然不会改变。
数组既可以存放基本数据类型(如: int\char\boolean),也可以存放引用数据突型(如: String),只要数组的数组元素具有相同的类型就可以。
-
定义:
声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
int[] arr = new int[10]; -
初始化:--------------------初始化的是数组中的元素
int[] arr = new int[3]; //0,0,0 int[] arr = {2,5,8}; //2,5,8 int[] arr = new int[]{2,5,8}; //2,5,8 int[] arr; //arr = {2,5,8}; //编译错误，此方式只能声明同时初始化 arr = new int[]{2,5,8}; //正确 -
访问：----------------访问的是数组中的元素
-
通过(数组名.length)可以获取数组的长度(元素个数)
int[] arr = new int[6]; System.out.println(arr.length); //6 -
通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组长度-1)
int[] arr = new int[3]; 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]); //输出每个元素的值 }
-
下标越界异常
ArrayIndexOutOfBoundsException数组下标越界异常：运行时才发生
- 数组下标从0开始，最大到(数组长度-1)，若不符合这个范围，则运行时发生数组下标越界异常
复制
-
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 System.arraycopy(a,1,b,0,4); //灵活性好 for(int i=0;i<b.length;i++){ System.out.println(b[i]); }a:源数组 1:源数组的起始下标 b:目标数组 0:目标数组的起始下标 4:要复制的元素个数 -
int[] b = Arrays.copyOf(a,6)
of—"…的"
copyOf(a,6)表示的是(a,6)的copy(复制)
-
int[] a = {10,20,30,40,50}; int[] b = Arrays.copyOf(a,6); for(int i=0;i<b.length;i++){ System.out.println(b[i]); }//a:源数组 //b:目标数组 //6:目标数组的长度 // ---若目标数组长度>源数组长度，则末尾补默认值 // ---若目标数组长度<源数组长度，则将末尾的截掉
-
-
数组的扩容a = Arrays.copyOf(a,a.length+1)
-
数组的扩容(创建了一个更大的新的数组，并将数据复制进去)
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]); }
-
-
求数组元素的最大值
-
求数组元素的最大值，并将最大值放在数组最后一个元素的下一个位置
public class MaxOfArray { public static void main(String[] args) { int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ arr[i] = (int)(Math.random()*100); 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); //对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); //升序排列 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]); }
12.方法
函数.过程
- 作用：封装一段特定的业务逻辑功能
- 建议：尽可能独立，一个方法只干一件事
- 可以被反复多次调用
- 减少代码重复，有利于代码维护
- 何时用：一个业务有很多地方使用，只要是一个独立的功能就一定得抽到方法中
- 方法的签名：方法名+参数列表
方法的定义(五要素)
修饰词 返回值类型 方法名(参数列表) {
方法体
}
-
形参
- 形式参数，定义方法时的参数叫做形参
-
实参
- 实际参数，调用方法时的参数叫做实参
创建方法举例
有无参数和返回值
-
无参无返回值
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){ //------------------形参 if(age>=50){ //在某种特定条件下，提前结束方法 return; //结束方法的执行 } System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); } -
无参有返回值
public static double getNum(){ //return "abc"; //编译错误，返回值类型必须匹配 return 8.88; //1)结束方法的执行 2)返回结果给调用方 }* 若方法有返回值，则在方法中必须出现return关键字 * 并且return后跟的数的类型还必须与返回值类型匹配 * 作用: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" //------------------实参 sayHi("wangwu"); //String name="wangwu" //------------------实参 sayHello("zhangsan",25); //String name="zhangsan",int age=25 //-------实参 sayHello("lisi",24); //String name="lisi",int age=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); //------------------实参 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",25);
double a = getNum(); //输出a----模拟对返回值的后续操作
int b = plus(5,6); //输出b----模拟对返回值的后续操作
int m=5,n=6; 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; //return num1+num2;
}
public static int[] testArray(){
int[] arr = ...; return arr;
}
Java语言基础-连接
浮点数不能不精确保存数的原因
| 种类名称 | 存储大小 | 取值范围 |
|---|---|---|
float(单精度) | 4字节（32bit） | -3.403E38~ 3.403E38 |
double(双精度) | 8字节（64bit） | -1.798E308~ 1.798E308 |
存储结构
以下01代码都是补码
在实际计算机内存中存储分为3部分:符号位,指数位,尾数位(有效数字)
单精度浮点数32位=1位符号位+8位指数位+23位有效数字
双精度浮点数64位=1位符号位+11位指数位+52位有效数字
- 符号位：1表示负值，0表示正值
- 指数位：
float的指数范围8位（为-128~ +127），而double的指数范围11位（为-1024~+1023），并且指数位是按补码的形式来划分的。
其中负指数决定了浮点数所能表达的绝对值最小的非零数；而正指数决定了浮点数所能表达的绝对值最大的数，也即决定了浮点数的取值范围。 - 尾数位：
float和double的精度是由尾数的位数来决定的。浮点数在内存中是按科学计数法来存储的，其整数部分始终是一个隐含着的“1”，由于它是不变的，故不能对精度造成影响。 float：2^23 = 8388608，一共七位，由于最左为1的一位省略了，这意味着最多能表示8位数： 2*8388608 = 16777216 。有8位有效数字，但绝对能保证的为7位，即float的精度为7~8位有效数字；double：2^52 = 4503599627370496，一共16位，double的精度为16~17位。
水平制表位，固定占8位
###java.lang包
java语言的核心
java.lang包是java语言的核心，它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。
java.util包
各类常用工具包
- 包含集合框架、遗留的
collections类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式日期时间工具等各类常用工具包
System类
| 英文 | 翻译 |
|---|---|
current Time Millis | 当前时间 |
-
System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。 -
由于该类的构造方法是
private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。 -
long System.currentTimeMillis()获取当前系统时间,格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数
Array类
数组类—属于
java.lang数组是length属性，String字符串是length方法
Java中最基本的一个存储结构。- 提供了动态创建和访问
Java数组的方法。其中的元素的类型必须相同。 - 效率高，但容量固定且无法动态改变。
- 它无法判断其中实际存有多少元素，
length只是告诉我们array的容量。
Arrays类
[返回连接](#int[] b = Arrays.copyOf(a,6))
静态类—属于java.util
针对数组进行操作的工具类。
- 此静态类专门用来操作array ，提供搜索、排序、复制等静态方法。
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
