时间戳

首页 > 技术文章 > 2.java基础语法

2.java基础语法

ryxiong-blog 2020-10-28 11:48 原文

java基础语法

java注释

注释：程序在指定位置的说明性信息，不参与程序的运行逻辑

  • 当行注释：//注释信息
  • 多行注释：/*注释信息*/
  • 文档注释：/**注释信息*/
/*
	java程序基本组成单位是类，
	类的定义格式
		public class 类名 {
			...
		}
*/
public class HelloWrold{
	pulic static void main(String[] args) {
        // 输出语句
		System.out.println("hello world");
	}
}

java关键字

关键字：被java语言赋予了特定含义的单词

  • 关键字的字母全部小写
  • 常用编辑器对关键字，会有特殊颜色标记

image-20200629134332011

java常量

常量：程序运行中，其值不可以发生改变的量

常量类型 说明 距离
字符串常量 双引号括起来的内容 "Hello world"
整数常量 不带小数的数字 666
小数常量 带小数的数字 13.14
字符常量 单引号括起来的内容 'A'
布尔常量 布尔值，表示真假 true, false
空常量 一个特殊的值，空值 null 
public class ConstantDemo{
	public static void main(String[] args) {
		// 字符常量
		System.out.println("hello world");

		// 整数常量
		System.out.println("666");

		// 小数常量
		System.out.println("6.66");

		// 字符常量
		System.out.println('A');

		// 布尔常量
		System.out.println(true);

		// 空常量, 不能直接打印
		// System.out.println(null);
	}
}

java数据类型

存储单位：计算机存储设备最小心的单位：”位（bit）“，称为”比特位“，通常用小写字母”b“表示。而计算机中最小的存储单位为”字节（byte）“，通常大写字母”B“表示，字节是有连续的8个位组成。

数据类型：java是强类型语言，对于每一种数据都给出明确的数据类型，不同的数据类型也分配了不同的内存空间，所以他们表示的数据大小也不一样。

image-20200629161710373

数据类型内存占用和取值范围

image-20200629161816233

java变量

变量：在程序运行过程中，其值可以发生改变的量，用来指向内存中的具体区域。

变量三要素：1.变量名，2.数据类型，3.变量值

定义变量格式：数据类型 变量名 = 变量值；

int a = 10

变量取值格式：变量名

a

变量修改值：变量名 = 变量值;

a = 20;

示例：

public class VirableDemo{
	public static void main(String[] args) {
		// 变量定义
		int a = 10;
		// 输出变量
		System.out.println(a);
		
		// 修改变量
		a = 20
		// 输出变量
		System.out.println(a);
	}
}

使用变量注意的问题：

  1. 变量名不能重复
  2. 变量未赋值，不能使用
  3. long类型的变量定义时，为防止整数过大，整数后面加L
long l = 10000000000L;
  1. float类型的变量定义时，为防止格式不兼容，后面加F
float f = 13.14F;

java标识符

标识符：用于给类、方法、变量等命名的符号。

标识符定义规则：

  1. 由数字、字母、下划线(_)、美元符($)组成
  2. 不能以数字开头
  3. 不能是关键字
  4. 区分大小写

常见命名规则：

  1. 小驼峰：方法、变量
  • 标识符是一个单词时，首字母小写：name
  • 标识符有多个单词组成，第一个单词首字母小写，其他大写：firstName
  1. 大驼峰：类
  • 标识符为一个单词，首字母大写：Student
  • 标识符为多个单词组成，每个单词首字母大写：GoodStudent

java类型转换

1.自动类型转换：

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量

public class ConversionDemo{
	public static void main(String[] args) {
		// 自动类型转换
		double a = 10;
		System.out.println(a);
        
        // 定义byte类型的便令
        byte b = 10;
        short s = b;
        int i = b;
        
        // 这种不可以
        // char c = b;
	}
}

2.强制类型转换

把一个表示护具范围大的数值或变量赋值给另一个表示范围小的变量

格式：目标数据类型变量名 = （目标数据类型）值或者变量；

会产生数据丢失，不建议使用

public class ConversionDemo{
	public static void main(String[] args) {  
        // 强制类型转换
        int k = (int)88.88;
        System.out.println(k);
	}
}

