Java基础语法

最新推荐文章于 2024-10-27 15:49:02 发布

冰烬之沫

最新推荐文章于 2024-10-27 15:49:02 发布

阅读量199

点赞数

分类专栏： # java 文章标签： java 编程语言 javase

本文链接：https://blog.csdn.net/BingJin_mo/article/details/107996540

版权

java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1. 注释

1.1 单行注释

语法：在需要注释的内容前添加“//”

    // 这是注释的内容

1.2 多行注释

语法：在需要注释的内容其前添加“/*”，其后添加“*/”

    /* 
        这是注释的内容1
        这是注释的内容2
        这是注释的内容3
    */

1.3 文档注释

语法：在需要注释的内容其前添加“/**”，其后添加“*/”，并在每行之前添加“*”

    /**
     *
     * @author：作者。
     * @version：版本。
     * @docroot：表示产生文档的根路径。
     * @deprecated：不推荐使用的方法。
     * @param：方法的参数类型。
     * @return：方法的返回类型。
     * @see：用于指定参考的内容。
     * @exception：抛出的异常。
     * @throws：抛出的异常，和exception同义
     *
     */

2. 标识符和关键字

2.1 认识标识符和关键字

标识符：在Java中，类名、变量名以及方法名都被称为标识符

关键字：在Java中，Java语言提前预定义的具有特殊意义的标识符为关键字，常见关键字如下：

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

2.2 标识符的注意点

所有标识符应以字母(A-Za-z)、美元符号($)或下划线(_)开头
从第二位开始可以是字母(A-Za-z)、美元符号($)、下划线(_)或数字的自由组合
不能使用关键字作为变量名或方法名
标识符大小写敏感
合法标识符举例：name, $num1, _bank
不合法标识符举例：123, #age, *red
~~可以使用中文作为标识符，但不推荐~~

3. 数据类型

3.1 数据类型的分类

数据类型分为两大类：基本数据类型（primitive type）和引用数据类型（reference type），其中基本数据类型分为数值类型、字符类型和boolean类型，而数值类型又细分为整数类型、浮点数类型和字符类型。整数类型包括byte、short、int和long，浮点数类型包括float和double，字符类型只有char，boolean类型只有boolean。引用类型分三类：类、接口和数组。

3.2 基本数据类型

3.2.1 数值类型

整数类型

byte，占1个字节，范围：-128~127

//byte变量的定义
byte byteNumber = 10;

short，占2个字节，范围：-32768~32767

//short变量的定义
short shortNumber = 2000;

int，占4个字节，范围：-2147483648~2147483647（最常用）
```
//int变量的定义
int intNumber = 40000;
```

long，占8个字节，范围：-9223372036854775808~9223372036854775807

//long变量的定义
long longNumber = 3000000000L;	//注意在数字后面加上L

浮点数类型

浮点数是有限的、离散的，其具有舍入误差，不适合进行高精度的比较。若要进行浮点数比较用BigDecimal数学工具类
- float，占4个字节
```
//float变量的定义
float floatNumber = 888.88888F;	//注意在数字后面加上F
```
- double，占8个字节（最常用）
```
//double变量的定义
double doubleNumber = 888.88888;
```

常用进制表示

二进制

//前缀0b表示二进制
int num = 0b10101100; //0b10101100相当于十进制的172

八进制

//前缀0表示八进制
int num = 0254; //0254相当于十进制的172

十六进制

//前缀0x表示十六进制
int num = 0xAC; //0xAC相当于十进制的172

3.2.2 字符类型

char，占两个字节

//char变量的定义
char charName = 'A';

转义字符，具有特殊意义的字符
- \a 响铃(BEL) 007
- \b 退格(BS) 008
- \f 换页(FF) 012
- \n 换行(LF) 010
- \r 回车(CR) 013
- \t 水平制表(HT) 009
- \v 垂直制表(VT) 011
- \\ 反斜杠 092
- ? 问号字符 063
- \’ 单引号字符 039
- \" 双引号字符 034
- \0 空字符(NULL) 000
```
System.out.println("Hello\tWorld!");	//输出Hello	World!
System.out.println("Hello\nWorld!");	/* 输出：Hello
											    World! */
```

