java的基本语法学习总结

最新推荐文章于 2024-05-17 08:41:38 发布

LKIDTI数据

最新推荐文章于 2024-05-17 08:41:38 发布

阅读量512

点赞数 1

分类专栏：大数据文章标签： java eclipse maven 算法 hadoop

本文链接：https://blog.csdn.net/weixin_45014634/article/details/118657893

版权

大数据专栏收录该内容

11 篇文章 3 订阅

订阅专栏

java的基本语法

一、关键字与标识符

1.1、java关键字的使用

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所字母都为小写，关键词定义

用于定义类型的关键字
class、interface、enum、byte、short、int、long、float、double、char、boolean、void
用于定义流程的关键词
if、else、switch、case、default、while、do
for、break、continue、return
用于定义权限的关键词
private、protected、public
用于定义类、函数、变量修饰符的关键字
abstract、final、static、synchronized
用于类和类之间的关键词
extends、implements
用于使用实例、类继承等关键词
new、this、super、instanceof
用于异常处理的关键词
try、catch、finally、throw、throws
用于包的关键词
package、import
其他
true、false、null

以上关键词，我们只是初始一个大概内容，如果已经学过java内容，或者有点编程基础的话，我们看到思考一下将会无比的熟悉。

1.2、标识符的使用

定义：凡是自己可以起名字的地方都叫标识符。
涉及到的结构：
包名、类名、接口名、变量名、方法名、常量名
规则：(必须要遵守。否则，编译不通过)
在这里插入图片描述
良好的编程风格，是一名大师的基本修养。

在这里插入图片描述
建议了解一下程序员的自我修养。当然主要还是为了好的习惯，从开始就养成。

二、基本变量类型

Java属于强类型语言，强类型语言必须为每一个变量声明一种类型。

Java中基本数据类型也称做简单数据类型，包括以下八种

1、整型

byte 、short 、int 、long

2、浮点型

float 、 double

3、字符型

char

4、布尔型

boolean

2.1、整型

整型（byte、short、int、long）

整型数据有四种，它们的取值范围不同

byte 的取值范围：-128～127（-2的7次方到2的7次方-1）

short 的取值范围：-32768～32767（-2的15次方到2的15次方-1）

int 的取值范围：-2147483648～2147483647（-2的31次方到2的31次方-1）

long 的取值范围：-9223372036854774808～9223372036854774807（-2的63次方到2的63次方-1）

2.2、浮点型

浮点型包括float和double两种，区别在与精度，float是单精度、32位、符合IEEE 754标准的浮点数；double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数。

float（单精度浮点型）取值范围：3.402823e+38～1.401298e-45

double（双精度浮点型）取值范围：1.797693e+308～4.9000000e-324

java对于浮点型数据默认会使用double。

2.3、字符类型

char 类型是一个单一的 16 位 Unicode 字符；

最小值是 \u0000（十进制等效值为 0）；

最大值是 \uffff（即为 65535）；

char 数据类型可以储存任何字符；

2.4、布尔类型

布尔类型只有两个取值，分别是true 、false 。

java默认是false。

2.5、变量

2.5.1、变量类型

java属于强类型语言，所以变量在使用前必须进行声明，以下是几个声明与赋值的示例：

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

java有三类变量，分别是：

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

public class var{
    static int lei_var;    // 类变量
    String str="hello world";  // 实例变量 
    public void test(){
        int local_var =0;  // 局部变量 
    }
}

局部变量

如果在成员方法中定义一个变量，那么这个变量就被称为局部变量。

局部变量在方法实行时被创建，在方法执行结束的时候被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则出现编译错误。

例如，我们创建一个类文件，在该类中定义getName()方法，在getName()方法中声明int型的局部变量id，并赋值为0，代码如下：

public class BookText(){
	public String getName(){
	int id = 0; //局部变量，如果我们把初始值去掉，会报错
	setName("Java"); //调用类中的其他方法（此类中省略定义方法）
	return i + this.name;
	}
}

注意：类成员变量和成员方法可以统称为类成员。如果一个方法中含有与成员变量同名的局部变量，则方法中对这个变量的访问以局部变量的值为基准。例如，变量id在 getName()方法中值为0，而不是成员变量中id的值。

局部变量的作用域，即局部变量的有效范围，下图描述了局部变量的作用范围。

public void doString(String name){ 
	int id = 0; 
	for(int i = 0; i< 10; i++) 
		System.out.println(name + String.valueOf(i));
}

在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量，如下图

public void doString(String name){
	 int id = 0; 
	 for(int i= 0; i<10; i++){
	 	 System.out.println(name ＋ String.valueOf(i)); 
	 	 }
	 for (int i= 0; i <3; i++)
	 	System.out.println(i);
}

但是在相互嵌套的区域中不可以这样声明，如果将局部变量id在方法体的for循环中再次定义，编译器将会报错，如图所示。

public void doString(String name){ 
	int id = 0; 
	for(int i= 0; i<10; i++)
		System.out.println(name + String.valueOf(i));
	for(int i = 0; i<3; i++)
		 System.out.println(i); int id = 7;
}

注意：在作用范围外使用局部变量是一个常见的错误，因为在作用范围外没有声明局部变量的代码。

实例变量

也叫类成员变量，声明在一个类当中，方法、构造方法和语句块之外。实例变量的生命周期与对象一致。

类变量/静态变量

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。生命周期与类一致。

2.5.2、类型转换

在平时编程的时候，经常需要将一种数值类型转换为另一种数值类型。

若两个操作数中有一个是double类型，另一个操作数就会转换为double类型；
若其中一个操作数是float类型，另一个操作数也会转换为float类型；
若其中一个操作数为long类型，另一个操作数也会转换为long类型；
否则两个操作数都会转换为int类型。