java运算符

算术运算符

运算符：对常量或者变量进行操作的符号

表达式：用运算法把常量或者变量连接起来符合java语法的式子可以称为表达式，不用运算法连接的表达式体现的是不同类型的表达式。

如：

public class OperatorDemo01{
	public static void main(String[] args) {  
        // 定义两个变量
        int a = 1;
        int b = 3;
        
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);  // 商
        System.out.println(a % b);  // 余
        
        // 整数相除只能的到整数，要想的到小数，必须要有浮点数
        System.out.println(6.0 / 4);
	}
}

注意事项

  • 整数相除只能的到整数，要想的到小数，必须要有浮点数

字符的 + 操作

字符的 + 操作会拿字符在计算机底层对应的数值来进行计算

'A' - 65 A-Z连续

'a' - 97 a-z连续

'0' - 48 0-9连续

public class OperatorDemo02{
	public static void main(String[] args) {  
        // 定义两个变量
        int i = 10;
        char = 'A';
        
		c = 'A'; // 'A'的值是65
		c = 'a'; // 'a'的值97
		c = '0'; // '0'的值48
        
        // 整数相除只能的到整数，要想的到小数，必须要有浮点数
        System.out.println(i + c);

		// char ch = i + c;
        // char类型会被自动提升为int类型
        int j = i + c;
        System.out.println(j);
        
        // int d = 10 + 13.14;
        double d = 10 + 13.14;
	}
}

提升规则：

  • byte类型，short类型和char类型将被提升到int类型
  • 整个表达式的类型自动提升到表达式中最高等级操作同样的类型

字符串的 "+" 操作

public class OperatorDemo03 {
	public static void main(String[] args) {
		System.out.println("it" + "heima");
		System.out.println("itheima" + 666);
		System.out.println(666 + "itheima");
		
		System.out.println("itheima" + 6 + 66);
		System.out.println(1 + 99 + "itheima");
	}
}

当 "+" 操作中出现字符串时，这个 "+" 是字符串连接符，而不是算术运算符，如："itheima" + 666

当 "+" 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行 "+" 操作时，从左到右逐个执行，如：1 + 99 + "itheima"

赋值运算符

赋值运算符

符号 作用 说明
= 赋值 a=10，将10赋值给变量a
+= 加后赋值 a += b，a+b赋值给a
-= 减后赋值 a -= b，a-b赋值给a
*= 乘后赋值 a *= b，a*b的乘积赋值给a
/= 除后赋值 a /= b，a/b的商赋值给a
%= 取余后赋值 a %= b，a/b的余数赋值给a 
public class OperatorDemo04 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		System.out.println("i:" + i);
        
        // += 把左边和右边数据做加法，结果赋值给左边
        i += 20;  // 等价于 i = i + 20
        System.out.println("i:" + i);
        
        // 注意：扩展的赋值运算底层隐含了强制类型转换
        short s = 10;
        // s += 20;
        s = (short)(s + 20);
        System.out.println("s:" + s);
	}
}

自增运算符

符号 作用 说明
++ 自增 变量值加1
-- 自减 变量值减1

注意：

  • ++和--既可以放在变量的后面，也可以放在变量的前边。
  • 单独使用时，++和--无论是放在变量前面或者是变量后面，结果是一样的。
  • 参与操作时：如果放在变量前面，变量先参与操作，后做++或--；如果放在变量后面，变量先做++或--，后参与操作。

最常见的用法：单独使用

public class OperatorDemo05 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		System.out.println("i:" + i);
        
        // 单独使用的时候，i++和++i是等效的
        i++;
        System.out.println("i:" + i);
        ++i;
        System.out.println("i:" + i);
        
        // 参与操作时
        int i = 10;
        int j = i++;
        System.out.println("i:" + i);
        System.out.println("j:" + j);
        
        int i = 10;
        int j = ++i;
        System.out.println("i:" + i);
        System.out.println("j:" + j);
	}
}

关系运算符

常见关系运算符

