Java变量、结构化编程及数组（有点乱哈）

Java基础入门学习

变量

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

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

int kk=100;

Java中的数据类型可以分为两大类型：基本类型【原生】和引用类型【复杂】

基本类型

4型8种

1、整型：byte 1、short 2、int 4、long 8

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

4种不同的表示方法：十进制、0八进制、0x十六进制、0b二进制

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

2、浮点数：float 4、double 8

在Java种浮点数无法精确存放，除非使用Java提供的类BigDecimal

​ 不允许使用等值==判断，应该使用Math.abs(a-b)<1e-6

字面量的表示方式：十进制123.0、科学计数法1.23e2，注意e后面只能是整数

​ 数值末尾使用f/F表示float，使用D/d表示double

3、字符类型 char char c='中';（注意是单引号，不是双引号）

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

字符类型的变量可以当作整数使用

‘0’<‘A’<‘a’

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

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

​ \uxxxx 1-4位的16进制数对应的字符

​ \'表示单引号，注意不允许`’’’``

​ \"表示双引号

​ \\表示反斜杠字符

4、布尔类型 boolean

只有两个数值：true表示真，false表示假

在Java中整型数据和boolean值之间没有转换关系

整形数的进制转换

int kk = 123;
//在控制台上输出参数内容
System.out.println("0"+Integer.toOctalString(kk));//将十进制数转换为8进制
System.out.println("0x"+Integer.toHexString(kk));//将十进制数转换为16进制
System.out.println("0b"+Integer.toBinaryString(kk));//将十进制数转换为2进制

常见的数学计算

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

Math.sqrt()计算平方根

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

Math.abs()求絕對值

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

Math.ceil獲取距離目標值最近的最小的整型數值，floor取距離目標值最近的最大的整型數值

Math.round四捨五入的計算

Math.random獲取一個大於或者等於0.0小於1.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; //0开头表示8进制数
	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类型,但是如果超出范围则自动报错
1ong k1 = b1;
double k2 = k1;


//大转小
double d1 = 123.456;
1ong k1 = d1;//语法错误Type mismatch: cannot convert from double to long
1ong k2 = (1ong)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空指针

public class demo06{
	public static void main(String[] args){
	object bb;//定义变量bb为复合类型Object，Object类是系统预定义
	//System.out.println(bb); 这里报错是因为要求临时变量必须先定义后使用，必须先赋初始值然后使用
	bb = null;
	Syetem.out.println(bb);
	}
}

常量

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

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 demo7 {

	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

==和=的区别

• k=100；这是一个赋值计算，就是将=右边的计算结果赋值给=左边的变量
• k==100；这是比较计算，判断k是否值为100，如果是则返回true，否则false

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

逻辑运算符

用于表达多个条件之间的关系，例如年龄大于18并且年龄小于65age>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的值没有关系

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("xxxxxx");
System.out.println(age);  //或運算結果值為101   與運算結果值為100，因爲與運算執行了短路操作

赋值运算符

= += -= *= /= %=

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

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

考点：

short k = 3;
k = k + 3;  //语法错误，k+3中的3被系统识别为int类型，计算结果自动转换为int。但是int类型的数据不能直接赋值给短整型的变量，这里代码可以修改为 k = (short)(k + 3)

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

结构化编程

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

编程过程

流程图是使用画图的方式来说明某个过程，常见的离线绘制工具有Vision、PowerDesigner等；目前还有在线的绘制工具ProcessOn等。

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

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

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

平行四边形表示处理流程中的输入输出

箭头线用于代表工作流的方向

结构化编程的推论

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

条件分支语句

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;
}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的判断，如果条件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 + … + 100 = 5050

while循环

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

while(条件){ 执行语句: }当条件成立时反复执行语句，直到条件不成立为止

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

写法1：

int res = 0;
int k = 0;
while(k++ < 100)
	res += k;//使用0进行比对，累加值是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; //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;//终止本次循环，直接进入下次循环，不会执行后续代码。直接返回到语句3
	res += k;
}
System.out.println(res);//输出累加结果值

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

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

do / while循环

先执行循环体，然后进行条件判断，如果条件为true，则执行下次循环；如果条件为false则终止循环。

不同于while循环的特征：do / while循环至少需要执行循环体一次，而while循环体肯一次都不执行循环体

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

实现：

