JAVA初级基础

Chen Mon

已于 2022-08-14 08:49:01 修改

阅读量369

点赞数

文章标签： java 开发语言 java-ee

于 2022-06-06 20:05:14 首次发布

本文链接：https://blog.csdn.net/weixin_52112640/article/details/125137796

版权

文章目录

第一章 Java语言概述
第二章 Java中的基本语法
第三章数组
- 1、一维数组
- 2、二维数组
第四章面向对象（上）

第一章 Java语言概述

1、Java语言概述

是SUN(Stanford University Network，斯坦福大学网络公司 ) 1995年推出的一
门高级编程语言。
是一种面向Internet的编程语言。Java一开始富有吸引力是因为Java程序可以
在Web浏览器中运行。这些Java程序被称为Java小程序（applet）。applet使
用现代的图形用户界面与Web用户进行交互。 applet内嵌在HTML代码中。
随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言

2、Java语言的运行机制

（1）Java虚拟机

JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指
令，管理数据、内存、寄存器。
对于不同的平台，有不同的虚拟机。
只有某平台提供了对应的java虚拟机，java程序才可在此平台运行
Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”

（2）垃圾回收

不再使用的内存空间应回收—— 垃圾回收。
在C/C++等语言中，由程序员负责回收无用内存。
Java 语言消除了程序员回收无用内存空间的责任：它提供一种系统级线程跟踪存储空
间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。
垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预。
Java程序还会出现内存泄漏和内存溢出问题吗？会!

3、Java语言的环境

（1）环境搭建

https://www.oracle.com/
单击Resources
双击下载的exe,jdk-8u333-windows-x64
进入安装向导
下一步,更改安装路径，选择安装所有组件
下一步安装
安装 jre，可以更改 jre 安装路径。(过程同上述安装目录的选择)

在这里插入图片描述

点击下一步，开始安装
结束安装

（2）配置环境变量

在桌面选中我的电脑 ->右键 ->属性 ->高级系统设置

-单击环境变量
在系统环境变量：新建 ->JAVA_HOME
在配置Path里配置
检查是否配置成功

（3）编写第一个Java程序

编写代码
javac 编译
java 运行

（4）注释

/*
**1.java规范了三中注释方式：
单行注释
多行注释
文档注释（java特有）
2.单行注释和多行注释的作用
	* 对所写的程序进行解释说明，增加可读性。方便自己方便他人
	* 对写的代码进行调试
3.特点：单行注释和多行注释，注释了的内容不参与编译。
	编译以后生成的.class 结尾的字节码文件中不包含注释掉的信息
4.文档注释的使用：
	* 注释的内容可以被JDK提供的工具 javadoc所解析，生成一套以网页文件形式体现的程序的说明文档
*/
class  HelloJava
{
   
	/*
	多行注释：
	如下的main方法是程序的入口！
	main的格式是固定的！**
	*/
	public static void main(String[] args) 
	{
   
		// 单行注释：表示输出到控制台
		System.out.println("Hello World!");
	}
}

第二章 Java中的基本语法

1、关键字和保留字

（1）关键字

关键字(keyword)的定义和特点
定义：被Java语言赋予了特殊的定义，用做专门的用途(单词)
特点：关键字的字母都是小写

（2）保留字

Java保留字：现有Java版本尚未使用，但以后的版本可能会作为关键字使用。自己命令标识符时要避免使用这些保留字
goto、const

2、标识符

（1）标识符使用

/*
标识符的使用
1、标识符：凡是自己可以起名字的地方都叫标识符
	比如：类名、变量名、方法名、接口名、包含...

2、标识符的命名规则		---> 如果不遵守如下规则，编译不可以通过！
	由26个英文字母大小写，0-9 _或$组成
	数字不可以开头
	不可以使用关键字和保留字，但能包含关键字和保留字。
	Java中严格区分大小写，长度无限制。
	标识符不能包含空格

3、Java中的名称命名规范：	---> 如果不遵守如下规则，编译可以通过！
包名：多单词组成是所有字母都小写：xxxxyyyyzzzz
	类名、接口名：多单词组成时，所有单词的首字母大小写：XxxYyyZzz
	变量名、方法名：多单词组成时，第一个单词首字母大小写，第二个单词开始首字母大写：xxzYyyZzz
	常量名：所有字母都大小写。多单词时，每个单词用下划线链接：XXX_YYY_ZZZ

4、
注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode()字符集，因此标识符也可以使用汉字声明，但不建议使用。

*/


