循环语句,数组,方法,面向对象(封装)

今天的内容是循环语句,数组,类,对象,面向对象的三大特征之一的封装;
对这些内容有格式,怎么用,还有注意事项; 这些知识点里面的内容考试题型做了一个总结,
希望对正在学习java的你可以有所帮助;以后每周都会更新,知道我退出这个行业;

1循环结构语句

for :使用最多: 普通for循环
求和思想
统计思想
什么是水仙花数 :三位数,每个位上的数据的立方相加的,是这个数据本身 157?
while: 其次才是这个while
do-while 很少用
引入两个死循环 :一定要出口条件

for(; ; ){循环体;
}
while(true){ //使用多一些循环体;
}

1.1for语句

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

/**
*需求:需要在控制台输出 10次 "我爱章若楠"
*这一个代码:10句话放在程序中
* 1)阅读性差
* 2)代码的冗余度非常高(重复性太大)* 这个时候,计算机语言提供了流程控制语句之循环语句
* //明确循环次数优先的for循环* 格式
* for(初始化语句;条件表达式;控制体语句或者步长语句){循环体语句;}*/public class Demo {public static void main(String[] args){//最原始的做法:输出10句话System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("我爱章若楠") ;System.out.println("------------------------------------------------");//10次 "我爱章若楠“for(int x = 1 ; x <=10;x++){       //x=1，x<=10, x=2,2<=10,x = 3 ,3<=10,x=10,x<=10,x=11,11<10System.out.println("我爱章若楠") ;        //1，2,3....... 10}}
}

• 执行流程

1)初始化语句:给变量赋值 (只执行一次)
2)然后执行条件表达式,看其是否成立,如果成立,执行的是循环体语句------>再次回到控制体语句或者步长语句—>变量自增或者自减
3)再次执行条件表达式,是否成立,成立,继续循环体语句---->再次回到控制体语句或者步长语句---->变量自增或者自减
4)一直执行到条件表达式不成立,for循环结束;

1.2循环求和思想

需求:
* 1)在控制台输出1-10的每一个数据
*
* 2)循环的求和思想
* 在控制台输出1-10的之间的所有的数据之和
* 1+2+3+4+5+6+7+8+9+10 :原始做法比较麻烦,随着数据规模越来越大,这种
做法不合适;
*
* 求和思想:
* 将上面的这种格式变形一下:
* 定义一个结果变量: 从0开始 sum这个变量
* 0 + 1 = 1 ;
* 1 + 2 = 3 ;
* 3 + 3 = 6 ;
* 6 + 4 = 10 ;
* 10 +5 = 15 ;
* 15 + 6 = 21 ;
* 21 + 7 =28 ; ....
*
* 两个加数:
* 前面的这个加数:就是求和结果变量sum,从0开始
* 后面的这个加数:就是1-10的数据;
*
*
* 使用步骤:
* 1)定义一个最终结果变量sum,从0开始记录
* 2)使用for(初始化语句;条件表达式;控制体语句){* //循环体语句
* //先取出来每一个数据
* 使用结果变量就是上面的数据求和,然后再赋值给最终结果变量;
* }
* 3)输出sum即可
public class ForDemo {public static void main(String[] args) {//1)在控制台输出1-10的每一个数据//原始的做法System.out.println(1) ;System.out.println(2) ;System.out.println(3) ;System.out.println(4) ;System.out.println(5) ;System.out.println(6) ;System.out.println(7) ;System.out.println(8) ;System.out.println(9) ;System.out.println(10) ;System.out.println("--------------------------------") ;//上面的重复度很高,改进
/* for(初始化语句;条件表达式;控制体语句或者步长语句){
循环体语句;
}*/for(int i = 1;i<=10 ; i ++){   //x=1,1<10 , i++-->2 <=10System.out.println(i) ;    //1, 2....}System.out.println("---------------求和思想的引入------------------");// 在控制台输出1-10的之间的所有的数据之和//原始的做法:System.out.println(1+2+3+4+5+6+7+8+9+10) ;System.out.println("---------------------------------------------") ;//定义一个结果变量int sum = 0 ;for(int x = 1 ; x <=10 ; x ++) {// 1-10之间的数据//x的取整:1,2....10;sum += x ; //sum = sum + x ;
/**
* sum = 0 ;
* x = 1 ; x <=10 ;成立---循环体: sum = sum+x 0 +1 =1 x++
* x = 2 ; 2<=10 ;成立--- 循环体: 1 + 2 = 3 -- sum = 3 ; x ++
* x = 3 ; 3<=10 ; 成立--- 循环体: 3+3 = 6 --- sum= 6; x++
* x=4 .....................
*/}System.out.println("1-10的数据之和是:"+sum);}
}

1.3水仙花数获取

需求:在控制台输出所有的水仙花数

• 水仙花数

• 水仙花指的是三位数,而且这个三位数的每一个位上的立方相加就是当前数据本身;

• 举例:153 = 1 * 1 * 1 + 555 + 333

• 153 % 10 = 3 ;—确定个位的数据

• 153 / 10 % 10 = 5 — 确定十位的数据

• 153 /10 /10 %10 = 1 — 确定百位上的数据

• 分析:

• 1)三位数,明确了范围 100-999—使用for循环 x

• 1. 确定每各位的数据本身的值:
     定义三个变量,分别代表个位,十位,百位数据本身
     int ge = 当前这个数据 % 10 ;
     int shi = 当前这个数据 /10 %10 ;
     int bai = 当前这个数据 /10/10 % 10 ;

