java周记(二)

循环

for循环

格式

for(初始化语句;条件表达式;控制体或者步长语句){
循环体语句;
}

执行流程

初始化语句对当前变量赋值,执行一次;
判断条件表达式是否成立,如果成立,执行循环体语句------>执行控制体语句
继续判断条件表达式是否成立,如果成立,执行循环体语句------>执行控制体语句
for结束条件当前条件表达式不成立的时候,for循环结束!

如何获取每个位上的数据呢?

举例:153
获取个位
int ge = 153 % 10(对10求余) 3
获取十位:
int shi = 153 /10(取整) % 10(取整的结果对10求余)5
获取百位:
int bai = 153/100; 1

应用(水仙花数)

class WaterFlower {
public static void main(String[] args) {
	int count = 0;
	for (int i = 100; i <1000; i++) {
		int bai = i /100;
		int shi = i %100/10;
		int ge  = i%10;
		if (i==bai*bai*bai+shi*shi*shi+ge*ge*ge) {
			System.out.println(i+"为水仙花数");
			count +=1;

			}
		}
		System.out.println("水仙花数共"+count+"个");
	}
}

while循环

格式:
基本格式:

while(初始化语句以及条件表达式){
循环体语句;
步长语句(控制体语句) ;
}

扩展格式(推荐):

初始化语句;
while(条件表达式){
循环体语句;
步长语句(控制体语句) ;
}

执行流程

1)首先初始化语句进行赋值
2)判断条件表达式是否成立,如果成立,执行循环体语句
再次执行步长语句;
3)继续判断条件表达式是否成立,如果成立,执行循环体语句
再次执行步长语句;
…
4)当条件表达式为false,不成立,while循环语句结束

While循环和for循环的区别?

1)从格式上不太一样
2)从内存角度:(是否节省内存空间)
for循环:for循环语句结束,变量从内存中释放掉了,节省内存空间(优先)
while循环:while循环语句结束,依然可以访问变量,耗费内存空间
3)应用场景:是否明确次数
针对for循环:(使用居多) 明确循环次数
举例: == :基本类型: int a = 10 ; int b = 20 ;
模拟用户登录, 给三次机会! (String类:equals())
针对while循环:(使用:仅此for) :不明确循环次数
举例:
猜数字游戏: (不知道猜多少次,能猜中!)
键盘录入一个数据

==两个死循环 ==

格式1:
for( ; ; ){
循环体语句;
}

格式2 :(推荐)
while(true){
循环体语句;
}

java.lang.Math

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
取随机数的方法
使用:
public static double random() :取值范围[0.0,1.0)
static:静态的 (面向对象讲)
需求:使用Math类中的方法 random()获取一个1-100之间的随机数
int number = (int)(Math.random()*100+1) ;

do-while循环

格式:

初始化语句;
do{
循环体语句;
步长语句(控制体语句) ;
}while(条件表达式) ;

执行流程:

1)初始化语句赋值
2)直接执行循环体语句---->步长语句—>条件表达式
…
…

特点:循环体至少执行一次 (它和while,for的区别)

while循环的应用

使用Math类中的random产生一个1-100之间的随机数,键盘录入一个数据然后进行比较
统计总共多少次猜中了

import java.util.Scanner;
class Random {
	public static void main(String[] args) {
		int num = (int)(Math.random()*100 + 1);
		int count = 0 ;
		while(true){
			Scanner sc = new Scanner(System.in) ;
			System.out.println("请您输入一个要猜的数据:") ;
			int guess = sc.nextInt() ;
			if(guess > num){
				System.out.println("猜的数据大了") ;
				count += 1;
			}else if(guess < num){
				System.out.println("猜的数据小了") ;
				count += 1;
			}else{
				System.out.println("猜中了!!!") ;
			break ;
				}
		}
		System.out.println("次数为"+count+"次");
	}
}

for循环嵌套

for(初始化语句;条件表达式;步长语句){
//循环体语句
for(初始化语句;条件表达式;步长 语句){
}
}

