JavaSE基本语法上

目录

Java-基本语法上

关键字和保留字

标识符(Identifier)

变量

运算符

参考文献

---

Java-基本语法上

关键字和保留字

关键字(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

基本数据类型之间的运算规则

• 自动类型转换：容量小的类型自动转换为容量大的数据类型
• 强制类型转换

package com.atguigu.java;
/*
基本数据类型之间的运算规则：

前提：这里只讨论7种基本数据类型变量间的运算

1.自动类型提升:
	当容量小的数据类型的变量与容量大的数据类型的变量作运算时，结果自动提升为容量大的数据类型
	byte,char,short --> int --> long --> float --> double
	特别的：当 byte,char,short这三种变量的数据做运算时，结果为int型
	
2.强制类型转换:自动类型提升的逆运算
	需要使用强转符 :()
	注意点:强制类型转换,可能导致精度损失


说明：此时的容量大小指的是,表示数的范围和大小 例 容量(float) > 容量(long)
 */
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类型的使用

package com.atguigu.java;
/*
String类型变量的使用
1.String属于引用数据类型,意为字符串
2.声明String类型变量时,使用一对""
3.String可以和8种基本数据类型变量做运算,且只能是连接"+"运算
4.运算结果仍然是String类型
 */
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

String类型的练习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*
*	*

String类型的练习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);
		}	
	}

//结果
i=10i1=11
i=12i1=12
i=20i2=19
i=18i2=18

赋值运算符的使用

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);
		
		//开发中 如果希望变量实现自增2的操作 int num = 10;
		//一:num = num + 2;
		//二:num += 2;推荐
		
		//开发中 如果希望变量实现自增1的操作 int num = 10;
		//一:num = num + 2;
		//二:num += 2;推荐中
		//三:num++;
		
	}
}
//结果
12
14

赋值运算符的练习题

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
	}
}

比较运算符

package com.atguigu.java;
/*
运算符之三:比较运算符
== != > < >= <= instanceof

结论:
1.比较运算符的结果是boolean类型
2.区分 == 和 =
 */
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
		
		
	}
}

逻辑运算符

package com.atguigu.java;
/*
运算符之四：逻辑运算符
& && | || ! ^

说明:
1.逻辑运算符操作的都是boolean类型的变量
 */
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
	}
}

位运算符(有点麻烦 不记了)

三元运算符

package com.atguigu.java;
/*
运算符之六：三元运算符
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
}
 */
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零基础教程-java入门必备_宋红康

https://www.bilibili.com/video/BV1Kb411W75N?