JAVA开发环境
编译运行过程:
从 .java源文件经过编译生成 .class字节码文件,通过JVM加载.class文件并运行。
JDK、JRE、JVM的区别:
JDK:java开发工具包,是java的核心,包括:JRE+编译、运行等命令工具。
JRE:java运行环境,是运行java程序所必须的环境集合,包括:JVM+java系统类库。
JVM:java虚拟机,是java实现跨平台的最核心部分,能够运行java语言所开发的程序。
变量
命名法
小驼峰命名法:第1个单词首字母小写,其余单词首字母大写。
帕斯卡命名法/大驼峰命名法:所有单词首字母大写。
八种基本数据类型
byte:字节型,用于存储整数的,占用1个字节,范围-128到127。
short:短整型,用于存储整数的,占用2个字节,范围-32768到32767。
int:最常用的整型,用于存储整数的,占用4个字节,范围-231到231-1。
long:长整型,用于存储较大的整数的,占用8个字节,范围-263到263-1。
float:单精度浮点型,用于存储小数的,占用 4个字节,不能表示精确的值。
double:双精度浮点型,最常用的存储小数的类型,占用8个字节,不能表示精确的值。
boolean:布尔型,用于存储true或false,占用1个字节
char:字符型,采用Unicode字符编码格式,用于存储单个字符,占用2个字节。
字符间的转化
小转大为隐性转换,即自动转换。
大转小为强制转换 ,强转可能会溢出或丢失精度。
byte,short,char型数据参与运算时,系统会将其自动转换为int类型再运算。
运算符
算数运算符
+、-、*、/、%、++、–
关系运算符
<、>=、<=、==、!=、>
逻辑运算符
&&、||、!
赋值
=、+=、-=、*=、/=、%=
字符串连接符
+
条件运算符
boolean?数1:数2
分支结构
任何复杂的程序逻辑都可以通过顺序结构,分支结构,循环结构三种结构来实现
if结构
1路
1)语法:
if(boolean){
语句块--------------基于条件执行的语句
}
2)执行过程:
判断boolean的值:
若为true,则执行语句块(整个结束)
若为false,则直接结束
if…else结构
2路
1)语法:
if(boolean){
语句块1
}else{
语句块2
}
2)执行过程:
判断boolean的值:
若为true,则执行语句块1(整个结束)
若为false,则执行语句块2(整个结束)
3)说明:
语句块1和语句块2,必走其中之一-------------2选1
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
switch…case
优点:效率高,结构清晰
缺点:只能对整数判断相等
switch中数据类型:byte,short,int,long,char,String,枚举
default位置:可以写在case前面但要加break
一般格式
switch(整数变量){
case 整数:
语句;
break;
case 整数:
语句;
break;
...
default:
语句;
}
判断变量==case后的数,相等则结束分支
都和case后的数不相等执行default的语句
循环结构
while循环结构
先判断后执行,有可能一次都不执行
1)语法:
while(boolean){
语句块/循环体------------反复执行的代码
}
2)执行过程:
先判断boolean的值,若为true则执行语句块,
再判断boolean的值,若为true则再执行语句块,
再判断boolean的值,若为true则再执行语句块,
如此反复,直到boolean的值为false时,while循环结束
do…while循环结构
先执行后判断,至少执行一次
1)语法:
do{
语句块
}while(boolean);
2)执行过程:
先执行语句块,再判断boolean的值,若为true则
再执行语句块,再判断boolean的值,若为true则
再执行语句块,再判断boolean的值,若为true则
再执行语句块,如此反复,直到boolean的值为false时,do...while结束
for循环结构
1)语法:
// 1 2 3
for(要素1;要素2;要素3){
语句块/循环体--------------反复执行的代码 4
}
2)执行过程:
1243243243243243...2为false时,循环结束
嵌套循环
循环中套循环,常常多行多列时使用,外层控制行,内层控制列
执行规则:外层循环走一次,内层循环走所有次
建议:嵌套层数越少越好,能用一层就不用两层,能用两层就不用三层
break默认只能跳出当前一层循环
小结
如何选择循环:看循环是否与次数相关
相关…选择for
无关…do…while或者while
任何复杂的程序逻辑都可以通过三种结构来实现:
顺序结构:从上往下逐行执行,每句必走
分支结构:有条件的执行某语句一次,并非每句必走
循环结构:有条件的执行某语句多次,并非每句必走
变量的作用域/范围:
从变量的声明开始,到包括它最近的大括号结束
作用域重叠时,变量名不能相同
break:跳出当前一层循环
continue:跳出循环体中剩余语句而进行下一次循环
数组
一种相同数据类型元素的集合,是一种引用数据类型
定义
//声明整型数组a,包含5个元素,每个元素都是int类型,默认值为0
int[] a = new int[5];
//声明浮点型数组d,包含10个元素,每个元素都是double类型,默认值为0.0
double[] d = new double[10];
//声明布尔型数组b,包含26个元素,每个元素都是boolean类型,默认值为false
boolean[] b = new boolean[26];
初始化:初始化数组中的元素
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.length); //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]); //300,输出最后一个元素的值
遍历/迭代
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]); //输出每个元素的值
}
排序
将数组型小到大排列可以调用:Arrays.sort(arr);
数组默认值
byte,short,int,long,char-------------0
float,double-------------------------0.0
boolean------------------------------false
其他----------------------------------null
复制
方法1:
可以给数组插入元素
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]);
}
方法2:
可以给数组扩容缩容
int[] a = {10,20,30,40,50};
//a:源数组
//b:目标数组
//6:目标数组的长度
// --若目标数组长度>源数组长度,则末尾补默认值
// --若目标数组长度<源数组长度,则将末尾的截掉
int[] b = Arrays.copyOf(a,6); //灵活性差
方法:函数、过程
作用:用于封装一段特定的业务逻辑功能
建议:尽可能独立,一个方法只干一件事
方法可以被反复多次调用
好处:可以减少代码重复,有利于代码维护
何时用:只要是一个独立的业务功能,就得封装到一个方法中
方法的定义:五要素
修饰词 返回值类型 方法名(参数列表){
方法体---------具体的业务逻辑功能实现
}
//无参无返回值
public static void say(){
System.out.println("大家好");
}
//有参无返回值
public static void sayHi(String name){ //----------------------形参
System.out.println("大家好");
}
//有参无返回值
public static void sayHello(String name,int age){ //-----------形参
if(age>=60){ //在某种特定条件下,提前结束方法
return; //结束方法
}
System.out.println("大家好,我叫"+name+",今年"+age+"岁了");
}
//无参有返回值
public static double getNum(){
//在有返回值的方法中,必须得通过return来返回数据
//return; //编译错误,return后必须跟一个数据
//return "abc"; //编译错误,return后数据的类型必须与返回值类型匹配
return 8.88; //1)结束方法的执行 2)返回结果给调用方
}
方法的调用
无返回值:方法名(有参传参)
public static void main(String[] args) {
say(); //调用say()方法
//sayHi(); //编译错误,有参则必须传参
//sayHi(250); //编译错误,参数类型必须匹配
sayHi("zhangsan"); //String name="zhangsan" //-----实参
}
有返回值:数据类型 变量 = 方法名(有参传参)
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---模拟对返回值的后续操作
return
作用1:结束方法的执行
作用2:返回结果给调用方
方法的重载
方法的签名:方法名+参数列表
发生在同一类中,方法名相同,参数列表不同
编译器在编译时会根据方法的签名自动绑定方法
package day06;
public class MethodDemo {
public static void main(String[] args) {
say(); //自动绑定无参show
say("zhangsan"); //自动绑定String参的
say("lisi",25); //自动绑定String+int参的
//say(3.456); //编译错误,没有double参的say方法
}
//无参无返回值
public static void say(){
System.out.println("大家好,我叫WKJ,今年39岁了");
}
//有参无返回值
public static void say(String name){ //-----------------形参
System.out.println("大家好,我叫"+name+",今年39岁了");
}
//有参无返回值
public static void say(String name,int age){ //------形参
if(age>=50){ //在某种特定条件下,提前结束方法
return; //结束方法的执行
}
System.out.println("大家好,我叫"+name+",今年"+age+"岁了");
}
public static void say(int age) {} //正确的重载
public static void say(int age,String name){} //正确的重载
//public static int say(){ return 1; } //编译错误,重载与返回值类型无关
//public static void say(String address) {} //编译错误,重载与参数名称无关
参数
形参:形式参数,定义方法的参数为形参
实参:实际参数,调用方法的参数为实参
总结
练习时用到过的方法:
Scanner scan = new Scanner(System.in);//用户输入值得扫描器
Random rand = new Random();//随机整数
Arrays.sort(arr);//数组降序排列
Arrays.toString;//查看数组内容
\t------------水平制表位,固定占8位