JAVA变量、常量、结构化编程

变量

数据类型：Java是一种强类型编程语言

生命周期：有效范围，Java提供了垃圾回收机制

int kk = 100;

Java中的数据类型可以分为两大类

基本类型【原生】和引用类型【复杂】

基本类型

4型8种：

整型：byte、short、int、long

①Java采用补码的方式存储数据

②四种不同的表示方式：十进制、0 八进制、0x十六进制、0b 二进制

③在使用字面量，Java中的整数默认类型是int，如果想表示long则在数值末尾加l/L，一般建议使用L

浮点数 float单精度、double双精度

字符类型 char

char = ‘中’ 注意：使用单引号

1、Java中字符采用的是Unicode编码字符集，2B，对应的整数为0-65535

2、字符类型的变量可以当做整数使用

3、'0'<'A'<'a'

4、Java中提供了转意字符，以反斜杠开头

(1)\ddd 1-3位的8进制数对应的字符

(2)\uxxxx 1-4位的16进制数对应的字符

布尔类型

整型数的进制转换

int kk = 123;
//将十进制数转化为8进制
System.out.println(Integer.toHexString(kk));
//将十进制数转化为2进制数
System.out.println(Integer.toBinaryString(kk));

常见的数学计算

Java提供了一个Math类，其中包含了基本运算的属性和方法

Math.sqrt()开平方

Math.pow(a,b)计算a的b次方

Math.abs()求绝对值

Math.max/min获取最大值最小值

Math.cell获取距离目标值最近的最小的整型数值，floor获取距离目标值最近的最大的整型数值

Math.round 四舍五入计算

Math.random 获取一个大于或等于0

double dd = 144.d;
System.out.println(Math.sqrt(dd));// 开平方
int k1 = 12;
System.out.println(Math.pow(k1, 2));// 计算k1的2次方
System.out.println(Math.pow(dd, 0.5));
k1 = -123;
System.out.println(Math.abs(k1)); // 绝对值
System.out.println(Math.max(dd, k1));// 获取2个数值之间较大的数
System.out.println(Math.min(dd, k1));// 獲取2个数值之间较小的数
// 浮点数转整型数
dd = 3.45;
System.out.println(Math.ceil(dd)); // 天花板
System.out.println(Math.floor(dd)); // 地板
dd = -3.45;
System.out.println(Math.ceil(dd));
System.out.println(Math.floor(dd));
// 四舍五入，注意考核中的坑在于复数的处理
dd = -3.45;
System.out.println(Math.round(dd)); // -3
dd = -3.56;
System.out.println(Math.round(dd));// -4
// 随机数
System.out.println(Math.random); // 0.7683377459693336 

除了简单计算之外，还有指数、对数、三角和反三角函数等方法

char c = 'a';
System.out.println(c);
c++;//给C+1，计算结果等价于c=c+1,但是这里涉及数据类型转换问题，所以c=c+1会有语法错误。
System.out.println(c);
//將字符转换为整数
System.out.println((int)c);
c = '中';
System.out.println(c+"==="+(int)c);

//转义字符
System.out.println('\123');
int kk = 0123;
System.out.println((char)kk);
	
System.out.println('\u9110');
kk = 0x9110;
System.out.println((char)kk);
	
char cc = '\\';
System.out.println(cc);
System.out.println((int)cc);

基本类型数据转换

小转大自动转，大转小需要强制转 窄化操作

//小转大
byte b1 = 123;//自动识别123位byte类型，但是如果超出范围则自动报错
long k1 = b1;
double k2 = k1;

//大转小
double d1 = 123.456;
long k1 = d1; //语法错误 Type mismatch: cannot convert from
long k2 = (long)d1

强制类型转换的语法**(目标类型)变量**

注意：Boolean类型和数值类型之间没有任何对应关系，所以进行强制类型转换会报语法错误

boolean bb = true;
System.out.println((int)bb);

int kk = 123;
System.out.println((boolean)kk);

针对浮点数的特殊处理

针对浮点数系统默认的是double类型，所以123.456系统识别为double类型，但是变量声明为float，所以这里需要进行数据转换或者进行特殊声明

double d1 = 123.456;		
//long k1 = d1;
long k1 = (long)d1;//强制类型转换
System.out.println(k1);//使用强制类型转换可能会导致精度丢失问题

