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 类名() ;
要给具体的人赋值属性 :
对象名.成员变量= 值; (需要和数据类型保持一致!)
使用人的功能:学习,打游戏,睡觉
对象名.成员方法名() ;
扫一扫
450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
