Java 零基础 02（java基本语法结构一）

最新推荐文章于 2023-05-31 13:25:57 发布

Wuguan_7

最新推荐文章于 2023-05-31 13:25:57 发布

阅读量192

点赞数 2

分类专栏： java基础知识

本文链接：https://blog.csdn.net/Wuguan_7/article/details/118310481

版权

java基础知识专栏收录该内容

4 篇文章 0 订阅

订阅专栏

关键字

关键字---在java中具有特殊功能的单词

53个关键字，全部是小写

const、goto（新的jdk版本中算作关键字）

标识符

1.概念：标识符---在java中可以自定义的名称

2.组成范围：
2.1各国常见文字

2.2.数字（0-9）

2.3.特殊符号（_、$(慎用——内部类使用)）

3.命名规则：在组成范围内的内容且遵守命名规则的是符合java语法的标识符（合法）
3.1不能出现关键字

3.2不能以数字开头

4.驼峰命名法（是在标识符合法的基础上）

4.1类名/接口名---XxxYyyZzz

4.2方法名/变量名---xxxYyyZzz

4.3包名（包是用来区分同名类）

4.3.1单级---xxx cn

4.3.1多级---xxx.yyy.zzz tedu.cn.day01

5.见名知意

注释

注释——用于解释说明的文字（不参与程序的执行）

单行注释---//注释内容

多行注释---/*注释内容*/（可以嵌套单行注释不能嵌套多行注释）

文档注释---/**注释内容*/（可以通过javadoc命令生成解释说明的文档）

常量

1.概念：程序运行过程中不发生改变的值

2.分类：
2.1整数常量 1000 1871

2.2小数常量 1.1 0.345

2.3字符串常量 "12" "askjhg"

2.4字符常量 '3' 'd'

2.5布尔常量 true false

2.6空常量 null

2.7字面值常量

2.8自定义常量

3.整数表示形式

3.1二进制：由0和1表示的数据以0b开头的数据就是二进制数据 0b1000

3.2八进制：由0~7表示数据以0开头的数据就是八进制数据 0x1010

3.3十进制（默认）：由0~9表示数据

3.4十六进制：由0~9 ,a~f(不区分大小写)表示数据以0x开头的数据是十六进制数据

进制转换

1.其他进制转换为十进制：项乘以基数为底的权次幂之和

2.十进制转换为其他进制：除基取余，直到商为0，余数翻转

3.任意进制之间的转换：X进制转换为十进制，再将十进制转换为对应的Y进制

有符号的数

计算机上所有的数据在底层都是以二进制数据的补码形式来表示

1.原码：符号位表示正负，零正一负

2.反码：正数的原码和反码一致，负数的反码是在原码的基础上，符号位不变，数值位0变1，1变0

3.补码：正数的原码和补码一致，负数的补码是在反码的基础上，符号位不变，数值位末尾加一

注意：绝大部分的二进制小数是无限位数

变量

1.概念：在程序运行过程中可以改变的值，可以用来存储单个数据的容器

2.定义：数据类型变量名=初始化值

3.基本数据类型（4类8种）占用空间（字节）范围

3.1byte 字节型 1 -128~127（-2`7~2`7-1）

3.2short 短整型 2 -32768~32767(-2`15~2`15-1)

3.3int 整型 4 -2`31~2`31-1

3.4long 长整型 8 -2`63~2`63-1 整数型

