Java程序基础结构详解（基础学习）

Java程序详解

1.3.1 Java程序中JDK、JRE、JVM的概念

1.JDK

JDK是Java开发工具包，是Sun Microsystems针对Java开发人员的产品。
　JDK中包含JRE，在JDK的安装目录下有一个名为JRE的目录
　

里面有两个文件夹bin和lib，在这里可以认为bin里的就是JVM

lib中则是JVM工作所需要的类库，而JVM和 lib和起来就称为JRE。

JDK是整个JAVA的核心，包括了Java运行环境JRE（Java Runtime Envirnment）

SE(J2SE)，standard edition，标准版，是我们通常用的一个版本，从JDK 5.0开始，改名为Java SE。
　EE(J2EE)，enterprise edition，企业版，使用这种JDK开发J2EE应用程序，从JDK 5.0开始，改名为Java EE。
　ME(J2ME)，micro edition，主要用于移动设备、嵌入式设备上的java应用程序，从JDK 5.0开始，改名为Java ME。

2.JRE

是运行基于Java语言编写的程序所不可缺少的运行环境。也是通过它，Java的开发者才得以将自己开发的程序发布到用户手中，让用户使用。
　JRE中包含了Java virtual machine（JVM），runtime class libraries和Java application launcher，这些是运行Java程序的必要组件。
　与大家熟知的JDK不同，JRE是Java运行环境，并不是一个开发环境，所以没有包含任何开发工具（如编译器和调试器），只是针对于使用Java程序的用户。
　

3.JVM

就是我们常说的java虚拟机，它是整个java实现跨平台的最核心的部分，JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。因此所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行。
　也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。
　只有JVM还不能有效的执行.class文件，因为在解释.class文件的时候JVM需要调用解释所需要的类库lib，而jre包含lib类库。（上图所示）
4.三者之间的关系
简单来说就是JDK包含JRE,JRE又包含JVM的关系

Java程序基本结构

Java语言是面向对象的程序设计语言，Java程序的基本组成单元是类，类体中又可包括属性与方法两部分。而每一个应用程序都必须包含一个main（）方法，含有main（）方法的类称之为主类。

package com.ambow.test;
public class HelloWord {
public static void main(String[] args) {
	System.out.println("helloword!");
}
}

2.1.1 Java程序的主类及其格式

作为一个可以独立运行的Java程序，在它的众多类中必须要有一个类作为程序的起始类。当需要执行一个程序时，人们在java命令后面输入的便是这个主类的文件名（也是主类名），因此主类文件是Java运行环境建立起来之后第一个被装入虚拟机的用户文件。为了使虚拟机可以找到程序运行的起始入口，主类必须为public类，并含有一个在格式上符合约定的入口方法main（），其格式如下：

public static void main(String[] Args){
System.out.print(“......”);
}

其中各参数含义如下。

main:入口方法名称。
Args:命令行参数，这是一个 String:对象数组。
static:修饰字，说明
main（）是一个静态方法（类方法）。
public:修饰字，说明main()具有公有访问属性。

于是，主类框架的源代码如下：

public class主类名{
public static void main(String[] Args){
System.out.print(“......”);
}
}

2.1.2 Java源程序的完整组成

1．package语句；
2．import语句；
3．public class Definition; //公共的类定义部分，至多只有一个公共类的定义
//java语言规定该java源程序的文件名必须与该公共类名完全一致
4．class Definition; // 类定义部分，可以有0个或多个
5．interface Definition; // 接口定义部分，可以有0个或多个
6．interface Definition; // 接口定义部分，可以有0个或多个
7．package:java编译器为每个类生成一个字节码文件，且文件名与类名相同，这就会带来一个问题：同名的类会发生冲突。package便可管理类命名空间。

一般地，具有相同功能的类放在一个package中。一个java源程序至多只能有一个公共类的定义。若java源程序有一个公共类的定义，则该源文件名字必须与该公共类的名字完全相同。若源程序中不包含公共类的定义，则该文件名可以任意取名。若一个源程序中有多个类定义，则在编译时将为每个类生成一个.class文件

2.2 Java编程规范

—————————————————————————————————

2.2.1 Java编码规范存在的意义是什么

