Java基础语法

Joker me

已于 2022-04-29 00:14:30 修改

阅读量136

点赞数

分类专栏： Java基础语法文章标签： java

于 2020-05-25 22:55:11 首次发布

本文链接：https://blog.youkuaiyun.com/qq_41767919/article/details/106344365

版权

Java基础语法专栏收录该内容

1 篇文章

订阅专栏

day01

简述java的编译及运行工程

java文件从源文件中创建到编译运行的主要过程

源文件由编译器编译成字节码文件(ByteCode)
字节码文件由java虚拟机解释运行

JDK:java Development kit(JRE+开发工具)
JRE:java Runtime Envirment(JVM+系统类库)
JVM:java Virtual Machines(Java虚拟机)
运行一个java程序所需要的最小环境为JRE,开发一个Java程序所需的最小环境为JDK

针对不同的操作系统有不同的JVM

java的可移植性:

源代码的可移植性
在不同的CUP,操作系统,或java编译器上,产生同样的结果
CPU的可移植性
由于Java编译器产生的目标代码是正对一种不存在CPU的运行环境–JVM
操作系统的可移植性
由于Java提供一套与平台无关的库函数(lang,util…)

day02

标识符

标识符是用来给变量,类,包以及方法来命名的

标识符必须要以字母下划线(_),美元符号($)开头
标识符其他部分可以使字母,数字,下划线,美元符号的任意组合
Java标识符大小写敏感,且长度无限制
标识符不可以是Java的关键字

标识符的使用规范

表示类名的标识:每个单词的首字母大写,eg:Student,DormBuild…
表示方法和变量的标识符:第一个单词小写,第二个单词开始首字母大写(驼峰命名法),eg:setName(),getName()…

八大基本数据类型

byte,short,int,long
整型:表示没有小数部分的数值,允许负值

类型	各种	封装类	占用空间(字节)	字符	取值
byte	位	Byte	1	8	-128~+127
short	短整型	Short	2	16	-32768~+32767
int	整形	Integer	4	32	-2^31 ~+2^31-1(约21亿)
long	长整形	Long	8	64	-2^63 ~+2^63-1
float,double

浮点型:带小数的数据

类型	各种	封装类	占用空间(字节)	字符	取值
float	单精度	Float	4	32	-3.403E38~+3.403E38
double	双精度	Double	8	64	-1.798E308~+1.798E308

char
字符型:在内存中占两个字节,在Java中使用单引号来表示字符常量.eg:‘A’

类型	各种	封装类	占用空间(字节)	字符	取值
fchar	字符	Character	2	16	0~65535

boolean
布尔型:有且只有两个常量,true,false.在内存中占一个字节,不可以用0或非0的数据代替true或false;

变量
程序运行期间,内容可以改变的量

		变量的初始化
		数据类型 变量名称;//创建了一个变量
		变量名称 = 数据值;//赋值,将做右边的数据值赋值给左边的变量
		
		数据类型 变量名称 = 数据值;//创建了一个变量,同时将数据值付给变量

注意事项:

如果创建多个变量,变量名称不可重复,若创建同名的同名的变量名称,必须保证它们的作用域互不相交
对于float和long类型来说,字母后缀不能丢,否则,会默认为double类型或者是int类型
对于byte类型和short类型的变量,赋值的数据不能超过其范围,佛足额会出现编译错误,另外,在运算时不要超过其范围,否则发生溢出,损失精度
初始化的变量一定要进行赋值,不能直接使用,否则会出现编译错误,赋值之后才能使用
在变量运算中,会默认的将数值转化为int类型

强制转化

		数据类型 变量名 = (数据类型)被转数据;
		byte a = 2;
		byte a = 3;
		byte c = (byte)(a+b);

注意事项

强制转换一般不推荐使用,因为有可能发生精度损失,数据溢出等
byte/short/char,运算时,会被提升为int类型
char类型,可以默认为整数.例:‘0’–>48
boolean类型不能发生数据类型的转换

ASII编码表
‘0’–>48,‘A’–>65,‘a’–>97

day03

运算符

算术运算符(+(加),-(减),*(乘),/(除),%(取余))
注意:a++,++a;
前加加:先使用,再自加
后加加:先自加,再使用

		int a = 2;
		int b = a++ + ++a;//2+4
		int c = (a++)+(++a);//4+6

关系运算符(>,<,>=,<=,==,!=,)
位运算符(&(按位与),^(按位异或),|(按位或),>>(按位右移),<<(按位左移),>>>(逻辑右移))

		int a = 2;			//0010
		int b = 3;			//0011
		int c = a & b;		//0010
		int d = a ^ b;		//0001
		int e = a | b;		//0011
		int g = a << 2;		//1000

>>与>>>的区别
‘>>’:如过该数为正数,则高位补0,若为负,则高位补1
‘>>>’:若为正数,则高位补0,而该数为负数,高位同样补0

		int a2 = -2;			//1111 1110
		int f = a2>>3;			//1111 1111
		int h = a2>>>3;			//0001 1111

逻辑运算符(&&(逻辑与,并且),||(逻辑或,或者),!(逻辑非,取反))
&&:连接时,前面的条件为false,即为false,后面语句不执行
||:连接时,前面的语句为true,后面语句不执行
注意事项: 先做关系运算,再做逻辑运算
赋值运算符(=,扩展运算符(+=,-=,*=,/=,%=))

		int a = 1 ;
		注意:b *= 4; ==>int b = (int)(b*4);

