循环语句,数组,方法,面向对象(封装)
今天的内容是循环语句,数组,类,对象,面向对象的三大特征之一的封装;
对这些内容有格式,怎么用,还有注意事项; 这些知识点里面的内容考试题型做了一个总结,
希望对正在学习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<10
System.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 <=10
System.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
- 确定每各位的数据本身的值:
定义三个变量,分别代表个位,十位,百位数据本身
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循环 x
for (int x = 100; x < 1000; x++) {
//x:100-999的数据
//确定每各位的数据本身的值:
// 定义三个变量,分别代表个位,十位,百位数据本身
int ge = x %10 ; //x=153
int shi = x /10 %10 ;
int bai = x /10 /10 % 10;
//如果当前x == (ge*ge*ge)+(shi*shi*shi)+(bai*bai*bai),满足条件,
//直接输出x
if(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];
//然后把数组中的要交换的元素赋给索引0
array[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);//找13
System.out.println("index:"+index);
System.out.println("----------------------------") ;
int index2 = getIndex(arr, 133);//找13
System.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;
}
}
//查询数组:找不到元素,返回负数 -1
return -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){//判断第第二处索引的值与第一处大的大小,要是第一处的大,那就把第一处的赋值给nax
max=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){//判断小孩男人女人搬砖加人数等于36
System.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())
封装的好处
提高代码的安全性。
提高代码的复用性。
“高内聚”：封装细节，便于修改内部代码，提高可维护性。
“低耦合”：简化外部调用，便于调用者使用，便于扩展和协作
5.6.3 注意事项:
以后在书写的代码的时候,写一个类,描述真实存在事物的属性的时候, 需要属性(英文单词字母全部小写)全部加入private
5.6.4 面试题:
- private关键字的特点?
- 1)被private修饰的成员变量以及成员方法只能在本类中访问
- 2)可以修饰成员变量也可以成员方法,就是为了外界不能直接访问
- 3)被private修饰的成员变量/成员方法可以间接的通过通过的方法访问
扫一扫
1207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