3.5float 单精度 4 -e`38~e38(e是10)

3.6double 双精度 8 -e`308~e`308 浮点型

3.7true、false 布尔型 1

3.8Char 字符型 2 0~65535

4.码表——文字转成底层数字---编码文字转成底层数字的规则

4.1ASCII（阿斯克码表占用一个字节）

4.2ISO8859-1（西欧码表占用一个字节）

4.3BIG5（繁体中文--占用2个字节）

4.4GB2312（简体中文--占用2个字节）

4.5GBK（国标码占用2个字节）

4.6Unicode（编码体系 UTF-8（占用3个字节）、UTF-16（占用2个字节）、UTF-32等等）

4.7注意

4.7.1所有的完整码表默认兼容西欧码表

4.7.2char c='中';以u8进行编码，底层占用3个字节

4.7.3char c='a';以u8进行编码，底层占用1个字节
5.转义字符

5.1'\t'---制表符空格

5.2'\r'---回车

5.3'\n'---换行

6.引用数据类型（类、接口、数组）

7.定义变量

/*
定义变量
 注意：
    1.在java中初始化进行赋值时如果给定的是整数那么这个整数的类型默认是int类型
    2.在整数后面加上L/l，此时整数类型指定为了long类型
    3.在java中初始化进行赋值时如果给定的是小数那么这个小数的类型默认是 double类型
    4.在整数后面加上F/f，此时整数类型指定为了float类型
    5.变量的定义分为声明和初始化两个过程
    6.变量在哪定义在哪使用
*/
class JavaDemo{
public static void main(String[] args) { 
    //定义int类型的变量 
    int i=1;
     //给定的是变量名称但是操作的是变量值
    System.out.println(i); 
    //定义long类型的变量 
    long l=234628348734L; 
    System.out.println(l); 
    //定义float类型的变量 
    float f=2.12F; 
    //如果变量没有被操作，那么变量可以先不给值 
    int i1;
    //声明 
    i1=1;
    //初始化 
    System.out.println(i1);
}
}

8.类型转换

/*
变量的操作
类型转换
    类型提升（默认  从小到大）
        byte-short、char-int-long-float-double 
        byte、short、char无论做任何操作都会类型提升为int类型 
    强制类型转换
        目标类型名称=（目标类型）数据； 
        可能会出现一些意想不到的数
*/
class Demo{
public static void main(String[] args) { 
//定义变量 
/*byte a=1; 
int b=2; 
byte 
c=a+b; 
// 
System.out.println(c);*/ 
public static void main(String[] args) { 
class Demo{
//说明byte和short之间有类型提升 
/*byte b=1; short s=b;*/
//把字符转成对应的编码值再赋值给short变量 
//如果字符转成的编码值大于short的范围就不能正常赋值 
/*short s='达';
//97 
//'0'---48  'A'---65   'a'---97 
//把数字通过编码转成对应的字符再赋值给char变量 
char c=99;*/ 
//没有类型提升，short类型的取值范围包含负数但是字符不能出现负数 
/*short s=1; char c=s;*/
//int和char之间有类型提升 
/*char c='1'; int i=c;*/ 
//int和long之间有类型提升 
/*int i=1; long l=i;*/ 
//float和long之间有类型提升 
//从整型到浮点型进行类型提升时可能会出现精度丢失问题
/*long l=13456287343L; 
float f=l; 
System.out.println(f);*/ 
//float和double之间有类型提升 
/*float f=1.1F; double d=f;*/
//byte,char,short底层的类型就是int类型 
byte b1=1; /*short s=2; char c=3;*/ byte b2=2; 
//强制把int类型转成byte类型 
byte b3=(byte)(b1+b2); 
//小数强制类型转成整数时可能会出现舍弃 
float f=4.99993476F; int i=(int)f; System.out.println(i);
// int b=128; byte bb=(byte)b; 
//-128? System.out.println(bb); 
//当等号右边所有参与运算的数据都是常量 
//那么在编译时期会进行优化直接计算结果再把结果赋值给变量 
byte bbb=128-1; }
} 
/*
00000000 00000000 00000000 10000000  int 128 补码 
转成byte类型 10000000  byte  补码  负数
            11111111  byte  反码  负数 
            10000000  byte  原码  负数---  -0 规定表示对应类型的最小值 
            是-128（特殊认为可以把最高位既当做符号位也当做数值位）
*/

运算符

1.算术运算符

/*

	算术运算符
		+、-、*、/、%、++、--
		++、--
			单独运算
			参与运算
			如果++出现在操作数的后面，先赋值再自加1
			如果++出现在操作数的前面，先自加1再赋值
			如果--出现在操作数的后面，先赋值再自减1
			如果--出现在操作数的前面，先自减1再赋值
*/
class SuanShuDemo{
	public static void main(String[] args) {
		//操作+
		//功能---求和、字符串连接符
		/*int a=1;
		int b=2;
		System.out.println(a+b);//3
		//数值类型变量遇到字符型数据，先把字符型数据转成
		//对应的编码值，再进行运算
		System.out.println(1.0+2.34+'a');//100
		System.out.println(a+'b'+b);//101
		//字符串常量遇到任意类型数据都是拼接
		System.out.println(a+"a"+b);//1a2
		System.out.println(a+b+"a");//3a

		//操作-
		//小数不精确
		System.out.println(2.1-1.9);*/

		//操作/
		/*int a=1;
		int b=2;
		//如果参与运算的都是整数结果一定是整数
		//如果参与运算的有小数结果就是小数
		System.out.println(a*1.0/b);//0
		//ArithmeticException---算术异常
		//整数不能除0
		//System.out.println(1/0);
		//小数可以除0
		//Infinity(正无穷大)
		//-Infinity(负无穷大)
		System.out.println(-1.0/0);
		//NaN---Not A Number(和本身都不相等)
		System.out.println(0.0/0.0);*/

		//操作%  %左边的正负决定了结果的正负
		System.out.println(1%2);//1
		System.out.println(-1%2);//-1
		System.out.println(1%-2);//1
		System.out.println(-1%-2);//-1

		//
		/*int a=1;
		int b=++a;
		System.out.println(b);//1  2
		System.out.println(a);//2  2*/
		/*int a=3;
		int b=(a++)+(++a)+(a--)+(--a);
			//3+5+5+3
			//4 5 4 3
		System.out.println(b);//16
		System.out.println(a);//3*/
		//++、--针对byte、short以及char含有强制类型转换
		short b=-32768;
		b--;//int 128  (byte)--- -128
		System.out.println(b);
	}
}

2.赋值运算符

/*
	赋值运算符
		=（把右边的值赋值给左边）
		扩展赋值运算符（强制类型转换）
		+=、-=、*=、/=、%=、&=(按位与等)、|=(按位或等)^=(按位异或等)、>>=(右移等)、<<=(左移等)、>>>=(无符号右移等)
*/
class FuZhiDemo{
	public static void main(String[] args) {
		/*byte a=1;
		//a+=4;//a=a+4;含有强制类型转换
		a=a+4;
		System.out.println(a);//5*/

		//java不允许出现连等定义
		//int a=b=c=4;
		//java允许连等赋值
		int a=3;
		int b=a+=a-=a+=7;
		//b=a+=a-=a=a+7-10
		//b=a+=a-=10
		//b=a+=a=a-10- -7
		//b=a+=-7
		//b=a=a-7- -4
		System.out.println(b);//-4
		System.out.println(a);//-4
	}
}

3.关系运算符

/*
	比较（关系）运算符(结果一定是布尔值)
		==、>、<、>=、<=、!=
		
*/
class BiJiaoDemo{
	public static void main(String[] args) {
		System.out.println(1==2);//false
		System.out.println(1>=2);//false
		System.out.println(1<=2);//true
		System.out.println(1!=2);//true
	}
}

4.逻辑运算符

/*
	逻辑运算符
		a>b>c  a>b b>c
		连接左右两边布尔值
		&、|、^（异或）、！（非）、&&（双与）、||（双或）
		&&（双与）、||（双或）（常用）
		&&和&的运算规律一致，如果&&左边是false右边不执行---短路效果
		||和|的运算规律一致，如果||左边是true右边不执行---短路效果

		总结
			&：遇见false就是false
			|:遇见true就是true
			^:相同则false，不同则true（吸铁石）
			!:取反（false变true，true变false 奇数个非结果取反，偶数个非结果不变）
*/
class LuoJiDemo{
	public static void main(String[] args) {
		int a=1;
		int b=2;
		int c=3;
		//操作&
		System.out.println((a>b)&(b>c));//false&false  false
		System.out.println((a>b)&(b<c));//false&true   false
		System.out.println((a<b)&(b>c));//true&false  false
		System.out.println((a<b)&(b<c));//true&true   true
		System.out.println("--------------------");
		//操作|
		System.out.println((a>b)|(b>c));//false|false  false
		System.out.println((a>b)|(b<c));//false|true   true
		System.out.println((a<b)|(b>c));//true|false  true
		System.out.println((a<b)|(b<c));//true|true   true
		System.out.println("--------------------");
		//操作^
		System.out.println((a>b)^(b>c));//false^false  false
		System.out.println((a>b)^(b<c));//false^true   true
		System.out.println((a<b)^(b>c));//true^false  true
		System.out.println((a<b)^(b<c));//true^true   false
		System.out.println("--------------------");
		//操作！
		System.out.println(!(!(!(a>b))));//false true
		System.out.println("--------------------");
		//操作&&
		System.out.println((a>b)&&(b>c));//false&&false  false
		System.out.println((a>b)&&(b<c));//false&&true   false
		System.out.println((a<b)&&(b>c));//true&&false  false
		System.out.println((a<b)&&(b<c));//true&&true   true
System.out.println("--------------------");
		//a=1 b=2 c=3
		//如果||出现在&&左边且||左边布尔值为true
		//||会把后面的所有内容一并短路掉
		System.out.println(true||(a++>b)&&(b<c++));
		System.out.println(a);
		System.out.println(c);

5.位运算符

/*
	位运算符
		针对二进制数据的补码形式做运算
		&(按位与)、|（按位或）、^（按位异或）、~(按位取反)、>>(右移)、<<(左移)、>>>(无符号右移)

*/
class WeiDemo{
	public static void main(String[] args) {
		int a=2;
		//操作&
		System.out.println(a&3);//2
		//操作|
		System.out.println(a|3);//3
		//操作^
		System.out.println(a^3);//1
		//操作~
		System.out.println(~a);//-3		
	}
}
/*
	00000000 00000000 00000000 00000010 int 2 补码
	00000000 00000000 00000000 00000011 int 3 补码

	操作&（遇0则0） 任意整数&1=1是奇数
	任意整数&正数---结果一定是正数
	00000000 00000000 00000000 00000010
	00000000 00000000 00000000 00000011
	------------------------------------
	00000000 00000000 00000000 00000010    2  补码

	操作|(遇1则1) 任意整数|0结果还是本身
	任意整数|负数---结果一定是负数
	00000000 00000000 00000000 00000010
	00000000 00000000 00000000 00000011
	-----------------------------------
	00000000 00000000 00000000 00000011   3  补码


	操作^(相同则0，不同则1)
	00000000 00000000 00000000 00000010
	00000000 00000000 00000000 00000011
	-----------------------------------
	00000000 00000000 00000000 00000001   1  补码

	操作~(每一位按位取反)
	00000000 00000000 00000000 00000010
	-----------------------------------
	11111111 11111111 11111111 11111101   负数  补码
	11111111 11111111 11111111 11111100   负数  反码
	10000000 00000000 00000000 00000011   负数  原码   -3
*/

/*
	位运算符
		>>(右移)：如果是正数，右移几位就要在最左边（高位）补上几个0；如果是负数，右移几位就要在最左边（高位）补上几个1.
		<<（左移）：无论正负数，左移几位就要在最右边（低位）补上几个0
		>>>(无符号右移)：无论正负数，右移几位就要在最左边（高位）补上几个0
*/
class WeiDemo1{
	public static void main(String[] args) {
		int a=8;
		//操作>>
		//8/2`2=2
		//数据/2`移动位数
		System.out.println(a>>2);//2
		//操作<<
		//8*2`2=32
		数据*2`移动位数
		System.out.println(a<<2);//32
		//操作>>>  结果一定是正数
		System.out.println(a>>>2);//2
	}
}
/*
	00000000 00000000 00000000 00001000  int 8 补码

	操作>>
	[00]00000000 00000000 00000000 000010(00)
	00000000 00000000 00000000 	00000010  2  补码

	操作<<
	(00)000000 00000000 00000000 00001000[00]
	00000000 00000000 00000000 00100000 32 补码

	操作>>>
	[00]00000000 00000000 00000000 000010(00)
	00000000 00000000 00000000 	00000010  2  补码

*/

/*

	一个整数和另外一个整数按位异或两次结果还是本身

*/
class WeiDemo2{
	public static void main(String[] args) {
		int a=5;
		int b=6;
		System.out.println(a^b^a);//6  a^a  0^b
		System.out.println(b^a^b);//5
	}
}

/*
	两个整数值交换

	效率高低：2.按位异或（前提是整数）、3.求和（前提一般是整数）、1.中间变量
	常用：中间变量（容易实现、任意类型数据）

*/
class WeiText{
	public static void main(String[] args) {
		//定义变量
		int a=3;
		int b=4;
		System.out.println("a的值:"+a+",b的值:"+b);

		//1.中间变量
		/*int temp=a;
		a=b;
		b=temp;
		System.out.println("a的值:"+a+",b的值:"+b);*/

		//2.按位异或
		/*a=a^b;
		b=a^b;//b=a^b^b=a
		a=a^b;//a=a^b^a=b
		System.out.println("a的值:"+a+",b的值:"+b);*/

		//3.求和
		a=a+b;
		b=a-b;//b=a+b-b=a
		a=a-b;//a=a+b-a=b
		System.out.println("a的值:"+a+",b的值:"+b);
	}
}

6.三目运算符

/*
	~a(一目)
	a+b（二目）
	三目（元）运算符（结果一定会返回一个值）
		格式
			布尔表达式?表达式值1：表达式值2;
		执行过程
			先去计算出布尔表达式的值，如果是true表明执行表达式1返回值1，如果是false执行表达式2返回值2。
*/
class SanMuDemo{
	public static void main(String[] args) {
		//获取两个整数的最大值
		/*int a=4;
		int b=5;*/
		//两个表达式值的类型可以不一样但是要保证两个类型的最大范围在接受值类型范围之内
		//int max=a>b?'a':b;
		
		//System.out.println(a>b?"a":b);//如果没有接受值两个表达式的类型不受限制

		//获取三个整数的最大值
		int a=4;
		int b=5;
		int c=3;
		/*//求两个整数的最大值
		int max=a>b?a:b;
		//拿着两个整数最大值和第三个整数进行比较
		System.out.println(max>c?max:c);*/
		//三目嵌套
		System.out.println(a>b?(a>c?a:c):(b>c?b:c));

	
		
	}
}