class IdentifierTest {
   
	public static void main(String[] args) {
   
		System.out.println("Hello World!");
	}
}
class Hello1_${
   
}
// 数字不可以开头
class 1Hello
{
   	
}
// 不可以使用关键字和保留字，但能包含关键字和保留字。
class static {
   

}
// 标识符不能包含空格
class user Persion{
   
}

2 、变量

（1）变量的使用

/*
变量的使用
1、java定义变量的格式：数据类型 变量名 = 变量值；
2、说明：
	变量必须先声明，后使用
	变量都定义在其作用域内。在作用域内，它是有效的。除了作用域，就失效了
	同一个作用域内，不可以声明两个同名的变量

*/



class VariableTest{
   
	public static void main(String[] args) {
   
		// 变量的定义
		int myAge = 12;
		// 变量的使用
		System.out.println(myAge);

		// 使用myNumber之前并未定义过myNumber
		// System.out.println(myNumber)

		// 变量的声明
		int myNumber;
		
		// 编译错误：使用myNumber之前并未赋值过myNumber，变量初始化失败
		// System.out.println(myNumber)
		
		// 变量的赋值
		myNumber = 1001;

		// 不可以在同一个作用域内定义同名的变量
		// int myAge = 30
		System.out.println(myNumber);
		// 编译不通过,不在同一个作用域里
		// System.out.println(myClass)
	}
	public void method(){
   
		int myClass = 1;
	}
}

（2）数据类型的定义

/*
Java定义的数据类型
1、变量按照数据类型来分类：
	
	基本数据类型
		整型：byte \ short \ int \ long
		浮点型：float \ double
		字符型：char
		布尔型：true \ flase 
	引用数据类型：
		类(class)
		接口(interface)
		数组(array)

2、变量在类中声明的位置：
		成员变量  vs  局部变量
*/
class VariableTest1 {
   
	public static void main(String[] args) {
   
		// 1.整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
		// byte范围：-128 ~ 127
		byte b1 = 12;
		byte b2 = -128;
		// b2 = 128; //编译不通过
		System.out.println(b1);
		System.out.println(b2);
		// 声明long型变量，必须一"1"或者"L"结尾
		// 通常定义整型变量时，是哟int类型
		short s1 = 128;
		int i1 = 1234;
		long l1 = 341245456L;
		System.out.println(l1);

		
		//2.浮点型：float(4字节) \ double(8字节)
		//	浮点型，表示带小数点的数值
		// float 表示数值的范围比long大
		
		double d1 = 123.3;
		System.out.println(d1 + 1);
		// 定义float类型变量时，变量要以"f"或"F"结尾
		float f1 = 12.3F;
		System.out.println(f1);
		// 通常，定义浮点型变量时，使用double型。因为范围大、精度高、不用写"F"
		
		// 3.字符型：char(1字符=2字节)
		// 定义char型变量,通常使用一对''，内部只能写一个字符
		char c1 = 'a';
		// c1 = 'AB';
		System.out.println(c1);

		// 表示方式：1.声明一个字符 2.转义字符
		char c5 = '\n'; //换行符
		c5 ='\t'; //制表符
		System.out.println("hello" + c5);
		
		char c6 = '\u0123';
		System.out.println(c6);

		// 4.布尔型：boolean
		// 只能取两个值之一：true、false
		// 常常在条件判断、循环结构中使用
		boolean bb1 = true;
		System.out.println(bb1);

		boolean isMarried = true;
		if(isMarried){
   
			System.out.println("你就不能参加单身party了！很遗憾");

		}else{
   
			System.out.println("你可以多谈谈女朋友!");
		}

	}
}

（3）基本数类型之间的运算规则

/*
基本数据类型之间的运算规则:
前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

	1.自动类型提升：
		结论：当容量小的数据类型的变量域容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
		byte --> short --> int --> long --> float -->double 
		byte 、char 、short --> int --> long --> float -->double 
		特别的：当byte、char、short三种类型的变量做运算时，结果为int类型
	
	2.强制类型转换：自动类型提升运算的逆运算。
		1.需要使用强转符：()
		2.注意点：强制类型转换，可能导致精度损失。


	说明：此时的容量大小指的是，表示数的范围的大和小。比如float的容量大于long的容量
*/
class VariableTest2 {
   
