java基本语法规范

1 Java 语言的特点

Java是一种面向对象的程序设计语言

Java不仅是一种编程语言，在该平台上可以开发应用程序，并在因特网或企业内部网络中运行

Java开发工具包（JDK&JRE）是开发、调试、编译、运行Java程序的一整套工具

Java是面向对象的，java语言使用起来比较简单 Java提供自动垃圾回收站 安全性高 多线程 可移植性高

Java的三个版本

JavaME （微型版） javaSE （标准版）C/S javaEE（企业版）B/S

Java环境变量的配置 PATH： E:\\JDK\\bin Java_HOME E:\\JDK

安装时候分别设置两个文件夹一个JDK 一个JRE 分别安装两个文件

HelloWorld.java：

public class HelloWorld{

2 java语言的操作原理

package com.mstanford.demo;

public class HelloJava { //关键字class表示要定义一个类 public static void main(String[] args) { //main方法必须是public static void类型 System.out.println(\！\ } } /**

* 描述：第一个java应用程序 * @author admin * @version 1.0 */

class Mstanford { /**

* 主函数

* @param args 命令行参数 */ public static void main(String[] args) { //向控制台输出一串字符 System.out.println(\！\ /* * 使用javac命令编译源文件 * 使用java命令运行应用程序 */} }

程序所需要注意的地方：

Java严格区分大小写

class表示一个类， Java应用程序的全部内容都必须在类中 源代码的文件名必须与公有类的名称相同

main函数必须是共有的、静态的、无返回类型的，并带有一个字符串数组类型的参数

每个Java应用程序必须有一个main函数 System.out.println()用于向控制台输出数据

public static void main(String args[]){ //入口函数

System.out.println(\ //控制台输出 是l不是i } }

编译期：

解释期：将代码在平台上解释执行

Javac 解释

HelloWorld.java ====?编程======?HelloWorld.class文件=====?010101010101==》执行 JDK 给开发人员的工具包，也包括java开发工具，javac编译 java执行 JRE java运行环境 JDK=JRE+开发工具 JRE=JVM+核心类库

3 Java控制台的输出

public class PrintProgram { public static void main(String[] args) { //输出不换行，使用空格分割字符 System.out.print(\ //通过换行符\换行 System.out.print(\ System.out.println(\ System.out.print(\ //通过制表符\定位显示数据，与Tab键的定位效果相似

System.out.println(\ } }

import java.util.Scanner;

public class ScannerPrograme {

public static void main(String[] args) { System.out.println(\实现控制台输入\

System.out.println(\ System.out.print(\请输入文字：\ //通过Scanner实现控制台的输入

Scanner sc = new Scanner(System.in); //通过Scanner实现控制台的输入，需要导入java.util.Scanner包

String strText = sc.next();

System.out.println(\你输入文字为：\ } }

import java.util.*;

public class Console { //定义一个类Console 必须大小写和前面的前缀是一样的 //主方法

public static void main(String [] args){

Scanner scan = new Scanner(System.in); //控制台输入 String str = scan.next(); //接受控制台输入的值

System.out.println(\输入的值为：\打印输出 } }

4 标示符

a) 什么是标识符？ i. 1. 标识符由字母、数字、下划线（_）和美元符号（$）组成。 ii. 2. 标识符不能是Java关键字和保留字，但可以包含其内。 iii. 3. 标识符大小写敏感。 iv. 4. 标识符长度没有限制。 v. 5. 标识符不能有空格。

identifier、 userName、 User_name、 _sys_var、 $change

? 注释主要起到解释说明的作用，可以有效地增强程序的可读性和可维护性。Java语

言支持三种格式的注释：单行注释、区域注释和文档化注释。

? 单行注释。以“//”开头，注释内容从“//”开始到本行行尾结束。

? 区域注释。以“/*”开始，以“*/”结束，中间可以跨多行的注释内容。 ? 文档注释。以“/**”开始，以“**/”结束，中间可以跨多行的注释内容。

在Java中，数据类型分为基本数据类型和引用数据类型两大类 8种基本数据类型

整 型： byte 、short、int、long 浮点型：float、double 字符型：char 布尔型：boolean 整型 数据类型 所占位数 取值范围 byte short int long 8 16 32 64 -128~127 -32768∽32767 -231∽231-1 -263∽263-1 int age = 19; short num = 20;

long myQq = 491329889;

浮点型 数据类型 float double 所占位数 4字节 8字节 取值范围 大约±3.40282347E+38F （有效位数6～7 位） 大约±1.79769313486231570E+308 （有效位数15 位） 一般情况下，double最常用；float型的数值有一个后缀“f”，没有后缀的浮点数默认为double型

float a = 123.45f;

double b = 123.45;

字符型 是指由单引号括起的单个字符 char sex = '男';

布尔型 boolean类型只有两个值：false和true，用于判定逻辑条件 boolean a=false; boolean b=true;

在Java中，数据类型分为基本数据类型和引用数据类型两大类

引用数据类型(非基本数据类型，除了基本的数据类型以外都是引用数据类型，String （scanner）

数 组 接 口 类

变量是在程序运行过程中，其值可以改变的量 1、在使用变量之前，要对变量的类型加以声明

2、变量的声明就是一条完整的Java语句，必须在结尾使用分号 每个声明语句也是一条完整语句，必须以“；”结束 int days;//天数

long earthPopulation;//地球人口数

变量初始化

声明一个变量之后，必须利用赋值语句进行初始化

变量必须要赋值后才能使用 int days;//天数 days = 15;

变量必须要赋值后才能使用 int days;// 天数

System.out.println(days);

整型变量b的初始化是将a的值赋给了b，这就是动态初始化 int a = 100; int b = a;

a 没有初始化，不能为b赋值 int a; int b = a;

public class test{ //声明test类

public static void main(String [] args){//主方法 byte i=5;//声明一个byte型的变量 System.out.println(i); } }

public class test{

public static void main(String [] args){ byte i=5;

long num=100000000l; //结尾可以加l char sex='男';

System.out.println(\性别是\System.out.println(\

System.out.println(\

System.out.println(\} }

Javac test.java Java test

输出某人的基本信息 import java.util.Scanner; public class Person{

public static void main(String [] args){ String name; String sex; int age;

String birthday; String address;

boolean married = false;

Scanner scan = new Scanner (System.in); System.out.println(\请输入姓名！\name=scan.next();

System.out.println(\请输入性别！\sex=scan.next();

System.out.println(\婚否（1代表已婚0代表未婚）\int marry=scan.nextInt(); if(marry==1){ married = true; }else{

married=false; }

System.out.println(\姓名是：\性别是：\是否结婚：\ } }

5 变量转化

自动类型转换的条件

a) 类型兼容

b) 目标类型大于源类型 byte b = 12; 一杯水 int i; 一个缸

i = b; 将杯子中的水倒入缸中

下列类型不能自动转换

数字型 不兼容 字符型 不兼容 布尔型 不兼容 数字型、字符型、布尔型相互不兼容，不能自动转换

强制类型转换

从取值大的范围转向取值小的范围必须强制转换，反之默认转化 目标类型 变量=(目标类型)值; double d = 125.685; int a = (int)d;

下图是合法的数据类型之间的转换，6个实心箭头代表无损转换，3个虚线代表有可能丢失精度

public class Test02{

public static void main(String [] args){ byte num = 5; int num1 = 10;

num1= num; 从小到大默认转化

num=(byte)num1; 从大到小强制转化 } }

6 运算符与表达式

Java中，+ 、 - 、 * 、 /、%分别表示加、减、乘、除、取模运算

参与除法运算的两个操作数都是整数时，表示整数除法；否则表示浮点除法

15/2 等于7 15.0/2等于7.5

算术运算符二元运算符的简化格式

可以在赋值语句中使用简化的格式书写二元运算符。通常，将运算符放在赋值号的左侧（如*=、%=等）

x+=4; 等价于x=x+4;

? 自增运算符和自减运算符

? 将数值变量加1和减1是比较常见的操作，Java中借鉴了C和C++的语法

class A{ public static void main(String [] args){ int n=4; n++; //先赋值再做运算 System.out.println(n); ++n; //先运算再赋值 System.out.println(n); n--; System.out.println(n); --n; System.out.println(n); Int i = 10;

System.out.println(++i) //11 System.out..println(i++) //11 System.out.println(i) //12 } }

输出 5 6 5 4

++n和n++的区别 class A{ public static void main(String [] args){ int m = 7; int n = 7; int a = 2 * ++m; //a=16 int b = 2 * n++; // b=14 }}

public class Test{

public static void main(String [] args){ int sum = 0; int i=3;

3 4 3 5 5 5 6 sum=(i++)+(i--)*(i++)+(++i)+(i++)-(--i)+(++i);

System.out.println(\} }

关系运算符

Java中具有各种关系运算符，关系表达式的结果只能是true或false class A{ public static void main(String [] args){ System.out.println(3!=8); System.out.println(3==8); } }

其他的关系运算符还包括：<、>、<=、>= import java.util.*; public class Test02{

public static void main(String [] args){ System.out.println(\请输入第一个数\Scanner scan = new Scanner(System.in); int num1=scan.nextInt();

System.out.println(\请输入第二个数\int num2=scan.nextInt(); if(num1>num2){

System.out.println(\大的数为：\}else{

System.out.println(\大的数为：\} } }

import java.util.*; public class Test02{

public static void main(String [] args){ System.out.println(\请输入第一个数\Scanner scan = new Scanner(System.in); int num1=scan.nextInt();

System.out.println(\请输入第二个数\int num2=scan.nextInt();

int Test02 = num1>num2?num1:num2; true返回num1 否则返回num2 System.out.println(\最大值为：\} }

逻辑运算符

与C++相同，Java中使用“&&”表示逻辑“与”、使用“||”表示逻辑“或”、使用“!”表示逻辑“非”

“||”是按照“短路”方式求值的。如果第一个操作数已经能够确定值，第二个操作数就不进行计算了 &和&&的区别

&所有的条件都要判断

&&如果条件不满足则后面的无需判断

class A{ public static void main(String [] args){ System.out.println((1>5)&& (2>1)); //false System.out.println((1>5)|| (2>1)); //true System.out.println(!((1>5)&& (2>1))); //true } }

运算符的优先级 顺序 1 2 3 4 5 6

运算符 括号，如 ( ) 和 [ ] 一元运算符，如 -、++、- -和 ! 算术运算符，如 *、/、%、+ 和 - 关系运算符，如 >、>=、<、<=、== 和 != 逻辑运算符，如 &&、|| 条件运算符和赋值运算符，如 ? ：、=、*=、/=、+= 和 -= 7 程序的3种结构

顺序结构：自上而下地逐行执行代码

选择结构：根据逻辑判断代码的执行顺序 循环结构：根据逻辑重复执行某个代码块

选择结构

根据逻辑判断代码的执行顺序

循环结构：根据逻辑重复执行某个代码块

循环条件 条件 成立 循环体 条件不成立

if控制语句

满足判断条件，则执行相对应的代码，否则不执行任何代码 class Example{

public static void main(String[] args) { int a=1; if(a==1){

System.out.println(\等于2\ } }

if-else条件分支语句

不满足条件，所以执行else后面的语句块 class Example {

public static void main(String[] args) { int a=1; if(a==2){ System.out.println(\等于2\ }else{ System.out.println(\不等于2\ } } }

三元运算符与if-else的区别 class Example {

public static void main(String[] args) { int x = 2; int y; //使用if-else语句来判断 if(x<0){ y=x; }else{ y=-x; } System.out.println(\使用if语句得到的y=\ y=x<0?x:-x; System.out.println(\使用三元运算符得到的y=\ } }

import java.util.*; public class Test02{

public static void main(String [] args){ System.out.println(\请输入成绩\

Scanner scan=new Scanner(System.in); //接受包 int num=scan.nextInt(); if(num>90){

System.out.println(\优\

}else if(num>=80){

System.out.println(\良\}else{

System.out.println(\中\

} }

嵌套if-else class Example{

public static void main(String[] args) { //定义年龄变量 int age = 4;

if(age<18){//当年龄在18岁以下时执行 System.out.println(\未成年\ }else{//年龄大于8岁进入else。 if(age>=18 && age<35){//当年龄在18～35之间时执行 System.out.println(“成年\ }else{ if(age>=35 && age<55){//当年龄在35～55之间时执行 System.out.println(“中年\ }else{ System.out.println(\老年\ }} }}}

if-else多级嵌套 if(条件表达式){ 语句块1 }else if(条件表达式){ 语句块2 }else{ 语句块3 }

多重if-else

class Example3_7 {

public static void main(String[] args) { //定义年龄变量 int age = 4;

if(age<18){//当年龄在18岁以下时执行 System.out.println(\未成年\

}else if(age>=18 && age<35){//当年龄在18～35之间时执行 System.out.println(“成年\

}else if(age>=35 && age<55){ //当年龄在35～55之间时执行 System.out.println(“中年\ }else{//当年龄大于55时 System.out.println(\老年\

} } }

Switch-case语句 switch (表达式) {

case 取值1: 语句块1; break;

case 取值2 : 语句块2; break; ........

default : 语句块n; }

与if-else比较，switch-case的优点在于：

? 可以利用switch的开关功能来实现批处理 ? 增加了代码的可读性 ? 使代码更容易编写 ? 性能更高

其缺点是：不能实现嵌套判断

while语句

编写程序，计算1+2+3+……+100的值 int a1=1; int a2=2; int a3=3; ……

int a100=100;

a100=a1+a2+??+a100;

while(条件表达式){ 循环体 }

只要表达式为true，就一直执行循环体

int counter=1; int sum=0;

while (counter<=100){ //判断循环条件 sum=sum+counter; //执行循环体，再判断循环条件 ++counter; }

System.out.println(\

do-while语句

循环体 循环条件 条件 成立

条件 不成立

for循环

主要用于按预定的次数执行语句或语句块 for(initialization; condition; iteration) { 循环体 }

最先执行，仅被执行一次, 必须是布尔表达式, 增加或减少循环变量的一个表达式

class Example {

public static void main(String[] args) { int sum=0;

for(int i=0;i<=10;i++){ sum=sum+i; }

System.out.println(\ }

}

（1）为i赋值 （2）判断i<10 （3）执行循环体 （4）i++

（5）回到步骤（2）

break语句

除了可以用于switch语句中，还可以用于循环体中

在循环体中遇见break语句时，立即结束循环，跳至循环外，执行循环结构后面的语句 class Example3_18 {

public static void main(String[] args) { int i=0;

for(i=1000;i<=2000;i++){

if(i3==0){//判断是否能被123整除 break; //若能整除，则跳出for循环 ，如果条件成立，执行break语句 } }

System.out.println(\第一个能被123整除的数是\ } }

continue语句

用于结束本次循环，即在循环体中遇见continue语句，循环体中continue语句后面的语句不会执行，接着进行下一次循环的判定 class Example{

public static void main(String[] args) { int i=0;

for(i=1000;i<=2000;i++){

if(i3==0){//判断是否能被123整除 continue;//若能整除，则进入下一次for循环，如果条件成立，执行continue语句

} }

System.out.println(\第一个能被123整除的数是\ } }

一维数组

? 过程繁琐 ? 变量定义太多 ? 操作变量不方便

Java中的数组即存放一些相同元素的集合

Result，数组名 result[0] 数组下标从0开始。数组中每个变量用“数组名[下标]”标示

一维数组的声明

类型 [] 数组名 或者 类型 数组名[ ]; 类型说明符，说明数组的类型 数组名，用标识符命名

一维数组的定义

数组名的命名规则与变量名的命名规则相同

“[ ]”是数组的标志，不能用圆括号或其他符号代替

在Java语言中，不能在声明数组时指定数组的长度，而应该在定义时指定，例如：

int x[5]; //编译时将出错 int []x=new int[5]; //正确

类型 [ ] 数组名=new 类型 [常量表达式]; int [] r=new int[5];

数组元素的个数，数组的下标从0变化到常量表达式的值减1

一维数组的默认初始化 class Test { public static void main(String[] args) { int[ ] x=new int[3]; //第一个元素下标从零开始 System.out.println(“第一个元素是：”+x[0]); System.out.println(“第二个元素是：”+x[1]); System.out.println(“第三个元素是：”+x[2]); } }

数组中的数值型元素（包括byte、char、int、short、float、double、long）的默认值都是0。布尔型的默认值是false

数组的声明和定义 一维数组的显示初始化 int[ ]x={3,5,7,1,4}; 或

int[ ] x=new int[ ]{3,5,7,1,4}; class Test { public static void main(String[] args) { int[ ]x={3,5,7,1,4}; int [] y=new int[]{3,5,7,1,4}; int[] z=new int[]{}; //定义数组长度为零 int[] w={}; } }

一旦创建了数组，其长度将无法再改变

不可将静态初始化和动态初始化同时使用，即不要在数组初始化指定数组长度的同时为每一个数组元素赋初值。 Eg： String[] str=newString[5]{\，此时编译会报错

一维数组的遍历 class Test { public static void main(String[] args) { int [] item=new int [10]; int total=0;//求和变量 for(int index=0;index<10;index++){ //循环给数组赋值 item[index]=index*3; } for(int index=0;index<10;index++){ //循环访问数组中的元素 total=total+item[index]; } System.out.println(\ } }

数组的遍历和数组的长度 一维数组的长度 class Test { public static void main(String[] args) { char[] chars=new char[]{'H','e','l','l','o',',','M','s','t','a','n','f','o','r','d'}; System.out.println(\的长度为：\//使用chars.length获得字符串的长度 for(int index=0;index

? 冒泡排序算法

? 冒泡法的思路是(由小到大)：将相邻两个数比较，将小的调至前面

class Test { public static void main(String[] args) { int[] intArray=new int[]{3,0,1,18,5,0,-5,-6,3}; int tempLength=intArray.length; for(;--tempLength>0;){ for(int index=0;index

intArray[index]=intArray[index+1]; intArray[index+1]=temp; } } } }

在实际应用中，经常会遇到一些使用多维索引的数据。如：四个学生三门课的成绩。可以用下表表示：

显然，该表的每一项需要有两个索引项。表现为数组的两个下标。超过一个下标的数组称为多维数组

二维数组的声明

类型说明符[ ][ ] 数组名;或 类型说明符 数组名[ ][ ]; 例如：

“int[ ][ ] x;”与“int x [ ][ ];”声明二维数组的方式都是正确的 数组在声明时不能指定其长度。如：int [ 2][3 ] x 是错误的

? 二维数组的定义 int[ ][ ] x =new int[2][3];

二维数组的初始化

例如： int[ ][ ] x=new int[ ][ ]{{1,2,3},{5,7,73},{0,74,76}};或 int[ ][ ] x= {{1,2,3},{5,7,3},{0,4,6}}; class Test { public static void main(String[] args) { String [][] x =new String[2][3]; for(int i=0;i

public class SecondArrayStaticInit { public static void main(String[] args) { //声明String类型的二维数组strArray String[][] strArray=new String[4][2]; //为strArray进行动态初始化 strArray=new String[][]{ {\比尔盖茨\微软\乔布斯\苹果\ {\扎克伯格\拉里佩奇\谷歌\ for (int i = 0; i < strArray.length; i++) { System.out.println(\公司：\ 创始人：\ }

}

}

本文来源：https://www.bwwdw.com/article/y6f7.html