//针对浮点数的特殊处理
//float f1 = 123.456；
float f1 = 123.456f;
float f2 = (float)123.456;

复合数据类型

复合数据类型包括：类class、接口类型interface、数组

特殊值null，在运行时并没有对应的类型，但是它可以被转换成任何复杂类型，但是不能赋值给

简单类型

复合类型的默认值就是null空指针

常量

常量就是指在程序执行的期间其值

final double PI = 3.1415;
PI = PI + 1;//语法报错原因是final表示PI是常量，不允许修改
System.out.println(PI);

表达式

表达式就是运算符、操作符以及方法的调用序列，用来说明某个计算过程并返回计算结果。

基本运算符可以分为：

算术运算符：+ - * / % ++ –

关系运算符：> >= < <= == !=

逻辑运算符：&&与运算，表示并且的关系 ||或运算 表示或者的关系 ，！非运算，表示不是。重点在于计算过程中支持短路操做

位运算符：&与 |或 ^异或 ~按位取反 <<左移位 >>右移位，基本不做要求，位运算符不支持短路操作

赋值运算符：= += -= *= /= %=

三目运算符：(表达式1? 表达式2: 表达式3) 表达式1为真 返回表达式2的值，为假 返回表达式3的值

算术运算符

+-*/
特殊：整除计算，参与计算的双方都是整数，则计算为整数计算，结果中不会有小数部分，即10/3=3不是3.3333.如果10./3返回值就是3.333...因为10.为浮点数，不是整除
%取余[取模]
10%3 = 1 实际上就是10除以3的余数

double k = 10.12;
System.out.println(k%3);

++和--是单目运算符
i++计算结果等价于i = i + 1,i--结果等价于i = i - 1;

有两种写法:i++是先获取i的值，然后针对i执行+1操做、
    int age = 99;
System.out.println(age++);//输出值为99
System.out.println(age);//没有运算符，输出值为100

++i针对i执行+1操做,然后获取i的值
int age = 99;
System.out.println(++age);//输出值为100
System.out.println(age);//输出值为100

问题：将一个任意正整数进行反转，如果数值越界则返回-1.

最大整数Integer.MAX_VALUE,最小整数Integer.MIN_VALUE

public class Test7 {

	public static void main(String[] args) {
		int k=2000009999;
		long res=0;
		while(k>0) {
			int p=k%10;
			k=k/10;
			res=res*10+p;	
			if(res>Integer.MAX_VALUE) {
				res=-1;
				break;//立即终止循环执行
			}
		}
		System.out.println(res);
	}
}

如果这段代码需要多个地方使用，则需要定义一个方法，其中包含处理逻辑，其他地方使用时直接通过名称就可以进行调用