• 3)for循环中加入逻辑判断
  如果当前x == (gegege)+(shishishi)+
  (baibaibai),
  满足条件,直接输出x

public class forDemo3 {public static void main(String[] args) {System.out.println("水仙花数是:") ;// 1)三位数,明确了范围 100-999---使用for循环 xfor (int x = 100; x < 1000; x++) {//x:100-999的数据//确定每各位的数据本身的值:// 定义三个变量,分别代表个位,十位,百位数据本身int ge = x %10 ; //x=153int shi = x /10 %10 ;int bai = x /10 /10 % 10;//如果当前x == (ge*ge*ge)+(shi*shi*shi)+(bai*bai*bai),满足条件,//直接输出xif(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){System.out.println(x) ;}}}
}

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

需求:猜数字游戏

写代码的过程,经常用alt+enter键:自动提示,补全代码

分析:
1)需要产生一个随机数:java.lang.Math 里面的功能random()产生一个1-100之间的随机数不断的键盘录入
Math.random使用
jdk提供了类:java.lang.Math

• java.lang包下的类不需要导包
• 针对数学运算的工具类,提供了很多的方法;
• 获取伪随机数,取值范围:[0.0,1.0)
• public static double random():
• 快速使用:

•   Math.random()---获取一个随机数
  

 while(true){2)创建一个键盘录入对象,录入int类型3)录入的数据要和Math里面产生的1-100之间数据进行对比,如果大了,提示 "你要猜的数据大了"如果小了,提示"你要猜的数据小了"如果一致,提示"恭喜您,猜对了"结束死循环,break ;

   }

