- Java语言基础
- 基础
- 编程语言
- 机器语言:0,1
- 汇编语言:也称为符号语言
- 高级语言
- 面向过程的高级语言:程序设计的基本单位是函数—— c ,c++
- 面向对象的高级语言:程序设计的基本单位为类----Java,c#
- Java语言的特点:
- 一次编译,到处运行 ,跨平台 ,不同的操作系统对应不同的JVM
- 平台性无关
- 面向对象
- 多线程
- 自动内存管理:对临时数据进行回收
- 编程语言
- 基础
注:Java官方提供了针对不同平台的JVM软件,这些JVM遵循着相同的标准，只要是标准的.class文件,就可以在不
同的JVM上运行,而且运行的效果相同,这样,就实现了所谓“-次编程到处使用”
- Java编译运行过程
- 编译期: (.Java)源文件编译生成(.class)字节码文件 (byte code 字节码)
- 运行期:JVM加载(.class)文件并运行(.class)文件JDK: Java开发工具包 包含JRE和编译运行等命令工具名词解释:
名词解释
- JDK: Java开发工具包 包含JRE和编译运行等命令工具 ,开发Java程序的最小环境
- JRE:Java运行环境 包含JVM和Java系统类库小零件,运行Java程序的最小环境
- JVM:加载(.class)文件并运行(.class)文件
- Eclipse:IBM公司开发 ,开源,免费,集成开发环境
- 注释:
- //单行注释
- /*回车/ 多行注释
- /**回车/ 文本注释
- 变量
- 什么是变量:变量就是指代在内存中开辟的存储空间,用于存放运算过程中需要到数据
- 声明: 数据类型 变量名 ; int a ;
- 初始化: 数据类型 变量名 = 初始值 ; 第一次赋值
- 访问/使用
- 是对存储数据的使用
- 使用前必须声明并初始化赋值
- 必须符合其数据类型
- 命名
- 用字母,$,_,数字命名 但不能用数字开头,更不能包含特殊符号
- 严格区分大小写 ,所有符号必须是英文模式
- 不能使用关键字
- 不建议中文命名 建议英文见名知意 驼峰命名法
- 8种基本数据类型
- byte: 1字节. 取值 -128~127
- short: 2字节 -32768~32767
- int 整型 4字节 -2147483648~2147483647
- 整数直接量默认 int 类型 赋值超范围 会编译错误
- 两个整数相除还是整数, 小数位无条件舍去 不会四舍五入
- 整数运算时若超出范围会发生溢出， 溢出不会报错 但是需要避免
- long 长整型 8字节
- 长整型直接量需要在数字后加 L
- 整数运算结果会发生溢出时 建议在第一个数字后加大写L
- long times = System.currentTimeMillis(); 用于获取1970.01.01零时到此时此刻的毫秒数
- float 浮点型 4字节
- 表示float 要在数字后面加F或f
- double 浮点型 8字节
- 浮点型直接默认量为double 类型
- double类型 可在数字后加D或d 或不加
- double 和float 类型 参与运算时 发生舍入误差 精度丢失
- boolean 布尔型 1字节 true/false
- 用来 判断关系 只有true 或false 两中结果
- char 字符型 2字节 0~65535
- char 类型本身是采用 统一码字符 0-65535数位 ,'a'=97 'A'=65 '0'=48
- 必须放在单引号中 只能有一个 可以空格符 不能空字符 '\''转译
- 本质上也是int 数字类型
System.out.println(2+2);//4
System.out.println(2+'2');//52 2加上'2'的码
System.out.println('2'+'2');//100 '2'的码50，加上'2'的码50
int b = '2';
System.out.println(b);//50- 基本类型间的转换
- 两种方式
- 1.自动转换 小类型到大类型 :从小到大 byte - short - int - long -float - double -char-
- 2.强制类型转换语法：数据类型 变量名 =（要转换的类型）变量名
- int a =5;long b =a;//自转// 强转（要转换的类型）变量int c = (int)b;//强转
- 强转可能发生溢出
- 强转 可能会丢失精度
- 两点规则
- 整数可以直接赋值给 byte short char 只要不超出范围即可
- byte short char 在参与运算时 一律转化为int 在计算
- 两种方式
byte b1 = 5;//整数直接量可以直接赋值给byte ，short ， char
byte b2 = 6;
//byte b3 = b1 + b2;//编译错误，byte ，char，short 型数据参与运算，先一律转换为int 类型
byte b4 = (byte)(b1 + b2);
System.out.println(b4);- 运算符和表达式
1)算数运算符：
- % ：取余/取模
- ++ ,--/*自增1/自减
- 1* 1)单独使用时 在前在后都一样*
- 2)被使用时*
- 2.1) a++的值为a ———— (a--的值为a)*
- 2.2)++a的值为a+1 ———— (--a的值为 a-1)
int x =3;
x =x++;//被使用
System.out.println(x);//3
int y = 3;
y =++y;//被使用
System.out.println(y);//42)赋值运算符：
- 2.1)简单赋值运算符 ： =
- 2.2)扩展赋值运算符： += ,-= , *=, /= ,%= * （自带强转功能）
//常见面试题
short s = 5;
s +=10;// 相当于s = (short)(s+10)
//s = s+10;//编译错误 ，需要强转 s = (short)(s+10)- 3)关系运算符:
- 关系运算符的结果为 boolean 型关系成立为true 关系不成立为false
4)字符串连接符：
- 4.1)两边为数字做加法运算
- 4.2)若两边有字符串 则做字符串连接
5)逻辑运算符：
- 5.1)逻辑与 && 并且
- 5.2)逻辑或 || 或者
- 5.3)逻辑 非 ！
- 1) && 与 并且
- 1.1)两边都为真则为真 见false 则false
- 1.2)短路 ：当第一个数boolean值为false 则发生短路 后面的不执行
- 2) || 或 或者 2.1)有一边为真则为真 ，见true则true
- 2.2)短路： 第一个数为true时 ，则发生短路 后面的不执行
- 3) ！非 取反 ：非真则假 非假则真
/*
* 1)关于短路问题： && 和 || 是短语与和或 &和|是不短路与和或------一般不用
* &&和|| 一般我们都用短路的
* //相亲 条件不满足就短路
*/
int a = 5,b =10,c=5;
boolean m= a>b && c++>2;
System.out.println(m);//false
System.out.println(c);//5,发生短路了- 6)条件 /三目运算符
- 1)语法： boolean ？ 数1 : 数2
- 2)执行过程： 判断boolean 的值,为true 则表达式的结果为 数1, 为false 则表达式的结果为 数2
/*
* 2)闰年的 判断
* 闰年的判断公式
* 1)能被4整除 并且 不能被100整除 ：year%4==0&&year%100!=0
* 或者 ||
* 2)能被400整除 ：year%400==0
* //year%4==0&&year%100!=0||year%400==0
*/
int year = 2004;//年份
boolean flag = (year%4==0 && year%100!=0 || year%400==0);
//flag 为true 说明是闰年 为false说明是平年
String str = flag? year+"闰年" : year+"平年";
System.out.println(str);
Scanner scan = new Scanner(System.in);
System.out.println("请输入年份：");
int year1 = scan.nextInt();
if(year1%4==0 && year1%100!=0 || year1%400==0){
System.out.println(year1+"是闰年");
}
System.out.println(year1+"是平年");
- 两个数交换 追尾并绕圈
//交换 两个数：
int a = 8,b =5;//换成a=5，b=8
int t =a;//t=8
a=b;//a=5
b=t;//b=t=8
System.out.println(a);
System.out.println(b);
/*
* 交换两个数： 追尾并绕圈
* int t =a; a=b; b=t;
* int t = b ; b =a; a =t;
*/
- 逻辑例题
- 4、int a=45; int b=23; 不使用第三方变量交换两个变量的
int a=45;
int b=23;
a=a+b;//68
b=a-b;//45
a=a-b;//23
System.out.println(a+","+b);
- 作用域
- 1）变量的作用域 范围 从变量的声明开始，到包含他，前面最近的大括号结束
- 2)变量的重命名：作用域重叠式 ，变量不能重名
- 分支结构 :基于条件执行某语句一次,并非每句必走
- if
/*
* if ： 1条路
* 1) 语法：
* if(boolean){
* 语句块
* }
* 2)执行过程：
* 判断boolean 的值：
* 若为true：则执行语句块
* 若为false：则不执行语句块
*/- if...else
/*
* if...else 两条路
if(boolean){
* 语句块1
* }else{
* 语句块2
* }
* 2)执行过程：
* 判断boolean 的值：
* 若为true：则执行语句块1
* 若为false：则执行语句块 2
* 3)结论 ：块1和块2必走其中之一
*/- if...else if
/*
* if... else if 结构： 多条路
* 1)语法：
* if(boolean1){
* 语句块1
* }else if(boolean2){
* 语句块2
* }else if(boolean3){
* 语句块3
* }else{
* 语句块4
* }
* 2)执行过程：
* 判断boolean
* 判断boolean-1，若为true则执行语句块1（结束），若为false则
* 再判断boolean-2，若为true则执行语句块2（结束），若为false则
* 再判断boolean-3，若为true则执行语句块3（结束），若为false则执行语句块4（结束
* 3)结论 ：语句块：1/2/3/4，必走其中之一
*/小练习:判断成绩
package day04;
import java.util.Scanner;
//命令解析程序
public class CammandBySwitch {
public static void main(String[] args) {
Scanner scan =new Scanner(System.in);
System.out.println("请输入您的成绩：");
double score = scan.nextDouble();
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-不及格");
}
System.out.println("over");
}
}
}
- switch...case ：
- 优点： 效率高 、结构清晰
- 缺点： 只能判断整数或相等 //byte, short, char, int ,String (JDK1.7--开始支持String) 当缺点不再是缺点时，就是首选循环结构
- 可以用switch...case实现的循环结构也可以用if...else if实现 , 用 if else if 实现的不一定能用switch...case 实现
- JDK1.7的switch新特性，如果传进去的是String类型
编译之后，反编译得代码如下：
String str = "123";
switch(str)
{
case "123":
System.out.println(str);
break;
case "456":
System.out.println(str);
break;
default:
System.out.println(str);
}
我们可以看到，其实传进switch的是字符串的hashCode值，而case 后面的字符串常量在编译之后也变成了它的hashCode。而在case后面的模块代码中多了一段比较case后面的字符串常量与传进来的字符串是否相等的判断代码。
String str = "123";
String str1;
switch ((str1 = str).hashCode())
{
case 48690:
if (str1.equals("123")) {
break;
}
break;
case 51669:
if (!str1.equals("456"))
{
break label80;
System.out.println(str);
break label87;
}
else
{
System.out.println(str);
}
break;
}练习:判断月份天数:
package day04;
//判断月份天数
public class Exer {
public static void main(String[] args) {
//根据年份和月份来计算天数
int year =2020;//年份
int month = 4;//月份
int days = 0;//天数
switch(month){
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
days=31;
break;
case 4:
case 6:
case 9:
case 11:
days = 30;
break;
case 2:
if(year%4==0&&year%100!=0||year%400==0){
days=29;
}else{
days=29;
}
break;
}
System.out.println("days="+days);
}
}- 循环结构 :有条件的执行某语句多次 并非每句必走
- 什么是循环
- 循环： 反复多次的执行一段相同或相似的代码
- 循环变量：在整个循环中一直改变的那个数
- 循环三要素 缺一不可 :->要素1：循环变量的初始化,-> 要素2：循环的条件（以循环变量的基础） -> 要素3：循环变量的改变：（向着循环的结束变）
- 什么是循环
while
/ *
* while结构：
* 1)语法：
* while(boolean){
* 语句块---------反复执行代码
* }
* 2)执行过程：
* 判断boolean的值，若为true则执行语句块，
* 再判断boolean的值，若为true则执行语句块；
* 再判断boolean的值，若为true则执行语句块；
* 如此反复，直到boolean的值为false则while循环结束
*/- 先判断 后执行可能一次不执行
do...while
/*
* do...while结构：
* 1)语法：
* do{
* 语句块
* }while(boolean);
*
* 2)执行过程：
*先执行语句块，再判断boolean的值，若为true则
*再执行语句块，再判断boolean的值，若为true则；
*再执行语句块，再判断boolean的值，若为true则再执行语句块；
*如此反复，直到boolean的值为false则do...while循环结束
*/- /1) 先写 do...while语法 //2) 再写 三要素
- 先执行 后判断
for
/*
* for 结构：
* 1)
* //
* for(要素1；要素2；要素3）{
* 语句块/循环体------------反复执行代码 4
* }
* 2)执行过程：12342342342342 必然以2结束 false 循环结束
*/
- 应用率最高
- for循环的其他写法
/*
* for 结构的特殊性写法-------了解
*/
/*
for(int i=0,j=5;i<5;i+=2,j-=2){
}
/*
*i=0, j=5
*i=2 ,j=3
*i=4, j=1
*i=6, j=-1
*/
/*
for(;;){//死循环 没有条件的循环
System.out.println("行动是成功的阶梯");
}
*/
/*
for(int times=0;times<10;){
System.out.println("行动是成功的阶梯");
times++;
}
*/小案例:100以内累加和
//小案例
//累加和：1+2+34+....+99+100
int sum =0;//存和
for(int i =0;i<=100;i++){
sum =sum+i;//在本身基础之上累加
}
System.out.println("sum="+sum);
案例 :for循环随机出运算题
package day06;
import java.util.Scanner;
//随机 加法题
public class Addition {
public static void main(String[] args) {
Scanner scan =new Scanner(System.in);
int score=0;//得分 (1)35+98=
for(int i=1;i<=10;i++){//10次
//1. 出题 2.答题 3.判断
/*
* Math.random();----0.0———0.99999999999.....
* Math.random()*1000+1;----0.0———999.99999999.....
* Math.random()*100+1;----0.0———99.999999999.....
*/
int a =(int)(Math.random()*100+1);//加数a(0-99之间随机数
int b =(int)(Math.random()*100+1);//加数b(0-99之间随机数
int result =a+b;//存正确结果
System.out.println("("+i+")"+a+"+"+b+"=?");//1.出题
System.out.println("算吧！");
int answer=scan.nextInt();//2)答题
if(answer == result){//判题
System.out.println("答对了");
score+=10;//score = score+10 答对一题加十分
}else{
System.out.println("答错了");
}
}
System.out.println("得分为："+score);
}
}
嵌套循环
- 嵌套循环:
- 1.循环中套循环 一般用于多行多了列 外层控制行 内层控制列
- 2.执行规则 外层走一次 内层走所有次
- 3.建议 嵌套循环层数越少越好 若需要三层以上才能解决 设计有问题
- 4. break 只能跳出一层嵌套
案例://99乘法表
package day06;
//九九乘法表
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 true i*2=2
* i=2 true i*2=4
* i=3 false
* 换行
* num 1；
* i=1 true 1*1=1;
* i=2 false
* 换行
*
*/
}
}
}
break continue的区别
- break->break 跳出for 循环
int m=0;
for(int i=0;i<=100;i++){
if(i%10==3){
/*m=0;
* i=1 m=0+1
* i=2 m=0+1+2=3
* i=3 %10=3 true break 跳出循环
*
*/
break;//break 当取模余三 跳出循环 不再循环
}
m=m+i;
}
System.out.println("sum="+m);//3- continue
- continue 跳出for循环剩下语句 开始下一次for循环
int num=0;
for(int i =1;i<=100;i++){
if(i%10==3){
continue;//跳过循环体中剩余语句 而直接进入下一次循环
//应用率不高
}
num =num+i;
}
System.out.println("num="+num);//4570循环结构的选择标准:
- 与次数有关直接选择for
- 无关看 要素1, 要素3是否相同 相同选do while 不同选while
数组
- 什么是数组: 相同元素类型的集合 是引用类型
- 数组的定义 :数据类型 [] 数组变量 = new 数据类型[leagth/长度];
- 数组的初始化
- int long byte short char 默认值为0
- double float 默认值为0.0
- boolean 默认值为false
package day06;
//数组的演示
public class ArrayDemo {
public static void main(String[] args) {
//数组也是一种数据类型 引用类型
//是相同数据类型元素的集合
//1.数组的定义
// 数据类型 [] 数组变量 = new 数据类型[leagth/长度];
/* int [] arr= new int[leangth/长度]; int类型数组 byte ,short ,char
//int, long默认值为0
* double [] arr= new double[length/长度]; double , float默认值为0.0
* boolean [] arr= new double[length/长度]; boolean 默认值为false
*/
int [] arr1 = new int[10];
//2.数组的初始化
int [] arr2 = new int[3];//0,0,0-声明整型数组 ，包含三个元素 每个元素是int 类型 占
//12个字节
int [] arr3 ={1,4,7};//1,4,7
int [] arr4 = new int[]{1,4,7};//1,4,7
int [] arr5;
//arr = {1,4,7}//编译错误，此方式只能声明同时初始化
arr5 = new int[]{1,4,7};
//3.数组的访问
//数组的使用： 使用的是数组中的元素
/*1.通过(数组名.length)可以获取数组的长度。数组的长度也就数元素的个数
*2.通过下标/索引来访问数组中的元素
* 下标从 0 开始，最大到(数组的长度 减1)
*/
int [] arr =new int[3];
System.out.println(arr.length);
arr[0] = 100;//给arr中第一个元素赋值给100
arr[1] = 200;//给arr中第二个元素赋值给200
arr[2] = 300;//给arr中第三个元素赋值给300
//arr[3] = 400;//运行时 会发生数组下标越界异常
System.out.println(arr[arr.length-1]);//输出arr中最后一个元素
//4.数组的遍历: 将所有的数组元素/数据全部走一遍
//只要用到数组长度就用 数组变量.length36
int [] num = new int[10];
for(int i=0;i<num.length;i++){//遍历 num 数组 固定模式
num [i] =100;//给num 中的每一个元素都赋值为100
System.out.println(num[i]);
}
}
}
- 数组访问/使用
- 使用 访问 对数组元素的使用 可用数组名 array.length (length长度)来获取数组长度也就是元素个数
- 可以通过下标/索引来访问数组元素 下标 ,开始为0,最大到数组长度-1,就是 length-1
- 数组遍历 : 将所有的数组元素/数据全部走一遍 for循环//只要用到数组长度就用 数组变量.length
找最大值
package day06;
//数组元素的最大值
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+1);//给每个元素赋值为0-100之间的随机数
System.out.println(arr[i]);//输出每个元素的值
}
int max =arr[0];//假设第一个元素为最大值
for(int i=1;i<arr.length;i++){//遍历剩余元素
if(arr[i]>max){
max = arr[i];//则修改max 的值为最大的
}
}
System.out.println("max="+max);
}
}- 数组的复制
- 1.System.arraycopy(a, 1, b, 3, 2); 更灵活
- 2.1)int[] b=Arrays.copyOf(a, 6);//从头到头复制 需要导入包import java.util.Arrays;
- 2.2) 第二功能 数组扩容 Arrays.copyOf(arr, arr.length+1); length-1缩容
小案例:数组元素的最大值 并放在数组的最后一个元素的 下一个位置
package day07;
import java.util.Arrays;
//数组元素的最大值 并放在数组的最后一个元素的 下一个位置
public class MaxOfArray {//最大 数组 扩容
public static void main(String[] args) {
int []arr=new int[10];
for(int i =1;i<arr.length;i++){//编译数组
arr[i]=(int)(Math.random()*100+1);//给每个元素赋值为0-100之间的随机数
System.out.println(arr[i]);//输出每个元素的值
}
int max =arr[0];//假设第一个元素为最大值
for(int i=1;i<arr.length;i++){//遍历剩余元素
if(arr[i]>max){
max = arr[i];//则修改max 的值为最大的
}
}
System.out.println("max="+max);
//数组扩容 import java.util.Arrays
arr =Arrays.copyOf(arr, arr.length+1);//数组扩容
arr[arr.length-1]=max;//奖最大值max复制到最后一个元素上
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
- 数组的排序 升序
- 数组的排序 升序 Arrays.sort(arr);
//8)数组的排序：
int [] arr= {2,34,42,54,667,76,8676,66};
Arrays.sort(arr);//升序排列
/*
for(int i =0;i<arr.length;i++){
System.out.println(arr[i]);
}
*/
for(int i=arr.length-1;i>=0;i--){//倒着输入 降序
System.out.println(arr[i]);
}- 方法
- 方法(函数,过程)
- 各种语言都有方法的概念,有的语言称其为函数或过程
- 1.1)封装一段特定的业务逻辑功能
- 1.2)方法尽可能独立,一个方法只做一件事
- 1.3)方法可以反复调用
- 1.4)方法可以提高代码利用率,防止代码冗余,有利于提高团队合作
- 方法的定义
- 5要素
- 方法(函数,过程)
1修饰词 2返回值类型 3方法名( 4参数列表){
5 方法体 }
- 1.修饰词 public static
- 2.1)返回值类型
- 有返回值-------返回值写成特定数据类型即可
- 无返回值----返回值写成void
- 2.2)何时有返回值 ?何时无返回值
- 法执行完以后 1-> 若需要用到方法中的某一数据----有返回值 * 2-> 若不需要用到方法中的数据----------无返回值
- 4:参数列表:方法名( 参数列表){ },方法可以有参, 也可以无参 ,有参更灵活 *
- 方法名( 有参传参){ }
- 方法的调用
- return 上的使用;
- 有返回值 必有 return; return 值;// 1.1)结束方法执行 1.2)返回结果给调用方 *
- 无返回值类型中 : return;//意为结束方法运行
- 方法的调用:
- 无返回值----方法名(有参传参)
- 有返回值 -----先声明 数据类型 变量= 方法名(有参传参)
package day07;
//方法的演示
public class MethodDemo {
public static void main(String[] args){
int c=2,d=5;
int e=plus(c,d);//----实参(实际参数) 此处传的是c和d里面的那个数
System.out.println(e);
int b =plus(5,6);//------实参(实际参数)
System.out.println(b);
double a= getNum();//getNum()的值就是return红藕的那个值
System.out.println(a);//2.22
sayHello1("张三",25);
sayHello1("lisi",52);*/
//方法的嵌套调用 (方法中调方法)
a();//111, 222, 333
System.out.println(444);//444 2431
}
public static void a(){
System.out.println(111);
b();
System.out.println(333);
}
public static void b(){
System.out.println(222);
}
//有参无返回值 return 的使用
public static void sayHello1(String name, int age){
if(age>=40){//在某种特定条件下，提前结束方法
return;//结束方法的执行
}
System.out.println("大家好，我叫"+name+",今年"+age+"岁了。");
}
//有参有返回值
public static int plus(int num1,int num2){//----------形参(形式参数)
int num= num1+num2;
return num;//返回的是num里面的数 （1）应用率最高
//return num1 +num2;//返回num1+num2的和 （2）
}
//无参有返回值
public static double getNum(){
//return;//返回 编译错误 ，return后必须跟一个值
//return"abx";//返回 编译错误 ,return 后值的类型必须以返回值类型匹配
return 2.22;//1)结束方法的执行 2)返回一个结果给调用方
}
}
package day07;
//练习
public class Exer {
public static void main(String[] args) {
/*
* 需求：
* 1)封装一个方法 generateArray
* 2)生成指定长度的int 数组
* 3）数组中的元素为0到指定范围的随机数
* 4）并将数组返回 返回值
*/
int[] arr = generateArray(3,20);
for(int i=0;i<arr.length;i++){//想输出数组所有数据或每个元素就需要遍历数组
System.out.println(arr[i]);
}
}
//生成数组
// 返回值int类型 指定长度 指定参数
public static int[] generateArray(int len,int max){
//数据想写活就用参数
int []arr=new int[len];//生面生成len个长度数组元素
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*(max+1));
}
return arr;
}
}
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