符号 说明
== a==b，判断a和b是否相等，成立true，否则false
!= a==b，判断a和b是否不相等，成立true，否则false
> a>b，判断a是否大于b，成立true，否则false
>= a>=b，判断a是否大于等于b，成立true，否则false
< a<b，判断a是否小于b，成立true，否则false
<= a<=b，判断a是否小于等于b，成立true，否则false

示例

public class OperatorDemo06 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		int j = 20;
		int k = 10;
        // 比较
		System.out.println(i == j);
		System.out.println(i != j);
		System.out.println(i > j);
		System.out.println(i >= j);
		System.out.println(i < j);
		System.out.println(i <= j);

	}
}

逻辑运算符

逻辑运算：用来连接关系表达式的运算符，也可以连接布尔类型和常量。

符号 作用 说明
& 逻辑与 a&b，ab都为True，则为true，否则false
| 逻辑或 a|b，ab任意为True，则为true，否则false
^ 逻辑异或 a^b，a和b结果不同为true，否则为false
! 逻辑非 !a，结果和a相反

示例

public class OperatorDemo07 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		int j = 20;
		int k = 30;
        // & 有false则false
        System.out.println((i > j) & (i > k));
        System.out.println((i < j) & (i > k));
        System.out.println((i > j) & (i < k));
        System.out.println((i < j) & (i < k));
        
        // | 有true则ture
        System.out.println((i > j) | (i > k));
        System.out.println((i < j) | (i > k));
        System.out.println((i > j) | (i < k));
        System.out.println((i < j) | (i < k));
        
        // ^ 相同为false，不同为true
        System.out.println((i > j) ^ (i > k));
        System.out.println((i < j) ^ (i > k));
        System.out.println((i > j) ^ (i < k));
        System.out.println((i < j) ^ (i < k));
        
        // ! 相反
        System.out.println((i > j));
        System.out.println(!(i < j));

	}
}

短路逻辑运算符

符号 作用 说明
&& 短路与 作用和&相同，但是有短路效果，前边为false，则为false，不再判断
|| 短路或 作用和|相同，但是有短路效果，前边为true，则为true，不再判断

示例

public class OperatorDemo08 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		int j = 20;
		int k = 30;
        // && 有false则false
        System.out.println((i > j) && (i > k));
        System.out.println((i < j) && (i > k));
        System.out.println((i > j) && (i < k));
        System.out.println((i < j) && (i < k));
        
        // || 有true则ture
        System.out.println((i > j) || (i > k));
        System.out.println((i < j) || (i > k));
        System.out.println((i > j) || (i < k));
        System.out.println((i < j) || (i < k));
        
        // &&和&
        System.out.println((i++ > 100) & (j++ > 100));
        // System.out.println((i++ > 100) && (j++ > 100));
        System.out.println("i:" + i);
        System.out.println("j:" + j);
	}
}

注意事项：

  • 逻辑与&，无论左边真假，右边都要执行

    短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

  • 逻辑或|，无论左边真假，右边都要执行

    短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

三元运算符

格式：关系表达式?表达式1: 表达式2;

范例：a > b ? a: b

public class OperatorDemo09 {
	public static void main(string[] args) {
		// 定义两个变量
		int a = 10;
		int b = 20;
		
		// 获取两个数据中的较大值
		int max = a > b ? a: b;
		// 输出结果
		System.out.println("max:" + max)
	}
}

java数据输入

Scanner使用基本步骤

/*
	数据导入
		导包：
			import java.util.Scanner;
		创建对象：
			Scanner sc = new Scanner(System.in);
		接受数据：
			int x = sc.nextInt();
*/
import java.util.Scanner;
public class ScannerDemo {
	public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);
		
		// 接收数据
		int x = sc.nextInt();
		
		// 输出数据
		System.out.println("x:" + x);
	}
}

java流程控制

流程控制语句分类

  • 顺序结构
  • 分支结构（if, switch)
  • 循环结构（for, while, do ... while）

顺序结构

最简单的基本流程控制，按照代码先后顺序，一次执行。

public class OrderDemo {
	public static void main(string[] args) {
		System.out.println("开始");
		System.out.println("语句A");
		System.out.println("语句B");
		System.out.println("结束");
	}
}

if分支结构

1.单分支格式