public class A1{
public static void main(String[]args){
    int k=2000009999;
    System.out.println(reverse(k));
}
public static int reverse(int k){//定义的方法，不会主动执行，需要在main方法中进行调用。这里可以先理解public static是固定写法【实际上有问题】，int表示返回值类型，reverse是方法名称，以后需要使用这段代码时通过名称就可以直接调用，int x是参数，表示调用方法时必须传入一个int类型的参数。
long res = 0;
    while(k>0) {
			int p=k%10;
			k=k/10;
			res=res*10+p;	
			if(res>Integer.MAX_VALUE) {
				res=-1;
				break;//立即终止循环执行
			}
		}
	return (int)res;
}

关系与算符

用于判断两个数据之间的大小关系，计算结果就是boolean值，如果成立则返回true，否则返回false ----- > < >= <= == !=

double d1=10;
System.out.println(d1>3);//返回true

==和=的区别

1.k=100：这是一个赋值计算，即将=右边的值赋值给左边的变量

2.k==100：为比较操作，判断k的值是否为100，如果是返回true，否则返回false

3.由于浮点数无法精确存放，所以判断k==1.0写法是错误的，正确应写为Math.abs(a-b)<1e-6.

逻辑运算符

用于表达多个条件之间的关系，例如年龄大于18并且小于65 age>18 && age<65

&&与运算，表示并且的关系

同真则真，其余为假

age>18 && age<65 age=25由于两个条件同时成立，所以结果为真

||或运算 表示或者的关系

同假则假，其余为真

age>18 || age<65 age=125由于age>18成立所以结果为true

！非运算，表示不是

非假则真，非真则假

考试重点：短路计算

例如A&&B,如果条件A为false，这里不管B的值为true还是false，则计算结果一定为false，所以计算结果和B的值没有关系，所以执行真正计算时B并不执行，而是直接返回false。

A||B，如果A为true，则不需要计算B的结果，其结果一定为true，计算结果与B的值无关

public class Test8 {
	public static void main(String[] args) {
		int age=100;
		char cc='A';
        System.out.println(cc+"---"+(int)cc);
		System.out.println('B'+"---"+(int)'B');
		if(cc>='B'||age++<200)//第一个表达式为false，所以第二个表达式必须进行计算
			System.out.println("xxxxxxx");
		System.out.println(age);
	}
}
输出结果：
A---65
B---66
xxxxxxx
101

赋值运算符

= += -= *= /= %=

int k=10,将10赋值存储在k对应的存储单元中

k=k+3可以简化为k+=3,其他的运算含义一致

考点

short k=3;
k=k+3;//语法错误，因为k+3中的3被系统识别为int类型，所以计算结果自动转化为int，但是int类型的数据不能直接赋值给短整型的变量

//另外写法
short k=3;
k+=3;  //这里可以直接运行，不需要手工转换

结构化编程

指导思想：自顶向下、逐步求精、模块化

编程过程

流程图：使用画图的方式来说明某个过程，常见的离线绘图工具：Visio或者PowerDesigner等；目前还有在线的绘图工具ProcessOn等

(1)圆角矩形表示一个流程的开始或者结束点

(2)矩形用于表示行动方案或者普通工作环节

(3)菱形用于问题的分支判断或者审核、审批之类的判断环节

(4)平行四边形来表示处理流程中输入输出

(5)箭头线用于表示工作流的方向

结构化编程的推论

任何复杂的问题都可以使用三中基本算法结构来描述：顺序、选择和循环

条件分支语句

Java提供了两种判断语句if和switch，这两种语句用于实现条件判断，当复合某些条件时执行某段代码，否则不执行

if结构

语法：

当条件成立时执行代码段，如果条件不成立则不执行，而是直接执行if后面的下一句

if(判断条件){
	代码段
}

当条件成立时执行代码段1，如果条件不成立则执行代码段2

if(判断条件){
	代码段1;
}else{
	代码段2;
}

允许if/else结构进行嵌套

if(判断条件1){
	代码段1;
}else if(条件2){//条件1不成立且条件2成立
	代码段2;
}else if(条件n){
	代码段n；
}else{
	代码段n+1;
}

需求：要求输入学生性别，如果false则显示女

Scanner sc= new Scanner(System.in);
boolean bb = sc.nextBoolean();//接受boolean类型的数
if(bb == false){//简化写法if(!=bb){}
    System.out.println("性别为女.");//输入值不是false是没有输出
}

要求：(1)输入学生成绩，假设成绩都是整数，如果>=60显示及格，否则不及格

Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score>=60){
	System.out.println("及格");
}else{
    System.out.println("不及格");
}

(2)输入学生成绩，假设成绩都是整数，如果>85显示优秀，>=70显示良好，>=60显示及格否则不及格**

Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score>=85){
	System.out.println("优秀");
}else if(score>=70){
    System.out.println("良好");
}else if(score>=60){
    System.out.println("及格");
}else{
    System.out.println("不及格");
}

问题：这里的判断顺序能不能进行调整，例如先判断>=70再判断>=85？

不能调整顺序，如果条件1成立则不会执行条件2的判定

开关分支语句

switch(表达式){
    case 值1:计算表达式的值是否等于1，如果相等则执行代码块1.
            代码块1;break;执行完毕后，如果没有break则继续向下执行，但是不做判断。如果有break语句则立即终止switch的执行，跳转到switch结构后的下句话开始执行。
    case 值2:
        	代码块2;break;
        ......
    default:
        	代码块n; break;
}

语法点：【考核点】

(1)表达式的计算结果可以是整数【不允许long类型】，可以是char，同时还允许是字符串类型[hashcode]

(2)default的位置实际上没有什么特殊要求，但是一定是所有的case值都不相等时才会执行。再具体开发中为了增强代码的可读性，一般建议写在所有case语句之后。

需求：输入月份、显示对应的本月天数

