一、相关概念
JVM：java virtrule machine,java虚拟机，专门用于执行Java代码的一款软件
JRE：java runtime enviroment,java运行时环境，Java官方提供的核心类库，jre中包含了核心类库和jvm
JDK：java development kit,java开发工具包，javac.exe,java.exe...jdk中包含了开发工具和jre
二、HelloWorid程序
Java程序的开发步骤：
1.编写.Java源代码文件
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld~");
}
}2.借助于javac.exe,编译。java源代码文件，生成.class字节码文件
javac Xxx.java
3.借助于java.exe，运行java程序
java Xxx
三、IDEA常用快捷键
//演示快捷键的使用
public class Demo01 {
//psvm+回车: 快速生成主方法
public static void main(String[] args) {
//sout+回车: 快速生成输出语句
System.out.println();
//ctrl+d: 快速复制当前行
//ctrl+x: 剪切当前行
//ctrl+z: 撤销
//ctrl+shift+z: 前进
//ctrl+shift+↑: 代码向上移动一行
//ctrl+shift+↓: 代码向下移动一行
//ctrl+alt+←: 回到光标上一次所在的位置
//ctrl+alt+→: 光标移动到下一次的位置
//alt+enter+根据提示回车: 解决错误
//ctrl+alt+L: 快速的格式化代码
System.out.println();
}
}四、字面量
概念：生活中的数据在程序中的书写方式
分类
整数: 88
小数: 88.88
字符: 'w'
字符串: "老鼠爱大米"
布尔: true|false
空: null
五、数据类型
数据类型的作用：程序把数据进行分类，为了更好的管理数据，并使用内存
分类：
基本类型：
整型：byte（1字节）short（2字节）int（4字节）long（8字节）
浮点型：float（4字节）double（8字节）
布尔型：boolean（1字节）
字符型：char（2字节）
注意：float表示的数据范围要大于long表示的数据范围
引用类型：
类（String），接口，数组，枚举，注解...
六、变量
6.1变量的基本使用
变量声明的格式：数据类型 变量名；
变量的赋值：
数据类型 变量名 = 值；
数据类型 变量名；
变量名 = 值；
//变量的基本使用
public class Demo03 {
public static void main(String[] args) {
/*
变量声明的格式:
数据类型 变量名;
变量的赋值:
数据类型 变量名 = 值;
数据类型 变量名;
变量名 = 值;
*/
//声明一个变量,记录某个人的年龄
byte age = 10;
System.out.println(age);
//声明一个变量,记录某个电脑的价格
double price;
price = 9999.8;
System.out.println(price);
//演示变量的声明
byte v1 = 1;
short v2 = 2;
//int v3 = 3;
//在java代码中,写一个字面量整数,默认是int类型,而int类型表示的范围最大为20个亿, 如果要把一个整数变成long类型,可以在整数后面加l或L
//int v3 = 12345678901; 报错
long v3 = 12345678901L;
long v4 = 4;
//注意: idea中写代码,如果报错,把光标浮动到报错的地方,看提示
//在java代码中,写一个字面量小数,默认是double类型,如果要变成flaot类型,在后面加f或F
float v5 = 5.1F;
double v6 = 6.1;
char v7 = '中';
boolean v8 = false;
String name = "玫瑰";
}
}6.2变量的注意事项
1.Java的作用域
2.同一个作用域内，变量不能重名
3.变量在使用前，必须先赋值，再使用
//变量的注意事项
public class Demo04 {
public static void main(String[] args) {
/*
0. java中的作用域
一对{}称为一个作用域, 而且作用域可以嵌套
1. 同一个作用域内,变量不能重名
2. 变量在使用前,必须先赋值,再使用
*/
{
int a = 10;//作用域范围: 从定义变量的这一行开始,到它所处的右大括号结束
//int a = 20; 新定义一个变量,起名为a,给a赋值20
//a = 20; 把20赋值给已经存在的变量a
}
int a = 20;//允许
//变量在使用前,必须先复制
int b;
b = 20;
System.out.println(b);
}
}6.3、数据类型转换
前提：数据类型 变量名 = 值；左右两边的数据类型保持一致，才能赋值成功
时机：当左右两边类型不一致的时候，需要数据类型转换
分类:
变量的范围:
byte < short(char) < int < long < float < duble
自动类型转换:
适用范围: 把小范围的数据或变量(自动)赋值给大范围的变量
//数据类型转换
public class Demo05 {
public static void main(String[] args) {
//自动类型转换: 小--->大
//1.先把整型22提升为double类型,22.0 2.再把值复制给左边
double price = 22;
System.out.println(price);
byte b = 10;
int a = b;
}
}强制类型转换:
适用范围: 把大范围的数据或变量赋值给小范围的变量
//数据类型转换
public class Demo05 {
public static void main(String[] args) {
//自动类型转换: 小--->大
//1.先把整型22提升为double类型,22.0 2.再把值复制给左边
double price = 22;
System.out.println(price);
byte b = 10;
int a = b;
//强制类型转换: 大--->小
//格式: 目标数据类型 变量名 = (目标数据类型)值;
int money = 10;
byte money2 = (byte)money;
System.out.println(money2);
//强制类型转换,可能发生数据溢出 不推荐使用
int v1 = 300;
byte v2 = (byte)v1;
System.out.println(v2);
//小数强转为整数,直接去掉小数点后面的数据, 精度损失
double v3 = 22.6;
int v4 = (int)v3;
System.out.println(v4);
}
}运算时候的类型转换:
如果一个表达式中,包含了不同类型的数据,那么需要把小范围的数据全部转换为该表达式中最范围最大的数据的类型,最后运算,运算完的数据的类型是该表达式中最大范围的类型
byte|short|char,只要参与运算,都会先提升为int,然后再计算
//计算时的类型转换
public class Demo06 {
public static void main(String[] args) {
//如果一个表达式中,包含了不同类型的数据,那么需要把小范围的数据全部转换为该表达式中最范围最大的数据的类型,最后运算,运算完的数据的类型是该表达式中最大范围的类型
double v1 = 1.5;
float v2 = 2.0F;
long v3 = 10;
int v4 = 20;
double result = v1+v2+v3+v4;
//byte|short|char,只要参与运算,都会先提升为int,然后再计算
byte b1 = 10;
short s1 = 20;
int result2 = b1+s1;
char ch = 'a';//字符a----97
int result3 = ch+1;
System.out.println(result3);
}
}六. 标识符
概念: 在java中,给类/变量/方法起名字使用的符号
组成:
0~9;
英文单词字母大小写(a~z,A~Z);
_;
$;
规则(必须遵守):
1.不能以数字开头
2.不能是关键字(被java征用的单词)
3.严格区分大小写
规范(不遵守,也不报错):
小驼峰:
使用场景: 给变量和方法起名字使用
约束: 如果该名字由多个单词组成,那么第一个单词首字母小写,后面的单词首字母大写
大驼峰:
使用场景: 给类起名字使用
约束: 如果该名字由多个单词组成,那么所有单词首字母大写
七. 运算符
7.1 算数运算符
分类:
+,-,*,/,%
//算数运算符
public class Demo07 {
public static void main(String[] args) {
int a = 3;
int b = 2;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);//整数除以整数,只能得到整数的商,如果要得到小数的商,必须有浮点型数据参与运算
System.out.println(3.0 / 2);
System.out.println(a % b);
//如果+的左右两边,出现了字符串,那么做的不是加法,而是字符串的拼接,拼接的结果依然是一个字符串
String result = "abc" + 1;
System.out.println(result);
System.out.println("0" + 1 + 0);
System.out.println(1 + 1 + "1" + 1);
}
}7.2 自增自减运算符
概念: 如果两个+或-连续写,那么就是自增或自减运算符
使用格式:
单独使用: 给当前的变量自增1或者自减1
变量名++;
++变量名;
结合其他操作使用:
sout(变量名++)
先用后加
sout(++变量名)
先加后用
//自增自减运算符
public class Demo08 {
public static void main(String[] args) {
//单独使用
int a = 10;
a++;//当前变量自增1 a = 11
System.out.println(a);
++a;//当前变量自增1 a = 12
System.out.println(a);
//结合其它操作使用
int b = 10;
System.out.println(b++);//变量在前: 先用后加 1.先把b当前的值10输出, 2.对b的值自增 b = 11
System.out.println(b);
System.out.println(++b);//变量在后: 先加后用 2.先对b的值自增 b=12, 2.再输出b的值
int x = 10;
int y = x++; //y = 10 x = 11
int z = ++x; // x = 12 z = 12
System.out.println(y);
System.out.println(z);
}
}
7.3 赋值运算符
分类:
基本赋值运算符: =
扩展赋值运算符: += -= *= /= %=
隐含了一个强制类型转换
//赋值运算符
public class Demo09 {
public static void main(String[] args) {
//扩展赋值运算符 +=
int x = 10;
x += 20;// 等同于 x = (int)(x+20)
System.out.println(x);
byte a = 10;
//a = a+20; 报错
//a = (byte)(a+20);
a+=20;// 等同于 a = (byte)(a+20);
System.out.println(a);
}
}7.4 关系运算符
分类:
> >= < <= == !=
注意: 关系运算符连接的表达式的结果都是boolean类型的
//关系运算符
public class Demo10 {
public static void main(String[] args) {
int a = 10;
int b = 11;
System.out.println(a > b);//false
System.out.println(a >= b);//false
System.out.println(a < b);//true
System.out.println(a <= b);//true
System.out.println(a == b);//false
System.out.println(a != b);//true
boolean result = a != b;
}
}7.5 逻辑运算符
分类：
&& || !
注意： 逻辑运算符连接的表达式的结果也是boolean类型的
//逻辑运算符
public class Demo11 {
public static void main(String[] args) {
//&&： 同true则true，一false则false
//||: 同false则false，一true则true
//!: 取反
int x = 10;
int y = 20;
System.out.println(x > y && x > 5); //false
System.out.println(x > y || x > 5); //true
System.out.println(!(x > y));//true
boolean flag = x > y && x > 5;
}
}7.6 三元运算符
格式：
条件表达式? 表达式1：表达式2
计算规则：
1.计算条件表达式的结果，要么是true，要么是false
2.如果条件表达式的结果为true,那么整个三元表达式的结果取表达式1的结果,否则取表达式2的结果
//演示三元运算符
public class Demo12 {
public static void main(String[] args) {
/*
格式：
条件表达式? 表达式1：表达式2
计算规则：
1.计算条件表达式的结果，要么是true，要么是false
2.如果条件表达式的结果为true,那么整个三元表达式的结果取表达式1的结果,否则取表达式2的结果
*/
int x = 10;
int y = 20;
int result = x > y ? x + 1 : x + 2;
System.out.println(result);
}
}八. 扫描器Scanner的使用
Scanner: jdk提供的一个类, 用于扫描控制台键盘录入的符号
使用步骤:
1.在类上,导入Scanner的包
2.创建Scanner扫描器对象
3.调用Scanner对象的nextXxx方法,获取键盘录入的内容
//导包 import xxx.xxx.xxx.Xxx;
import java.util.Scanner;
//Scanner的使用
public class Demo13 {
public static void main(String[] args) {
//创建Scanner对象
Scanner sc = new Scanner(System.in);
//调用Scanner的方法,从控制台获取用户输入的字符
/*
next():获取字符串
nextInt(): 获取整数
nextDouble(): 获取小数
*/
System.out.println("请输入您的女神: ");
String name = sc.next();//sc.next这样的方法,会等待用户的输入,程序在这卡死了
System.out.println("您刚才输入的name="+name);
System.out.println("请输入您的年龄: ");
int age = sc.nextInt();
System.out.println("您刚才输入的age="+age);
}
}九. 流程控制语句
概念: 控制代码的执行顺序的语句
默认代码的执行顺序: 从上往下,一行一行的执行
流程分类:
顺序;
分支;
循环;
9.1 if语句
第一种情况:
if(条件){
语句;
}
第二种情况:
if(条件){
语句1;
}else{
语句2;
}
第三种情况:
if(条件1){
语句1;
}else if(条件2){
语句2;
}
....
else{
语句n;
}
package com.itheima;
//演示if语句的使用
public class Demo15 {
public static void main(String[] args) {
//需求一: 如果今天是星期天,那么我去找我媳妇...
int week = 6;
if (week == 7) {
System.out.println("我找我媳妇一块去看望我小妾...");
}
System.out.println("需求一结束...");
//需求二: 如果今天是星期天,我去找我媳妇,否则我去找我小妾
if (week==7){
System.out.println("看我的正房...");
}else{
System.out.println("看我的偏房...");
}
System.out.println("需求二结束....");
//需求三: 如果是星期1,我去找我大媳妇,如果是星期2,我去找我二媳妇,如果是星期3,我去找我三媳妇,否则我去找我四媳妇
if (week==1){
System.out.println("找我大媳妇...");
}else if (week==2){
System.out.println("找我二媳妇...");
}else if (week==3){
System.out.println("找我三媳妇...");
}else{
System.out.println("找我四媳妇...");
}
System.out.println("需求三结束...");
}
}
9.2 switch语句
格式:
switch(变量|表达式){
case 值1:
语句1;
break;
case 值2:
语句2;
break;
....
default:
语句n+1;
break;
}
执行流程:
计算变量或者表达式的值, 拿着得到的值和case后面的值进行匹配,匹配到谁,执行那个case后面的语句, 执行break代表结束switch,如果所有case后面的值都没有匹配成功,执行default后面的语句
public class Demo16 {
public static void main(String[] args) {
/*
switch(变量|表达式){
case 值1:
语句1;
break;
case 值2:
语句2;
break;
....
default:
语句n+1;
break;
}
*/
//需求: 定义一个变量,代表星期数, 如果是星期一|星期二|星期三,我去学习, 如果是星期四|星期五|星期六,我去打牌, 如果是星期天,我去慢摇吧
int week = 8;
switch (week) {
case 1:
System.out.println("我去学习");
break;
case 2:
System.out.println("我去学习");
break;
case 3:
System.out.println("我去学习");
break;
case 4:
System.out.println("我去打牌");
break;
case 5:
System.out.println("我去打牌");
break;
case 6:
System.out.println("我去打牌");
break;
case 7:
System.out.println("我去慢摇吧");
break;
default:
System.out.println("您是火星来的吧...");
break;
}
}
}case穿透:
如果case后面忘记写break,会发生case穿透. 当值匹配成功后,如果没有遇到break, 会直接执行后面case的语句, 直到遇到break或者}结束
//case穿透
public class Demo17 {
public static void main(String[] args) {
//需求: 定义一个变量,代表星期数, 如果是星期一|星期二|星期三,我去学习, 如果是星期四|星期五|星期六,我去打牌, 如果是星期天,我去慢摇吧
int week = 5;
switch (week) {
case 1:
case 2:
case 3:
System.out.println("我去学习");
break;
case 4:
case 5:
case 6:
System.out.println("我去打牌");
break;
case 7:
System.out.println("我去慢摇吧");
break;
default:
System.out.println("您是火星来的吧...");
break;
}
}
}9.3 循环语句(for,while,do-while)
9.3.1for
格式:
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
执行流程:
1.执行初始化语句;
2.执行条件判断语句;
3.如果条件判断语句结果为true,那么执行循环体语句
4.执行条件控制语句
5.继续回到第2步,以此往复
直到条件判断语句的结果为false,那么循环结束
//for循环
public class Demo18 {
public static void main(String[] args) {
//需求: 在控制台输出3次HelloWorld
for (int i = 1; i <= 3; i++) {
System.out.println("HelloWorld");
}
}
}使用场景:
1.让重复的代码执行多次
2.可以批量产生连续的数据
//for循环
public class Demo18 {
public static void main(String[] args) {
//需求: 在控制台输出3次HelloWorld
for (int i = 1; i <= 3; i++) {
System.out.println("HelloWorld");
}
for (int i = 1; i <= 33; i++) {
System.out.println(i);
}
//快速生成for循环的代码 数字.fori+回车
for (int i = 0; i < 44; i++) {
}
}
}9.3.2while:
格式:
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
执行流程:
1.执行初始化语句;
2.执行条件判断语句;
3.如果条件判断语句结果为true,那么执行循环体语句
4.执行条件控制语句
5.继续回到第2步,以此往复
//while循环
public class Demo19 {
public static void main(String[] args) {
//需求: 在控制台输出3次我爱中华人民共和国
int i = 0;
while (i <= 2) {
System.out.println("我爱中华人民共和国");
i++;
}
}
}while循环和for循环的使用场景:
如果循环次数确定,一般使用for循环
如果循环次数不确定,一般使用while循环
9.3.3跳转关键字:
break:
结束整个循环
continue:
结束当次循环,继续下一次循环
//跳转关键字
public class Demo20 {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
if (i == 1) {
break;//立刻马上,结束整个循环
}
System.out.println("我是你大爷");
}
System.out.println("===================");
for (int i = 0; i < 3; i++) {
if (i == 1) {
continue;//结束当次循环(本次循环体后面的内容将不再执行),继续下一次循环(执行条件控制语句)
}
System.out.println("我是你大娘");
}
}
}循环标号:
前提: break 或者continue 作用于离它最近的循环
使用: 在循环的前面 名字:, 在使用跳转关键字的时候 跳转关键字后面加上循环的名字即可
//循环标号
public class Demo21 {
public static void main(String[] args) {
/*
循环嵌套:
外层循环执行一次,内存循环执行一轮
i=0, 0<3
System.out.println("我是中国人......");
j=0, 0<3 System.out.println("我是陕西人...");
j=1, 1<3 ,内层循环结束
i=1, 1<3
System.out.println("我是中国人......");
j=0, 0<3 System.out.println("我是陕西人...");
j=1, 1<3 ,内层循环结束
i=2, 2<3
System.out.println("我是中国人......");
j=0, 0<3 System.out.println("我是陕西人...");
j=1, 1<3 ,内层循环结束
i=3, 3<3 外层循环结束
*/
sb: for (int i = 0; i < 3; i++) {
System.out.println("我是中国人......");
sb2: for (int j = 0; j < 3; j++) {
if (j==1){
break sb;//结束内层循环
}
System.out.println("我是陕西人...");
}
}
}
}十. 数组
概念: 用于存储同类型的多个元素的【容器】
声明格式： 数据类型[] 数组名;
10.1初始化
静态初始化：
数据类型[] 数组名 = new 数据类型[]{元素一,元素二,元素三....}
简化格式: 数据类型[] 数组名 = {元素一,元素二,元素三....}
动态初始化：
数据类型[] 数组名 = new 数据类型[数组长度];
//数组的声明和初始化
public class Demo22 {
public static void main(String[] args) {
//声明数组 数据类型[] 数组名
//需求: 声明数组,用于存储多个学生的考试成绩
double[] scores;
//静态初始化: new 数据类型[]{元素一,元素二,元素三....}
scores = new double[]{11.1, 22.2, 33.3};
//简化格式: {元素一,元素二,元素三....}
double[] scores2 = {44.44, 55.66, 66.66};
//动态初始化: new 数据类型[长度]
scores = new double[5];
}
}10.2java的内存模型
在jvm运行java程序时,为了更好的管理内存, 对内存做了分区
分区:
栈: 运行方法使用, 记录方法运行时需要的一些数据
堆: 用于存储所有new 申请的内存
方法区: 存储.class文件的内容
寄存器: 记录程序执行的当前行号
本地方法栈: 执行native方法时使用
10.2数组的访问
格式:
数组名[索引];
索引:
数组元素的编号, 从0开始,每次步进1,最大到数组的长度-1
10.3静态初始化和动态初始化的区别
静态初始化:
数组初始化完毕, 每个索引处存储的是初始化时指定的值
动态初始化:
数组初始化完毕,每个索引处存储的是指定类型的默认值
注意:
在堆内存中,所有的数据都有默认值
整型: 0
浮点型:0.0
布尔型: false
字符型: 空字符
引用类型: null
//静态初始化和动态初始化的区别
public class Demo25 {
public static void main(String[] args) {
double[] scores = new double[3];
System.out.println(scores[0]);
System.out.println(scores[1]);
System.out.println(scores[2]);
boolean[] fs = new boolean[3];
System.out.println(fs[0]);
System.out.println(fs[1]);
System.out.println(fs[2]);
String[] names = new String[3];
System.out.println(names[0]);
System.out.println(names[1]);
System.out.println(names[2]);
}
}
数组的长度:
数组名.length
不同的使用场景:
如果初始化数组时,元素已知,那么建议使用静态初始化
如果初始化数组时,元素未知,那么建议使用动态初始化
10.4多个引用类型变量指向同一块内存
不管通过那个引用类型变量去修改堆中的数据,另外一个引用类型变量看到的堆中的数据是修改后的数据
10.5数组的遍历
把数组中的元素一个一个的取出来
//数组遍历
public class Demo27 {
public static void main(String[] args) {
int[] ages = {22, 33, 44, 55, 66, 77,88};
for (int i = 0; i < ages.length; i++) {
System.out.println(ages[i]);
}
//数组名.fori+回车
for (int i = 0; i < ages.length; i++) {
}
/* System.out.println(ages[0]);
System.out.println(ages[1]);
System.out.println(ages[2]);
System.out.println(ages[3]);
System.out.println(ages[4]);*/
}
}十一. 案例
/*
1.键盘录入五个学生的成绩
2.把这些成绩存储到数组中
3.求最大的成绩输出到控制台
*/
public class Test01 {
/*
1.键盘录入五个学生的成绩
2.把这些成绩存储到数组中
3.求最大的成绩输出到控制台
*/
public static void main(String[] args) {
//1.定义数组，存储5个学生的成绩
double[] scores = new double[5];
//2.创建Scanner对象
Scanner sc = new Scanner(System.in);
//3.利用循环,录入5个数据,并存储到数组中
for (int i = 0; i < scores.length; i++) {
System.out.println("请录入第" + (i + 1) + "个学生的成绩: ");
scores[i] = sc.nextDouble();
}
//4.求数组元素的最大值
//4.1 定义一个变量,记录最大值,给一个默认值,默认数组的0所引处的元素为最大值
double max = scores[0];
//4.2 遍历数组,得到其他的元素,和当前认为的最大值比较,如果其他的元素大,修正最大值
for (int i = 1; i < scores.length; i++) {
if (scores[i] > max){
max = scores[i];
}
}
System.out.println("最高的成绩为: "+max);
}
}
扫一扫
1460
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