if (关系表达式) {
	语句体;
}

执行流程：计算关系表达式，值为true，执行与语句体，否则不执行语句体，继续执行后面语句。

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		// 定义两个变量
		int a = 10;
		int b = 20;
		
		// 判断a和b是否相等，相等输出：a等于b
		if (a == b) {
			System.out.println("a等于b");
		};
		if (a != b) {
			System.out.println("a不等于b");
		};
		System.out.println("结束");
	}
}

2.二分支格式

if (关系表达式) {
	语句体1;
} else {
	语句体2;
}

image-20200629233927569

执行流程：

  1. 计算关系表达式的值
  2. 值为true，执行与语句体1
  3. 否则执行语句体2
  4. 继续执行后面语句。
public class IfDemo02 {
	public static void main(String[] args) {
		System.out.println("开始");
		// 定义两个变量
		int a = 10;
		int b = 20;
		
		// 判断a和b是否相等，相等输出：a等于b
		if (a == b) {
			System.out.println("a等于b");
		} else {
			System.out.println("a不等于b");
		};
		System.out.println("结束");
	}
}

3.多分支格式

if (关系表达式1) {
	语句体1;
} else if (关系表达式2) {
	语句体2;
}
...
else {
	语句体n+1;
}

执行流程：

  1. 计算关系表达式1的值；
  2. 值为true，执行与语句体1；值为false就计算关系表达式2的值；
  3. 值为true，执行与语句体2；值为false就计算关系表达式3的值；
  4. ...
  5. 如果没有任何关系表达式为True，则执行语句体n+1；
import java.util.Scanner;
public class IfDemo03 {
	public static void main(String[] args) {
		System.out.println("开始");
		// 输入一个星期数，对应星期一、星期二、星期三、...、星期日
		Scanner sc = new Scanner(System.in);
		System.out.println("输入一个星期数(1~7):");
		int week = sc.nextInt();
		
		if (week == 1) {
			System.out.println("星期一");
		} else if (week == 2) {
			System.out.println("星期二");
		} else if (week == 3) {
			System.out.println("星期三");
		} else if (week == 4) {
			System.out.println("星期四");
		} else if (week == 5) {
			System.out.println("星期五");
		} else if (week == 6) {
			System.out.println("星期六");
		} else {
			System.out.println("星期日");
		};
		System.out.println("结束");
	}
}

switch语句

流程格式

switch (表达式) {
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		[break;]
}

说明：

  • 表达式：取值为byte、short、int、char、JDK5以后可以是枚举，JDK7以后可以使String。
  • case：后面跟的是要和表达式进行比较的值
  • break：表示中断，结束的意思，用来结束switch语句
  • default：表示所有情况都不匹配的时候，就执行该处的内容，和if-else语句相似

执行流程：

  1. 计算表达式的值
  2. 依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，执行过程中，遇到break会结束。
  3. 如果所有case后面的值和表达式的值不匹配，就会执行default里面的语句体，然后程序结束。

image-20200630085948630

import java.util.Scanner;

public class SwitchDemo{
	public static void main(String[] args) {  
        System.out.println("开始");
		// 输入一个星期数,对应输出星期一,...星期日
		Scanner sc = new Scanner(System.in)

		System.out.println("请输入一个星期数(1-7):")
		int week = sc.nextInt();
		switch (week) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("输入星期数有误");
				break;
		}

		System.out.println("结束")
	}
}

for循环语句

循环结构组成：

  • 初始化条件：表示循环开始时的起始状态
  • 条件判断语句：用于判断循环是否反复执行的条件
  • 循环体语句：循环反复执行的内容
  • 条件控制语句：循环中每次变化的内容，控制循环体是否执行下去

格式

for (初始化语句; 条件判断语句; 条件控制语句) {
	循环体语句;
}

流程：

  1. 执行初始化语句
  2. 执行条件判断语句：结果是false，循环结束；结果是true，继续执行
  3. 执行循环体语句
  4. 执行条件控制语句
  5. 回到2重复执行

image-20200630091233564

public class ForDemo{
	public static void main(String[] args) {  
		// 输出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}
	}
}

while循环语句

完整格式