public class DisLooperTest {public static void main(String[] args) {System.out.println("-------猜数字小游戏-------");System.out.println("---------游戏开始-----");//需要产生一个随机数:java.long.Math 里面的功能random()产生一个1-100之间的随机数int number= (int) (Math.random()*100+1);//创建键盘录入对象Scanner sc = new Scanner(System.in);//提示输入并输入要猜的数字System.out.println("请输入你要猜的数字:");int count=0;while(true) {//如果猜错了重新录入int number1= sc.nextInt();count++;//拿键盘录入的数字和Math产生的随机数做比较if (number1 > 100 || number1 < 0) {System.out.println("你输入的数字有误!请输入1-100之间的数字");} else if (number1 > number) {System.out.println("你猜的数" + number1 + "大了!"+"请重新输入");} else if (number1 < number) {System.out.println("你猜的数" + number1 + "小了!"+"请重新输入");} else {System.out.println("恭喜你猜对了!");System.out.println("你第" + count + "猜对了");break;}}System.out.println("--------游戏结束--------");}
}

2 for循环的综合运用(for循环嵌套)

for(初始化语句1;条件中表达式1;控制体语1){ //外层循环// 循环体语句又是一个for循环for(初始化语句2;条件表达式2;控制体语2){//内层循环循环体语句...}
}4行5的列*
*****
*****
*****
******
**
***
****
*****
******
*******
********
**********
99乘法表

2.1 99乘法表代码

/*九九乘法表*/
public class Demo {public static void main(String[] args) {//外层循环,表示行数,一共有多少行for (int i = 1; i <= 9; i++) {//内层循环表示列数,for (int j = 1; j <= i; j++) {//列数随着x的变化而变化//Java中 转移字符 "\t"---->制表符 相当于tab 缩进空格System.out.print(i + " x " + j + " = " + (i * j) + "\t");}System.out.println();//换行}}
}

2.2do-while循环和其他循环语句的区别

初始化语句;
do{循环体语句;控制体语句;
}while(条件表达式) ;
//区别于其他循环: 当条件不成立的时候,循环体语句至少执行一次; 开发中使用的比较少;

2.3断点调试

• 在方法中的有效代码第一行打断点,在行号上直接单击即可

• 使用debug启动Java应用程序 右键—选择 debug run xxx类名.main :debug启动这个类的main方法
  
  

2.4 break和contine的笔试题

for(int x= 1 ; x <=10;x++){ if(x %3==0){ //补全代码
}
System.out.println("我爱章若楠"); }
//在补全代码的地方需要打印以下内容:该如何补?
//1)需要在控制台输出 2次"我爱章若楠" break
//2)需要在控制台输出7次"我爱章若楠" continue
//3)需要在控制台输出13次"我爱章若楠" System.out.println("我爱章若楠") ;

2.5跳转控制语句break和continue的区别

两个都在循环中使用居多;
break:结束中断,结束循环语句也可以结束switch语句,应用范围比continue大
continue:仅仅在循环中使用,表示"结束当期循环,立即进入下一次循环"

循环的基本内容结束了,接下来是方法啦

3 java中的方法

方法(method) 的概述：就是完成特定功能的代码块

3.1无参无返回值方法的定义和调用

定义
public static void 方法名(){//方法体
}
范例: public static void isEvenNumber(){//方法体
}
调用
格式:        方法名();
范例:        isEvenNumber();
idea演示public class MethodDemo {public static void main(String[] args) {//调用方法isEvenNumber();}

    //需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数public static void isEvenNumber() {//在方法中定义一个变量int number = 10;number = 9;//判断该数据是否是偶数if (number % 2 == 0) {System.out.println(number + "是偶数");} else {System.out.println(number + "不是偶数");}}
}

注意事项：

方法定义完毕后，需要调用才能执行

方法必须先定义后调用，否则程序将报错

3.2 Debug查看方法调用

• 按照 Debug 的正常使用即可，但是要注意如下事项：
• 进入一个方法的时候，需要用 Step Into F7
• 在方法内部，看每一行代码的执行流程，使用 Step Over F8
• 注意观察方法的出现和消失，以及变量的变化

练习输出较大值
题目:
① 定义一个方法，用于打印两个数字中的较大数，例如：getMax()
② 方法中定义两个变量，用于保存两个数字
③ 使用if语句对两个数字的大小关系进行处理
④ 在main()方法中调用定义好的方法
代码:

public class MethodTest {public static void main(String[] args) {//在main()方法中调用定义好的方法getMax();}//定义一个方法，用于打印两个数字中的较大数，例如：getMax()public static void getMax() {//方法中定义两个变量，用于保存两个数字int a = 10;int b = 20;//使用if语句对两个数字的大小关系进行处理if(a >= b) {System.out.println("较大的数是：" + a);} else {System.out.println("较大的数是：" + b);}}
}

3.3 带参无返回值方法的定义和调用

定义
格式: public static void 方法名(数据类型 参数1,数据类型 参数2,,,,,,,,){...........}
注意事项：

带参方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

带参方法定义时，多个参数之间使用逗号(,)分隔

调用
格式: 方法名(变量名1/字面量值1,变量名1/字面量值1);
注意事项：

带参方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

代码演示:

public class MethodDemo {public static void main(String[] args) {//字面量值调用isEvenNumber(10);isEvenNumber(9);//变量的调用int number = 11;isEvenNumber(number);number = 12;isEvenNumber(number);}

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数public static void isEvenNumber(int number) {if (number % 2 == 0) {System.out.println(true);} else {System.out.println(false);}}
}

3.4 形参和实参

形参：方法定义中的参数
等同于变量定义格式，例如：int number
实参：方法调用中的参数
等同于使用变量或字面量，例如： 10 number
输出较大值(练习)
题目要求:
① 定义一个方法，用于打印两个数字中的较大数，例如：getMax()
② 为方法定义两个参数，用于接收两个数字
③ 使用if语句对两个数字的大小关系进行处理
④ 在main()方法中调用定义好的方法（使用字面量）
⑤ 在main()方法中调用定义好的方法（使用变量）

public class MethodTest {public static void main(String[] args) {//在main()方法中调用定义好的方法（使用字面量）getMax(10,20);//在main()方法中调用定义好的方法（使用变量）int x = 10;int y = 20;getMax(x,y);}//定义一个方法，用于打印两个数字中的较大数getMax()//为方法定义两个参数，用于接收两个数字public static void getMax(int a, int b) {//使用if语句对两个数字的大小关系进行处理if(a >= b) {System.out.println("较大的数是：" + a);}else {System.out.println("较大的数是：" + b);}}
}

3.5 带返回值方法的定义和调用

定义格式:

public static 返回值类型 方法名(数据类型  参数1,数据类型 参数2,,,,,,,,){return 数据;
}

注意事项：

方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

调用格式:
数据类型 变量名 = 方法名(参数);

注意事项：

方法的返回值通常会使用变量接收，否则该返回值将无意义

有返回值较大值的练习
题目要求:
① 定义一个方法，用于获取两个数字中的较大数，例如：getMax()
② 使用if语句对两个数字的大小关系进行处理
③ 根据题设分别设置两种情况下对应的返回结果
④ 在main()方法中调用定义好的方法并使用变量保存

public class MethodTest {public static void main(String[] args) {//在main()方法中调用定义好的方法并使用变量保存int max = getMax(10, 20); //.var的使用，它能够帮我们自动补齐左边的内容System.out.println(max); //max.sout，能够把max变量放到输出语句中System.out.println(getMax(10,20));System.out.println(getMax(10, 20));}//定义一个方法，用于获取两个数字中的较大数，例如：getMax()public static int getMax(int a,int b) {//使用if语句对两个数字的大小关系进行处理//根据题设分别设置两种情况下对应的返回结果if(a >= b) {return a;} else {return b;}}
}

方法的注意事项

方法不能嵌套定义 void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

3.6 方法的通用格式

public static 返回值类型 方法名(参数){方法体;return 数据;
}

格式说明：

public static 修饰符，目前先记住这个格式

返回值类型
方法操作完毕之后返回的数据的数据类型，如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return

方法名 调用方法时候使用的标识

参数 由数据类型和变量名组成，多个参数之间用逗号隔开

方法体 完成功能的代码块

return 如果方法操作完毕，有数据返回，用于把数据返回给调用者

定义方法时，要做到两个明确

明确返回值类型： 主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型

明确参数： 主要是明确参数的类型和数量而在调用方法时，我们要知道下面两种不同返回值类型的方法调用：

void类型的方法，直接调用即可非void类型的方法，推荐用变量接收调用

3.7 方法重载

概述: 指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

格式:

多个方法在同一个类中

多个方法具有相同的方法名

多个方法的参数不相同，类型不同或者数量不同

方法重载的特点:

类型不同或者数量不同重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载 用代码解释方法重载

public class MethodDemo {public static void main(String[] args) {//调用方法int result = sum(10, 20);System.out.println(result);//每次调用需要从新创建对象double result2 = sum(10.0, 20.0);System.out.println(result2);int result3 = sum(10, 20, 30);System.out.println(result3);}//需求1：求两个int类型数据和的方法public static int sum(int a,int b) {return a + b;}//需求2：求两个double类型数据和的方法public static double sum(double a,double b) {return a + b;}//需求3：求三个int类型数据和的方法public static int sum(int a,int b,int c) {return a + b + c;}
}

4 数组(默认都是一维数组)---------- 进入到引用数据类型 (重点)

4.1 JVM在java内存的内存分配

• 栈内存

• 堆内存

• 方法区

• 字节码文件区域

• static区域

• 常量池…

• 寄存器

• 本地方法区

4.2 什么是数组?

• 数组定义格式
• 动态初始化
• 静态初始化

数组: Java中数组就是容器,这个容器 “只能存储同一种类型的元素”
在数组中定义格式
动态初始化和静态初始化

动态初始化:自己定义数组的长度,数组的元素有系统(jvm)默认分配

格式:
数据类型[] 数组名称 = new 数据类型[数组长度] ; 推荐第一种
数据类型 数组名称[] = new 数据类型[数组长度] ;

举例
int[] arr = new int[3] ;
int arr[] = new int[3] ;
静态初始化

数组的定义格式第二种
静态初始化:直接我们自己给定的了元素内容,数组的长度由系统默认分配

原生的格式写法: 数据类型[] 数组对象名 = new 数据类型[]{元素1,元素2,元素3…} ; 数据类型 数组对象名[]
= new 数据类型[]{元素1,元素2,元素3…} ;
举例 int[] arr = new int[]{1,2,3} ; int arr[] = new int[]{1,2,3} ;
静态初始化的简写格式 数据类型[] 数组对象名 = {元素1,元素2,元素3…} ;
推荐的写法 数据类型 数组对象名[] = {元素1,元素2,元素3…} ; int[]
arr = {1,2,3} ; int arr[] = {1,2,3} ;

在数组中有一个特有的属性:length 数组名称.length: 获取数组长度 数组中的最大索引值: 数组名称.length-1

java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常 :访问了数组中的不存在的索引就会出现这种问题;

异常:Exception 编译时期异常:idea写代码的,编译通过不了,无法运行; 语法有问题; 运行时期异常:
开发者在编写代码的时候,大部分逻辑性不严谨,比如: 数组的5个元素,角标最大4,你访问角标5

public class ArrayDemo3 {public static void main(String[] args) {// 数据类型[] 数组对象名 = {元素1,元素2,元素3.....} ; 推荐的写法//创建一个数组,静态初始化int[] arr = {11,22,66,77,67} ;System.out.println(arr.length-1);//获取最大索引值System.out.println(arr) ;//地址值System.out.println(arr[0]) ;System.out.println(arr[1]) ;System.out.println(arr[2]) ;System.out.println(arr[3]) ;System.out.println(arr[4]) ;//java.lang.ArrayIndexOutOfBoundsException:数组//角标越界异常 :访问了数组中的不存在的索引就会出现这种问题;//System.out.println(arr[5]) ;//jvm在校验:这个语法通过的,满足 数组名称[索引值]}
}

4.3 数组的基本应用

    数组中的元素----一一获取出来 (数组的遍历) 数组 存储了5个不同的元素,获取元素中最大值/           最小值查询这个数组的某个元素的角标import java.util.Arrays;

import java.util.Scanner;

/*2.键盘录入5个不同int类型的数据，将数据存储在数组中,把这个数组中所有元素顺序进行逆序。（静态初始化）*/
public class ArrayDemo01 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int[] arr = {0, 0, 0, 0, 0};//静态初始化for (int i = 0; i < 5; i++) {//为数组添加元素System.out.println("请输入第"+(i+1)+"处的元素:");arr[i] = sc.nextInt();//键盘录入}//数组逆序for (int i = 0; i < arr.length/2; i++) {//元素交换int temp = arr[i];arr[i]=arr[arr.length-1-i];arr[arr.length-1-i]=temp;}//打印数组System.out.println(Arrays.toString(arr));}
}

/*元素逆序*/
public class ArrayDemo02 {public static void main(String[] args) {//定义一个数组int[] array={1,2,3,4,5,6};//遍历数组2分之1次取值for (int i = 0; i < array.length/2; i++) {//定义变量存放数组中的第0处索引的值int temp = array[i];//然后把数组中的要交换的元素赋给索引0array[i]=array[array.length-1-i];//然后把变量中存放的元素赋给要交换的索引位置array[array.length-1-i]= temp;}//打印数组System.out.println(Arrays.toString(array));for (int start=0,end= array.length-1; start < end; start++,end--) {int temp= array[start];array[start]=array[end];array[end]= temp;}System.out.println(Arrays.toString(array));}
}

/*** 数组中的基本元素查找法: 查询元素 的第一次出现的索引值,每次都需要从头查到尾*   对于基本元素查找法的----数组的元素的内容,可以无序/可以有序***   后面:高级查询:二分搜索法(称为"折半查找):前提条件:数组的元素必须有序!*   特点:能够节省查询时间,效率高*** 需求:*  已知一个数组,静态初始化了,查询数组中某个元素的索引值;**  int[] arr = {69,57,13,24,87} ;  //查询13这个元素第一次出现的索引值*                                      //133元素***          分析:*               1) 定义一个方法*                      方法的返回值 int*                      方法的参数类型和参数个数*                          int[],查询的具体的元素   2个参数*               2)*                    遍历数组,获取所有元素*                    判断:如果要查询的元素和数组的中元素一致,就找到了*                              返回角标值*/
public class ArrayDemo03 {public static void main(String[] args) {//已知这个数组:int[] arr = {69,57,13,24,87} ;//调用方法int index = getIndex(arr, 13);//找13System.out.println("index:"+index);System.out.println("----------------------------") ;int index2 = getIndex(arr, 133);//找13System.out.println("index2:"+index2);}/*** 定义一个方法*  明确返回值类型: int*  明确参数类型以及参数个数*          nt[],查询的具体的元素   2个参数*/public static int getIndex(int[] array,int target) {//array:传递一个数组,target:查询目标元素//遍历数组,获取所有元素for (int x = 0; x < array.length; x++) {//array[x]:每一个元素就可以获取到//判断//如果array[x] 和target 相等,就找到了,x返回if (target == array[x]) {//考虑找到的情况return x;}}//查询数组:找不到元素,返回负数  -1return  -1 ;}
}

4.4 方法重载

什么是overload? 就是方法重载
方法重载:为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同 ,与返回值无关, 参数列表不同
1)参数个数不同
2)参数类型不同
3)参数类型的顺序不同

public static double getSUM(int x,double y){return x+y ;
}
public static double getSum(double a,int b){double result = a +b;return result ;
}
public static double getSum(int a,double b){double result = a +b;return result ;
}

4.5 编程作业

4…定义一个方法，根据商品总价，计算出对应的折扣并输出。折扣信息如下：
总价<100，不打折
总价在100到199之间，打9.5折
总价在200以上，打8.5折
要求：
1)定义一个方法，根据商品总价输出折后总价
2)在主方法中调用方法,输出结果

public class Test01 {public static void main(String[] args) {double v = DiscountTest();//调用方法,接收返回值System.out.println("你购买的商品的价格为: "+v+"元");//打印返回值}public static double DiscountTest(){//创建键盘录入对象Scanner sc= new Scanner(System.in);//提示并输入数System.out.println("请输入你要购买的商品价格:");int num1= sc.nextInt();double x=0.0;//定义返回值if (num1<100){//小于一百x= num1;//把价格赋值给x}else if (num1<=199&&num1>=100){//100到199之间x= num1*0.95;//把价格赋值给x}else if (num1>200){//200以上x= num1*0.85;//把价格赋值给x}return x;//返回值}
}

5.数组的遍历 :
定义一个数组,静态初始化,将数组中的元素按照下面格式输出
[元素1, 元素2, 元素3, 元素4 …] ,使用方法调用完成(遍历,直接输出,没有返回值类型 void)

public class Test02 {public static void main(String[] args) {//定义静态初始化数组int[] arr ={12,23,45,67,78,89};//调用方法,遍历数组ArrayList(arr);}//遍历数组public static void ArrayList(int[] arr){System.out.print("[");//打印[//遍历数组for (int i = 0; i < arr.length; i++) {if (i!=arr.length-1) {//判断i不等于arr[]的最后一个元素System.out.print(arr[i] + ", ");//成立打印arr[i] + ", "}else{System.out.print(arr[i]);//否则直接打印}}System.out.print("]");//打印]}
}

6.键盘录入5个不同的数据,组成数组,然后获取数组中的最大值(使用方法完成,明显有返回值----int)

public class Test03 {public static void main(String[] args) {//定义动态初始化数组int[] arr= new int[5];//创建键盘录入对象Scanner sc = new Scanner(System.in);//遍历为数组添加元素for (int i = 0; i < arr.length; i++) {//提示并录入System.out.println("请输入第"+i+"号索引处的数");int num = sc.nextInt();arr[i]=num;//添加元素}//调用方法int i1 = ArrayMax(arr);System.out.println("最大值为:"+i1);}public static int ArrayMax(int[] arr){//定义变量为最大值int max=arr[0];//遍历数组求最大值for (int i = 1; i < arr.length; i++) {if (arr[i]>max){//判断第第二处索引的值与第一处大的大小,要是第一处的大,那就把第一处的赋值给naxmax=arr[i];//true}}return max;//返回值}
}

7.编写方法，求数组元素的平均值
要求
1)定义一个方法，求数组的平均值
2)在主方法中定义对象，并初始化一个float类型的数组(直接在main方法中静态初始化一些值)，调用方法求数组元素的平均值，并将平 均值打印输出

public class Test04 {public static void main(String[] args) {//初始化数组float[] arr= new float[]{12.4F,18.2F,18.365F,14.023F,45.2F,3.14159260718F};//调用方法并接收返回值float avg = getAVG(arr);System.out.println("平均数为:"+avg);//打印平均数}//定义方法,,求数组元素的平均值public static float getAVG(float[] arr){float avg=0;//定义变量,用来返回平均值//遍历数组,,先把数组元素累加起来for (int i = 0; i < arr.length; i++) {avg=arr[i];//累加}avg/=arr.length;//平均值return avg;//返回平均值}
}

8.将昨天的Math中random()求1-100的随机数,使用键盘不断录入数据,猜数字游戏,使用方法来完成;最终在主方法中进行测试
展示,多少次猜中了;

public class Test05 {public static void main(String[] args) {//调用方法并接收返回值int count = GamePlay();//输出返回值System.out.println("你第" + count + "猜对了");}public static int GamePlay() {System.out.println("-------猜数字小游戏-------");System.out.println("---------游戏开始-----");//需要产生一个随机数:java.long.Math 里面的功能random()产生一个1-100之间的随机数int number = (int) (Math.random() * 100 + 1);//创建键盘录入对象Scanner sc = new Scanner(System.in);//提示输入并输入要猜的数字System.out.println("请输入你要猜的数字:");int count = 0;while (true) {//int number1 = sc.nextInt();count++;//拿键盘录入的数字和Math产生的随机数做比较if (number1 > 100 || number1 < 0) {System.out.println("你输入的数字有误!请输入1-100之间的数字");} else if (number1 > number) {System.out.println("你猜的数" + number1 + "大了!" + "请重新输入");} else if (number1 < number) {System.out.println("你猜的数" + number1 + "小了!" + "请重新输入");} else {System.out.println("恭喜你猜对了!");break;}}System.out.println("--------游戏结束--------");return count;//返回第循环次数}
}

9…搬砖问题：36 块砖，36 人搬，男搬4，女搬3，两个小孩抬1 砖，
要求一次全搬完，问男、女和小孩各若干？(穷举法题型,和百钱买百鸡同理)

public class Test06 {public static void main(String[] args) {int xiao=0;//小孩的数量for (int i = 0; i <= 9; i++) {//男人群举法for (int j = 0; j <= 12; j++) {//女人的群举法xiao=36-i-j;//小孩的数量就等于36减去男人和女人的数量if (i*4+j*3+xiao/2==36&&xiao%2==0){//判断小孩男人女人搬砖加人数等于36System.out.println("男人:"+i+" ,女人:"+j+" ,小孩:"+xiao);//成立输出小孩子,老头子,老婆子的数量}}}}
}

4.6 数组的高级排序算法:冒泡排序

package Test;import java.util.Arrays;
import java.util.Scanner;/*冒泡排序1比较相邻的元素。如果第一个比第二个大，就交换他们两个。2对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。3针对所有的元素重复以上的步骤，除了最后一个。4持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。分析:定义俩个方法,第一个方法为数组添加元素(提示键盘录入)第二个方法为数组*/
public class Effervescence {public static void main(String[] args) {//定义键盘录入对象Scanner sc = new Scanner(System.in);//提示并打印数组System.out.println("请输入需要排序的索引长度:");int x = sc.nextInt();//定义动态初始化数组int[] arr= new int[x];//调用方法给数组添加元素ArrayList(arr);//调用方法给数组排序BubbleSort(arr);}//定义方法用冒泡排序为数组排序public static void BubbleSort(int[] arr){int count=0;//定义一个计数器for (int i = 0; i <arr.length-1 ; i++) {//第一遍冒泡排序boolean dong= true;//定义退出循环变量for (int j = 0; j < arr.length-1-i; j++) {//判断第一个和第二元素大小;用元素交换方法交换他们的位置if (arr[j] > arr[j + 1]) {dong=false;int temp= arr[j+1];arr[j+1]=arr[j];arr[j] = temp;}}//判断是否排序完成;如果完成排序直接结束循环if(dong){break;}//提示这个打印每个进行一遍排序,且输出排序一遍后的元素;System.out.println("---------第" + ++count +"次排序结果----------");System.out.println(Arrays.toString(arr));}//最终排序结果System.out.println("最终排序结果:"+Arrays.toString(arr));}//定义方法为数组插入元素public static void ArrayList(int[] arr){//定义键盘录入对象Scanner sc = new Scanner(System.in);//遍历数组添加元素for (int i = 0; i < arr.length; i++) {//提示并为数组添加元素System.out.println("请输入位置"+i+"索引处的值:");arr[i]=sc.nextInt();}//定义数组//int[] arr = {12, 23, 8, 35, 89, 21, 78,2};//把冒泡排序运行数组长度减一次//换到最后一个数最后一个就不动了System.out.println("排序之前的数组:"+Arrays.toString(arr));}
}

4.7 面试题

int] array = new int[3]; 这句话完了哪些事情? —内存 于了什么事情
1)需要在栈内存中开辟空间int]
array这个变量
2)new int[3];需要在堆内存中申请空间
3)为这个堆内存中的这些数组的元素，进行系统默认机始化int类型的元素在数组中默以值0
4)系统初始化完毕,为堆内存空间产生一个空间地址值,
5)将堆内存空间地址值赋值给线内存的变量array
6)栈内存中array指向堆内存地址:

5 进入面向对象

数组和方法的基础学完了
接下来我们就要进入一个新的层次叫面向对象
什么是面向对象?接下来我们开始学习
什么是面向对象? Java语言 --对比面向过程:代表c语言
面向对象的思想特点是什么?
面向对象的三大特征: 封装继承多态(整个java最重要的)
Java重要特点:代码的健壮性(里面涉及Java面向的对象特征以及java设计模式)

5.1 类和事物的关系

什么是类----代码中体现类

事物:现实世界的真义存在的东西

class Student(} 学生事物 对象?

5.2 面向对象

什么是面向对象? Java语言 —对比 面向过程: 代表 c语言
面向对象的思想特点是什么?
面向对象的三大特征: 封装,继承,多态 (整个java最重要的)
Java重要特点:代码的健壮性(里面涉及Java面向的对象特征以及java设计模式)
面向对象思相特点是什么?

• 特点:
  1)更符号生活中的思想行为习惯
  2)让复杂的事情简单化
  3)从执行者变成了指挥者