	public static void main(String[] args) {
   
		
		byte b1 = 2;
		int il = 12;
		//编译不通过
		// byte b2 = b1 + il;
		int i2 = b1 + il;
		long l1 = b1 + il;
		System.out.println(i2);

		float f = b1 + il;
		System.out.println(f);

		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);
		
		// ***********特别的************

		char c1 = 'a';
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);

		short s2 = 10;
		//char c2 = c1 + s2; //编译不通过

		byte b2 = 10;
		// char c3 = c1 + b3; //编译不通过

		// short s3 = b2 + s2; //编译不通过
		
		// short s4 = b1 + b2; //编译不通过
		// ***********************
		double e1 = 12.9;
		//精度损失举例1
		int gl = (int)e1; // 截取操作
		System.out.println(gl);

		//没有精度损失
		long h1 = 123;
		short j2 = (short)11;

		//精度损失举例2
		int k2 = 128;
		byte b = (byte)k2;
		System.out.println(b);//-128
	}
}

（4）编码情况

class VariableTest4 {
   
	public static void main(String[] args) {
   
		
		// 1.编码情况
		long l = 123213;
		System.out.println(l);
		// 编译失败：过大的整数
		// long l1 = 1278324798327894;
		long l1 = 1278324798327894L;


		//********************
		//编译失败(类型不兼容)
		// float f1 = 12.3;
		float f1 = (float)12.3;
		float f2 = 12.3F
		
		//2.编码情况2：
		//整数常量，默认类型为int型
		//浮点型常量，默认类型为double型
		byte b = 12;
		// byte b1 = b + 1;//编译失败

		//float f1 = b + 12.3;//编译失败
	}
}

（5）String类型

/*
String类型变量的使用
	1.String属于引用数据类型,翻译为:字符串
	2.声明String类型变量时，使用一对""
	3.String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
	4.运算的结果任然是String类型
*/
class StringTest {
   
	public static void main(String[] args) {
   
		String s1 = "Hello World!";
		System.out.println(s1);

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过

		// ******************
		int number = 1001;
		String numberStr = "学号:";
		String info = numberStr + number;// +: 连接运算
		boolean b1 = true;
		String info1 = info + b1;// +: 连接运算
		System.out.println(info1);
		
		//练习1
		char c = 'a';
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str );//107hello
		System.out.println(str + num + c);//hello10a

		//练习2(是否可以变成(*	*))
		System.out.println("*	*");//yes
		System.out.println('*' + '\t' + '*');//no
		System.out.println('*' + "\t" + '*');// yes
		System.out.println('*' + '\t' + "*");// no
		System.out.println('*' + ('\t' + "*"));//yes

		// String str1 = 123; //编译不通过
		String str1 = 123 + "";
		System.out.println(str1);// "123"

		// int num = str1;
		// int num = (int)str1;//"123"

		int num1 = Integer.parseInt(str1);
		System.out.println(num1);// 123
	}
}

3、运算符

（1）算术运算符

图解

/*
运算符之一：算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/

class AriTest {
   
	public static void main(String[] args) {
   
		//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);//2

		int result2 = num1 / num2 * num2;
		System.out.println(result2);//10

		double result3 = num1 / num2;
		System.out.println(result3);//2.0

		double result4 = num1 / num2 + 0.0;//2.0
		double result5 = num1 / (num2 + 0.0);//2.4
		double result6 = (double)num1 / num2;//2.4
		System.out.println(result4);
		System.out.println(result5);
		System.out.println(result6);

		// %:取余运算
		// 结果符号与被模数的符号相同

		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 =" + m1 % n1);

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

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

		int m4 = -12;
		int n4 = -5;
		System.out.println("m1 % n1 =" + m4 % n4);
		
		// ***************************************
		
		//(前)++：先自增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++;
		int b3 = a3;

		System.out.println("a3 = " + a3 +",b3 = " + b3);//a3 = 11,b3 = 11

		//注意点：
		short s1 = 10;
		//s1  = s1 + 1;//编译失败(类型)
		//s1 = (short)(s1 + 1);//编译成功
		s1++;
		System.out.println(s1);

		byte s2 = 127;
		s2++;
		System.out.println(s2);

		//(前)--：先自减1，在运算
		//(后)--：先运算，在自减1
		int a4 = 10;
		a4--;
		System.out.println(a4);
		int a5 = 12;
		--a5;
		System.out.println(a5);



	}
}

练习

/*
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况下：
个位数：
十位数：
百位数：
列如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
*/
class AriExer {
   