转移字符:

\t : 制表符号 ----->类似于文本文件中那个tab键 :缩进
\n : 换行符号
后面学习:IO流(输入/输出) :
windows操作系统:换行符号"\r\n"

跳转控制语句:

break :中断,结束
continue: 结束当前循环,立即进入下一次循环
return :结束方法方法去使用的!(结合方法)
break:中断,结束的意思
不能单独使用,没有意义!
在switch中以及循环中使用!
循环中使用:
1)可以在单层循环中使用
2)早期的使用:用在for循环嵌套中使用(外层循环,内层循环)

标签语句

给外层循环/内层循环中起一个名字
格式:标签名称:for(初始化语句;条件表达式;步长语句){…}
标签名称:for(){}
循环嵌套:应用场景:
后期使用:
增强for循环: 遍历集合
类上于: HashMap<String,ArrayList<>> 集合嵌套集合

方法

概念:

将一个独立的代码块{}抽取出来并为当前这个起名字!(作用:提高代码的复用性)
使用{}将代码包裹起来,并给这个代码起一个名字:方法名
---->以后直接使用方法名调用. {}代码块

定义方法

• 有返回值类型的方法的定义
• 没有返回值类型的方法定义

方式一

固定格式:

public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2…){
业务需求…
return 结果;
}

格式的详细介绍:

权限修饰符:public(公共的,访问权限足够大) static(静态)
返回值类型:数据类型(目前基本数据类型:四类八种: )
举例:求两个数据之后 结果:int类型
方法名:遵循标识符的规则(见名知意)
单个单词:全部小写
多个单独:第一个单词小写,从第二个单词开始,每个单词首字母大写,其余小写
小驼峰命名法!
形式参数类型:数据类型(目前基本数据类型:四类八种: )
参数名称:变量名称
return: 这个方法调用完毕了,带回具体的结果!

有返回值类型的方法调用:

1)单独调用(没有意义)
2)输出调用:不推荐
3)赋值调用:推荐

定义有具体返回值类型的方法的定义的注意事项!

1)方法和方法平级关系,不能嵌套使用!
特殊:方法递归(IO流后面讲):方法调用方法本身的一种现象!
2)定义方法注意两个明确
明确返回值类型
明确参数类型以及参数个数
3)定义方法的时候:参数类型必须携带的!
public static int add(x,y){} 错误的:
因为Java是一种强类型语言:语法非常严谨的,以及格式是有要求的!
4)定义方法的时候,()后面不要出现; (目前来说没意义的方法!)
5)调用方法的时候,实际参数不需要携带数据类型

应用

键盘录入两个数据,比较两个数据是否相等

public static boolean compare(int a,int b){//形参
		//简写方式
		//return a==b ; //== :比较两个数据值是否相等! ==
		return (a==b)? true: false ;
	}

键盘录入两个数据,求两个数据中的最大值

方式1:三元运算符

public static int getMax(int a,int b){
		//业务:
		//比较a和b的最大值
		
		return (a > b) ? a: b ;
	}

方式2:if…else 语句

public static int getMax2(int a,int b){
		//定义max变量
		int max ; 
		if(a> b){
			max = a ;
		}else{
			max = b ;
		}
		
		return max ;
	}

键盘录入三个数据,求三个数据中的最大值

方式1:使用中间变量+三元运算符

public static int getMax(int a,int b, int c){
		//定义变量
		int temp = (a > b) ? a : b ;
		int max = (temp > c) ? temp : c ;
		return max ;
	}

方式二使用if语句实现:if嵌套

public static int getMax2(int a,int b,int c){
		//定义一个max变量
		int max ; 
		if(a  > b ){
			if(a > c){
				max = a ;
			}else{
				max = c ;
			}
		
		}else{
			if( b > c ){
				max = b ;
			}else{
				max = c ;
			}
		}
		return max ;//返回
	}

方式三直接采用三元运算符

