JavaSE基本语法上
关键字和保留字
关键字(keyword)的定义和特点
- 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
- 特点：关键字中所有字母都为小写
Java保留字：
现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 goto 、const。
标识符(Identifier)
标识符
- 定义：Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧：凡是自己可以起名字的地方都叫标识符。
命名规则：
(如果不遵守以下的规则，编译不通过！需要大家严格遵守)
- 由26个英文字母大小写，0-9 ，_或 $ 组成
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
Java中的名称命名规范：
(如果不遵守以下的规范，编译可以通过！建议大家遵守)
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz 大驼峰式
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个 单词首字母大写：xxxYyyZzz 小驼峰式
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注意一：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。多积累，多看，多模仿。
注意二：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用
变量
变量的概念：
- 内存中的一个存储区域
- 该区域的数据可以在同一类型范围内不断变化
- 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值。
变量的作用：
- 用于在内存中保存数据
使用变量注意：
- Java中每个变量必须先声明，后使用 (强类型语言：需要明确指出变量的类型)
- 使用变量名来访问这块区域的数据
- 变量的作用域：其定义所在的一对{ }内
- 变量只有在其作用域内才有效
- 同一个作用域内，不能定义重名的变量
class VariableTest{
public static void main(String[] args){
//java定义变量的格式 ： 数据类型 变量名 = 变量值;
int mgAge = 12;
System.out.println(mgAge);
int myNumber;
myNumber = 1601012;
System.out.println(myNumber);
}
}
变量的类型：
按数据类型：对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间
按声明的位置的不同：(在后面会讲到)
- 在方法体外，类体内声明的变量称为成员变量
- 在方法体内部声明的变量称为局部变量
各种基本数据类型的使用
package com.atguigu.java;
public class VariableTest1 {
public static void main(String[] args) {
//1.整型 byte(单字节) short(双字节) int(四字节) long(八字节)
//byte 范围 -128 ---- 127
byte b1 = 12;
byte b2 = -128;
//b2 = 128; 编译错误
System.out.println(b1);
System.out.println(b2);
//声明long型变量必须以"l"或"L"结尾
//通常定义整型变量时 使用int即可
short s1 = 128;
int i1 = 1234;
long l1 = 1234656l;
System.out.println(l1);
//2.浮点型 float(四字节) double(八字节)
//浮点型：表示带有小数点的数值
//float表示数值的范围要比long的范围还大
double d1 = 123.3;
System.out.println(d1);
//定义float类型时 变量必须以"f"或"F"结尾
float f1 = 123.2f;
System.out.println(f1);
//通常，定义浮点型变量时 优先使用double
//3.字符型 (双字节)
//定义char型变量时 通常使用一对'',内部只能写一个字符
char c1 = 'a';
//c1 = 'ab'; 编译不通过
System.out.println(c1);
//表示方式 1.声明一个字符 2.转义字符 3.直接使用Unicode来表示字符型常量
char c5 = '\n';
c5 = '\t';
System.out.print("hello" + c5);
System.out.println("World");
//4.布尔型 boolean
//只能取两个值之一：ture or false
//常常在条件判断,循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if(isMarried) {
System.out.println("不能参加单身party");
}else {
System.out.println("多找找对象！");
}
}
}
/*
//结果
12
-128
1234656
123.3
123.2
a
hello World
true
不能参加单身party
*/
基本数据类型之间的运算规则
- 自动类型转换：容量小的类型自动转换为容量大的数据类型
- 强制类型转换
基本数据类型之间的运算规则：
前提：这里只讨论7种基本数据类型变量间的运算
1.自动类型提升:
当容量小的数据类型的变量与容量大的数据类型的变量作运算时，结果自动提升为容量大的数据类型
byte,char,short --> int --> long --> float --> double
特别的：当 byte,char,short这三种变量的数据做运算时，结果为int型
2.强制类型转换:自动类型提升的逆运算
需要使用强转符 :()
注意点:强制类型转换,可能导致精度损失
说明：此时的容量大小指的是,表示数的范围和大小 例 容量(float) > 容量(long)
package com.atguigu.java;
public class VariableTest2 {
public static void main(String[] args) {
//自动类型提升
byte b1 = 2;
int i1 = 12;
//byte b2 = b1 + i1 编译不通过
int i2 = b1 + i1;
System.out.println(i2);
float f1 = b1 + i1;
System.out.println(f1);
short s1 = 123;
double d1 = s1;
System.out.println(d1);
//********************
char c1 = 'a';
int i3 = 10;
int i4 = c1 + i3;
System.out.println(i4);
short s2 = 10;
char c2 = 'b';
int i5 = s2 + c2;
byte b2 = 10;
int i6 = b2 + c2;
//强制类型转换
double d11 = 12.3;
int i11 = (int)d11;//截断操作
System.out.println(i11);//存在精度损失
//没有精度损失
long l11 = 123l;
short s22 = (short)l11;
System.out.println(s22);
}
}
/*
#结果
14
14.0
123.0
107
12
123
*/
两种特殊情况
package com.atguigu.java;
public class VariableTest3 {
public static void main(String[] args) {
//1.编码情况 long型后丢失 'l'或者'L'
//这种情况下 系统自动默认此变量为int型 ,若超出int型的范围，则报错
long l = 123321;
System.out.println(l);
//long l1 = 1314121323546468; 编译错误 过大的整数
//********
//float型后丢失'f' 默认为double型 此时使用float接受属于强制类型转换,需要使用强转符
//float f1 = 123;
//2.编码情况 对常量
//整型常量：默认类型为int型
//浮点型常量：默认类型为double型
byte b1 = 12;
int i1 = b1 + 10;
System.out.println(i1);
float f2 = 123.2f;
double d1 = f2 + 13;
System.out.println(d1);
};
}
/*
#结果
123321
22
136.1999969482422
*/
练习
package com.atguigu.java;
public class VariableTest4 {
public static void main(String[] args) {
//判断是否能通过编译
short s = 5;
s = s - 2; //判断：no 整数常量默认为int型 short与int做运算,结果为int型
byte b = 3;
b = b + 4; //判断：no 整数常量默认为int型 byte与int做运算,结果为int型
b = (byte)(b+4); //判断：yes 整数常量默认为int型 byte与int做运算,结果为int型。
//使用强转符 (byte) 可以用byte型接受
char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：yes 自动类型提升,double可以接受char int float型运算的结果
byte b = 5;
short s = 3;
short t = s + b; //判断：no byte与short做运算,结果为int型
}
}
String类型的使用
注意：String 不属于基本数据类型
String类型变量的使用
1.String属于引用数据类型,意为字符串
2.声明String类型变量时,使用一对""
3.String可以和8种基本数据类型变量做运算,且只能是连接"+"运算
4.运算结果仍然是String类型
package com.atguigu.java;
public class StringTest1 {
public static void main(String[] args) {
String s1 = "Hello world";
System.out.println(s1);
String s2 = "a";
String s3 = "";
int number = 1001;
String numberStr = "学号：";
String info = numberStr + number;
System.out.println(info);
boolean b1 = true;
String info1 = info + b1;
System.out.println(info1);
}
}
/*
//结果
Hello world
学号：1001
学号：1001true
*/
练习1
package com.atguigu.java;
//关于String类型 的练习题
public class StringExer1 {
public static void main(String[] args) {
//练习1
char c = 'a';//97
int num = 10;
String str = "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);//hello10a
//练习2
//控制台输出这种格式 ： * *
System.out.println("* *");
System.out.println('*' + '\t' + '*');
System.out.println('*' + "\t" + '*');
System.out.println('*' + '\t' + "*");
System.out.println('*' + ('\t' + "*"));
//注：+ 两端都不是String类型,为加法运算
// + 两端若存在一着者 为String类型 ,为拼接运算
// char与char 类型的加法运算 结果为 int型(自动类型提升)
}
}
/*
//结果
107hello
ahello10
a10hello
107hello
hello10a
* *
93
* *
51*
* *
*/
练习2
package com.atguigu.java;
public class StringExer2 {
public static void main(String[] args) {
String str1 = 4; //判断对错：no 字符串必须用双引号标识
String str2 = 3.5f + “”; //判断str2对错：yes "3.5"
System.out.println(str2); //输出：”3.5”
System.out .println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1
}
}
变量之进制(了解内容)
- 所有数字在计算机底层都以二进制形式存在
- 对于整数，有四种表示方式：二进制 八进制 十进制 十六进制
运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符的使用
运算符之一：算术运算符
+ - + - * / % ++(前) (后)++ --(前) (后)-- +(拼接)
package com.atguigu.java;
public class AriTest1 {
public static void main(String[] args) {
// 除号:/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2 ;//int运算结果为int 2
System.out.println(result1);
double result2 = (double)num1 / num2;//double与 int 运算结果为double 2.4
System.out.println(result2);
// %:取余运算
//结果的符号与被模数的符号相同
//开发中，经常使用%来判断能否被除尽
System.out.println("12 % 5 = "+ (12%5));
System.out.println("-12 % 5 = "+ (-12%5));
System.out.println("12 % -5 = "+ (12%-5));
System.out.println("-12 % -5 = "+ (-12%-5));
//运算顺序从右往左
//++(前): b = ++a; 先自增一,后运算
//(后)++: b = a++; 先运算,后自增一
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = "+ b2);
//注意点:
short s1 = 10;
//s1 = s1 + 1;//编译错误
//s1 = (short)(s1+1);//编译正确
s1++;//自增一 不会改变本身变量的数据类型
System.out.println(s1);
}
}
/*
//结果
2
2.4
12 % 5 = 2
-12 % 5 = -2
12 % -5 = 2
-12 % -5 = -2
a1 = 11,b1 = 11
a2 = 11,b2 = 10
11
*/
自增自减的练习题
看看就行，看不懂就算了
package com.atguigu.java;
public class AriRxer1 {
public static void main(String[] args) {
int i1 = 10;
int i2 = 20;
int i = i1++;//i = 10 i1 = 11
System.out.print("i="+i);
System.out.println("i1="+i1);
i = ++i1;//i1 = 12 i = 12
System.out.print("i="+i);
System.out.println("i1="+i1);
i = i2--;//i = 20 i2 = 19
System.out.print("i="+i);
System.out.println("i2="+i2);
i = --i2;//i2 = 18 i = 18
System.out.print("i="+i);
System.out.println("i2="+i2);
}
}
赋值运算符的使用
运算符之二:赋值运算符
= += -= *= /= %=
package com.atguigu.java;
public class SetVauleTest1 {
public static void main(String[] args) {
//连续赋值
int i1,j1;
i1 = j1 = 10;
int i2 = 10,j2 = 10;
//扩展运算符
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12
short s1 = 12;
s1 += 2;//不会改变变量本身的数据类型
System.out.println(s1);//14
//开发中 如果希望变量实现自增2的操作 int num = 10;
//一:num = num + 2;
//二:num += 2;推荐
//开发中 如果希望变量实现自增1的操作 int num = 10;
//一:num = num + 2;
//二:num += 2;推荐中
//三:num++;
}
}
练习题
package com.atguigu.java;
public class SetValueExer1 {
public static void main(String[] args) {
short s = 3;
//s = s+2; 编译不通过
s += 2; //正确
int i = 1;
i *= 0.1;//i = i * 0.1
System.out.println(i);//0 不改变数据类型 int(0.1) = 0
i++;
System.out.println(i);//1
int m = 2;
int n = 3;
n *= m++;// n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6
int n1 = 10;
n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1) n1 = 10 + 10 + 12
System.out.println(n1);//32
}
}
比较运算符
运算符之三:比较运算符
== != > < >= <= instanceof
结论:
1.比较运算符的结果是boolean类型
2.区分 == 和 =
package com.atguigu.java;
public class CompareTest {
public static void main(String[] args) {
int i = 10,j = 20;
System.out.println(i == j);//false
System.out.println(i = j);// 20
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2);//true
System.out.println(b1 = b2);//false
}
}
逻辑运算符
运算符之四：逻辑运算符
& && | || ! ^
说明:
逻辑运算符操作的都是boolean类型的变量
package com.atguigu.java;
public class LogicTest {
public static void main(String[] args) {
//区分 & 与 &&
//相同点1： &与 && 运算结果相同
//相同点2：当符号左边是true时,二者都会执行符号右边的操作
//不同点：当符号左边是false时,&会继续执行符号右边的操作,&&不在执行符号右边的操作
// 开发中推荐使用 && ||
boolean b1 = false;
int num1 = 10;
if(b1 & (num1++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在南京
System.out.println("num1 = " + num1);//num1 = 11
boolean b2 = false;
int num2 = 10;
if(b2 && (num2++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在南京
System.out.println("num2 = " + num2);//num2 = 10
//区分 | 与 ||
//相同点1： | 与 || 运算结果相同
//相同点2：当符号左边是false时,二者都会执行符号右边的操作
//不同点：当符号左边是true时,|会继续执行符号右边的操作,||不在执行符号右边的操作
boolean b3 = true;
int num3 = 10;
if(b3 | (num3++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在北京
System.out.println("num3 = " + num3);//num3 = 11
boolean b4 = true;
int num4 = 10;
if(b4 || (num4++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在北京
System.out.println("num4 = " + num4);//num4 = 10
}
}
练习
package com.atguigu.java;
public class LogicExer1 {
public static void main(String[] args) {
int x = 1;
int y=1;
if(x++==2 & ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);//x=2 y=2
//解析 1.x++==2 先运算 (x=1) ==2 false 后自增 x = 2
//2. &运算 前者为false 需要继续看后者
//3.++y==2 先 自增 y = 2 后运算(y=2)==2 true
//4.条件为false 不执行if语句 所以 x=2 y=2
int x = 1,y = 1;
if(x++==2 && ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);//x=2 y=1
//解析1.x++==2 先运算 (x=1) ==2 false 后自增 x = 2
//2. &&运算 前者为false 不需要看后者 此时y=1
//3.条件为false 不执行if语句 所以 x=2 y=1
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=2
//解析:1.x++==1 先运算(x=1)==1 true 后自增 x=2
//2.|运算 前者为true 还需要执行后者
//3.++y==1 先自增 y=2 在运算(y=2)==1 false
//4.条件为true 执行if语句 所以 x=7,y=2
int x = 1,y = 1;
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=1
解析:1.x++==1 先运算(x=1)==1 true 后自增 x=2
//2.||运算 前者为true 不需要执行后者 此时y=1
//3.条件为true 执行if语句 所以 x=7,y=1
}
}
package com.atguigu.java;
public class LogicExer2 {
public static void main(String[] args) {
boolean x =true;
boolean y =false;
short z=42;
if((z++==42)&&(y=true)) z++;
if((x = false) || (++z==45)) z++;
System. out.println("z="+z);//z=46
//解析
//1. 赋值 x,y,z
//2 if((z++==42)&&(y=true)) z++;
//2.1 (z++==42) 先运算 (z=42)==42 true 后自增 z = 43
//2.2 &&运算 前者为 true 还需要执行后者
//2.3 (y=true) 将true赋值给y 并判断y是否等于true 结果为true
//2.4条件整体为true 执行 z++; 结果为z = 44
//3 f((x = false) || (++z==45)) z++;
//3.1 (x = false) 结果为false
//3.2 ||运算 前者为false 还需要执行后者
//3.3 (++z==45) 先自增z=45 后运算(z=45)==45 结果为true
//3.4 条件整体为true 执行 z++; 结果为z = 46
//4 输出结果 z=46
}
}
位运算符(麻烦 没做笔记)
看源码时会有一些位运算符的使用
三元运算符
运算符之六：三元运算符
1.结构 : (条件表达式)?表达式1:表达式2
2.说明
2.1 条件表达式的结果为boolean类型
2.2 根据条件表达式真或假,决定执行表达式1,还是表达式2
如果表达式为true,则执行表达式1
如果表达式为false,则执行表达式2
2.3.表达式1 和 表达式2 要求是一致的
2.4.三元运算符是可以相互嵌套的
3.凡是可以使用三元运算符的地方,都可以改写为if-else.反之,不成立
4.如果程序即可以使用三元运算符,又可以使用if-else结构.那么优先使用三元运算符。原件：简单 高效
if(条件表达式){
表达式1
}else{
表达式2
}
package com.atguigu.java;
public class SanYuanTest {
public static void main(String[] args) {
//获取两个整数中较大值
int m = 25,n = 12;
int max = (m > n)? m:n;
System.out.println(max);//25
String maxStr = (m > n)?"m大":((m == n)?"m等于n":"m小");
System.out.println(maxStr);// m大
//获取三个数的最大值
int n1 = 12,n2 = 30,n3 = -43;
int max1 = (n1 > n2)?n1:n2;
int max2 = (max1 > n3)?max1:n3;
System.out.println(max2);//30
//不建议这样写
int max3 = (n1 > n2)?((n1 > n3)?n1:n3):((n2>n3)?n2:n3);
System.out.println(max3);//30
}
}
参考文献
链接: B站尚硅谷宋红康Java.
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