5.2.1 面向对象语言被设计出来的理念

不断的去创建对象,使用对象,指挥对象做事情;

5.2.2 面向对象三大特征

• 封装,继承,多态 (整个java最重要的)

5.3 什么是类

类是能够描述现实世界事物属性和行为的集合

类和事物的关系:一对应的关系

事物:定现实真实存在的

• 学生事物
  属性: 姓名,身高,年龄,等等…
  行为:主要目的是学习

Java中规定,需要定义类描述这个事物 ,Java中最基本单元就是类 代码体现 描述哪一个事物 class 类名{
//类名:满足标识符的规范: 见名知意 }

5.3.1 面向对象思想特点

举生活中的例子;

面向对象基于面向过程,面向过程的代表C语言;
举例:
键盘录入三个数据,获取最大值1)分析:2)创建键盘录入3)写比较的逻辑4)输出结果...
面向过程:我们始终是一个执行者;面向对象基于面向过程:举例:现实生活中的例子买电脑面向过程:1)了解电脑笔记本的配置2)自己要去电脑城,了解, 谈价格3)砍价4)买完电脑,发现被坑了
面向对象:1)了解笔记电脑配置---告诉懂行的朋友2)你的朋友买回来洗衣服:面向过程:1)脱下脏衣服2)洗衣盆,泡一泡3)搓一搓4)透一透,拧一拧5)晾衣服..面向对象:1)脱下脏衣服2)放在自动洗衣机里面 一键即可3)晾衣服...高斯林:Java之父 "万物皆对象"

