JAVA编程基础

Posted 2020-12-20

? JAVA的命名规则、数据类型和运算符
? JAVA自动类型转换与强制类型转换
? JAVA各种基本数据类型的定义与作用
? JAVA各种运算符与表达式的应用
? 数据输入输出
? 选择语句
? 循环语句
? 数组
? 字符
（1） 标识符与关键字

关键字：由系统定义具有特定意义和用途的词汇或符号。

标识符：必须英文，编译才能识别。
通过举例子人名来说明标识符意义。地球上的小明，中国小明，河南小明等。
标识符（Identifier）定义程序中各个元素的名字。
标识符包含字母、数字、下划线和美元符号，标识符区分大小写，不能以数字开头，没有最大长度限制。

分隔符：①注释符 ②空白符 ③普通分隔符
注释符： 单行注释符 // ; 多行注释符//; 文档注释符 / */
空白符：空格、回车、换行和制表符《tab》键
普通分隔符：和空白符作用相同，用来区分程序组成部分；
; 分号 用来终止一个语句
{} 花括号、大括号 用来包括自动初始化的数组的值，也用来定义程序块、类、方法以及局部范围
[] 方括号、中括号 用来声明数组的类型，也用来表示撤消对数组值的引用
, 逗号 在变量声明中，区分变量说明的各个变量。在for控制语句中，用来将圆括号内的语句连接起来
. 原点 用来将软件包的名字与它的子包或类分隔。也用来将引用变量与变量或方法分隔
() 圆括号 在定义和调用方法时用来容纳参数表。在控制语句或强制类型转换组成的表达式中用来表示执行或计算的优先权

（2） 基本数据类型
数据是程序的组成部分，也是程序处理对象，那么这个对象就分了8中数据类型。

（3） 常量与变量
常量：程序运行过程保持不变的量是常量 （使用程序例子聚类说明）
声明格式： final type varName = value;
常量分为：整型常量、实型常量、布尔常量、字符常量
① 整型常量:就是整数。Byte，short，int，long
JAVA整型常量可以由十进制、八进制、十六进制表示。 长整型必须在数字后面加字母L（l）
② 实型常量:实型常量也叫浮点数单精度和双精度Float 和double两种类型。只能十进制表示，有小数点和指数形式两种。
③布尔常量：boolean 常量只有true和false两种状态。不能代表整数、不是字符串、不能转换成字符。
④ 字符串常量: Java字符采用Unicode编码。字符常量由单引号括起来的单字符。字符常量是无符号常量，占2个字节内存。
public class TestConstants {
public static void main(String[] args) {
final double PI = 3.14;
// PI = 3.15; //编译错误，不能再被赋值！
double r = 4;
double area = PI r r;
double circle = 2 PI r;
System.out.println("area = " + area);
System.out.println("circle = " + circle);
}
}
转义符：表示特俗意义的字符

变量：变量本质上就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。
格式：
type varName [=value][,varName[=value]...];
//[]中的内容为可选项，即可有可无
数据类型 变量名 [=初始值] [,变量名 [=初始值]…];
变量声明
double salary;
long earthPopulation;
int age;

注意点：每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须以分号结束
变量作用域
成员变量：在类中声明就是作用域整个类；
局部变量：方法内部或者语句块内部声明作用对应部分作用域。
以{} 区分作用域。类比（省长、市长、县长）

（4） 运算符与表达式

算数运算符：
算术运算符中+，-，*，/，%属于二元运算符，二元运算符指的是需要两个操作数才能完成运算的运算符。其中的%是取模运算符，就是我们常说的求余数操作
规则：整数

1. 如果两个操作数有一个为Long, 则结果也为long
2. 没有long时，结果为int。即使操作数全为short，byte，结果也是int
   　　　　浮点运算：
   　　　　　　　　３．　如果两个操作数有一个为double，则结果为double
   　　　　　　　　４．只有两个操作数都是float，则结果才为float
   public class AutoIncDemo{
   public static void main(String[] args) {
   int x =5;
   System.out.println ("x : " +x);
   System.out.println ("++x: " +(++x)); // 前缀
   System.out.println ("x++ : " + (x++));//后缀
   System.out.println ("x : " +x);
   System.out.println ("--x : " + (--x)); //前缀
   System.out.println ("x-- : " + (x--)); //后缀
   System.out.println ("x : " + x);
   }
   }

关系运算符

注意
=是赋值运算符，而真正的判断两个操作数是否相等的运算符是==
==、!= 是所有（基本和引用）数据类型都可以使用

、>=、 <、 <= 仅针对数值类型（byte/short/int/long, float/double。以及> 、>=、 <、 <= 仅针对数值类型（byte/short/int/long, float/double。以及char）
逻辑运算符

短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。
赋值运算：

位运算符：

&和|既是逻辑运算符，也是位运算符。如果两侧操作数都是boolean类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符
不要把“^”当做数学运算“乘方”，是“位的异或”操作

