安装上了Java环境,我们就可以开始Java的学习了。首先学习一些基础知识,为Java学习打好地基!
第二周:Java基础
一、学会起名字(Java中的标识符)
给类、接口、方法、包等起名字的字符序列;标识符的组成规则:
1)英文字母(包含大小写);
2)数字字符;
3)$与_ ; //注意:不能以数字字符开头
1)给包起名
规则:字母全部都小写
单级包:javastudy
多级包:org.java_name //tips:常采用域名反写的方式给包命名
2)给类、接口起名:
规则:单个单词:第一个字母大写:class Java
多个单词:每个单词的首字母大写:class JavaStudy
3)给方法(函数)起名: //C语言面向过程的语言中称为函数,Java面向对象的语言中一般称作方法
规则:单个单词:字母全部都小写:public static void function()
多个单词:第一个单词全部小写,从第二个单词开始每个单词首字母大写:public static void functionTest()
4)给常量起名:
规则:单个单词:字幕全部大写:JAVA
多个单词:字母全部大写,单词直接用下划线隔开:JAVA_STUDY
二、了解关键字
关键字:关键字是Java中具有特殊含义的字符序列(单词),是程序的重要组成部分。Java不允许对关键字赋予别的含义。所有的关键字都是小写的,如果被大写就不是关键字了。
常用的几个:
class:Java中被赋予特定含义的单词
public:权限修饰符:公开的
private:私有的
a.定义数据类型的关键字:byte、short、int、long、float、double、char、boolean;
b.流程控制的关键字:if···else、switch、case、default、do···while、for、break、continue;
c.方法、类型、变量的修饰关键字:private、public、protected、final、static、abstract、synchronized、volatile;
d.异常处理关键字:try、catch、finally、throw、throws;
e.对象相关关键字:new、extends、implements、class、instanceof、this、super;
f.字面常量关键字:false、true、null:
g.方法相关关键字:return、void;
h:包相关关键字:package、import;
Java中的几种注释方法:
a-->单行注释://
b-->多行注释:/* 内容 */
c-->文档注释:/** 内容 */
简单了解一下结构:
public class Hello{ //class表示这是类 Hello是类名
public static void main(String[ ]args){ //这是一个主方法
System.out.println("HelloWorld!"); //这是一个输出语句的固定格式}
}
三、常量与变量
常量:Java中的常量定义和变量基本相同,在类型前面加修饰符final关键字即可。
final int MAX_NUM=100; //注意命名规则,全部大写,单词之间用下划线_隔开;常量一般定义之后不再修改!
1)字面值常量:
a.字符串常量:用双引号括起来的内容:“hello”;
b.字符常量:用单引号括起来的内容:‘A’、‘b’、‘0’ //‘ab’单引号里面有多个字符是错误的
c.整数常量:100、1000;
d.小数常量:3.1415;
e.布尔(boolean)常量:true、false;
f.空常量:null(在讲面向对象的时候,如果一个对象为null,那么一定要给对象进行非空判断)
// 2)自定义常量 //继承学了之后补充
变量:变量是Java中的基本存储单元,值可以被修改;
变量三要素:1)数据类型;2)变量名;3)初始化值;
数据类型的分类
1)基本数据类型:4类8中
整数类型: (整数类型默认int类型) 占用的字节数 范围byte :字节类型 1 -128~127
short :短整型 2 -2^15~2^15-1
int :整数类型 4 -2^31~2^31-1
long :长整型 8 -2^63~2^63-1
浮点类型: (浮点类型默认double类型)
float :单精度 4 3.4e-038~3.4e+038
double:双精度 8 1.7e-308~1.7e+308
字符类型: char 2
布尔类型: boolean(true/false) 1
//定义long类型的变量:由于整数类型默认是int类型 ,所有在long类型变量值后面加上一个标记:L或者l ,建议使用L
//float :浮点类型默认是double类型,float类型加标记:F或者f,建议使用F
注意事项:
1)定义变量,不能是Java中的关键字;
2)不能是以数字开头;
3)一个变量名不能重复定义;
4)建议:一行定义一个变量;
数据类型转换:各种数据类型的数据可以在一起进行混合运算。运算时,不同类型的数据先转换为相同类型的数据再进行运算。数据类型之间的转换分为自动类型转换和强制类型转换两种;
自动类型转换:从低级到高级发生自动类型转换,也就是从表示范围小的类型向表示范围大的类型发生自动类型转换;
低-----------------------------------------------高
byte、short、char->int->long->float->double
在进行变量计算的时候 :尽量同一个的数据类型之间进行换算
不同类型之间的数据:数据类型的默认提示
byte,short,char 三个之间相互不转换的,但是一旦参与运算,都默认转换转换成int类型
强制类型转换: 目标数据类型 变量名 = (目标数据类型)(变量值);
例题:
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢?为什么呢?
b=b1+b2;编译失败: byte,short,char之间相互不转换,一旦进行运算的,默认提升为一个int类型
变量相加,是先看数据类型,最终相加后的结果是否在当前这个类型范围之内
b=3+4; 编译正确: 常量相加,是运算,看当前结果是否在范围之内!
2)引用数据类型 //数组学了之后补充
四、运算符
java中用到的运算符:算数运算符、赋值运算符、比较运算符、逻辑运算符、三目运算符;
1)算数运算符
二元:+、-、*、/(取得是整数)、%(去摸:取余数) //二元运算符,运算结果的数据类型一般为操作数中表达范围大的;
一元:+、-、++、-- //一元运算符,远算结果的类型和操作数的类型相同;
java中对‘+’运算进行了扩展:
a.可以作为运算符; b.表示一个数是正整数; c.可以作为字符串的拼接符;
扩展的算术运算符:
++或者--
单独使用:结论:无论++或者--再数据前还是数据后,都是自增1或者自减1
参与运算使用:
结论:如果++或者--在数据的前面,先自增或者自减,再参与运算
如果++或者--在数据的后面,先运算,再进行自增或者自减
//在实际开发中,++在后用的多(比如:流程空语句 for循环语句 步长语句变量名++)
例题:请分别计算出a,b,c的值
int a=10;
int b=10;
int c=10;
a=b++; //a=10,b=11, c=10
c=--a; // a=9, b=11,c=9
b=++a; //a=10,b=10,c=9
a=c--; //a=9, b=10,c=8
2)赋值运算符
基本的赋值运算符:=
举例:int a=10; 将10赋值给int类型的变量a;
扩展的赋值运算符:+=、-=、*=、/=、%=;
举例:y+=10; 相当于 y=y+10;
a*=b+5;相当于 a=a*(b+5); 因为赋值运算符的优先级最低;
//变量的定义,1)直接去初始化值 2)如果是声明了,但是没有赋值,那么在使用之前必须给它进行赋值,否则会报错;
可以一行给多个变量赋值:a=b=10;
例题:short s=1;
s = s+1; //有问题:1为int类型,s默认类型提升,提升为int类型,,不能用short类型的s去接收int类型的数据 ,
short s=1;
s+=1; //等价于: s = (s)(s+1) ;
扩展的赋值运算符隐藏了强制类型转换!
上面两个代码有没有问题,如果有,那里有问题。
3)关系(比较)运算符
关系运算符用来比较两个值之间的大小,结果返回布尔值:true或false;
共有6种:>、>=、<、<=、!=、== //==不能写成=!!
4)逻辑运算符
基本逻辑运算符:&(逻辑与)、|(逻辑或)、^(逻辑异或)、!(逻辑非)
逻辑&:有false则false;
逻辑|:有true则true;
逻辑^:相同则为false,不同则true;
逻辑!:非true则false,非false则true,双!则为它本身;
扩展的逻辑运算符:||(逻辑双与)、&&(逻辑双或)
a:共同点:效果是一样的
b:逻辑双与&& ,如果左边的表达式如果是false,那么右边不执行(具有短路效果); //实际开发中较为常用
逻辑双或|| :如果左边的表达式是true,那么右边不执行(具有短路效果);
5)三目(条件)运算符
格式:(表达式)?true的结果:false的结果;
举例:int a = 10 ;
int b = 20 ;
int max = (a >b) ? a :b ;
五、键盘录入
由于之前的变量与运算符值都是写死的,程序操作不灵活,所以提前学习键盘录入
步骤:
1)创建一个键盘录入对象
Scanner scanner = new Scanner(System.in) ;
2)由于java.lang.* 包不是不用导包的,但是Scanner它是java.util.Scanner
导包: import java.util.Scanner;
3)接收键盘录入的数据(以int类型为例)
int number = sc.nextInt() ; nextXXX() ; //接收字符串的方式String num = sc.nextLine() ;
4)输出数据
六、表达式
1)表达式是程序设计语言的基本组成部分,表示一种求值的规则,是由运算符和操作数组成的符号序列。表达式根据运算符的优先级别和结合性,首先执行指定的计算,再返回某个值。
2)表达式的运算结果的类型就是表达式的类型。表达式一般用来给变量赋值,以及在程序中作为控制条件。在表达式中使用的变量必须已经被初始化。
3)如果把一个表达式赋值给某个变量,同样需要进行类型检查,如果两边类型不同,则需要进行强制或自动类型转换。
4)一个变量或者变量名是最简单的表达式,其值就是该常量或变量的值。
5)在对表达式进行运算时,遵循一定的规则,要按运算符的优先级从高到底进行,同级的运算符则按从左到右的方向进行。
运算符的优先级:
结论://为了使表达式的结构更清楚可以使用( )表明运算次序;
a.赋值运算符的优先级最低,因为赋值运算符要使用表达式的值。 b.关系运算符的优先级比逻辑运算符的优先级高。 c.一元运算符的优先级也比较高。 d.算数运算符要比关系运算符和二元逻辑运算符的优先级要高。
七、程序(流程)控制语句
Java程序控制语句分为3种:选择、循环、跳转;
1)选择语句根据条件表达式计算结果,并使程序可以选择不同的执行路径;
2)循环语句使程序能够重复执行一个或多个语句;
3)跳转语句允许程序以非线性的方式执行;
1.选择结构语句之 if 语句
if语句有三种格式:
1)第一种:
if(条件表达式){ //条件表达式无论简单复杂,它的值都是boolean类型
语句;
}
执行流程:如果表达式成立,那么执行括号中的语句,否则不执行;
适合单个条件的判断;
2)第二种:
if(条件表达式){
语句1;
}else{
语句2;
}
执行流程:判断条件表达式是否成立,成立则执行语句1;否则执行语句2;
3)第三种:
if(条件表达式1){
语句1;
}else if(条件表达式2){
语句2;
}else if(..){
语句3;
}else{
语句n+1;
}
执行流程:先判断条件表达式1是否成立-->成立,则执行语句1
不成立,判断条件表达式2是否成立-->成立,执行语句2
...如果都不成立,最终执行else中的语句
if语句的注意事项:
1)if语句中的大括号,可以省略,但是不建议省略
2)有大括号的地方不能有分号,有分号的地方不能有大括号!
3)这种格式的if语句,适合单个条件的判断
2.选择结构语句之 switch 语句
语句格式:
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break;
case 值3:
语句3;
break;
....
default:
语句n+1;
break;
}
执行流程:
case语句中的值1和表达式中的值比较,如果一致,执行语句1
如果不一致,走case 值2,再进行比较,如果一致,执行语句2
....
如果上述都不一致,执行default中的语句;
格式的解释:
switch:当前是一个选择结构语句,它的作用和if语句是一样
case语句:它后面的值是和表达式进行比较
break:表示结束当前switch语句
default:是和if语句中的else意识时候一样的,如果条件都不成立,执行default中的语句
switch语句中的表达式能跟的类型:
byte,short,int,char
jdk5以后,可以跟枚举jdk7以后,可以String类型
switch语句中的注意事项:
1)case语句的后面只能跟常量(根据具体的需求),不能跟变量! //javascript中的case后面是可以跟变量并且还可以是表达式
2)default语句可以在switch语句中的任何位置,不影响代码执行,如果是在语句中间,那么break最好带上
3)建议把break带上,否则会造成一个现象:case穿透!
4)switch语句的结束条件:
a.语句break语句结束
b.执行默认执行到末尾语句结束
5)case语句的后面是冒号(:),表示和switch语句中的表达式进行比较
6)跳转控制语句: break,continue,retrun
两个例题:看程序写结果
int x = 2 ;
int y = 3 ;
switch(x) {
default:
y++;
break ;
case 3:
y++ ;
case 4:
y++;
}
y的值为多少? //y=4;因为switch语句的结束条件: 1)语句break结束,2)程序默认执行的末尾
int a =2 ;
int b = 3 ;
switch(a) {
default :
b++ ; //4
case 3:
b++ ; //5
case 4:
b++; //6
}
b的值为多少? //b=6;同样因为switch语句的结束条件为遇break结束或程序默认执行的末尾;
case穿透实例:
System.out.println("请你输入月份的值:");
int month = sc.nextInt() ;
//使用switch语句进行判断
switch(month) {
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 ;
case 8:
System.out.println("夏季");
break ;
case 9:
System.out.println("秋季");
break ;
case 10 :
System.out.println("秋季");
break ;
case 11 :
System.out.println("秋季");
break ;
case 12:
System.out.println("冬季");
break ;
default:
System.out.println("没有该月份...");
break ;
}
/**
* 上述代码非常麻烦:优化改进
* 利用的case穿透
*/
switch(month) {
case 1:
case 2:
case 12:
System.out.println("冬季");
break ;
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 ;
default:
System.out.println("没有该月份...");
break ;
}
3.循环结构语句之 for 语句
语句结构:
for(初始化语句;条件语句;步长语句){
循环体语句;}
执行流程:
初始化语句:给当前变量进行赋值,如果满足条件语句,那么执行循环体语句
执行步长语句,对变量进行自增或自减---->在对条件语句进行判断,如果满足条件,再次执行循环体---->步长语句
直到不满足条件为止,循环语句结束...
注意事项:
1)条件语句,不管是一个简单的表达式还是复杂的表达式,都是boolean类型
2)初始化语句和条件表语句后面都要带上分号;
例题:
简单求和:
int sum = 0 ;
for(int x =1 ; x <= 10 ; x ++) {
//sum和变量x进行求和
sum += x ;
}
System.out.println("1-10之间的和是:"+sum);
求偶数和:
//需求:求1~100之间的偶数和
//方式1:
int sum = 0;
for(int x = 1 ; x <=100 ; x ++) {
//可以判断:如果能够被2整除
if(x%2==0) {
sum +=x ;
}
}
System.out.println("1~100之间的偶数和是:"+sum);
//方式2:
int sum= 0 ;
for(int x = 0 ; x <=100 ; x +=2 ) {
sum+=x ;
}
System.out.println("1~100之间的偶数和是:"+sum);
}
输出水仙花数:
public class ShuiXianHuaShu {
public static void main(String[] args) {
//定义一个统计变量
int count=0;
//建立for循环遍历水仙花数
for(int x = 100 ; x < 1000; x ++) {
//获取每个位上的数据
//个
int ge = x %10 ;
//十
int shi = x /10 %10 ;
//百
int bai = x /10 /10 %10 ;
//满足条件就输出
if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
count++; //满足条件统计数自增一次
System.out.println("所有的水仙花数是:"+x);
}
}
System.out.println("水仙花数共有 "+count+"个");
}
}
3.1 forfor 循环嵌套
可以利用 for 循环中嵌套 for 循环输出一些阵列
举例:
输出4行5列的 *
*****
*****
*****
*****
for(int x = 0 ; x <4; x ++) {//控制行数
for(int y = 0 ;y<5; y ++) {//控制列数
System.out.print("*");
}
System.out.println(); //换行
}
输出下列的形状
*
**
***
****
*****
for(int x = 0 ; x < 5 ; x ++) {//行
for(int y = 0 ;y<=x ; y++) {//列
System.out.print("*");
}
System.out.println();
}
99乘法表
for(int x = 1 ; x <= 9 ; x ++) {//行数
for(int y = 1 ; y <=x ; y ++) {//列数
System.out.print(y+"*"+x+"="+(y*x)+"\t");
}
System.out.println();
}
4.循环结构语句之 while 循环
格式:
基本格式:
while(条件表达式){
循环语句体;
}
扩展格式:(优于基本格式)
初始化语句 ;
while(条件表达式){
循环体语句;
步长语句;
}
执行流程:
初始化语句对变量进行赋值,如果满足条件表达式,那么执行循环体语句,执行步长语句---->继续判断是否满足条件--->满足条件,继续执行循环体语句,步长语句---->当满足不足条件为止结束
实例:
while 语句实现水仙花数
//3位数
int x = 100 ;
while(x<1000) {
//获取每个位上的数据
int ge = x%10 ;
int shi = x /10 %10;
int bai = x/10/10 %10;
if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
System.out.println(x);
}
x ++ ;
}
4.1while循环和for循环的区别?
1)如果从内存角度考虑,for循环要优于while循环,for循环语句执行完毕之后,变量会及时被GC垃圾回收器回收掉while循环,它可以去访问循环语句中的变量
2)根据具体需求具体分析,
如果循环次数明确的情况下,应用for循环
如果不知道要循环多少次,应该去使用while循环
5.循环结构语句之 do-while 语句
基本格式
do{
循环体语句
}whiel(判断条件语句) ;
扩展格式:
初始化语句;
do{
循环体语句;
控制体语句;(步长语句)
}while(条件判断语句) ;
do-while和前两者之间最大的区别:循环体语句至少执行一次
实际开发:优先考虑 for循环,其次while循环,最后,do-while
6.跳转控制语句
break:表示中断,结束的意思,结束语句;不能单独使用,一般在switch、for等循环(loop)语句中起跳出当前循环的作用
实例:
for(int i=0;i<10;i++) {
System.out.println("i="+i);
if(i==5) {
System.out.println("已跳出循环");//验证i=5时可以跳出循环
break;
}
}
//实例效果
i=0
i=1
i=2
i=3
i=4
i=5
已跳出循环
continue:继续的意思,跳出当前循环,直接进入一次循环;有时需要强迫一次循环提前结束从而进行下一次循环,
也就是可以继续运行循环,但是要忽略这次循环剩余的循环体的语句,这时要用到continue语句;continue不能单独使用,常用于循环语句
实例:
for(int i=1;i<=20;i++) {
System.out.print(i+"\t");
if(i%5!=0) {
continue; //如果i不能被5整除则跳出这次循环,忽略下面的换行
}
//当i被5整除时,if条件不满足,则不执行continue跳出循环的操作,这时可以执行一次下面的换行操作
System.out.println(" ");
}
//实例效果
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
return:return语句用来明确地从一个方法返回。
也就是说,return语句使程序控制权返回到调用它的方法,因此return也属于跳转语句
在一个方法的任何时间,return语句可以返回到调用它的方法