5.3.2 面向对象思想特点是什么?

特点:

1)更符号生活中的思想行为习惯
2)让复杂的事情简单化
3)从执行者变成了指挥者

5.4 基本类型作为形式参数和引用数组(数组,类,接口)作为形式参数的特点(重点)

实际需求业务中,数组这种在后期用的不是很多,用的"集合" List,Set,Map(高级集合特 性),支持长度可变的需求;

基本类型作为形式参数,形式参数改变不影响实际参数; 引用类型作为形式参数,形式参数的改变直接影响实际参数;

5.5 类 描述现实世界事物的一组属性和行为,代码体现对某事物的描述以及在对应的主方法中测试;

1)手机有品牌(brand),价格,颜色,内存等属性,
手机可以打电话,发短信,打游戏等行为,
请使用面向对象的方式描述手机并且进行定义一个PhoneTest类,在主方法中测试手机类

public class Phone {String brand;//品牌double price;//价格String color;//颜色double size;//内存大小
//定义成员方法打电话public void call(){System.out.println("给章若楠打电话;");}
//定义成员方法拍照片public void takePhotos(){System.out.println("给章若楠拍风景照;");}//定义成员方法聊天public void chat (){System.out.println("和章若楠发消息;");}//定义测试方法public void show(){System.out.println("品牌:"+brand+" ,价格:"+price+", 颜色:"+color+", 内存大小:"+size);}
}
//测试类
public class PhoneTest {public static void main(String[] args) {Phone p = new Phone();p.brand="华为nova8";//品牌p.price=1232;//价格p.color="幻影黑";//颜色p.size= 8;//内存大小p.show();//用来测试的方法p.call();//打电话的方法p.takePhotos();//拍照的方法p.chat();//聊天的方法}
}

2)学生有姓名,年龄,性别属性
学生主要行为就是学习,还可以玩游戏,
请使用面向对象的方式描述学生类并且定义一个StudentTest类,在主方法中测试学生类