*1.好的编码规范可以尽可能的减少一个软件的维护成本，并且几乎任何一个软件，在其整个生命周期中，均由最初的开发人员来维护；
2.好的编码规范可以改善软件的可读性，可以让开发人员尽快而彻底地理解新的代码；
3.好的编码规范可以最大限度的提高团队开发的合作效率；
4.长期的规范性编码还可以让开发人员养成好的编码习惯，甚至锻炼出更加严谨的思维；

2.2.2 Java命名规范

1.类名是由字母、数字、下划线或$符组成，且第一个字符不能是数字。
2.如果用的是拉丁字母，那么名字的首字母使用大写字母。
3.如果多个单词复合而成，我们习惯上，每个单词的第一个字母大写。
各名称规范
4.包名：全小写的名词，中间可由点分割，com.ambow.demo
5.类名：首字母大写，多个单词合成，每个单词首字母也要大写

Netherworld

1.接口名： 同类名，Collection
2.方法名： 由多个单词合成，第一个单词通常为动词，首字母小写，中间的每个单词的首字母都要大写， Buttressed
3.变量名： 全小写，一般为名词，length
4.常量名： 基本数据类型的常量名为全大写，如果由多个单词构成，可以用下划线隔开， int YEAR, int WEEK_OF_MONTH,对象类型的常量，则是小写混合，由大写字母把单词隔开。*
—————————————————————————————————

2.3 Java的关键字和标识符

2.3.1 Java 中的标识符

简单地说，标识符由程序设计或者开发人员定义的单词，用来标识一个类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。定义Java 中的标识符，必须遵循一定的语法规则并且有必要遵守一定的规范。Java 语言规定：

1.标识符的组成由字母、下划线、美元符号$和数字组成。
2.第一个字符不能是数字。
3.标识符不能是 Java 的关键字和保留字。

另外在定义合法的标识符的前提下，对于类名、接口名或者枚举名建议采用“驼峰”命名方式，即每个单词的首字母要大写；对于变量名和方法名一般建议采用“匈牙利”命名法，即从第二个单词开始首字母大写；对于常量名全部要大写，单词组合用下划线进行连接；包名则全部小写。

注意事项：Java 语言的标识符严格区分大小写。例如，后面这些都是合法的标识符：username、PI、_$3abc、password。由于 Java 语言使用的是 Unicode 字符集（C/C++使用 ASCII 字符集，256 个），含有 65535 个字符，其中前 256 个是 ASCII 码及扩展的 ASCII。

2.3.2 Java 关键字与保留字

Java 中的关键字是系统预先定义好的标识符，这些关键字可用于基本数据类型定义、语法判断、跳转语句、异常处理、修饰定义、类和接口、包定义。保留字未来 Java 扩展的需要。Java 中的关键字与保留字详见下表。

abstract	default
if	private
Boolean	do
implements	protected
throws	Break
import	public
transient	Byte
else	instanceof
return	try
Case	extends
int	short
void	Catch
final	interface
static	volatile
Char	finally
long	super
while	Class
float	native
switch	null
onst	for
new	synchronized
strictfp	Continue
goto	package
this	assert
Enum	generic
rest	enter
operator	Fature
inner	var

1.用于基本数据类型的定义

boolean	char
byte	float
double	int
short	long
true	false

2.用于语法判断和语句

if…else	do…while
break	continue
newthrow	this
super	synchronized
switch…case…default	instanceof
null	return
try	catch
finally

3.用于修释定义

abstract	final
static	transient
volatile	native
throws	private
protected	public

4.用于类和接口

class	enum
interface	extends
implements

5.用于包

package	import

6.未来扩展用关键字（也称为保留字）

cast const	fature
generic	goto
inner	enter
rest var	operator

保留字(reserved word):保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。因此我们在命名时要避开这些保留字。

2.4 Java的数据类型

详见上篇

2.5 Java中数据类型的转换

2.5.1 隐式类型转换

隐式类型转换也叫作自动类型转换, 由系统自动完成,从存储范围小的类型到存储范围大的类型。
数据类型有小到大：
byte ->short(char)->int->long->float->double
示例：