其他运算符
条件运算符：
？：　　x ? y : z
其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个运算的结果为表达式 y 的值否则整个运算结果为表达式 z 的值
int score = 80;
int x = -100;
String type =score<60?"不及格":"及格";
int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
System.out.println("type= " + type);
System.out.println("flag= "+ flag);
ｔｙｐｅ＝及格
ｆｌａｇ＝１

ｉｎｓｔａｎｃｅｏｆ对象引用，左侧是右侧实例值为ｔｒｕｅ
public class InstanceOfDemo{
public static void main (String args[]){
InstanceOfDemo p= new InstanceOfDemo ();
if (p instanceof InstanceOfDemo )
System.out.println ("p 是InstanceOfDemo的实例");
else
System.out.println ("p 不是InstanceOfDemo的实例");
}
}

ＪＡＶＡ运算符优先级

不需要去刻意的记这些优先级，表达式里面优先使用小括号来组织！
逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）。如：a||b&&c的运算结果是：a||(b&&c)，而不是(a||b)&&c

数字类型转换
自动转换

强制转换
高精度数据转换到低精度数据时需要强制类型转换。

（5） ｊａｖａ基本输入输出
基本输入
import java.util.*;
public class InputTest
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
//读取用户的名字
System.out.println("What is your name?" );
String name = in.nextLine();
//读取用户的年龄
System.out.println("How old are you?" );
int age = in.nextInt();
in.close();
//输出信息
System.out.print("Hello, " + name + " . “ );
System.out.println("Next year, you‘ll be " + (age + 1)+”years old.” );
}
}
基本输出
（6） 流控制语句
１、选择语句
① if单选择结构 ②if-else双选择结构 ③if-else if-else多选择结构 ④switch结构

① if单选择结构
if(布尔表达式){
语句块
}
if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块

②if-else双选择结构
if(布尔表达式){
语句块1
}else{
语句块2
}
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分

③if-else if-else多选择结构
if(布尔表达式1) {
语句块1;
} else if(布尔表达式2) {
语句块2;
}……
else if(布尔表达式n){
语句块n;
} else {
语句块n+1;
}
当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3??????;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分

③ ｓｗｉｔｃｈ结构

switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:
默认语句;]
}
switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)

２、循环语句
循环结构分两大类，一类是当型，一类是直到型

ｗｈｉｌｅ，ｄｏ－ｗｈｉｌｅ
①ｓｗｉｔｃｈ结构

while (布尔表达式) {
循环体;
　　}

②do-while循环

do {
循环体;
} while(布尔表达式) ;

③for循环
for (初始表达式; 布尔表达式; 迭代因子) {
循环体;
}
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子
A. 初始化部分设置循环变量的初值
B. 条件判断部分为任意布尔表达式
C. 迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进
④ 嵌套循环
在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环

跳转语句
break语句和continue语句retune语句　
break
在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句
Continue
１、continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余
２、continue用在for循环中，跳到for循环的迭代因子部分
3、Retune retune expression 返回一个值给调用方法在语句，且数据一致。
Retune (void)声明返回类型为空时候，使用此格式。

（7） 数组
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。数组的三个基本特点

1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型，不允许出现混合类型。
3. 数组类型可以是任何数据类型，包括基本类型和引用类型。
   ①一维数组　　②二维数组　　③三维数组
   ①一维数组　　
   int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
   Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

import java.io.;
import java.util.;
public class Average{
public static void main(String args[]) {
int score[]=new int[30];
int x;
Scanner in = new Scanner(System.in);
System.out.print("输入30个学生的成绩：");
/ 以下输入30个学生的成绩存入数组score中 /
for (int k=0;k<30;k++)
score[k] = in.nextInt(); //成绩存入数组
/ 以下计算平均成绩 /
int sum=0;
for (int k=0;k<30;k++)
sum+=score[k];
System.out.println("平均成绩为："+sum/30);
}
}
② 二维数组
二维数组是数组的数组

public class MulArray{
public static void main(String args[]) {
int arrayA[][]={{1,2,3},{4,5,6},{7,8,9}};
System.out.println( arrayA[0][0]+" "+ arrayA[0][1]+" "+ arrayA[0][2]);
System.out.println( arrayA[1][0]+" "+ arrayA[1][1]+" "+ arrayA[1][2]);
System.out.println( arrayA[2][0]+" "+ arrayA[2][1]+" "+ arrayA[2][2]);
System.out.println();
arrayA[0][0]=arrayA[0][1]+arrayA[0][2];
arrayA[1][1]=arrayA[1][0]+arrayA[1][2];
arrayA[2][2]=arrayA[2][0]+arrayA[2][1];
for (int i=0;i<=2;i++){
for (int j=0;j<=2;j++)
System.out.print( arrayA[i][j]+" ");
System.out.println();
}
}
}

（8） 字符串
String StringButter