public class Student {String name;//姓名int age;//年龄String gender;//性别String faxing;//发型//定义成员方法,,吃饭的行为public void eat(){System.out.println("吃香辣牛腿加汉堡");}//定义成员方法,,抽烟的行为public void somke(){System.out.println("抽华子");}//定义成员方法,,打游戏的行为public void playGame(){System.out.println("打穿越火线");}//定义成员方法,,学习的行为public void Java(){System.out.println("学习java");}
}
//测试学生类
public class StudentTest {public static void main(String[] args) {//创建学生对象Student s= new Student();s.name="刘德华";//给学生对象变量提供具体的值s.age=19;//年龄s.gender="男";//性别s.faxing="中风";//发型//打印System.out.println("名字:"+s.name+", 年龄:"+s.age+", 性别:"+s.gender+", 发型:"+s.faxing);s.eat();//调用方法吃饭s.somke();//调用抽烟的方法s.playGame();//调用打游戏的方法s.Java();//调用学习的方法}
}

5.6 通过上面的代码,思想 问题—>封装;

5.6.1 private

private作为一种权限修饰符可以修饰类、属性和方法；
用private修饰的类、属性、方法，只能自己使用，别的类是不能访问的，也就是说对于别的类来说是隐藏不可见的，
private一般不修饰类，但是可以修饰内部类。
可以使用private实现封装： 将属性和方法用private封装后表示，被封装的属性与方法只能在本类中使用，类外部不可见。

5.6.2 封装:

• 就是将显示世界事物的属性隐藏了(加入一个关键字private),
• 私有的,无法直接访问的,对外数据的安全性!(外界不能访问的)
• 对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX())
  封装的好处

