Java学习目录
一、运行首个案例
1.1 HelloWorld代码块
public class HelloWorld {
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
1.2 注意问题
1. 第三行后面是英文的分号。
2. " System "中的S必须大写。
3. println()
其实调用了print()
再调用newLine()
来实现换行。改成print()
没有换行功能。
二、注释
2.1 注释概述
1. 注释是在指定位置添加的说明性信息。
2. 注释不参与程序运行,仅起到说明性作用。
2.2 注释分类
1. 单行注释
- 格式:
//
注释信息
2. 多行注释
- 格式:
/*
注释信息*/
3. 文档注释(很少用到,不做讲解)
- 格式:
/**
注释信息*/
2.3 为首个案例添加注释
/*
Java中最基本的组成单位是类
类的基本格式:public class 类名 {
}
*/
public class HelloWorld {
//这是main方法,它是程序的入口方法,程序的执行是从这里开始的
public static void main(String[] args){
//这是输出语句
System.out.println("HelloWorld"); //System类是一些与系统有关的属性和方法的集合
}
}
三、关键字
3.1 关键字特点
1. 关键字的字母全部小写。
2. 常用的代码编辑器,针对关键字有特殊的颜色标记,非常直观。
3. 关键字和保留字均不能用作变量名、方法名、类名、包名和参数。
3.2 常用的关键字
Java中常用的关键字有五十多个,如:
- 具体的保留字:goto、const
- 访问修饰符:public、protected、private
- 类、接口、抽象类:class、interface、abstract——定义,extends——继承类,implements——实现接口,new——新建一个对象,super——调用父类方法,this——指代当前对象
四、常量
4.1 常量概述
常量:在程序运行过程中,其值不可以发生改变的量。
4.2 常量分类
常量类型 | 说明 | 举例 |
---|---|---|
字符串常量 | 用英文双引号括起来的内容 | " HelloWorld “,” Java学习 " |
整数常量 | 不带小数的数字 | 666,-88 |
小数常量 | 带小数的数字 | 13.14,-5.21 |
字符常量 | 用英文单引号括起来的内容 | ’ A ‘,’ 0 ‘,’ 我 ’ |
布尔常量 | 布尔值,表示真假 | 只有两个值:true,false |
空常量 | 一个特殊的值,空值 | 值是:null |
注意事项:空常量是不能直接输出的 !
五、数据类型
5.1 类型分类
Java语言是强类型语言,对于每一种数据都给出了明确的数据类型,不同的数据类型也分配了不同的内存空间,所以它们表示的数据大小是不一样的。
数据类型分为基本数据类型和引用数据类型:
- 基本数据类型:①数值型:整数(byte、int、short、long)、浮点数(float、double)、字符(char)。 ②非数值型:布尔(boolean)。
- 引用数据类型:类(class)、接口(interface)、数组([ ])。
5.2 数据类型内存占用
关键字 | 内存占用 |
---|---|
byte | 1B |
short | 2B |
int | 4B |
long | 8B |
float | 4B |
double | 8B |
char | 2B |
boolean | 1B |
注意事项:给一个整数,默认int
类型;给一个浮点数,默认double
类型。
六、变量
6.1 变量概述
变量:在程序运行过程中,其值可以发生改变的量。从本质上讲,变量是内存中的一小块区域。
6.2 变量定义
1. 变量组成:变量名、数据类型、变量值。
2. 格式:数据类型 变量名=变量值;
例如:int a=10;
6.3 变量的使用
1.取值:
- 取值格式:变量名
- 范例:
a
2. 修改值:
- 修改值格式:变量名=变量值;
- 范例:
a=20;
public class Demo {
public static void main(String[] args){
//定义变量
int a=10;
//输出变量
System.out.println(a);
//修改变量
a=20;
//输出变量
System.out.println(a);
}
}
6.4 变量使用的注意事项
1. 变量名不能重复。
2. 定义变量时一定要给个初始值,未赋值的变量不能直接使用。
3. 定义long类型的变量时,为了防止整数过大,后面要加L。
4. 定义float类型的变量时,为了防止类型不兼容,后面要加F。
public class Demo {
public static void main(String[] args){
//加L,因为默认是int
long a=10000000000L;
System.out.println(a);
//加F,因为默认是double
float b=13.14F;
System.out.println(b);
}
}
七、标识符
7.1 标识符概述
1. 标识符:就是给类、方法、变量等起名字的符号。
2. 标识符定义规则:
- 由数字、字母、下划线(_)和美元符($)组成。
- 不能以数字开头。 例如:
2b
- 不能是关键字。 例如:
class
- 区分大小写。
7.2 常见命名约定
1. 小驼峰命名法:适用于定义方法和变量。
- 标识符是一个单词的时候,首字母小写。例如:
name
- 标识符是多个单词组成的时候,第一个单词小写,其它单词首字母大写。例如:
firstName
2. 大驼峰命名法:适用于定义类。
- 标识符是一个单词的时候,首字母大写。例如:
Student
- 标识符是多个单词组成的时候,每个单词首字母大写。例如:
GoodStudent
八、类型转换
8.1 自动类型转换
1. 把一个表示数据范围小的数值或变量赋值给另一个表示数据范围大的变量。
2. 转换规则图:
8.2 强制类型转换
1. 把一个表示数据范围大的数值或变量赋值给另一个表示数据范围小的变量。
2. 格式:目标数值类型 变量名=(目标数值类型)变量或值;
例如:int k=(int)88.88;
8.3 代码举例
public class Demo {
public static void main(String[] args){
//自动类型转换
double d=10;
System.out.println(d); //输出10.0
//强制类型转换
int k=(int)88.88;
System.out.println(k); //输出88
//这些是可以的
byte b=8;
short a=b;
int i=b;
//这是不可以的,会报错
char c=b;
}
}
九、运算符
9.1 算术运算符
1. 算术运算符表格:
符号 | 作用 |
---|---|
+ | 加 |
- | 减 |
× | 乘 |
/ | 除 |
% | 取余 |
2. 注意事项: 两个数做除法,/
取结果的商,%
取结果的余数。整数操作只能得到整数,要想得到小数,必须有浮点数参加运算。
9.2 “+”操作
1. 字符的+操作:
- 'A’→65,A-Z是连续的。
- 'a’→97,a-z是连续的。
- '0’→48,0-9是连续的。
2. 算术表达式中包含多个基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。等级顺序:byte,short,char→ int → long → float → double
public class Demo {
public static void main(String[] args){
int i=10;
char a='A'; //'A'的值是65
System.out.println(i+a); //输出75
//这是不可以的,int不能降为char
char j=i+a;
//char类型会自动提升为int类型
int k=i+a;
}
}
3. 字符串的+操作:
- 当“+” 操作中出现字符串时,这个“+” 是字符串连接符,而不是算术运算。
- 在“+” 操作中,如果出现了字符串,就是连接运算符,否则就是算术运算。当连续进行“+” 操作时,从左到右逐个进行。
public class Demo {
public static void main(String[] args){
System.out.println("Good"+"Student");//输出GoodStudent
System.out.println("Good"+666); //输出Good666
System.out.println(1+20+"Good"); //输出21Good
}
}
9.3 赋值运算符
1. 赋值运算符表格:
符号 | 作用 | 说明 |
---|---|---|
= | 赋值 | a=10,将10赋值给变量a |
+= | 加后赋值 | a+=b,将a+b的值赋给a |
-= | 减后赋值 | a-=b,将a-b的值赋给a |
*= | 乘后赋值 | a*=b,将a×b的值赋给a |
/= | 除后赋值 | a/=b,将a÷b的值赋给a |
%= | 取余后赋值 | a%=b,将a÷b的余数赋给a |
2. 注意事项: 扩展运算符隐含了强制类型转换。
public class Demo {
public static void main(String[] args){
short a=20;
a+=20; //隐含了强制类型转换
a=(short)(a+20); //a=a+20; 这样会报错的
System.out.println(a); //输出结果为40
}
}
9.4 自增自减运算符
1. 自增自减运算符表格:
符号 | 作用 | 说明 |
---|---|---|
++ | 自增 | 变量的值加1 |
- - | 自减 | 变量的值减1 |
2. 注意事项:
- ++和- -既可以放在变量的后边,也可以放在变量的前边。
- 单独使用的时候,++和- -无论放在变量的前边还是后边,结果是一样的。
- 参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者- -;参与操作的时候,如果放在变量的前边,先拿变量做++或者- -,后拿变量参与操作。
public class Demo {
public static void main(String[] args){
int i1=10;
int j1=i1++;
int i2=10;
int j2=++i2;
System.out.println(j1); //输出10
System.out.println(i1); //输出11
System.out.println(j2); //输出11
System.out.println(i2); //输出11
}
}
9.5 关系运算符
1. 关系运算符表格:
符号 | 说明 |
---|---|
== | a==b,判断a和b的值是否相等 ,成立为true,不成立为false |
!= | a!=b,判断a和b的值是否不相等 ,成立为true,不成立为false |
> | a>b,判断a是否大于 b,成立为true,不成立为false |
>= | a>=b,判断a是否大于等于 b,成立为true,不成立为false |
< | a<b,判断a是否小于 b,成立为true,不成立为false |
<= | a<=b,判断a是否小于等于 b,成立为true,不成立为false |
2. 注意事项:
- 关系运算符的结果都是boolean类型,要不为
true
,要么为false
。 - 如果把==写成了=,则成为了赋值运算。
public class Demo {
public static void main(String[] args){
int i=10;
int j=20;
int k=10;
System.out.println(i==j); //输出false
System.out.println(i==k); //输出true
System.out.println(i!=j); //输出true
System.out.println(i!=k); //输出false
System.out.println(i>=j); //输出false
System.out.println(i>=k); //输出true
//不小心把==写成了=,则就会把j的值赋值给了i,然后输出i的值
System.out.println(i=j); //输出为20
}
}
9.6 逻辑运算符
1. 逻辑运算符概述:是用来连接关系表达式的运算符,也可以直接连接布尔类型的常量或者变量。
2. 逻辑运算符表格:
符号 | 作用 | 说明 |
---|---|---|
& | 逻辑与 | a&b,a和b的结果都是true,结果为true,否则为false |
丨 | 逻辑或 | a丨b,a和b的结果都是false,结果为false,否则为ture |
^ | 逻辑异或 | a^b,a和b的结果不同为true,相同false |
! | 逻辑非 | !a,结果与a的结果正好相反 |
3. 代码块举例:
public class Demo {
public static void main(String[] args){
int i=10;
int j=20;
int k=30;
System.out.println(i>j & i>k); //输出false
System.out.println(i<j & i>k); //输出false
System.out.println(i>j & i<k); //输出false
System.out.println(i<j & i<k); //输出true
}
}
9.7 短路逻辑运算符
1. 短路逻辑运算符表格:
符号 | 作用 | 说明 |
---|---|---|
&& | 短路与 | 作用和&相同,但是有短路效果 |
丨丨 | 短路或 | 作用和丨相同,但是有短路效果 |
2. 注意事项:
- 逻辑与&,无论左边真假,右边都要执行。
- 短路与&&,如果左边为真,右边执行;如果左边为假,右边不执行。
- 逻辑或|,无论左边真假,右边都要执行。
- 短路或||,如果左边为假,右边执行;如果左边为真,右边不执行。
public class Demo {
public static void main(String[] args){
int i=10;
int j=20;
int k=30;
//&& 有false则false;|| 有true则true
System.out.println(i>j && i>k); //输出false
System.out.println(i<j && i>k); //输出false
System.out.println(i>j && i<k); //输出false
System.out.println(i<j && i<k); //输出true
//这里i++ >100为假,所以不会执行j++操作
System.out.println(i++ >100 && j++ >100);
System.out.println(i); //输出为11
System.out.println(j); //输出为20
}
}
9.8 三元运算符
1. 三元运算符格式:关系表达式 ? 表达式1 : 表达式2;
范例:a>b ? a : b;
2. 计算规则:
- 首先计算关系表达式的值。
- 如果值为true,表达式1的值就是运算结果。
- 如果值为false,表达式2的值就是运算结果。
3. 代码块举例:
public class Demo {
public static void main(String[] args){
int a=10;
int b=20;
//获取两个数据中的较大值
int max=a>b ? a:b;
System.out.println(max);
}
}
9.9 三元运算符案例举例
案例1:动物园里有两只老虎,两只老虎的体重分别是180kg和200kg。请写程序判断两只老虎的体重是否相同。
public class Test1 {
public static void main(String[] args){
int weight1=180;
int weight2=200;
boolean b=weight1==weight2 ? true:false;
System.out.println(b);
}
}
案例2:一个寺庙住着三个和尚,他们的身高分别是150cm、185cm、165cm。请写程序获得三个和尚中的最高身高。
public class Test2 {
public static void main(String[] args){
int height1=150;
int height2=185;
int height3=165;
//先求的前两个中的最高值用临时变量保存起来
int tempmax=height1>height2 ? height1:height2;
//再用前两个中的最高值和第三个身高值比较,求最大身高
int max=tempmax>height3 ? tempmax:height3;
System.out.println(max);
}
}
十、数据输入
10.1 数据输入步骤
1. 导包:import java.util.Scanner;
注:导包的动作必须出现在类定义的上面。
2. 创建对象:Scanner sc=new Scanner(System.in);
注:上面这个格式里面,只有sc是变量名,可以变,其他的都不允许变。
3. 接收数据: int x=sc.nextInt();
注:上面这个格式里面,只有x是变量名,可以变,其他的都不允许变。
10.2 代码块举例
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
int x=sc.nextInt();
//输出数据
System.out.println("x:"+x);
}
}
10.3 Scanner类介绍
java.util.Scanner类,这是一个用于扫描输入文本的新的实用程序。
10.4 数据输入案例举例
案例:一个寺庙里住着三个和尚,他们的身高必须经过测量得出,请用程序实现获取这三个和尚的最高身高。
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
//创建对象
Scanner sc=new Scanner(System.in);
System.out.println("请输入第一个和尚的身高:");
int height1=sc.nextInt();
System.out.println("请输入第二个和尚的身高:");
int height2=sc.nextInt();
System.out.println("请输入第三个和尚的身高:");
int height3=sc.nextInt();
int tempmax=height1>height2 ? height1:height2;
int max=tempmax>height3 ? tempmax:height3;
//输出数据
System.out.println(max);
}
}
十一、分支语句
11.1 流程控制
1. 流程控制语句分类:
- 顺序结构
- 分支结构
- 循环结构
2. 顺序结构是程序中最简单最基本的流程控制,没有特定的语法结构,按照代码的先后顺序,依次执行,程序中大多数的代码都是这样执行的。
11.2 if语句
1. 语句格式:
if(关系表达式){
语句体;
}
2. 执行流程:
- 首先计算关系表达式的值。
- 如果关系表达式的值为true就执行语句体。
- 如果关系表达式的值为false就不执行语句体。
- 继续执行后面的语句内容。
public class Demo {
public static void main(String[] args){
int a=10;
int b=20;
if(a==b){
System.out.println("a等于b"); //a不等于b,这行未执行
}
System.out.println("结束");
}
}
11.3 if…else结构
1. 语句格式:
if(关系表达式){
语句体1;
}
else{
语句体2;
}
2. 执行流程:
- 首先计算关系表达式的值。
- 如果关系表达式的值为true就执行语句体1。
- 如果关系表达式的值为false就执行语句体2。
- 继续执行后面的语句内容。
//需求:判断a和b两个数是否相等
public class Demo {
public static void main(String[] args){
int a=10;
int b=20;
if(a==b){
System.out.println("a等于b");
}
else{
System.out.println("a不等于b");
}
System.out.println("结束");
}
}
11.4 案例分析1
案例1:任意给出一个整数,请用程序实现判断该整数是奇数还是偶数,并在控制台输出该整数是奇数还是偶数。
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
int x=sc.nextInt();
//判断奇偶数
if(x%2==0){
System.out.println(x+"是偶数");
}
else{
System.out.println(x+"是奇数");
}
}
}
11.5 if…else…if结构
1. 语句格式:
if(关系表达式){
语句体1;
}
else if(关系表达式2){
语句体2;
}
......
else{
语句体n+1;
}
2. 执行流程:
- 首先计算关系表达式的值。
- 如果关系表达式的值为true就执行语句体1,如果关系表达式的值为false就计算关系表达式2的值。
- 如果关系表达式的值为true就执行语句体2,如果关系表达式的值为false就计算关系表达式3的值。
- ………………
- 如果没有任何关系表达式的值为true,则执行语句体n+1。
//需求:从键盘1-7数字上录入一个数字,输出对应的星期几
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
int week=sc.nextInt();
if(week==1){
System.out.println("星期一");
}
else if(week==2) {
System.out.println("星期二");
}
else if(week==3) {
System.out.println("星期三");
}
else if(week==4) {
System.out.println("星期四");
}
else if(week==5) {
System.out.println("星期五");
}
else if(week==6) {
System.out.println("星期六");
}
else{
System.out.println("星期日");
}
}
}
11.6 案例分析2
案例2:小明快考试了,小明爸爸说,会根据不同的考试成绩,送小明不同的礼物,请用程序实现小明到底该获得什么样的礼物。
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
//创建对象
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个分数:");
//接收数据
int score=sc.nextInt();
if(score>100 || score<0){
System.out.println("你输入的分数有误");
}
else if(score>=95 && score<=100) {
System.out.println("奖励山地自行车一辆");
}
else if(score>=90 && score<95) {
System.out.println("奖励游乐场玩一次");
}
else if(score>=85 && score<90) {
System.out.println("奖励变形金刚玩具一个");
}
else if(score>=80 && score<85) {
System.out.println("奖励吃大餐一顿");
}
else{
System.out.println("无奖励");
}
}
}
11.7 switch语句
1. 语句格式:
- case:后面的是要和表达式进行比较的值。
- break:表示中断、结束的意思,用来结束switch语句。
- default:表示所有情况都不匹配的时候,就执行该处的内容,和if语句的else相似。
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
default:
语句体n+1;
break;
}
2. 执行流程:
- 首先计算表达式的值。
- 依次和case后面的值进行比较,如果有对应的值,就执行相应的语句,在执行的过程中,遇到break就会结束。
- 如果所有的case后面的值和表达式的值都不匹配,就会执行default里面的语句体,然后程序结束掉。
//需求:从键盘1-7数字上录入一个数字,输出对应的星期几
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
int week=sc.nextInt();
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;
}
}
}
11.8 案例分析3
案例3:一年有12个月,分属于春夏秋冬4个季节,键盘录入一个月份,请用程序实现判断该月份属于哪个季节,并输出。
春:3、4、5
夏:6、7、8
秋:9、10、11
冬:12、1、2
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
int month=sc.nextInt();
//采用case穿透
switch(month) {
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("你输入的月数有误");
break;
}
}
}
注意事项: 在switch语句中,如果case控制的语句体后面不写break,将出现穿透现象,继续向下运行,直到遇到break或者整个switch语句结束。
十二、循环语句
12.1 for循环语句
1. 语句格式:
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
2. 执行流程:
- ① 执行初始化语句。
- ② 执行条件判断语句,看其结果是true还是false。如果是false,循环结束;如果是true,继续执行。
- ③ 执行循环体语句。
- ④ 执行条件控制语句。
- ⑤ 回到②继续执行。
//需求:在控制台上输出5次 "HelloWorld"
public class Demo {
public static void main(String[] args){
for(int i=1;i<=5;i++){
System.out.println("HelloWorld");
}
}
}
12.2 案例分析
案例:在控制台输出所有的水仙花数。水仙花数是一个三位数,且个位、十位、百位的数字立方和等于原数。
public class Demo {
public static void main(String[] args){
for(int i=100;i<1000;i++){
int ge=i%10;
int shi=i%100/10;
int bai=i/100;
if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
System.out.println(i);
}
}
}
}
//最后结果是:153、370、371、407
12.3 while循环语句
1. 语句格式:
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
2. 执行流程:
- ① 执行初始化语句。
- ② 执行条件判断语句,看其结果是true还是false。如果是false,循环结束;如果是true,继续执行。
- ③ 执行循环体语句。
- ④ 执行条件控制语句。
- ⑤ 回到②继续执行。
//需求:在控制台上输出5次 "HelloWorld"
public class Demo {
public static void main(String[] args){
int i=1;
while(i<=5){
System.out.println("HelloWorld");
i++;
}
}
}
12.4 do…while循环语句
1. 语句格式:
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
2. 执行流程:
- ① 执行初始化语句。
- ② 执行循环体语句。
- ③ 执行条件判断语句。
- ④ 执行条件判断语句,看其结果是true还是false。如果是false,循环结束;如果是true,继续执行。
- ⑤ 回到②继续执行。
//需求:在控制台上输出5次 "HelloWorld"
public class Demo {
public static void main(String[] args){
int i=1;
do {
System.out.println("HelloWorld");
i++;
}while(i<=5);
}
}
12.5 三种循环区别
1. 三种循环区别:
- for循环和while循环先判断条件是否成立,然后决定是否执行循环体(即: 先判断后执行)。
- do…while循环先执行一次循环体,然后判断条件是否成立,是否继续执行循环体(即: 先执行后判断)。
2. for和while的区别
- 条件控制语句所控制的自增变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了。
- 条件控制语句所控制的自增变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用。
3. 死循环格式:
for( ; ; ) {}
while(true) {}
do{} while(true);
- 注意事项: while的死循环格式是最常用的,命令提示符窗口中
Ctrl+C
可以结束死循环。
12.6 跳转控制语句
1. 跳转控制语句概述:
- 用
continue
跳过某次循环体内容的执行。注意事项: 使用是基于条件控制的。 - 用
break
终止循环体内容的执行。注意事项: 使用是基于条件控制的。
2. 代码块举例:
public class Demo {
public static void main(String[] args){
for(int i=1;i<=5;i++){
if(i%2==0){
continue; //如果是break,则只有1输出
}
System.out.println(i);
}
}
}
12.7 Random
1. 作用:用于产生一个随机数。
2. 使用步骤:
- 导包:
import java.util.Random;
,导包的动作必须在类定义的上面。 - 创建对象:
Random r=new Random();
,上面这个格式里面,r是变量名,可以变,其他的都不允许变。 - 获取随机数:
int number=r.nextInt(10);
,获取数据的范围 [0,10),包括0但不包括10。
3. 代码块举例:
import java.util.Random;
public class Demo {
public static void main(String[] args){
Random r=new Random();
int number=r.nextInt(10);
System.out.println(number);
}
}
十三、数组
13.1 数组定义格式
1. 格式(1):数据类型 [] 变量名;
,范例:int [] arr;
。含义:定义了一个int类型的数组,数组名是arr。
2. 格式(2):数据类型 变量名[];
,范例:int arr[]
。含义:定义了一个int类型的变量,变量名是arr数组。
13.2 数组初始化
1. 数组初始化概述:就是为数组中的每个元素分配内存空间,并为每个数组元素赋值。
2. 动态初始化举例:
public class Demo {
public static void main(String[] args) {
int[] arr=new int[3];
}
}
3. 静态初始化举例:
public class Demo {
public static void main(String[] args) {
int[] arr=new int[]{1,2,3};
//int[] arr={1,2,3}; 这是简化格式
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
4. 获得数组长度:System.out.println(arr.length);
。
13.3 数组操作中的两个问题
1. 索引越界:访问了数组中不存在的索引对应的元素,造成索引越界问题。
2. 空指针异常:访问的数组已经不再指向堆内存的数据,造成空指针异常。
十四、方法
14.1 方法概述
1. 方法(method):是将具有独立功能的代码块组织成为一个整体,使其具有特殊功能的代码集。
2. 注意事项:
- 方法必须先创建才能使用,该过程称为方法定义。
- 方法创建后并不是直接运行的,需要手动使用后才执行,该过程称为方法调用。
14.2 方法的定义和调用
1. 方法的定义:
public static void 方法名() {
//方法体
}
2. 方法调用的格式:方法名();
,通常在main()方法中调用。
3. 代码块举例:
public class Demo {
public static void main(String[] args) {
Number();
}
public static void Number() {
int number=10;
if (number%2==0){
System.out.println(number+"是偶数");
}
else{
System.out.println(number+"是奇数");
}
}
}
14.3 带参数方法的定义和调用
1. 带参数方法定义:public static void 方法名( 参数 ) {......}
,其中参数=数据类型 变量名
,可以有一个参数,也可以有多个参数。
2. 注意事项:
- 方法定义时,参数中的数据类型和变量名都不能缺少,缺少任意一个程序将报错。
- 方法定义时,多个参数之间使用英文逗号(,)分隔。
3. 带参数方法调用:方法名(参数);
,通常在main()方法中调用。
- 方法调用时,参数的数量与类型必须与方法定义中的设置相匹配,否则程序将报错。
4. 代码块举例:
public class Demo {
public static void main(String[] args) {
int number=9;
Number(number);
//或者直接Number(9);
}
public static void Number(int number) {
if (number%2==0){
System.out.println(number+"是偶数");
}
else{
System.out.println(number+"是奇数");
}
}
}
5. 形参和实参:
- 形参:方法定义中的参数。等同于变量定义格式。
- 实参:方法调用中的参数。等同于使用变量或常量。
14.4 带返回值方法的定义和调用
1. 带返回值方法的定义:
public static 数据类型 方法名(参数) {
return 数据;
}
注意事项: 方法定义时return后面的返回值与方法定义上的数据类型要匹配,否则程序将报错。
2. 带返回值方法的调用:数据类型 变量名=方法名(参数);
。
- 方法的返回值通常会使用变量接收,否则返回值毫无意义。
3. 代码块举例:
public class Demo {
public static void main(String[] args) {
int number=9;
boolean flag=Number(number);
//或者直接Number(9);
System.out.println(flag);
}
//偶数返回true,奇数返回false
public static boolean Number(int number) {
if (number%2==0){
return true;
}
else{
return false;
}
}
}
14.5 方法的两个注意事项
1. 方法不能嵌套定义。
2. void表示无返回值,可以省略return;也可以单独写return,但后面不加数据。
14.6 方法重载
1. 方法重载概述:指同一个类中定义的多个方法之间的关系,满足下列条件的多个方法相互构成重载。条件如下:
- 条件①:多个方法在同一个类中。
- 条件②:多个方法具有相同的方法名。
- 条件③:多个方法的参数不相同,类型不同或者数量不同。
2. 方法重载特点:
- 重载仅对应方法的定义,与方法的调用无关,调用方式参照标准格式。
- 重载仅针对同一个类中方法的名称与参数进行识别,与返回值无关。换句话说不能通过返回值来判断两个方法是否相互构成重载。
注意事项: 在调用时,Java虚拟机会通过参数的不同来区分同名的方法。
14.7 方法的参数传递
1. 对于基本数据类型的参数,形式参数的改变,不影响实际参数的值。
2. 代码块举例:
public class Demo {
public static void main(String[] args) {
int number=100;
System.out.println("调用方法前:"+number); //调用方法前:100
Change(number);
System.out.println("调用方法后:"+number); //调用方法后:100
}
public static void Change(int number){
number = 200;
}
}
3. 对于引用类型的参数,形式参数的改变,会影响实际参数的值。
4. 代码块举例:
public class Demo {
public static void main(String[] args) {
int[] number={10,20,30};
System.out.println("调用方法前:"+number[1]); //调用方法前:20
Change(number);
System.out.println("调用方法后:"+number[1]); //调用方法后:200
}
public static void Change(int[] number){
number[1] = 200;
}
}
14.8 案例分析
案例:用数组遍历通用格式对数组进行遍历。
public class Demo {
public static void main(String[] args) {
int[] number={10,20,30,40,50};
Print(number);
}
public static void Print(int[] number){
System.out.print("[");
for(int x=0;x<number.length;x++){
if(x== number.length-1){
System.out.print(number[x]+"]");
}
else{
System.out.print(number[x]+",");
}
}
}
}
十五、Debug
15.1 Debug概述
Debug:是供程序员使用的程序调试工具,它可用于查看程序的执行流程,也可以用来追踪程序执行过程来调试程序。
15.2 Debug操作流程
1. 如何加断点:选择要设置断点的代码行,在行号的区域后面单击鼠标左键即可。
2. 如何运行加了断点的程序:在代码区右键Debug执行。
3. 看哪里:看Debugger(调试器)窗口。
4. 点哪里:点箭头(或者F7)。
5. 如何删除断点:选择要删除的断点,单击鼠标左键即可。
十六、类和对象
16.1 对象
1. 对象:万物皆对象,客观存在的事物皆为对象。
2. 生活举例图:
16.2 类
1. 类:类是对现实生活中一类具有共同属性和行为的事物的抽象。
2. 对象的属性:对象具有的各种特征,每个对象的每个属性都拥有特定的值。
3. 对象的行为:对象能够执行的操作。
4. 类和对象的关系:类是对现实生活中一类具有共同属性和行为的事物的抽象;而对象是能看得到摸得到的真实存在的实体。
16.3 类的定义
1. 类的重要性:是Java程序的基本组成单位。组成为属性和行为。
- 属性:在类中通过成员变量来体现(类中方法外的变量)。
- 行为:在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)。
2. 类的定义步骤:
- ①:定义类。
- ②:编写类的成员变量。
- ③:编写类的成员方法。
public class 类名 {
//成员变量
变量1数据类型 变量1;
变量2数据类型 变量2;
......
//成员方法
方法1;
方法2;
}
3. 定义一个电话类:
public class Phone {
//成员变量:品牌和价格
String brand;
int price;
//成员方法:打电话和发短信
public void call() {
System.out.println("打电话");
}
public void message() {
System.out.println("发短信");
}
}
16.4 对象的使用
1. 创建对象:
- 格式:
类名 对象名=new 类名();
。 - 范例:
Phone p=new Phone();
。
2. 使用对象:
- 使用成员变量:①格式:
对象名.变量名;
。②范例:p.brand;
。 - 使用成员方法:①格式:
对象名.方法名;
。②范例:p.call();
。
3. 代码块举例:Phone类和Demo类在两个文件中。
public class Demo {
public static void main(String[] args) {
Phone p=new Phone();
p.brand="小米";
p.price=3000;
System.out.println(p.brand);
System.out.println(p.price);
p.call();
p.message();
}
}
16.5 成员变量和局部变量
1. 成员变量:类中方法外的变量。
2. 局部变量:方法中的变量。
3. 成员变量和局部变量的区别:
区别 | 成员变量 | 局部变量 |
---|---|---|
类中的位置不同 | 类中方法外 | 方法内或者方法声明上 |
内存中的位置不同 | 堆内存 | 栈内存 |
生命周期不同 | 随着对象的存在而存在,随着对象的消失而消失 | 随着方法的调用而存在,随着方法的调用完毕而消失 |
初始化值不同 | 有默认的初始值 | 没有默认的初始值,必须先定义,赋值,才能使用 |
十七、private讲解
17.1 private关键字
1. private
是一个权限修饰符,可以修饰成员(包括变量和方法)。作用是保护成员不被别的类使用,被private
修饰的成员只在本类中才能被访问。
2. 针对private
修饰的成员变量,如果需要被其他的类使用,要提供相应的操作:
- 提供
get变量名()
方法,用于获取成员变量的值,方法用public
修饰。 - 提供
set变量名(参数)
方法,用于设置成员变量的值,方法用public
修饰。
3. 代码块举例:创建两个Java文件。
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s=new Student();
//为变量赋值
s.name="张三";
s.setAge(20);
//调用show()方法
s.show();
}
}
public class Student {
//成员变量
String name;
private int age;
//成员方法
public void setAge(int a) {
if(a<0||a>120) {
System.out.println("你输入的年龄有误");
}
else{
age=a;
}
}
public void show() {
System.out.println(name+","+age);
}
}
17.2 private关键字的使用
一个标准类的编写:
- 把成员变量用
private
修饰。 - 提供对应的
getXxx()
或者setXxx()
方法。
十八、this讲解
18.1 this关键字
1. this
关键字修饰的变量用于指代成员变量:
- 方法的形参如果与成员变量同名,不带
this
修饰的变量指的是形参,而不是成员变量。 - 方法的形参没有与成员变量同名,不带
this
修饰的变量指的是成员变量。
2. 什么时候使用this
:在解决局部变量隐藏成员变量时使用。
18.2 this内存原理
十九、字符串
19.1 API讲解
1. API(Application Programming Interface):应用程序编程接口。
2. Java API:指的就是JDK中提供的各种功能的Java类。这些类将底层的实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可。
19.2 String讲解
1. String类代表字符串,Java程序中的所有字符串文字(例如"abc")都被实现为此类的实例。也就是说,Java程序中所有的双引号字符串,都是String类的对象。
2. 字符串的特点:
- 字符串不可变,它们的值在创建后不能被更改。
- 虽然String的值是不可变的,但是它们可以被共享。
3. String的构造方法:
方法名 | 说明 |
---|---|
public String() | 创建一个空白字符串对象,不含有任何内容 |
public String(char[] chs) | 根据字符数组的内容,来创建字符串对象 |
public String(byte[] bys) | 根据字节数组的内容,来创建字符串对象 |
String s= “abc” | 直接赋值的方式创建字符串对象,内容就是abc |
推荐使用直接赋值的方法得到字符串对象。
public class Demo {
public static void main(String[] args) {
String s1=new String();
char [] chs={'a','b','c'};
String s2=new String(chs);
System.out.println(s2); //输出abc
byte [] bys={97,98,99};
String s3=new String(bys);
System.out.println(s3); //输出abc
String s4="abc";
System.out.println(s4); //输出abc
}
}
19.3 字符串的比较
1. 使用==
比较:
- 基本类型:比较的是数据值是否相同。
- 引用类型:比较的是地址值是否相同。
2. 字符串对象直接用==
比较的是地址值;要比较内容是否相同,是通过一个方法实现的,这个方法是equals()
。
public class Demo {
public static void main(String[] args) {
char [] chs={'a','b','c'};
String s1=new String(chs);
String s2=new String(chs);
System.out.println(s1==s2); //输出:false
String s3="abc";
String s4="abc";
System.out.println(s3==s4);
System.out.println(s1.equals(s2)); //输出:true
System.out.println(s1.equals(s3)); //输出:true
System.out.println(s1.equals(s4)); //输出:true
}
}
19.4 StringBuilder讲解
1. StringBuilder是一个可变的字符串类,我们可以把它看成一个容器。这里的可变指的是StringBuilder对象中的内容是可变的。
2. StringBuilder的构造方法:
方法名 | 说明 |
---|---|
public StringBuilder() | 创建一个空白字符串对象,不含有任何内容 |
public StringBuilder(String str) | 根据字符串的内容,来创建可变字符串对象 |
public class Demo {
public static void main(String[] args) {
StringBuilder s1=new StringBuilder();
System.out.println(s1.length()); //0
StringBuilder s2=new StringBuilder("hello");
System.out.println(s2.length()); //5
}
}
3. StringBuilder的添加和反转方法:
方法名 | 说明 |
---|---|
public StringBuilder append(任意类型) | 添加数据,并返回对象本身 |
public StringBuilder reserve() | 返回相反的字符序列 |
public class Demo {
public static void main(String[] args) {
//创建对象
StringBuilder s1=new StringBuilder();
//添加
s1.append("helloworld");
System.out.println(s1); //输出:helloworld
//反转
System.out.println(s1.reverse()); //输出:dlrowolleh
}
}
19.5 StringBuilder和String相互转换
1. StringBuilder转换为String:s1.toString();
。
public class Demo {
public static void main(String[] args) {
//创建对象
StringBuilder s1 = new StringBuilder();
//添加
s1.append("helloworld");
String s2 = s1.toString(); //String s2=s1; 这个是错误的
System.out.println(s2); //输出:helloworld
}
}
2. String转换为StringBuilder:new StringBuilder(String s);
。
public class Demo {
public static void main(String[] args){
String s1="hello";
StringBuilder s2 = new StringBuilder(s1); //StringBuilder s2=s1; 这个是错误的
System.out.println(s2); //输出:hello
s2.append(10);
System.out.println(s2); //输出:hello10
}
}
最后总结
有了C++基础,再学Java难度不大,但细节较多,建议大家整理一些笔记来帮助日后的复习。
此篇内容字数尚可!如果大家发现有什么错误的地方,可以私信或者评论区指出喔(虚心请教,渴望大佬帮助)。希望能与大家共同进步,那么本期就到此结束,让我们下期再见!觉得不错可以点个赞以示鼓励喔!