	public static void main(String[] args) {
   
		int num = 153;

		int bai = num / 100;
		int shi = num % 100 /10;
		int ge = num % 10;

		System.out.println("百位数："+ bai);
		System.out.println("十位数："+ shi);
		System.out.println("个位数："+ ge);

	}
}

（2）赋值运算符

/*
运算符之二：赋值运算符
=	+=	-=	/=	%=
*/
class SetValueTest {
   
	public static void main(String[] args) {
   
		// 赋值符号：=
		int il = 10;
		int jl =10;
		int i2,j2;
		//连续赋值
		i2  = j2 = 10;
		int i3 = 10,j3 = 20;

		// ******************
		int num1 = 10;
		num1 += 2;//num1 = num1 + 2;
		System.out.println(num1);

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

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

		//开发中，如果希望变量实现+2操做，有几种方法？(前提：int num = 10;)(先声明变量的类型为int)
		//方式一：num = num + 2；
		//方式二：num += 2;

		//开发中，如果希望变量实现+1操作有几种方法？(前提：int num = 10;)
		//方式一：int num = 10;
		//		  num++;
		//方式二：int num = 10;
		//		  ++num;
		//方式三：num = num + 1;
		//方式死：num += 2;


		//练习1
		int i = 1;
		i *= 0.1;
		System.out.println(i);//10
		i++;
		System.out.println(i);

		//练习2
		int m = 2;
		int n = 3;
		n *= m++;//n = n * m++;
		System.out.println("m=" + m);
		System.out.println("n=" + n);
		
		//练习3
		int n1 = 10;
		n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);
		System.out.println(n1);
		
	}
}

（3）比较运算符

图解

/*
运算符之三：比较运算符
==	!=	>	<	>=	<=	instanceof

结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 =
*/
class CompareTest {
   
	public static void main(String[] args) {
   
		// = 与 == 区分
		// = 是赋值(把左边的值赋值给右边)，而 == (就是数学中的等于(=))
		int i = 10;
		int j = 20;

		System.out.println(i == j);//false
		System.out.println(i = j);//20

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 == b1);//true
	}
}

（4）逻辑运算符

/*
运算符之四：逻辑运算符

&	&&	|	||	!	^

说明:
1.逻辑运算符操做的都是boolean类型的变量


*/
class LogicTest {
   
	public static void main(String[] args) {
   
		//区分$ 与 $$
		// 相同点1：& 与 && 的运行结果相同
		// 相同点2：当符号左边是true时，二者都会执行符号右边的运算
		// 不同点：当符号左边的是false时，&会继续执行符号右边的运算，&& 不会执行符号右边的运算。
		// 推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
   
			System.out.println("我现在在北京");

		} else {
   
			System.out.println("我现在在南京");
		}
		System.out.println("num1 = " + num1);

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
   
			System.out.println("我现在在北京");

		} else {
   
			System.out.println("我现在在南京");
		}
		System.out.println("num2 = " + num2);

		// ***************************
		// 区分：| 与 ||
		// 相同点1： | 与 || 的运算结果相同
		// 相同点2：当符号左边是false时，| 与 || 都会执行符号右边的算子
		// 不同点：当符号左边的是true是，| 会继续执行符号右边的运算，|| 不会执行符号右边的运算。
		// 在开发中推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
   
			System.out.println("我现在在北京");

		} else {
   
			System.out.println("我现在在南京");
		}

		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num3++ > 0)){
   
			System.out.println("我现在在北京");

		} else {
   
			System.out.println("我现在在南京");
		}
	}
}

（5）位运算符

位运算是直接对整数的二进制进行的运算

/*
运算符之六：三元运算符
1.结构：(条件表达式)？表达式1 ：表达式2
2.说明
	条件表达式的结果为boolean类型
	根据条件表达式真或假，决定执行表达式1，还是表达式2。
	如果表达式为true，则执行表达式1。
	如果表达式2为false，则执行表达式2。
	表达式1和表达式2要求是一致的。
	三元运算符可以嵌套的

3.凡是可以使用三元运算符的地方都可改写为if-else
*/
class SanYuanTest {
   
	public static void main(String[] args) {
   
		// 获取两个整数的较大值
		int m = 12;
		int n = 5;

		int max = (m > n)? m : n;
		System.out.println(max);

		double num = (m > n)? 2 : 1.0;

		// (m > n)? 2 : "n大";//编译错误

		// ******************************
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等":"n大");
		System.out.println(maxStr);

		// **********************
		// 三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;

		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)