目录
2.3.3byte,short,char三种比int小的整数可以用范围内的值直接赋值
2.5.2byte,short,char三种比int小的整数,运算时会先自动转换成int
一,Java语法基础
1.1标识符
标识符可以简单的理解成一个名字。
在Java中,我们需要给代码中的很多元素起名,包括类名、方法名、字段名、变量名等等。我们给对应元素起的名称就被称为标识符,一个正确的标识符需要遵循以下规则:
1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,但不能包含 @、%、空格等其它特殊字符
2. 不能以数字开头。如:123name 就是不合法
3. 标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
4. 标识符的命名最好能反映出其作用,做到见名知意。
5. 标识符不能是Java的关键字
1.2关键字
在Java中,有一些单词被赋予了特定的意义,一共有50个关键字。
这50个单词都是全小写,其中有两个保留字:const和goto。
注意,关键字不能被用作标识符!
需要注意的是,除了上述的50个关键字以外,true,false,null也不可以被用作标识符~
1.3注释
几乎所有编程语言都允许程序员在代码中输入注释
因为编译器会忽略注释,所以注释并不会影响程序的运行结果。
注释的真正作用是: 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息, 提高代码的可读性,方便后期的维护与复用。
Java的注释有3种:
1. 单行注释: 注释单行内容.
格式: 每行都以”//”开头.
快捷方式: Ctrl+/ 添加注释,同样的快捷键,再按一次取消注释
2. 多行注释:注释多行内容,虽然叫多行注释,也可注释单行内容.
格式: 以” /* ”开头, 以” * / ”结束.
快捷方式: 可以输入” /* ”之后按回车添加注释
3. 文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.
格式: 以” /** ”开头。 以” * / ”结尾
快捷方式: 输入 “ /** ” 之后按回车添加注释
1.4变量
在JAVA中,我们需要记录一些数据
但这些数据的值是不固定的,总在变,我们可以把这些数据理解为变量。
我们通过三个元素来描述变量:变量类型 变量名以及变量值。
定义变量的两种格式:
格式一:声明变量时并且赋值:int age = 18;
格式二:先声明变量:String tel ; 然后给变量赋值:tel = 119;
注意:
1.变量名必须是一个有效的标识符
2.变量名不可以使用java关键字
3.变量名不能重复
1.5常量
在程序运行过程中,值一直不会改变的量成为常量。
二,数据类型
2.1 基本类型介绍(八种)
变量要保存值,这个值是存在内存中的,所以就需要向内存申请存储空间
java是一个强类型的语言
为了方便内存管理系统根据变量类型更加合理的分配内存空间
会把我们常见的数据,分成不同类型
不同类型分配的内存大小是不同的,这个大小的单位就是字节Byte
拓展:常用的转换关系:
位 bit,来自英文bit,音译为“比特”,表示二进制位。
1 Byte = 8 Bits (1字节 = 8位)
1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB
2.1.1代码实现
package cn.tedu.basic;
/**本类用于完成个人信息输出案例*/
public class TestInfo {
//1.添加程序的入口函数main()
public static void main(String[] args) {
/**1.定义变量的规则:变量的类型 变量名 变量的值*/
/**2.String是字符串类型,用来保存多个字符*/
//2.定义变量
String name = "泡泡";//定义一个String变量用来保存姓名"江江"
int age = 16;//定义一个age变量用来保存年龄16
double salary = 100000.66;//定义一个变量salary用来保存工资
//3.我们可以通过打印语句查看变量的值
System.out.println(name);
System.out.println("java架构师"+name+",今年"+age+"岁,月薪"+salary+",感慨Java是世界上最好的语言!");
}
}
package cn.tedu.basic;
/**本类用于测试基本类型*/
public class TestTypeScope {
//1.创建程序的入口函数
public static void main(String[] args) {
/**1.整形类型:byte short int long*/
/**2.Java给8大基本类型都提供了类型对应的“工具箱”*/
/**3.int类型的工具箱比较特殊,叫做:Integer*/
//2.定义对应类型的变量:格式:类型 名字 = 值 ;
byte byteMin = Byte.MIN_VALUE;
byte byteMax = Byte.MAX_VALUE;
System.out.println("byte类型的最小值为:" + byteMin);
System.out.println("byte类型的最大值为:" + byteMax);
short shortMin = Short.MIN_VALUE;
short shortMax = Short.MAX_VALUE;
System.out.println("short类型的最小值为:" + shortMin);
System.out.println("short类型的最大值为:" + shortMax);
int intMin = Integer.MIN_VALUE;
int intMax = Integer.MAX_VALUE;
System.out.println("int类型的最小值为:" + intMin);
System.out.println("int类型的最大值为:" + intMax);
long longMin = Long.MIN_VALUE;
long longMax = Long.MAX_VALUE;
System.out.println("long类型的最小值为:" + longMin);
System.out.println("long类型的最大值为:" + longMax);
/**4.浮点类型 :float double*/
float floatMin = Float.MIN_VALUE;
float floatMax = Float.MAX_VALUE;
System.out.println("float类型的最小值为:" + floatMin);
System.out.println("float类型的最大值为:" + floatMax);
double doubleMin = Double.MIN_VALUE;
double doubleMax = Double.MAX_VALUE;
System.out.println("double类型的最小值为:"+ doubleMin);
System.out.println("double类型的最大值为:"+ doubleMax);
/**5.boolean布尔类型只有两个值true与false
* 虽然true和false不是关键字,但是也不可以用作标识符*/
boolean b1 = true;
boolean b2 = false;
/**6.测试char 字符类型
* 字符型的数据需要使用单引号 ' ' 来包裹
* char类型可以存数字,但是会从ASCII码表查出这个数字对应的字符来打印
* 128~65535这些数字,也可以保存,但是eclispe一般显示为?*/
char c1 = 'a';//字符型可以保存一个字母
char c2 = '中';//字符型还可以保存一个汉字
char c3 = '7';//字符型可以保存一个字符7
char c4 = 97;//字符型可以保存数字,但是会查ASCII,打印的是字符a
char c5 = 55;//字符型可以保存数字,但是会查ASCII,打印的是字符7
char c6 = 199;
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
}
}
2.1.2练习
需求:求出指定半径圆的面积
公式:圆的面积:π * r * r
package cn.tedu.basic;
import java.util.Scanner;
/**本类用于求圆形的面积*/
public class TestCircleArea {
//1.创建程序的入口函数main()
public static void main(String[] args) {
/**等号右边的值赋值给等号左边的变量来保存*/
//1.提示用户输入圆的半径:
System.out.println("请您输入要求的半径值:");
/**变量的第二种定义方式:先定义,再赋值*/
//2.1定义一个变量用来保存圆的半径
//double r = 5.5;
double r ;
//2.2接收用户在键盘上输入的数据,并把这个数据交给r保存
//开启扫描(发出一个系统指令,准备接收控制台输入的数据)
//nextDouble()控制用户只能输入double类型的数据,否则报错
r = new Scanner(System.in).nextDouble();
//根据半径值求出圆的面积
double circleArea = 3.14 * r * r;
//打印计算的结果
System.out.println("圆的面积是:"+circleArea);
}
}
2.1.3变量交换
需求: 接收用户输入的两个值:假设a=1,b=2,并将这两个变量的值进行互换
package cn.tedu.basic;
import java.util.Scanner;
/**本类用于练习值交换案例*/
public class TestValueExchange {
//1.创建程序的入口函数main
public static void main(String[] args) {
//2.提示并接受用户在控制台输入的两个整数
System.out.println("请输入要交换的第一个整数:");
int a = new Scanner(System.in).nextInt();
System.out.println("请输入要交换的第二个整数:");
int b = new Scanner(System.in).nextInt();
System.out.println("a的值:"+a);
System.out.println("b的值:"+b);
//3.交换 a b 这两个变量保存的值
int t;//定义一个变量用来辅助值交换
t = a;//把a的值交给t来保存
a = b;//把b的值交给a来保存
b = t;//把t的值交给b来保存
System.out.println("交换后,a的值:"+a);
System.out.println("交换后,b的值:"+b);
}
}
2.2引用类型
除了基本类型以外的所有类型都是引用类型
目前我们只遇到了String字符串类型,需要用双引号包裹
引用类型是一个对象类型,值是什么呢?
它的值是指向内存空间的引用,就是地址,所指向的内存中保存着变量所表示的一个值或一组值。如:类,接口,数组.
2.3基本类型的字面值(5条)
2.3.1整数类型的字面值类型是int类型
也就是说,我们只要写一个整数,就被认为是int类型
- int x = 99999;
- //byte y = 300;//错,300是int类型,byte存不下
- //int z = 999999999999;//错,虽然是int类型,但是超出范围 long h = 999999999999L;
- //如果要定义long类型需要加后缀L
2.3.2浮点数类型的字面值类型是double类型
也就是说,我们只要写一个小数,就被认为是double类型
- double d = 3.14;
- //float f = 3.14;//错,3.14认为自己是double类型
- float f = 3.14F;//如果要定义float类型需要加后缀F
- double d2 = 3D;//如果要定义的小数是整数,最好加D方便阅读
2.3.3byte,short,char三种比int小的整数可以用范围内的值直接赋值
- byte b1=127;//对,
- byte b2=128;//错,超出byte的范围
- char c1=97;//对,对应的是码表中的'a'
- char c2 =69999;//错,超出char的范围
2.3.4字面值后缀L D F
- long x =99999999999L;//字面值是int类型,需转成long类型的数据,加字面值后缀L即可
- float b = 3.0F;//3.0字面值是double类型,加后缀F会变成float类型
- double d = 3D;//3字面值是int类型,加后缀D,会变成double类型
2.3.5进制前缀
0b - 标识这是2进制 ,如:0b0101
- //10进制,底数为10:10^2 10^1 10^0 =100+0+0=100
- System.out.println(100);//默认10进制,打印100
- //2进制,底数为2:2^2 2^1 2^0 =4+0+0=4
- System.out.println(0b100);//2进制,打印4
- //8进制,底数为8:8^2 8^1 8^0 =64+0+0=64
- System.out.println(0100);//8进制,打印64
- //16进制,底数为16:16^2 16^1 16^0 =256+0+0=256
- System.out.println(0x100);//16进制,打印256
2.4基本类型的转换
箭头开始的地方是小类型,箭头指向的地方是大类型
我们此处所指的"大"和"小",指的是对应类型的取值范围,不是字节数哦
2.4.1小到大(隐式转换)
byte m = 120;
2.4.2大到小(显式转换)
容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度
例如:int i =128; byte b = (byte)i; //打印的结果是-128
因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入
例如:float f = 32.7f; int a2 =(int) f; //打印的结果是32
不能对boolean类型进行类型转换。
2.4.3口诀
小到大,直接转 大到小,强制转 浮变整,小数没
低 ------------------------------------> 高
byte,short,char→ int→ long→float→double
2.5运算规则(5条)
2.5.1计算结果的数据类型,与最大数据类型一致
System.out.println(3/2);//1,int/int,得到的结果类型还是int
2.5.2byte,short,char三种比int小的整数,运算时会先自动转换成int
byte a = 1;
2.5.3整数运算溢出
整数运算,类似于一个钟表,转到最大时,再转会回到最小。
计算:光速运行一年的长度是多少米?3亿m/s
//溢出的现象:
2.5.4浮点数运算不精确
1-0.8 (这是一个现象,后续会学习解决方案)
2.6拓展 标识符命名风格
1.【强制】标识符命名均不能以数字开头,而且下划线或美元符号开始,也不能以下划线或美元符号结束
错误案例:1name / _ name / name_ / $ name / name $
2.【强制】代码中的命名严禁使用拼音与英文混合的方式,更不允许直接使用中文的方式。
说明:正确的英文拼写和语法可以让阅读者易于理解,避免歧义。
注意,即使纯拼音命名方式也要避免采用。
正确案例:alibaba / taobao / youku / hangzhou 等国际通用的名称,可视同英文。
错误案例:DaZheModule [打折模块] / getPingfenByName() [评分]
3.【强制】类名使用 UpperCamelCase 风格,即第一个单词的首字母就要大写
三,运算符
1.1概述
运算符 用于连接 表达式 的 操作数,并对操作数执行运算。
例如,表达式num1+num2,其操作数是num1和num2,运算符是”+”。
在java语言中,运算符可分为5种类型:
算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。
根据操作数的不同,运算符又分为单目运算符、双目运算符和三目运算符。
单目运算符只有一个操作数,双目运算符有两个操作数,三目运算符则有三个操作数。
位运算符涉及到二进制位的运算,在java 程序中运用不是很多。
1.2运算符速查表
1.3代码测试
1.3.1测试自增自减
package cn.tedu.basic;
/**本类用于测试取余运算符*/
public class TestOperator {
//0.创建程序的入口函数main
public static void main(String[] args) {
//1.测试除法与取余数
System.out.println(25 / 10);//2
System.out.println(25 % 10);//5
//2.练习1:获取一个两位数59的十位与个位
int x = 59;
System.out.println(x/10);//打印十位,5
System.out.println(x%10);//打印个位,9
//3.练习2:获取一个三位数159的百位、十位与个位
int y = 159;
System.out.println(y / 100);//打印百位
System.out.println(y / 10 % 10);//打印十位
System.out.println(y % 10);//打印个位
//4.测试自增自减运算符
/** 前缀式:符号在前:++a --a ,先改变变量本身的值,再使用,比如打印
* 后缀式:符号在后: a++ a--,先使用,再改变变量本身的值
* ++:相当于给变量本身的值+1
* --: 相当于给变量本身的值-1*/
System.out.println("我是一个无情的分界线");
/**普通的四则运算并不会改变变量本身的值
* 自增自减运算符才会改变变量本身的值*/
int z = 1;
System.out.println(z+4);//5
System.out.println(z);//1
int a = 1;
System.out.println(++a);//2
System.out.println(a);//2
int b = 1;
System.out.println(b++);//1
System.out.println(b);//2
int c = 1;
System.out.println(--c);//0,符号在前,先自减,再打印
System.out.println(c);//0,上面已经自减过了
int d = 1;
System.out.println(d--);//1,符号在后,先打印,再自减
System.out.println(d);//0,打印过后,自减成0
//之前的代码会对后面的代码产生影响,c的值是0
System.out.println(c);//0
System.out.println(--c-c-c--);//1,-1-(-1)-(-1)=1
System.out.println(c);//-2,经历了两次自减,所以0-2=-2
}
}
1.3.2测试逻辑运算符
package cn.tedu.basic;
/**本类用于测试逻辑运算符*/
public class TestOperator2 {
public static void main(String[] args) {
/**与:全真才真*/
System.out.println("测试单与:");
System.out.println(true & true);
System.out.println(true & false);
System.out.println(false & true);
System.out.println(false & false);
System.out.println("测试双与:");
System.out.println(true && true);
System.out.println(true && false);
System.out.println(false && true);
System.out.println(false && false);
/**或:全假才假*/
System.out.println("测试单或:");
System.out.println(true | true);
System.out.println(true | false);
System.out.println(false | true);
System.out.println(false | false);
System.out.println("测试双或:");
System.out.println(true || true);
System.out.println(true || false);
System.out.println(false || true);
System.out.println(false || false);
}
}
1.3.3求两数的最大值
package cn.tedu.basic;
import java.util.Scanner;
/**需求:接收用户输入的两个整数,并比较输出这两个数的最大值*/
public class TestMaxNum {
public static void main(String[] args) {
//1.提示用户输入
System.out.println("请输入您要比较的第一个整数:");
//2.接收用户输入的整数,并把这个值交给变量a来保存
int a = new Scanner(System.in).nextInt();
System.out.println("请输入您要比较的第二个整数:");
int b = new Scanner(System.in).nextInt();
//3.比较接收两个数,使用三元运算符
/**1 ? 2 : 3
* 1是表达式,若1的结果为true,结果取2位置,若1的结果为false,结果取3位置
* */
//4.定义变量max来保存比较的最大值
int max = a > b ? a : b;
//5.打印最大值
System.out.println("两个数的最大值是:"+max);
/**思考题:如何判断3个数的最大值? int max = a>b?(a>c?a:c):(b>c?b:c);*/
}
}
1.3.4求平年闰年
需求:接收用户输入的年份,判断是平年还是闰年
package cn.tedu.basic;
import java.util.Scanner;
/**
* 需求:接收用户输入的年份,判断是平年还是闰年
* 如果年份是闰年,需要满足下面两个条件之一:
* 条件1:能被4整除,并且不能被100整除
* 条件2:能被400整除
* */
public class Test3_Year {
public static void main(String[] args) {
//1.提示并接收用户输入的年份
System.out.println("请输入您要判断的年份:");
int year = new Scanner(System.in).nextInt();
//2.定义一个变量用来保存结果
String result = "平年";//默认值是平年,假设每年都是平年
//3.判断用户输入的年份是否满足闰年的条件
/**解决方案1*/
/**条件1:能被4整除,并且不能被100整除*/
// if(year % 4 == 0) {//能被4整除
// if(year %100 != 0) {//不能被100整除
// result = "闰年";//符合闰年的条件1,修改结果为闰年
// }
// }
// /**条件2:能被400整除*/
// if(year % 400 == 0) {//能被400整除
// result = "闰年";//符合闰年的条件2,修改结果为闰年
// }
/**解决方案2*/
/**判断结构 if(判断条件){满足判断条件以后执行的代码} */
//if(条件1 || 条件2){是闰年 }
//if((小条件1 && 小条件2) || 条件2){ 是闰年 }
//if((能被4整除 && 不能被100整除) || 能被400整除){ 是闰年 }
if((year % 4 == 0 && year %100 != 0) || year % 400 == 0){
result = "闰年";//符合闰年的条件,修改结果为闰年
}
System.out.println(year+"年是"+result);
}
}
1.4总结1:算术运算符之自增自减运算符
a是操作数,++是自增运算符,- -是自减运算符,自增和自减运算符即可以放在变量的前面,也可以放在变量的后面,例如:a++、++a、a- -、- -a等。
自增(++):将变量的值加1
分前缀式(如++a)和后缀式(如a++)。前缀式是先加1再使用;后缀式是先使用再加1。
自减(- -):将变量的值减1
分前缀式(如- -a)和后缀式(如a- -)。前缀式是先减1再使用;后缀式是先使用再减1。
1.5总结2:逻辑运算符
逻辑运算符连接两个关系表达式或布尔变量,用于解决多个关系表达式的组合判断问题
注意逻辑运算符返回的运算结果为布尔类型
通常,我们用0表示false,用1表示true
与:表示并且的关系
&单与: 1 & 2 ,结果想要是true,要求1和2都必须是true
&&双与(短路与):1 && 2 ,当1是false时,2会被短路,提高程序的效率
或:表示或者的关系
|单或: 1 | 2,结果想要是true,要求1和2只要有一个为true就可以
||双或(短路或):1 || 2,当1是true时,2会被短路,提高程序效率
1.6总结3:优先级控制
当一个表达式包含多个运算符时,就需要考虑运算符的优先级,优先级高的运算符先参与运算,优先级低的运算符后参与运算。在实际的开发中,不需要特别去记忆运算符的优先级别,也不要刻意的使用运算符的优先级别,对于不清楚优先级的地方使用小括号辅助进行优先级管理。