public static int getMax(int a,int b, int c){
		//定义变量
		int max = (a>b)?((a>c)?a:c):((b>c)?b:c);
		return max ;
	}

方式二

方法定义:

public static void 方法名(形式参数类型1 变量名1,形式参数类型2 变量名2…){
直接输出语句或者其他业务操作;
}

应用

1)键盘录入行数m,列数n,输出m行和n列的

public static void printXing(int m,int n){
		for(int x = 0 ; x < m ; x ++){
			for(int y = 0 ; y < n ; y ++){
				System.out.print("*") ;
			}
			System.out.println() ;
		}
	}

打印nn乘法表

public static void printNN( int n){
	for(int i =1 ;i <=n ; i++){
		for(int j = 1; j<=i; j++){
			System.out.print(j+"*"+i+"="+j*i+"\t");
		}
		System.out.println();
	}
}

没有具体返回值类型的方法调用

单独调用
赋值调用
输出调用(推荐)

方法重载 (overLoad)

方法名相同,参数列表不同,与返回值无关!
参数列表不同:
1)数据类型一样的,参数个数不同
2)参数个数一样,类型不同!
参数个数不一样,参数类型不同

数组

数组:是可以存储元素的一种容器!
前提:元素的数据类型必须一致的!

定义格式

数据类型[] 数组名称 ; (习惯)
数据类型 数组名称[] ;

数组的初始化

1)动态初始化:指定了数组长度,系统默认给定数组的元素值.
2)静态初始化:指定了具体的元素的内容,系统默认指定数组的长度.

动态初始化

数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;
int[] arr = new int[3];

数组中元素的的访问方式:

数组名称[角标]来访问
角标(下标/索引):都是从0开始记录元素的!

静态初始化

数组的静态初始化 :指定数组的元素内容,系统给它默认长度

格式
标准格式

数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3…} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3…} ;

简化格式

数据类型[] 数组名称 ={元素1,元素2,元素3…} ;
数据类型 数组名称[] ={元素1,元素2,元素3…} ;

异常

(后期Throwable:异常的总称)

严重问题:
error : 内存异常了 (通过一些第三方工具避免了!)
举例: 一些软件通过一些特殊的操作:造成软件崩溃了!

异常:
Exception: 能够通过本身代码来解决问题
编译时期异常:只要不是运行时期的异常都属于编译时期(不解决,编译通过不了)
RuntimeExcetion:运行时期异常
在执行过程中,由于代码结构不严谨,导致的问题!

两个异常

数组角标越界

java.lang.ArrayIndexOutOfBoundsException:
出现的原因:访问不存在的角标!就出异常了
解决方案:改动角标值即可!

空指针异常

java.lang.NullPointerException:
出现的原因:
某个对象都为null,还需要使用对象访问内容或者调用其他功能!
解决方案
: 只需要对某个对象做一个非空判断!(逻辑判断)

数组的应用

遍历

public static void printArray2(int[] arr){
		System.out.print("{") ;
		//遍历数组
		for(int x = 0  ; x < arr.length ; x ++){
			//判断
			if(x == arr.length-1){ //遍历到了最后一个元素
				System.out.println(arr[x] +"}") ;
			}else{
				System.out.print(arr[x] +", ") ;
			}
		}
	}

最值问题

分析:假设思想(以求最小值为例)
1)将数组中第一个元素arr[0]看为最小值
2)从角标1开始遍历其他元素
2.1)分别将当前遍历的元素依次和最小值进行比较
如果当前元素小于最大值
将当前元素内容赋值min变量

public static int getMin(int[] arr){
		//参照物
		int min = arr[0] ;//假设第一个元素是最小值
		//从角标1开始遍历其他元素
		for(int x =1 ; x < arr.length ; x ++){
			//比较
			if(arr[x] < min){
				min = arr[x] ;
			}
		}
		return min ;
	}

数组的元素逆序

中心思想:
将13 arr[0]–57 arr[arr.length-1]互换
将87 arr[1]—24 arr[arr.length-1-1]互换…
…
保证 数组的长度/2