三目运算符(三元运算符)

		数据类型 变量名 = 布尔表达式 ? 结果1 : 结果2;
		int a = 1 , b = 2 ;
		int c = a > b ? a : b;

day04

分支结构

if结构:一条路

		if结构:一条路
			if(条件表达式){
				语句块
			}
		if...else if..结构:多条路
			if(条件表达式){
				语句块;
			} else if (条件表达式){
				语句块;
			}

		switch...case...结构：多条路
			switch(条件表达式){
				case 1:
					语句块;
					break;
				...
				default:
					语句块;
			}

优点:效率高,结构清晰.
缺点:必须整数,且相等

循环结构

while循环结构:先判断再执行

		变量初始化表达式;
		while(条件表达式){
			循环体;
			步进表达式;
		}

		int i = 1 ;//变量的初始化
		while(i <= 12){//条件表达式
			salary += 180;//循环体
			System.out.println(i+"月后的工资为"+salary);
			i++;
		}

do…while…循环:先执行一次循环体,再判断

		变量的初始化表达式
		do{
			循环体;
			步进表达式;
		}while(条件表达式);

		int i = 1;//变量的初始化
		do{
			salary += 180;//循环体
			System.out.println(i+"月后的工资为"+salary);
			i++
		} while(i < 12);//条件表达式

day05

循环结构

for循环

		int sum = 0;
		for(int i = 1; i <= 100; i++){
			sum += i; 
		}
		System.out.println("总和:"+sum);

		i		循环			sum
		1		true			1
		2		true			1+2
		3		true			1+2+3
		4		true			1+2+3+4
		...
		100		true			1+2+3+4+...+100
		101		false

总结:

while…:"当"循环
do… while:"直到"循环
for:与次数有关

break与continue的区别

break:跳出循环

		for(int i = 1; i <= 5; i++){
			if(i == 4){
				break;
			}
			System.out.println(" " + i);
		}

		输出结果: 1 2 3

continue:跳过本次循环

		for(int i = 1; i <= 5; i++){
			if(i == 4){
				continue;
			}
			System.out.println(" " + i);
		}

		输出结果: 1 2 3 5

嵌套循环

循环中套循环,一般多行多列,外层控制行,内层控制列,外层走一次,内层走所有次.
注意:循环次数越少越好,不要超过三层.

九九乘法表:

		for(int i = 1; i <= 9; i++){
			for(int j = 1; j <= i; j++){
				System.out.print(j + "*" + i + "=" + j * i + "\t");
			} 
			System.out.println();
		}

程序 = 数据结构 + 算法

算法:解决问题的流程(顺序,分支,循环)
数据结构:将数据按照某种特定的结构来保存

数组

相同数据类型元素的容器.(是一种引用数据类型,数据类型相同,数组长度不可变,初始化后,若没有赋值,则自动生成默认值0或null)
数组的初始化

动态初始化

		数据存储的数据类型[] 数组名字 = new 数组存储的数据类型[数组的长度];

静态初始化

		数据类型[] 数据名 = new 数据类型[]{元素1, 元素2, ...};
		//静态简写
		数据类型[] 数据名 = {元素1, 元素2, ...};

		int[] arr1 = new int[10];
		int[] arr2 = new int[]{1, 2, 3};
		int[] arr3 = {3, 4, 5};
		int[] arr4;
		arr4 = new int[4];

数组的访问:

		int[] arr1 = {1, 2, 3, 4, 5};
		int[] arr2 = {5, 6, 7, 8, 9, 10};
		int[] arr =new int[2];
		
		//数组的赋值(通过下标,来赋值)
		arr[0] = 0;
		arr[1] = 1;
		
		//数组的长度
		int len = arr1.length;
		System.out.println("arr1的长度:" + len);
		
		//遍历数组
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(" " + arr1[i]);
		}
		System.out.println();
		
		//数组的复制:arr1-->arr2
		System.arraycopy(arr1, 0, arr2, 1, arr1.length);
		//arr的长度+1,现在为3
		arr = Arrays.copyOf(arr, arr.length+1);//扩容
		
		//数组排序(升序)
		Arrays.sort(arr2);

day06

方法:函数过程

封装了一段特定的业务逻辑功能
方法尽可能的独立,一个方法只干一件事
方法可以被反复多次使用
减少代码的重复,有利于代码维护,有利于团队协作

方法的定义

	修饰符 返回值类型 方法名(参数列表){
		业务逻辑
	}

方法的调用

无返回值:方法名(有参传参);
有返回值:数据类型变量名 = 方法名(有参传参);

return

return 变量;
结束方法的执行
返回结果给调用方
return;
结束方法的执行(只能用在无返回值的方法中)
注意事项
无返回值:将返回值类型设计为void
有返回值:将返回值类型设计为具体的数据类型

public class Demo2 {
	public static void main(String[] args) {
		print();
		print(3);
		int rand = rand();
		int rand2 = rand(10);
		System.out.println(rand + "," + rand2);
	}
	//无参无返回值
	public static void print() {
		System.out.println("你好!");
	}
	
	//有参无返回值
	public static void print(int a) {
		System.out.println("打印的值为:" + a);
	}
	
	//无参有返回值
	public static int rand() {
		return (int)(Math.random() * 100)+1;
	}
	
	//有参有返回值
	public static int rand(int a) {
		return (int)(Math.random() * a) + 1;
	}
	
}