System.out.println("请输入月份：");
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();
switch(month){
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        System.out.println("本月31天");
        break;
    case 2:
        System.out.println("请输入年份：");
        int year = sc.nextInt();
        if(year%4==0 && year%100 !=0){
            System.out.println("本月29天");
        }else{
            System.out.println("本月28天");
        }
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        System.out.println("本月30天");
        break;
    default:
        System.out.println("月份输入错误");
        break;
}

循环结构

循环就是重复做某一件事情，在Java程序中间，循环控制就是在某一条件下，控制程序重复执行某一个代码段直到遇到循环终止条件为止

循环语句也称为迭代语句，在Java与语句中间存在while、for和do…while三中循环语句

需求：计算1+2+3+4+…+100=5050

while循环

while循环是Java中最基本的循环语句，满足循环条件才执行循环体，如果不满足则不执行，所以有可能循环体执行多次，也有可能一次也不执行

int res=0;//累加器用于存放每次循环体的执行结果
int k=1;//控制循环次序
while(k<=100){
	res+=k++;//res=res+k; k++;
}
Syste.out.println("1+2+3+...+100="+res);

写法1：

int res=0;
int k=0;
while(k++<100)//由0开始比较
	res+=k;//从1开始累加
System.out.println(res);

写法2：

int res=0;
int k=0;
while(++k<=100)
    res+=k;
System.out.println(res);

写法3：

int res=0;
int k=1;
while(true){
	res+=k;
	if(++k>100){
	break;
	}
}
System.out.println(res);

break和continue的用法

需求：计算100以内的奇数和

最直接思路：奇数相加，偶数跳过

int res=0;
int k=0;
while(true){
    if(++k>100){
        break;//终止程序  防止死循环
    }
    if(k%2==0)
        continue;//终止本次循环，直接进入下次循环，不会执行后续语句，直接返回语句三
    res+=k;
}
System.out.println(res);//输出结果

break是立即终止循环，进入循环结构的后续代码，循环体执行结束。

continue是终止本次循环，进入下一次循环，循环没有结束。

do/while循环

先执行循环体，后执行判定条件，如果条件为true，则执行下一次循环。若条件为false则终止循环。

循环至少执行一次

do{
	循环体；
}while(循环条件)；

与while循环不同点：

while循环可能一次也不执行，而do/while至少执行一次。

int res=0;
int k=0;
do{
	res +=k;
}while(++k>100);
System.out.println(res);

for循环

基本执行流程：1.执行表达式1 2.执行表达式2 ，一般表达式2是一个条件判断，如果值为真则执行循环体，否则终止循环体 3.执行完循环体后执行表达式3 4.再次执行表达式2判断是否执行循环体。

在整个循环的执行过程中表达式1执行且执行1次。

for(表达式1;表达式2;表达式3){
	循环体；
}

实现：

int res=0;
for(int k=1;k<=100;k++){
	res+=k;
}
System.out.println(res);

特殊写法：这里的表达式1、2、3都不是必须的

写法1：

int res=0;
int k=1;
for(;k<=100;k++){
	res +=k;
}
System.out.println(res);

写法2：

int res=0;
int k=1;
for(;k<=100;){
	res +=k++;
}
System.out.println(res);

写法3:

int res=0;
int k=1;
for(;;){
	res +=k++;
	if(k>100)
		break;
}
System.out.println(res);

循环总结

实际上三种循环可以相互替代。

(1)for循环一般用于可以明确循环次数的场景

(2)while循环不能明确循环次数的场景

(3)do/while循环一般用于不能预先明确循环次数但是同时要求循环体至少执行一次的场景中

系统预定义类

Scanner sc = new Scanner(System.in);//可以理解为获取标准输入设备的引用，用于接收用户的键盘录入。
//为了针对用户优化，所以一般输入之前需要对用户进行提示
System.out.println("您的年龄多少岁？");//在控制台上输出提示信息
int age = sc.nextInt();//这里需要输入一个int类型的值
System.out.println("年龄："+age);

数组Array

是一个容器，主要用于存储一组类型相同且连续的数据。(即下标是连续的)

数组中存储的每一个数据都叫做数组的元素

特点

1.数组内容可变

2.数组长度是不可变的

3.数组有下标，下标从左往右从0开始

数组的定义(声明)和赋值

1、静态初始化

int[] a= {10,20,30,40,50};

2、动态初始化