3.2.3 boolean类型

boolean，占一位，其值只有true和false两个
```
//boolean变量的定义
boolean flag = true;
```

3.3 引用数据类型

类，class
接口，interface
数组，[]

3.4 类型转换

类型转换有两种：自动类型转换和强制类型转换

3.4.1 自动类型转换

自动类型转换遵循低到高的原则：byet,short,char–>int–>long–>float–>double
在运算中，不同类型的数据先转换为高字节占位的同一类型，然后运算
byte、short、char之间的运算都先转换为int再运算
在运算中，运算结果超出当前类型范围时会造成内存溢出

//自动转换
byte num1 = 10;
short num2 = num1;
int num3 = num2;
long num4 = num3;
float num5 = num4;
double num6 = num5;

//short num7 = num1 + num2; (错)
int num7 = num1 + num2;	//(对)

int num8 = 2000000000;
//int num9 = num8*20; (错)
long num9 = num8*20;	//(对)

3.4.2 强制类型转换

转换格式：(类型)变量名
不能把不相关的类型进行转换
不能对boolean值进行转换
由高到低强制转换可能存在内存溢出或精度问题

//强制转换
short num1 = 10;
byte num2 = (byte)num1;
double num3 = (double)num2;

//char与int互相转换(字符类型本质为字符表中的字符序号)
char charNum1 = 'A';
int num4 = (int)charNum; //num4的值为65
int num5 = 66;
char charNum2 = (char)num5;	//charNum2的值为'B'

//int num6 = (int)true; (错)

double num7 = 49.9;
int num8 = (int)num7;	//num8值为49

4. 变量、常量、作用域

4.1 变量

变量是程序中最基本的单元，其没有固定值，可以变化
在使用变量之前都必须预先定义，定义格式：数据类型变量名 = 值
变量必须有数据类型，可以是基本数据类型或引用类型
变量名必须是合法的标识符

//定义变量
//int a=1,b=2,c=3; 可以写在一行，但不推荐
int num = 100;	//基本数据类型
String str = new String("Hello");	//引用类型

4.2 常量

常量是初始化赋值后就不能改变的量，值始终不变
常量可以看成是一种特殊的变量，它的值设定后就不允许改变
常量名一般用大写字符加下划线

//常量的定义 final 常量名 = 值
final double PI = 3.14159265;

4.3 变量的作用域

类变量（全局变量、静态变量）
实例变量（成员变量）
局部变量

public class Demo {
    
    static int staticNum = 0;	//类变量，作用于全局
    int oNum;	//实例变量，默认值为0，作用于类的实例化对象
    
	public static void main(String[] args) {
		
		int num = 66;	//局部变量，必须初始化值，作用于前后'{}'之内
        
	}
}

4.4 变量的命名规范

所有变量、方法、类名要见名知意
类成员变量（属性）、局部变量、方法名：首字母小写驼峰原则：除了第一个单词的首字母小写以外，后面的单词首字母一律大写，例如：myBook
常量：大写字母加下划线，例如：MAX_VALUE
类名：首字母大写驼峰原则，例如：RedBook

5. 运算符

java语言支持以下运算符：

算术运算符：+，-，*，/，%，++，-- （返回值为运算结果）
赋值运算符：=，+=，-=，*=，/= （将后面的值赋予前面的变量）
关系运算符：>，<，>=，<=，==，!=，instanceof （返回值为true或false）
逻辑运算符：&&，||，! （返回值为true或false）
位运算符：&，|，^，~，>>，<<，>>> （了解）
条件运算符：? : （根据条件判断返回冒号前或后的值）

/*************算术运算符*************/