package com.ambow.demo;
public class Demo {
	public static void main(String[] args) {
		//自动类型转换:将范围小的转换为范围大的
		//声明一个byte类型的变量b,并给其赋值
		byte b=14;
		//将变量b的值赋值给int类型的变量i
		int i=b;
		System.out.println("i="+i);
		// byte--->short--->int--->long--->float--->double
		double d=i;
		System.out.println("d="+d);
	}
}

2.5.2 显式类型转换

显示类型转换也叫作强制类型转换, 是从存储范围大的类型到存储范围小的类型.
当我们需要将数值范围较大的数值类型赋给数值范围较小的数值类型变量时，由于此时可能会丢失精度,因此，需要人为进行转换。我们称之为强制类型转换。
数据类型有大到小：

double→float→long→int→short(char)→byte

示例：

package com.ambow.demo;
public class Demo {
	public static void main(String[] args) {
		//强制类型转换:将范围大的转换为范围小的,需要强转(也就是在范围大的变量前加上范围小的变量类型)
		//范围从大到小:double--->float--->long--->int--->short--->byte
		int i1=34;
		short s=(short)i1;
		System.out.println("s="+s);
		double d1=3.78;
		int i2=(int)d1;
		System.out.println("i2="+i2);
		char c=97;
		int i3=98;
		c=(char)(i3+2);
		System.out.println("c="+c);
		//int类型转换为String类型
		int a=67;
		String str=a+"";
		System.out.println(str);
		//String类型转换为int类型
		String str1="123";
		int x=Integer.parseInt(str1);
		System.out.println("x="+x);
		double dou=3.141592611111111111;
		System.out.println(dou);
	}
}

2.6 变量和常量

2.6.1 变量
变量是在程序运行过程中值是可以改变的，变量名可以理解为是内存空间的标识。定义一个变量需要有一个类型，一个标识符，如果需要，还可以加上一个初值。定义变量的语法形式是：

数据类型 变量名 [= 变量值];

变量的类型可以是基本数据类型，也可以是引用类型（或者称为复合类型）。变量名可以自己设定，但首先变量名是一个标识符，定义时可以参照标识符章节中定义标识符规则与规范的内容。

示例：

1.数据类型   变量名；
		byte b;
		byte b1;
	2.数据类型  变量名=变量值；(推荐使用)
		short s=20;
	3.数据类型  变量名1=变量值1,变量名2=变量值2；
		int m=12,n=21;	
	4. 数据类型     变量名1，变量名2=变量值2；
		int i,i1=23;

注意：变量在没有赋值时，不能够直接使用，也不用进行运算

2.6.2 常量

在 Java 中，使用关键字 final 来表示常量。常量赋值后，在程序运行过程中其值不能改变，即只能有一次赋值的过程。定义常量的语法形式是：
final 数据类型 常量名 [= 常量值];
用 final 修饰常量的规则：以 final 关键字修饰时，常量名定义请参照标识符命名规范中关于常量定义的规范。
示例：

final double PI=3.14159;

2.7 运算符与表达式

2.7.1 运算符

1.算术运算符
Java 使用常见的算术操作符“+、-、*、/”进行加、减、乘、除的运算，用“%”表示取余运算,或者称为取模。当除法操作符“/”用于两个整数量，就表示整数除法，结果为整数，否则，表示浮点除法，结果为浮点数。
Java 中常用的算术运算符：

示例：

package com.ambow.demo;
/**
 * 算术运算符
 */
public class Demo {
	public static void main(String[] args) {
		int a=3;
		// +表示正号 
		System.out.println("+a="+(+a));
		// -表示负号
		System.out.println("-a="+(-a));
		
		int b=4;
		// +表示加法运算
		a=a+b;
		System.out.println("a="+a);//a=7
		// -表示减法运算
		b=a-b;//b=7-4
		System.out.println("b="+b);
		
		// * 表示乘法运算
		a=a*b;
		System.out.println("a="+a);
		
		//  /表示除法运算,取商
		a=a/5;//a=21/5
		System.out.println("a="+a);
		// %表示取余(取模)运算,取得是余数
		a=26%a;//a=26%4
		System.out.println("a="+a);
	}
}