1. 提高代码的安全性。

2. 提高代码的复用性。

3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。

4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作

5.6.3 注意事项:

以后在书写的代码的时候,写一个类,描述真实存在事物的属性的时候, 需要属性(英文单词字母全部小写)全部加入private

5.6.4 面试题:

• private关键字的特点?
• 1)被private修饰的成员变量以及成员方法只能在本类中访问
• 2)可以修饰成员变量也可以成员方法,就是为了外界不能直接访问
• 3)被private修饰的成员变量/成员方法可以间接的通过通过的方法访问

(002)循环语句,数组,方法,走进面向对象(封装)相关推荐

1. php循环语句w,php ftpconnectphp for 循环语句使用方法详细说明

   for循环只是一个多一点的代码,同时循环添加到它.而所涉及的一个循环的共同任务是: 设置一些计数器变量的初始值. 请检查条件语句是正确的. 执行中的代码循环. 增量在每个迭代结束通过循环计数器. fo ...

2. php foreach 一维数组遍历,php foreach 循环遍历数组方法

   摘要 腾兴网为您分享:php foreach 循环遍历数组方法,桌面时钟,找乐助手,银联商务,星球联盟等软件知识,以及西部证券,猫咪社区app,消逝的光芒风灵月影,精真估二手车,优视,布谷布谷,米乐网 ...