初始化语句;
while (条件判断语句) {
	循环体语句;
	条件控制语句;
}

执行流程：

  1. 执行初始化语句；
  2. 执行条件判断语句：结果是false，循环结束；结果是true，继续执行；
  3. 执行循环体语句；
  4. 执行条件控制语句；
  5. 回到2重复执行；

image-20200630120158886

public class WhileDemo01 {
	public static void main(String[] args) {  
		// for实现,输出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}

		// while实现,输出5次"HelloWrold"
		int j = 1;
		while (j <= 5) {
			System.out.println("HelloWorld");
			j++;
		}
	}
}

do...while循环语句

基本格式

do {
	循环体语句;
} while (条件判断语句);

完整格式

初始化语句;
do {
	循环体语句;
	条件控制语句;
} while (条件判断语句);

执行流程：

  1. 执行初始化语句；
  2. 执行循环体语句；
  3. 执行条件控制语句；
  4. 执行条件判断语句：结果是false，循环结束；结果是true，继续执行；
  5. 回到2重复执行；
image-20200630124406312 
public class WhileDemo02 {
	public static void main(String[] args) {  
		// for实现,输出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}

		// while实现,输出5次"HelloWrold"
		int j = 1;
		do {
			System.out.println("HelloWorld");
			j++;
		} while (j <= 5);
		
	}
}

三种循环的区别

循环区别：

  • for和while是先判断条件是否成立，在决定是否执行
  • do...while先执行一次，在判断是否成立，是否继续执行

for和while区别：

  • 条件语句控制的自增变量，在for循环结束后，外部不能再次访问到
  • 条件语句控制的自增变量，不属于while语法结构，while循环结束后，还可以继续使用
public class LoopTest {
	public static void main(String[] args) {
		// 区别一:  
		// for循环
		for (int i=3; i<3; i++) {
			System.out.println("i love java");
		}

		// while循环
		int j = 3;
		while (j < 3) {
			System.out.println("j love java");
			j++;
		}

		// do...while循环
		int k = 3;
		do {
			System.out.println("k love java");
			j++;
		} while (k < 3);

		// 区别2:
		// for循环
		for (int i=3; i<3; i++) {
			System.out.println("i love java");
		}
		// System.out.println(i);  // 不能再使用,会报错

		// while循环
		int j = 3;
		while (j < 3) {
			System.out.println("j love java");
			j++;
		}
		System.out.println(j);  // 可以正常使用
	}
}

三种死循环写法

while死循环是最常用的

public class LoopTest01 {
	public static void main(String[] args) {
		// 死循环
		for (;;) {
			System.out.println("for");
		}

		while (true) {
			System.out.println("while");
		}

		do {
			System.out.println("do...while");
		} while (true);
	}
}

跳转控制语句

continue：循环中，基于条件控制，跳过某次循环体内容的执行，继续下次的执行

break：循环中，基于条件控制，终止循环体内容的执行，结束当前整个循环。

public class ControlDemo {
	public static void main(String[] args) {
		for (int i=1; i<=5; i++) {
			// continue
			break
			System.out.println(i)
		}
	}
}

循环嵌套

分支语句中包含分支语句称为分支嵌套

循环语句中包含循环语句称为循环嵌套

public class LootNestDemo {
	public static void main(String[] args) {
		// for循环嵌套
		for (int hour=0; i<=3; i++) {
			for (int minute=0; minute<=3; minute++) {
				System.out.println(hour + "时" + minute + "分");
			}
			System.out.println("---------------")
		}
	}
}

Random模块

Random模块：产生一个随机数

使用步骤：

// 导入包
import java.util.Random
// 创建对象
Random r = new Random();
// 获取随机数
int number = r.nextInt(10); // 获取数据的范围: [0,10)

示例

import java.util.Random
public class RandomDemo {
	public static void main(String[] args) {
		// 创建对象
        Random r = new Random();
        // 获取随机数
        int number = r.nextInt(10); // 获取数据的范围: [0,10)
		System.out.println(number);
        
        // 获取一个1~100之间的随机数
        int x = r.nextInt(100) + 1;
        System.out.println(x);
		}
	}
}

推荐阅读