int num1 = 2 + 3;	// +为加，num1值为5

int num2 = 3 - 2;	// -为减，num2值为1

int num3 = 2 * 3;	// *为乘，num3值为6

int num4 = 3 / 2;	// /为除，num4值为1

double num5 = 3 / (double)2;	// /为除，num5值为1.5

int num6 = 5 % 3;	// %为取余，num6值为2

int num7 = 5;
num7++;	// ++为自增1，num7值为6（也可以写成++num7，++在前先进行自增运算，++在后后进行自增运算）

int num8 = 5;
num8--;	// --为自减1，num8值为4（也可以写成--num8，--在前先进行自增运算，--在后后进行自增运算）

//要进行幂运算可使用Math数学工具类
System.out.println(Math.pow(2,3));	//Math.pow(2,3)为2的3次方，输出8

/*************赋值运算符*************/

int num9 = 5;	// =为赋值符号，将5赋值给num9，num9的值为5

int num9 += 1;	// +=为加赋值符号，相当于num9 = num9 + 1，num9的值为6

int num9 -= 1;	// -=为加赋值符号，相当于num9 = num9 - 1，num9的值为5

int num9 *= 2;	// *=为乘赋值符号，相当于num9 = num9 * 2，num9的值为10

int num9 /= 2;	// /=为加赋值符号，相当于num9 = num9 / 2，num9的值为5


/*************关系运算符*************/

boolean flag1 = (2 > 3);	// >为大于比较符号，flag1的值为false

boolean flag2 = (2 < 3);	// <为小于比较符号，flag2的值为true

boolean flag3 = (2 >= 3);	// >=为大于等于比较符号，flag3的值为false

boolean flag4 = (2 <= 3);	// <=为小于比较符号，flag4的值为true

boolean flag5 = (2 == 3);	// ==为等于比较符号，flag5的值为false

boolean flag6 = (2 != 3);	// !=为不等于比较符号，flag6的值为true

Integer num10 = 1;	//Integer为int的包装类
boolean flag7 = (num10 instanceof Integer);
// instanceof为判断前面的对象是否属于后面的类，flag7的值为true


/*************逻辑运算符*************/

boolean flag8 = (true && false);
/* &&为短路与符号，&&左右都为true时返回true，只要遇见一个false结果就返回false并不再执行后面的判断，flag8的值为false */

boolean flag9 = (true || false);
/* ||为短路或符号，||左右都为false时返回false，只要遇见一个true结果就返回true并不再执行后面的判断，flag9的值为true */

boolean flag10 = !true;	// !为非符号，将!后面的结果取反，flag10的值为false


/*************位运算符*************/

System.out.println(0b1100 & 0b1010);	// &为按位与运算符，输出8，即0b1000

System.out.println(0b1100 | 0b1010);	// &为按位或运算符，输出13，即0b1110

System.out.println(0b1100 ^ 0b1010);	// &为按位异或运算符，输出6，即0b0110

System.out.println(~ 0b1010);	// ~为按位取反运算符，输出-11，即-0b0101

System.out.println(0b0010 >> 1);	// >>为右移运算符，输出1，即0b0001

System.out.println(0b0010 << 1);	// <<为左移运算符，输出1，即0b0100

System.out.println(0b0010 >>> 1);	// >>>为无符号右移运算符，输出1，即0b0001


/*************条件运算符*************/

System.out.println((2 > 3) ? 1 : 0);
// ?:为条件判断运算符，当?前为true则返回:前的值，否则返回:后的值，输出0

6. 包机制

为了更好的组织类，Java提供的包机制，用于区别类名的命名空间
包语句的语法格式：package pkg1[.pkg2[.pkg3…]]
一般用公司的域名倒置作为包名，例如：com.baidu.www
要使用其他包的成员，需要用“import”语句导入包，格式：

package pkg1[.pkg2[.pkg3…]].(classname|*);

冰烬之沫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录