方法一

public static void reverse2(int[] arr){
		//start:表示开启索引值
		//end:表示最大索引值
		for(int start = 0 ,end = arr.length-1 ; start<end ; start ++,end --){
	
			//中间变量互换
			int temp = arr[start] ;
			arr[start] = arr[end] ;
			arr[end] = temp ;
		}
	}

方法二

for(int x=0; x<arr.length/2; x++) { 
      int temp = arr[x]; 
      arr[x] = arr[arr.length-1-x];
       arr[arr.length-1-x] = temp; 
    }

数组元素查表法

数组名称[index:角标]访问元素

字符串数组: 数据类型[] 数组名称 = new 数据类型[]{元素1,…} ;
String[] strs = {“星期一”,“星期二”,
“星期三”,“星期四”,“星期五”,“星期六”,“星期天”} ;

import java.util.Scanner ;
class ArrayTest4{
	public static void main(String[] args){
		
		//字符串数组
		String[] strs = {"星期一","星期二",
						"星期三","星期四","星期五","星期六","星期天"} ;
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请您输入一个数据(0-6):") ;
		int index = sc.nextInt() ;
		
		System.out.println("你要查询的是:"+strs[index]) ;
	}
}

数组的元素基本查找:

查询数组中的元素在数组索引值

假设思想:
1)假设找不到
定义一个变量
int index = -1 ;
2)遍历数组,获取到每一个元素
如果当前元素和要查询的元素一致的话
改变index的值(将当前元素所在的角标值赋值给index)
break ;
3)找不到,直接返回index

public static void  findArray(int[] arr,int a){
	int index = -1;
	for (int i = 0; i < arr.length; i++) {
		if (arr[i]==a) {
		index = i;
		break;
		} 
	}
	if (index > 0) {
		System.out.println("该数据角标值为:"+index);
		}
	else {
		System.out.println("未查询到该数值");
		}

}

数组的高级应用(冒泡排序法)

冒泡排序思想

两两比较,将较大的值往后放;第一次比较完毕,最大值就出现在最大索引处!
依次这样比较:
规律:
第一次:有0个不比
第二次:有1个不比
…
…
比较的次数:数组长度-1次