int[] b=new int[] {1,2,3,4,5};
int[] c;
c=new int[] {100,200,300};

3、只给定长度，不指定具体元素内容(注意：(1)允许先定义，后指定长度.(2)不能在给定长度的时候在指定具体元素内容.(3)在只给定长度时，数组元素为默认值—整数类型-0 浮点数类型-0.0 字符类型-\u0000 布尔类型-false 其他引用类型-如String -NULL（没有默认值）)

数组的操作

1、数组的输出:

Array.toString(数组名称);

2、数组的长度

int len=arr.length

3、可以通过下标(偏移量)来访问或修改数组中的元素

//访问数组中的元素
String[] names={"張三","李四","王五","趙六","田七"};//下标从左往右，从0开始
//通过下标获取元素(0--数组长度-1)，超出该范围会出现'ArrayIndexOutOfBoundsException'错误
String name=names[0];
System.out.println("0位置的元素:"+name);//System.out.println("0位置的名字:"+name[0]);
//通过下标修改数组元素
names[2]="张思锐";
names[3]="老王";//names[6]="大黄";数组下标越界.
System.out.println(Arrays.toString(names));

4、数组的遍历:将数组中的元素逐个取出

//1.通过下标遍历
for(int i=0;i<names.length;i++){
    System.out.println("数组中第"+i+"位的名字为:"+names[i]);
}
//2.增强for循环，for-each迭代器
for(String n:names){//n:--每次将数组中遍历出来的元素赋值给变量n，names--需要进行遍历的数组
    System.out.println("n:"+n);
}

5、数组扩容(本质:创建一个新的数组，并把原数组的内容复制进来)

String[] students={"小明","小强","小刚","小东","小王"};
String[] stus = new String[students.length+1];
System.out.println(Arrays.toString(stus));
for(int i=0;i<stus.length;i++){
    stus[i]=students[i];
}
stus[stus.length-1]=students[students.length-1];
System.out.println(Arrays.toString(stus));
/*=====================================================*/
String[] students={"小明","小强","小刚","小东","小王"};
String[] stus=Arrays.copyOf(students,students.length+1);//第一个参数-源数组  第二个参数-新数组长度
String[] stus=Arrays.copyOf(students,students.length-2);
System.out.println(Arrays.toString(stus));
/*====================================================*/
//创建目标数组
String[] stus=new String[students.length+1];
//System.arraycopy(students,0,stus,2,2)
//(源数组，开始复制元素的下标，目标数组,目标数组开始放元素的位置，从原数组中复制几个元素到新数组)
System.arraycopy(students,0,stus,2,2);
System.out.println(Arrays.toString(stus));

习题:1.将数组中元素内容倒置

[“小明”,“小强”,“小刚”,“小东”,“小王”]

//1.
public class Tset {
public static void main(String[] args) {
	String[] students= {"小明","小强","小刚","小东","小王"};
	String[] stus=new String[students.length];
	for(int i=students.length-1,y=0;i>=0;i--,y++) {
		stus[y]=students[i];
	}
	System.out.println(Arrays.toString(stus));
}
}
//输出结果:[小王, 小东, 小刚, 小强, 小明]

2.定义一个数组，求出数组中的最大值

//[2,7,9,13,6,4,11]
public static void main(String[] args) {
		int[] a= {2,7,9,13,6,4,11};
		int max=a[0];//假设数组中第一个元素为最大值
		for(int i=1;i<a.length;i++) {
			if(a[i]>max) {
				max=a[i];
			}
		}
System.out.println("最大值为:"+max);
	}
}
//输出结果为:最大值为:13

二维数组

数组中的每个元素也是一个数组

1.静态初始化

int[][] arr01={{1,2,2,1},{3,4,4,3},{5,6,6,5}};

每一行的元素个数可以不一样int[][] [] [] arr01={{1},{3,4},{5,6,7}};不能先定义，在赋值。

2.动态初始化

int[][] arr02=new int[][]{{1},{3,4},{5,6,7}};

3.遍历输出二维数组

for(int i=0;i<arr01.length;i++){
    for(int j=0;j<arr01,length;j++){
       System.out,println(arr01[i][j]);
    }
}

4.只给定长度

//规则二维数组
String[][] arr03=new String[3][4];
//不规则二维数组
String[][] arr04=new String[3][];
arr04[0]=new String[2];
arr04[1]=new String[3];3