3. fou循环 php 剩余次数_php for 循环语句使用方法详细说明

   for循环只是一个多一点的代码,同时循环添加到它.而所涉及的一个循环的共同任务是: 设置一些计数器变量的初始值. 请检查条件语句是正确的. 执行中的代码循环. 增量在每个迭代结束通过循环计数器. fo ...

4. foreach循环遍历数组方法vue介绍

   在vue中用foreach循环遍历数组全部元素,利用回调函数对数组进行操作,自动遍历整个数组,且无法break中途跳出循环,不可控,不支持return操作输出,return只用于控制循环是否跳出当前循 ...

5. java do while 循环语句_java中do...while循环语句使用方法详解

   do..while循环语句也称为后测试循环语句,它的循环重复执行方式,也是利用一个条件来控制是否要继续重复执行这个语句.与while循环所不同的是,它先执行一次循环语句,然后再去判断 - do...w ...

6. birt脚本for循环语句_如何使用 for 循环语句嵌套方法！

   for循环语法: for( 表达式1:表达式2:表达式3) { 循环体 } 循环从表达式1开始 - 表达式2(判别表达式)- 真 - 执行循环体 - 表达式3 - 判断表达式2 真 : 继续 - 循环 ...

7. MySQL写循环语句的方法

   mysql常见的三种循环方式:while.repeat和loop循环.还有一种goto,不推荐使用. while循环 -- 设置mysql分隔符为//,也就意味着,当遇到下一个//时,整体执行SQL语 ...

8. java中遍历数组方法

   1循环遍历数组方法 在main主函数中给数组赋值即可调用该方法 public static void fun07(int[] array) {System.out.print("[" ...

9. 探索Julia(part8)--循环语句和条件语句

   学习笔记,仅供参考,有错必纠 参考自:Julia数据科学应用–Zacharias Voulgaris 使用Julia-1.1.1 文章目录 循环语句和条件语句 if条件语句 if-else语句 ife ...

10. python有几种循环语句_[14] Python循环语句（一）

    1. 概述 今天我们介绍循环语句,和条件判断一样,我们从流程图开始看起.首先看一下学习计划列表,粗体为已学,斜体为新增或修改内容.计算机编程的原理简要介绍 集成开发环境PyCharm 变量名.数字.字 ...

最新文章

1. Nanopore sequencing technology and tools for genome assembly: computational analysis of the current
2. free是自由，不是免费，从王开源说起
3. Cassandra 2016/00
4. python 连接数据库-设置oracle ，mysql 中文字符问题
5. b站的服务器在哪个位置,b站用的是哪个云服务器
6. python ide: pycharm
7. 华为GT3第一集-安装HAP
8. 多行查询结果合并sys_connect_by_path
9. android主题与风格入门
10. 策划通不过,不是老板的错
11. qlineedit限制输入数字_请注意：输入设计需要这些交互反馈
12. 【运维面试】面试官： 你们公司的上线流程是怎么样的？
13. Axis2创建web service（一） - eclipse安装Axis2插件
14. 程序员泪流满面的瞬间，第三季
15. Flash Helper Service 这个流氓，动不动弹出广告！！
16. 提高你的Java代码质量吧：不要让类型默默转换
17. day4 css复合选择器元素背景
18. JAVA第二次作业《胖瘦程度计算》
19. java如何设置jlabel位置_Java Swing – JLabel位置
20. 风云编程python基础语法（6）

热门文章

1. 2021韩顺平图解linux_狗剩学习笔记
2. 07 java.awt.Robot的一些使用
3. linux系统时间编程(2) 各种时间标准GMT、UTC、世界时、TAI
4. 【软件测试】BUG的管理
5. 5个适合提升自己的自学网站，每一个都很强大， 适合职场人自我提升的学习网站，利用起来，离加薪更近一步
6. 学会查看tomcat的日志文件
7. 采集PMS7003 颗粒度传感器数据，显示在TFT屏幕上，并通过webapi上传(1/2)
8. 微服务 细颗粒度的 soa
9. ubuntu安装百度输入法
10. L1-023 输出GPLT (20分) 给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按GPLTGPLT....这样的顺序输出，并忽略其它字符。当然，四种字符（不区分