2.自增（++）自减（–）运算符
我们都知道对数字变量最常见的操作之一就是增 1 或减 1。和 C/C++一样，Java 也有递增递减运算符，也有前缀与后缀之分。
示例：

package com.ambow.demo;
/**
 * 算术运算符
 */
public class Demo {
	public static void main(String[] args) {
		int a=3;
		int b=4;
		//自增运算符:++
		b=a++;
		/*
		 ++在后:
		 	先赋值,后自增
		 	b=a;
		 	a=a+1;
		 */
		System.out.println("b="+b);//b=3
		System.out.println("a="+a);//a=4
		System.out.println("===================================================");
		b=++a;
		/*
		 * ++在前:
		 * 	先自增,后赋值
		 *  a=a+1;//a=4
		 *  b=a; //b=4
		 */
		System.out.println("b="+b);
		System.out.println("a="+a);
		System.out.println("============================================");
		//自减运算符:--
		b=a--;
		/*
		 * --在后:
		 *   先赋值,后自减
		 *   b=a;
		 *   a=a-1;
		 */
		System.out.println("b="+b);
		System.out.println("a="+a);//a=3
		System.out.println("============================================");
		b=--a;
		/*
		 * --在前:
		 *  先自减,后赋值
		 *  
		 *  a=a-1;
		 *  b=a;
		 */
		System.out.println("b="+b);
		System.out.println("a="+a);
	}
}

3.关系（比较）运算符
Java 中的关系运算符有这么几种：“>、<、>=、<=、、!=”，关系运算结果的类型时是 Boolean 类型。用运算符执行运算时，会根据运算数类型（基本数据/对象）的不同产生不一样的运算规则：==运算符，如果是基本数据类型，比较值。
Java 中常用的比较运算符如下表所示：

示例：

package com.ambow.demo;
/**
 * 关系运算符
 */
public class Demo {
	public static void main(String[] args) {
		boolean flag;
		flag=3>(29/7);
		System.out.println("flag="+flag);
		//声明同一个变量类型的多个变量时,用逗号隔开
		int a=4,b=3;
		flag=(a++)<(++b);
		System.out.println("flag="+flag);//a=5,b=4
		flag=(a++)>=(++b);
		System.out.println("flag="+flag);//a=6,b=5
		flag=(a++)<=(++b);
		System.out.println("flag="+flag);//a=7,b=6
		System.out.println("===============================================");
		//比较两个表达式的值是否相等,用"==";
		flag=(a++)==(++b);
		System.out.println("flag="+flag);
		//比较两个值是否不相等
		flag=12!=16;
		System.out.println("flag="+flag);
	}
}

4.逻辑运算符
Java 中的逻辑运算符分为三种，是“&&、||、!”，分别代表逻辑与、逻辑或、逻辑非运算。使用时要求运算符的两边都是 Boolean 类型，运算结果也是 Boolean类型的。
Java 中常用的逻辑运算符如下表所示：

示例：

package com.ambow.demo;
/**
 * 逻辑运算符
 */
public class Demo {
	public static void main(String[] args) {
		boolean flag;
		//逻辑运算符与:& 只有两个表达式的结果都为true,最终结果为true;
		//如果有一个表达式的结果为false或者两个表达式的结果都为false,最终结果为false
		flag=(3>7)&(7<5);
		System.out.println("flag="+flag);
		
		//逻辑运算或:|  只要至少有一个表达式的结果为true,最终结果为true;
		//如果两个表达式结果都为false,最终结果为false
		flag=(3<7)|(7<5);
		System.out.println("flag="+flag);
		
		//逻辑运算符非:! !true==false,!false==true 
		flag=!(16/3<4);
		System.out.println("flag="+flag);
		
		//逻辑运算符异或:^ 只有两个表达式的结果不相同时,最终结果为true;
		//如果两个表达式的结果为false时,最终结果为false
		flag=(3<7)^(7>5);
		System.out.println("flag="+flag);
		
		//逻辑运算符短路与:&& 首先判断第一个表达式结果是否为true,如果true,再去判断第二个人表达式结果是否为true;
		//如果第二个表达式结果为true,最终结果为true;如果第二个表达式结果为false,最终结果为false;
		//如果第一个表达式结果为false,直接返回最终结果为false
		int a=4,b=4;
		flag=(a++>=4)&&(++b<4);
		System.out.println("a="+a);
		System.out.println("b="+b);
		System.out.println("flag="+flag);
		System.out.println("===========================================");
		//逻辑运算符短路或:|| 首先判断第一个表达式结果是否为true,如果为true,直接	返回最终结果为true;
		//如果第一个表达式为false,再去判断第二个表达式;如果第二个表达式结果为true,	最终结果为true;
		//如果第二个人表达式结果为false,最终结果为false
		int x=4,y=4;
		flag=(x++>4)||(++y<4);
		System.out.println("x="+x);
		System.out.println("y="+y);
		System.out.println("flag="+flag);
	}
}

