温故知新
- 标号:
- break 标号:可以直接结束,标号所对应的循环
- continue 标号:可以直接跳转到标号所对应的循环的迭代 for 或while
- 方法:
- 好处:代码复用,功能模块
- 定义方法语法:
【各种修饰符 】返回类型(java 支持的任意类型+void )方法名(参数列表){方法体}
3.return:
方法一旦返回(结束 )在方法中定义的局部变量在栈中分配内存,都将自动回收。
4.cpu:寄存器,其次是栈,最后是堆
5.方法的重载:overload:在同样一个类内部,方法名字相同,参数列表不同,与返回类型无关
//定义方法,对应指定概率事件,求本次事件是否发生的方法
/*实现一场战斗
亚瑟 VS 后裔
每个英雄 赋值 初始血量 1000,
每个英雄 伤害随机
亚瑟 damage[30,50)暴击率30% 暴击 伤害1.8
后裔 damage[20,40) 暴击率50% 暴击伤害2
然后普通攻击和暴击要求不同的输出内容,输出本次伤害,和对方剩余的血量
一人一刀互相伤害
使用循环模拟两人的一场战斗
最终输出结果,谁胜利,剩余血量**/
public class Test1 {
//主函数
public static void main(String[] args){
damage();
}
//定义方法对应指定的概率的事件,求本次事件是否发生的方法
public static boolean isHappened(double precent){
return Math.random()<precent;
}
//获取0,1随机数
public static int suiJi(int a,int b){
return (int)(Math.random()*(b-a));
}
//随机产生伤害方法
public static double getDamage(double min,double max){
return Math.random()*(max-min)+min;
}
//王者荣耀峡谷之战
public static void damage(){
//默认初始生命值
final double HP=1000;
//亚瑟的相关属性
final double YASE_DAM_MIN=30;
final double YASE_DAM_MAX=50;
final double YASE_CRITICAL_PERCENT=0.3;
final double YASE_CRITICAL_DAM=1.5;
//后裔的相关属性
final double HOUYI_DAM_MIN=20;
final double HOUYI_DAM_MAX=40;
final double HOUYI_CRITICAL_PERCENT=0.5;
final double HOUYI_CRITICAL_DAM=2;
//随机数
final int SUIJIMAX=3;
final int SUIJIMIN=1;
//初始化两个人物的血量
double yaseHP=HP,houyiHp=HP;
System.out.println("=====两人相遇战斗开始=====");
while(yaseHP > 0 && houyiHp > 0){
if(suiJi(SUIJIMIN, SUIJIMAX)==1){
System.out.println("亚瑟先手");
//亚瑟造成随机伤害
double yase =getDamage(YASE_DAM_MIN, YASE_DAM_MAX);
//是否产生暴击
boolean isCritical=false;
if(isHappened(YASE_CRITICAL_PERCENT)){
isCritical=true;
}
if(isCritical){
yase*=YASE_CRITICAL_DAM;
System.out.println("亚瑟挥舞一刀造成暴击伤害"+yase);
}else{
System.out.println("亚瑟挥舞一刀造成伤害"+yase);
}
houyiHp=houyiHp-yase<0?0:houyiHp-yase;
System.out.println("后裔剩余血量"+houyiHp);
}else{
System.out.println("后裔先手");
//后裔造成随机伤害
double houyi =getDamage(HOUYI_DAM_MIN, HOUYI_DAM_MAX);
//是否产生暴击
boolean isCritical=false;
if(isHappened(HOUYI_CRITICAL_PERCENT)){
isCritical=true;
}
if(isCritical){
houyi*=HOUYI_CRITICAL_DAM;
System.out.println("后裔射出一箭造成暴击伤害"+houyi);
}else{
System.out.println("后裔射出一箭造成造成伤害"+houyi);
}
yaseHP=yaseHP-houyi<0?0:yaseHP-houyi;
System.out.println("亚瑟剩余血量"+yaseHP);
}
}
if(houyiHp==0){
System.out.println("后裔战死");
}else if(yaseHP==0){
System.out.println("亚瑟战死");
}
}
}
数组
练习
public class Test1 {
//主函数
public static void main(String[] args){
getScoreArray();
}
//利用数组查看随机十个学生的成绩
public static void getScoreArray(){
final int count=10;
final int MAX=101;
final int MIN=60;
int sum=0;
//定义一个数组,这个数组要保存十个学生的分数。
//数组是一种数据类型。
//使用new关键字 向jvm申请内存空间
int[] scores =new int[count];
//数组中的每一个数,数组的元素element
//数组元素本质上就是一个变量,和变量的使用方式是一样
//如何访问每个元素,通过数组变量名[元素序号]
//元素的序号从0开始,到元素的数量-1,序号连续
for (int i = 0; i < count; i++) {
//将随机分数逐个赋值给每个元素变量
//int score=(int)getDamage(MIN, MAX);
scores[i]=(int)getDamage(MIN, MAX);
System.out.println("score【"+i+"】:"+scores[i]);
sum+=scores[i];
}
System.out.println("总分"+sum);
for (int i = 0; i < count; i++) {
System.out.println("score:"+scores[i]);
}
}
//得到十个随机的学生的分数【60-101】,然后求学生的分数的总分数和平均值
public static int getSum(){
final int count=10;
final int MAX=101;
final int MIN=60;
int sum=0;
for (int i = 0; i < count; i++) {
int score=(int)getDamage(MIN, MAX);
System.out.println("score:"+score);
sum+=score;
}
return sum;
}
//定义方法对应指定的概率的事件,求本次事件是否发生的方法
public static boolean isHappened(double precent){
return Math.random()<precent;
}
//获取0,1随机数
public static int suiJi(int a,int b){
return (int)(Math.random()*(b-a));
}
//随机产生伤害方法
public static double getDamage(double min,double max){
return Math.random()*(max-min)+min;
}
}
数组详解
数组是一个对象。是一个具有同种数据类型变量集合
定义数组:
语法:
元素类型[] 数组变量名=new 元素类型[元素个数]。
int [] scores =new int [10];
元素类型:java 支持的任意类型。
【】:代表这是数组
new :😗*java的关键字。用来向jvm申请空间的
数组内存分配图
数组的特点和属性
- 数组中只能存储一种类型的数据。
- 数组中保存的每个变量称为数组元素element .
- 数组的元素在堆内存中被分配空间而且元素的空间是连续分配的
- 数组的每个元素都有一个序号称为数组下标,数组的索引,数组的角标。数组元素的下标从0开始连续递增
- 数组有一个属性一个长度属性,一个int 类型的长度的属性。使用【数组名.leagth】得到数组的长度,元素的个数
- 数组的元素的下标的取值范围【0~length-1】
- 数组中的元素的使用和普通的变量的使用方式一致,数组名【下标】
- 数组元素一旦在堆中被分配了内存中被分配了空间,那么都会有默认值
- 数组变量名又可以称为数组引用,保存都是数组元素在堆内存中的首地址,数组变量指向堆内存中实际数组数据
数组初始化
如何初始化数组:
两种方式:
- 动态初始化:
int [] scores=new int[10];//元素被jvm进行默认初始化
- 静态初始化
int [] scores=new int[]{1,2,3,4,5};
int [] scores={1,2,3,4,5};
练习查找元素
package com.zhangjie.main;
import java.util.Random;
import java.util.Scanner;
public class Test1 {
//主函数
public static void main(String[] args){
int [] arr=getRandomArrays(10, 0, 21);
printArrays(arr);
}
//定义一个方法根据给定的长度,动态初始化一个int 类型元素数组,然后对元素随机赋值根据给定的区间,并返回该数组
public static int[] getRandomArrays(int length,int min,int max){
//动态初始化一个int 类型
int[] arr =new int[length];
//对数组进行赋值
for (int i = 0; i < arr.length; i++) {
arr[i]=(int)getRandom(min, max);
}
return arr;
}
//打印数组元素
public static void printArrays(int[] arrays){
System.out.print("[");
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+",");
}
System.out.print("]");
}
//定义一个boolean 类型数组,动态初始化,长度随机【5-10】并打印输出数组长度。然后对数组元素随机赋值Random提供nextBoolean方法
//遍历输出数组的元素的内容。
public static void testArraysBoolean(){
final int MIN=5;
final int MAX=10;
int length =(int)getRandom(MIN, MAX);
System.out.println("length="+length);
boolean[] bools=new boolean[length];
Random rand=new Random();
for (int i = 0; i < bools.length; i++) {
bools[i]=rand.nextBoolean();
}
for (int i = 0; i < bools.length; i++) {
System.out.println(bools[i]);
}
}
// 写一个方法;功能要求:定义一个byte 类型的数组,长度自定义输入,静态初始化,元素的数值要求随机【10-100】
public static void testByte(){
Scanner scanner=new Scanner(System.in);
System.out.println("请输出数组长度:");
int length=scanner.nextInt();
byte [] bytes=new byte[length];
for (int i = 0; i < bytes.length; i++) {
bytes[i]=(byte)getRandom(0, 100);
System.out.println(bytes[i]);
}
}
//利用数组查看随机十个学生的成绩
public static void getScoreArray(){
final int count=10;
final int MAX=101;
final int MIN=60;
int sum=0;
//定义一个数组,这个数组要保存十个学生的分数。
//数组是一种数据类型。
//使用new关键字 向jvm申请内存空间
int[] scores =new int[count];
//数组中的每一个数,数组的元素element
//数组元素本质上就是一个变量,和变量的使用方式是一样
//如何访问每个元素,通过数组变量名[元素序号]
//元素的序号从0开始,到元素的数量-1,序号连续
for (int i = 0; i < count; i++) {
//将随机分数逐个赋值给每个元素变量
//int score=(int)getDamage(MIN, MAX);
scores[i]=(int)getRandom(MIN, MAX);
System.out.println("score【"+i+"】:"+scores[i]);
sum+=scores[i];
}
System.out.println("总分"+sum);
for (int i = 0; i < count; i++) {
System.out.println("score:"+scores[i]);
}
}
//得到十个随机的学生的分数【60-101】,然后求学生的分数的总分数和平均值
public static int getSum(){
final int count=10;
final int MAX=101;
final int MIN=60;
int sum=0;
for (int i = 0; i < count; i++) {
int score=(int)getRandom(MIN, MAX);
System.out.println("score:"+score);
sum+=score;
}
return sum;
}
//定义方法对应指定的概率的事件,求本次事件是否发生的方法
public static boolean isHappened(double precent){
return Math.random()<precent;
}
//获取0,1随机数
public static int suiJi(int a,int b){
return (int)(Math.random()*(b-a));
}
//随机产生伤害方法
public static double getRandom(double min,double max){
return Math.random()*(max-min)+min;
}
}
数组练习:最大值
public class Test1 {
//主函数
public static void main(String[] args){
int [] arr=getRandomArrays(10, 0, 21);
printArrays(arr);
int max=maxArray(arr);
System.out.println("最大值"+max);
}
//自定义方法实现任意 int 类型的元素的数组,求出该数组的最大值
public static int maxArray(int[] array){
int max =array[0];
//将元素的最大值赋值给max
for (int i = 1; i < array.length; i++) {
if(array[i]>max){
max=array[i];
}
}
return max;
}
}
数组作为参数元素交换
方法操作的是形参,形参是对实际参数的拷贝,无法改变实际参数的值。
package com.zhangjie.main;
public class Test1 {
//主函数
public static void main(String[] args){
int [] arr=getRandomArrays(2, 0, 21);
printArrays(arr);
changeValue(arr);
printArrays(arr);
}
public static void changeValue(int[] arr){
int temp =arr[0];
arr[0]=arr[1];
arr[1]=temp;
}
//定义一个方法根据给定的长度,动态初始化一个int 类型元素数组,然后对元素随机赋值根据给定的区间,并返回该数组
public static int[] getRandomArrays(int length,int min,int max){
//动态初始化一个int 类型
int[] arr =new int[length];
//对数组进行赋值
for (int i = 0; i < arr.length; i++) {
arr[i]=(int)getRandom(min, max);
}
return arr;
}
//打印数组元素
public static void printArrays(int[] arrays){
System.out.print("[");
for (int i = 0; i < arrays.length-1; i++) {
System.out.print(arrays[i]+",");
}
System.out.print(arrays[arrays.length-1]+"]\n");
}
//随机数方法
public static double getRandom(double min,double max){
return Math.random()*(max-min)+min;
}
}
删除数组元素:效率不高
删除元素(指定下标):直接在原数组上删除,后续的元素需要整体前移。(最后的元素不需要处理)。最后返回数组的有效数据的个数。
//删除元素(指定下标):直接在原数组上删除,后续的元素需要整体前移。(最后的元素不需要处理)。最后返回数组的有效数据的个数
public static int removeElementByIndex(int [] srcArray,int removeIndex){
//原数组,堆内存里面没有空间
if(srcArray==null){
return -1;
}
int len=srcArray.length;
//元素长度为0
if(len==0){
return 0;
}
//removeIndex 不在 区间内之内
if(removeIndex<0 || removeIndex>len-1){
return -2;
}
//逐个移位
for (int i = removeIndex+1; i < len; i++) {
//将当前i的位置上的值赋值给它前面的一个元素的值i-1
srcArray[i-1]=srcArray[i];
}
return len-1;
}
数组中插入元素
//插入一个元素:后续元素整体后移,挤掉最后一个元素
public static void insertElementByIndex(int[] srcArray,int insertIndex,int value){
for (int i =srcArray.length-2; i >=insertIndex ; i--) {
srcArray[i+1]=srcArray[i];
}
}
增强for循环
jdk1.5版本之后才有的。
作用:用来遍历容器。可以用来遍历数组只能用来遍历元素
使用增强的for 循环访问的数组的数据,都是原数组元素的copy
语法:
int []arr=new int[10];
for(int value :arr){
}
arr 是被遍历的数组
value 是循环每迭代一次,从arr中顺序的取出的元素的值
for(int i=0;i<arr.length;i++){
arr[i];
}
总结:
增强的for 循环,只能遍历元素