数值类型的转换可能会发生精度的丢失，例如：123456789是一个大整组，它所包含的位数比float类型所能表达的位数还要多。当它由整型数值转换为float类型时，将会得到同样大小的结果，但却丢失一定的精度。

int n = 123456789;
float f = n;
System.out.println(f);

输出：1.23456792E8

强制类型转换

由上方可看出，在必要时候int类型会自动转换为double类型，而也会有将double类型转换为int类型的需要。这时，就需要通过强制类型转换来实现这个操作。

强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟着待转换的变量名。

double x = 9.997;
int nx = (int)x;

在这里，变量nx的值就会变成9。强制类型转换通过截断小数部分将浮点值转换为整型。

若想要对浮点数进行舍入运算，以便得到最接近的整数，就需要用Math.round方法：

double x = 9.997;
int nx = (int) Math.round(x);

现在变量nx的值为10。

2.5.3、常量

常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。例如：

byte a = 68;
char a = 'A'

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"
"two\nlines"
"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';
String a = "\u0001";

2.6、枚举类型

有时候，变量的取值只在一个有限的集合内，这个变量中很可能保存错误的值。针对这种情况，可以自定义枚举类型。枚举类型包括有限个命名的值。

例如：

销售服装的尺寸有小、中、大和超大四种尺寸。
enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE};
//声明这种类型的变量
Size s = Size.MEDIUM;
Size类型的变量只能存储这个类型声明中给定的某个枚举值，或null值。null表示这个变量没有设置任何值。

三、运算符

3.1、算术运算符

算术运算符主要就是四则运算如下：
在这里插入图片描述
另外还有：
前)++ (后)++ (前)-- (后)–

//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);//2
		// %:取余运算
		//结果的符号与被模数的符号相同
		//开发中，经常使用%来判断能否被除尽的情况。
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);

		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 = " + m2 % n2);

		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 = " + m3 % n3);

		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 = " + m4 % n4);
		//(前)++ :先自增1，后运算
		//(后)++ :先运算，后自增1
		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);
		
		int a3 = 10;
		++a3;//a3++;
		int b3 = a3;
		//(前)-- :先自减1，后运算
		//(后)-- :先运算，后自减1
		
		int a4 = 10;
		int b4 = a4--;//int b4 = --a4;
		System.out.println("a4 = " + a4 + ",b4 = " + b4);

注意：
1.//(前)++ :先自增1，后运算
//(后)++ :先运算，后自增1
2.//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1
3.连接符：+：只能使用在String与其他数据类型变量之间使用。

3.2、赋值运算符

= += -= *= /= %=

int i2,j2;
		//连续赋值
		i2 = j2 = 10;
		//***************
		int i3 = 10,j3 = 20;
		int num1 = 10;
		num1 += 2;//num1 = num1 + 2;
		System.out.println(num1);//12

		int num2 = 12;
		num2 %= 5;//num2 = num2 % 5;
		System.out.println(num2);

		short s1 = 10;
		//s1 = s1 + 2;//编译失败
		s1 += 2;//结论：不会改变变量本身的数据类型
		System.out.println(s1);

3.3、比较运算符

== != > < >= <= instanceof

特别说明：
Java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
也就是：

       s1 = new Student();
        s2 = new Student();
        if (s1 instanceof Student) {
            System.out.println("s1是Student的实例");

注意：
1.比较运算符的结果是boolean类型
2.> < >= <= :只能使用在数值类型的数据之间。
3. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。

3.4、逻辑运算符

& && | || ! ^

注意：
1、区分& 与 &&
2、相同点1：& 与 && 的运算结果相同
3、相同点2：当符号左边是true时，二者都会执行符号右边的运算
4、不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
5、开发中，推荐使用&&
6、区分：| 与 ||
7、相同点1：| 与 || 的运算结果相同
8、相同点2：当符号左边是false时，二者都会执行符号右边的运算
9、不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
10、开发中，推荐使用||
11、逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型

3.5、位运算符

处理整数类型时，可以直接对组成整型数值的各个位完成操作。位运算符包括：&(“and”)、|(“or”)、^(“xor”)、~(“not”)。另外还有>>和<<运算符将位模型左移或右移
一般来说少用。

3.6、三元运算符

三目运算符x?y:z，当x返回结果为true时就返回y，当x返回结果为false时就返回z

四、流程控制

4.1、分支结构

在这里也就是我们高中学过的if：else结构

结构一：
if(条件表达式){
	执行表达式
}

结构二：二选一
if(条件表达式){
	执行表达式1
}else{
	执行表达式2
}

结构三：n选一
if(条件表达式){
	执行表达式1
}else if(条件表达式){
	执行表达式2
}else if(条件表达式){
	执行表达式3
}
...
else{
	执行表达式n
}

条件控制块也就是控制条件，可选择的满足于条件以此达到不同的执行过程。

switch-case选择结构
switch(表达式){
case 常量1:
	执行语句1;
	//break;
case 常量2:
	执行语句2;
	//break;
...
default:
	执行语句n;
	//break;
}

switch语句将从与选项值相匹配的case标签处开始执行，直到遇到break语句，或执行到switch语句的结束处为止。若没有匹配的case标签，有default子句的话就会执行这个子句。
选择结构对条件控制块进行扩展，对比python语句，python中是没有这个语句的，但是据说最新版的python中加入了这个结构。

4.2、循环结构

for循环结构
for(①;②;④){
	③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

while循环结构
①
while(②){
	③;
	④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

do-while结构
①
do{
	③;
	④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②