5.赋值运算符

赋值运算符是指为变量或常量指定数值的符号。如可以使用 “=” 将右边的表达式结果赋给左边的操作数。
Java 支持的常用赋值运算符，如下表所示：

示例：

package com.anbow.test;
public class Demo {
	public static void main(String[] args) {
		/*赋值运算符
		 * 	=：给变量或者常量赋值
		 * 	==：比较两个数值之间是否相等（补充）
		 * 	===：绝对等（数值，地址等等都必须一样）[了解]
		 * */
		int a=12;
		int b=21;
		System.out.println(a);
		System.out.println(b);
		System.out.println("======================");
		/*
		 * X+=Y:加等于，相当于X=X+Y
		 * X-=Y:减等于，相当于X=X-Y
		 * X*=Y:乘等于，相当于X=X*Y
		 * X/=Y:除等于，相当于X=X/Y
		 * X%=Y：模（余）等于，相当于X=X%Y
		 * */
		int c=21;
		int d=1;
		c+=d;//相当于c=c+d
		c-=d;//相当于c=c-d
		c*=d;//相当于c=c*d
		c/=d;//相当于c=c/d
		c%=d;//相当于c=c%d
		System.out.println(c);
	}
}

6.运算符的优先级
Java 中有众多的运算符，优先级大体上是：算术运算符>关系运算符>逻辑运算符。和其它程序语言一样，在 Java 中，也最好使用圆括号来指明运算的执行顺序，因为圆括号是优先级最高的。

2.7.2 表达式

表达式是由运算符、操作数以及方法调用等组成的代码序列，用来说明某个计算过程并计算结果，有一个唯一类型的值。例如：double area = Math.PI * r*r;表达式有运算优先级，也可以嵌套。当不同优先级的运算符进行操作时，总是先做优先级高的操作。

2.8 Java注释

2.8.1 单行注释

注释一行或一行的后面部分，采用“//”标记。注释从“//”开始，到该行尾结束。

2.8.2 多行注释

以/* 开始，以 */ 结束，注释范围可以跨跃多行。

2.8.3 文档注释

以/** 开始，以 / 结束，注释范围可以跨跃多行。在用/**开头后，第一行，或者头几行是类、变量或方法的主要描述。其后，可以包括一个或多个不同的@标记。每个@标记必须在一个新行的开头，或者跟随一个星号()之后。同类型的多个标记应该组合在一起。
示例：

package com.ambow.demo;
/**
 * 文档注释
 * 
 * @author sqs
 * 
 * 三种注释
 *
 */
public class Demo {
	public static void main(String[] args) {
		//单行注释:只能注释一行,注释内容紧跟在单行注释符的后边
		
		/*
		 * 多行注释
		 */
	}
}

小练习：

管理员登录：
对管理员输入的用户名，密码进行验证，验证通过后，显示学生信息管理页面，否则返回登录页面。

Scanner sc= new Scanner(System.in);
String ID = "admin";
String pwss = "admin";
while(true) {
	System.out.println("进入登陆系统");
	
	System.out.println("输入ID");
	String ID1 = sc.next();
	
	System.out.println("输入密码");
	String pwss1 = sc.next();
	
	if(ID.equals(ID1)&&pwss.equals(pwss1)) {
		System.out.println("登陆成功,显示学生信息管理界面");
	}else {
		System.out.println("登陆失败，请重新登录");
	}
}