int sum = 0;
	int i = 1;
	do {
		i++;
		if(i % 2 == 1)
			continue;
		sum += i;
	}while(i < 100);
	
	System.out.println(sum);

for循环

基本执行流程：1、执行表达式1。

​ 2、执行表达式2，一般表达式2是一个条件判断语句，如果值为true则执行循环体，否则终止循环体的执行。

​ 3、执行完循环体后执行表达式3。

​ 4、再次执行表达式2以判断是否执行循环体。

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

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

实现：

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

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

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(;k <= 100;){//死循环
	res += k++;
	if(k > 100)
		bresk;
}
System.out.println(res);

循环总结

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

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

while循环一般用于不能明确知道执行次数的场景中

do / while循环一般用于不能预先明确循环次数，但是同时要求循环体至少执行一次

系统预定义类

Java 5添加了import java.util.Scanner;类，这是一个用于扫描输入文本的新的实用程序。

nextInt()只读取int值，就是只能读取整数类型的数据，nextFloat、nextDouble同理。

import java.util.Scanner;

public class demo06 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);//可以理解为获取标准输入设备的引用，用于接受用户的键盘录入
	
		//为了针对用户优化，所以一般输入之前需要对用户进行意识
		System.out.println("您的年龄是多少岁？");//在控制台上输出提示信息
		int age = sc.nextInt();//治理需要接收一个int类型的数据，如果不能转为int，则java.util.InputMismatchException
		System.out.println("年龄：" + age);
	}

}

数组

一、数组的概念Array（容器）

主要用于存储一组类型相同且连续（数组下标连续）的数组，数组中存储的每个数据都叫做元素

二、数组的定义（声明）和赋值（赋值）

1、静态初始化

int[] a = {10, 11, 12, 13, 14, 15};//不允许先定义后赋值

2、动态初始化

int[] b = new int[] {1 , 2, 3, 4, 5};//允许先定义后赋值
	int[] c;
	c = new int[] {11, 111, 1111, 11111};

3、只给定长度，不给定具体的元素内容

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

​ 注意：

​ 1.允许先定义，后给定长度

​ 2.不能在给定长度的时候，又指定具体的元素内容

​ 3.在给定长度时，数组元素默认值

​ 1)整数类型的默认值为0

​ 2)浮点类型：默认值为0.0

​ 3)布尔类型：默认值为false

​ 4)字符类型：默认值为’\u0000’ 0空格

​ 5)其他类型：例如字符串类型：默认值为null

//整数类型的默认值为0
System.out.println(Arrays.toString(arr01));

//浮点类型：默认值为0.0
float[] arr03 = new float[6];
System.out.println(Arrays.toString(arr03));

//布尔类型：默认值为false
boolean[] arr04 = new boolean[5];
System.out.println(Arrays.toString(arr04));

//一个布尔类型占几个字节：定义时是四个字节，在数组中是一个字节
boolean f = false;//四个字节

//字符类型：默认值为'\u0000' 0空格
char[] arr05 = new char[5];
System.out.println(Arrays.toString(arr05));
System.out.println((int)arr05[1]);

//字符串类型（引用类型，不属于八种基本类型）：默认值为null
String[] arr06 = new String[5];
System.out.println(Arrays.toString(arr06));

三、数组的操作

1、数组的输出

Arrays.toString(arr);

2、数组的长度

int len = arr.length;

3、数组中元素的访问和修改

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

2、下标从左到右，从0开始，最大下标为数组长度减1

3、下标范围[0,length-1]或者[0,length]

4、超出数组范围ArrayIndexOutOfBoundsException下标越界

访问：String names = arr[0]

修改：arr[index] = “xxx”

4、数组的遍历

1.通过下标来进行遍历

2.for-each迭代器

for(String n : names) {
		System.out.println("n:" + n);
	}

String:数组中每个元素的类型

n:每次将数组中遍历出来的元素复制给变量n

names:需要进行遍历的数组

5、数组的扩容

数组的扩容本质上是新建一个数组

1>Arrays.copyOf(源数组，新数组长度);

​ 返回新数组

2>System.arraycopy(

​ 源数组,

​ 源数组开始复制元素的下标,

​ 目标数组（新数组）,

​ 目标数组开始放元素的位置,

​ 从源数组中复制几个元素到新数组中);

四、二维数组

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

1、静态初始化

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

2、动态初始化

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

3、遍历二维数组

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

4、二维数组只给定长度，不给定具体内容

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