public static void bubboleSort(int[] arr){
		
		for(int x = 0 ; x < arr.length-1 ; x ++){ //x = 0 ; 1  2,3  控制比较的次数
			for(int y = 0 ; y < arr.length-1-x ; y++){//y表示元素的角标
				 if(arr[y] > arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		
	}

二维数组

定义格式

数据类型[] 数组名称[] ;
数据类型[][] 数组名称 ; (推荐)

初始化格式
格式一

数据类型[][] 数组名称 = new 数据类型[m][n] ;
m:表示当前二维数组中的一维数组的个数
n:表示每一个一维数组的长度

格式二

数据类型[][] 数组名称 = new 数据类型[m][] ;
数据类型[] 数组名称[] = new 数据类型[m][] ;

格式三

标准格式:
数据类型[][] 数组名称
=
new 数据类型[][]{{元素1,元素2,…},{元素1,元素2…},{元素1,元素2…}};

简化格式
数据类型[][] 数组名称 = {{元素1,元素2,…},{元素1,元素2…},{元素1,元素2…}}

二维数组的应用

二维数组的遍历

输出格式优雅:
{{1,2,3},{4,5,6},{7,8,9}}

public static void PrintlnArray2(int[][] arr){
		System.out.print("{");
		for(int i= 0; i<arr.length;i++){
			System.out.print("{");
			for(int j=0; j<arr[i].length;j++){
				if(j==arr[i].length-1 && i<arr.length-1){
					System.out.print(arr[i][j]+"},");
				}
				else if(j==arr[i].length-1 && i==arr.length-1){
					System.out.print(arr[i][j]+"}");
				}
				else{
					System.out.print(arr[i][j]+",");
				}
			}
		}
		System.out.println("}");		
	}

杨辉三角

A:如果是n行，那么最后一行是n列。
B:每一行的第一列和最后一列的元素是1。
C:规律： 每一行的第二列开始数据是：上一行的上一列+上一行的同一列
D:把二维数组组成，然后遍历即可。 遍历的时候，注意模仿九九乘法表的遍历。否则会有很多0。

import java.util.Scanner;
class YangHui{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入杨辉三角的行数:");
		int n = sc.nextInt();
		System.out.println("-----------------------:");
		
		
		
		int[][] arr =new int[n][n];
			for(int i =0;i<arr.length;i++){
				arr[i][0] = 1;
				arr[i][i] = 1;
			}
			//第三行开始
			for(int i=2; i<n; i++) { 
			//第二列开始,一定要记得减去最后一列
				for(int j=1; j<=i-1; j++) {
					arr[i][j] = arr[i-1][j-1]+arr[i-1][j];
			
				}
			}
			//输出的时候，千万要和九九乘法表的输出类似。
			for(int i=0; i<arr.length; i++){
				for(int j=0; j<=i; j++){ 
					System.out.print(arr[i][j]+"\t");
				}
				System.out.println(); 
			}
    }
}

思考题

一

基本类型作为形式参数进行传递,的特点:
形式参数的改变对实际参数没有影响!

class ArgsDemo{
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 10 ;
		int b = 20 ;
		System.out.println("a:"+a+",b:"+b);//10,20
		System.out.println("----------------------------") ; 
		change(a,b) ;//实际参数
		System.out.println("----------------------------") ;
		System.out.println("a:"+a+",b:"+b);//10,20   

		System.out.println("----------------------------") ;		
	}
	
	public static void change(int a,int b){ //a,b形式参数
		System.out.println("a:"+a+",b:"+b);//10,20
		a = b ;//a = b =20 ;
		b = a + b ;//b = 20 + 20 = 40 
		
		System.out.println("a:"+a+",b:"+b);//2,40
	}
}

二

如果形式参数是一个引用数据类型:数组
形式参数的改变对实际参数有影响!

class ArgsDemo2{
	public static void main(String[] args){
			
		//定义一个数组,静态初始化
		int[] arr = {1,2,3,4,5} ;
		System.out.println(arr[3]) ;//4
		System.out.println("-------------------------") ;
		change(arr) ;
		System.out.println(arr[3]) ;//8
	}
	
	public static void change(int[] arr){
		//遍历了数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断
			if(arr[x] % 2 == 0){
				arr[x] *=2 ;
			}
		}
	}
}

三

String类型是一种特殊的引用类型:
它作为形式参数,形参的改变对实际参数没有影响-----跟基本类型作为形式参数是一样!

class ArgsDemo3{
	public static void main(String[] args){
			
			String s = "hello" ; //字符串是一个常量,一旦被赋值,其值不能被更改!
			System.out.println(s) ;
			change(s) ;
			System.out.println(s) ;
	}
	
	
	public static void change(String s){ //String:引用类型 作为形式参数
		s += "world" ;
	}
	

面向对象

面向对象本质其实就是一个面向过程的!(基于面向过程)

面向过程:

代表语言:C语言
1)需求分析 :遍历数组
2)将分析结果使用功能改进
3)需要书写功能的业务操作(将元素一一获取出来,直接输出/按照特定格式输出)
4)在main方法中调用—输出数组的元素!

面向对象思想特点:

1)符合现实世界事物生活中的思想行为习惯!
2)让我们执行者变成了指挥者(角色发生了改变!)
3)让复杂的事情简单化!

类与对象

事物
描述现实世界真实存在的

Java中最基本的单元:class 类 :来描述现实世界事物的一组属性和行为的集合!
创建对象的格式:

类名 对象名 = new 类名() ;
要给具体的人赋值属性 :
对象名.成员变量= 值; (需要和数据类型保持一致!)
使用人的功能:学习,打游戏,睡觉
对象名.成员方法名() ;