数组与继承

1.数组概念：

在Java中，数组是一种引用数据类型，用于存储相同类型的多个元素。每个数组都有一个固定的长度，必须在创建数组时指定。Java中的数组可以存储基本数据类型（如整数、浮点数等）和对象（如字符串、自定义类等）。

2.数组语法：

1 ： 数据类型 [  ] 数组名 = new 数据类型 [ 数组长度 ];

例如：int[] arr = new int[10]

基本数据类型创建的数组中 默认值都是 0

引用数据类型创建的数组中 默认值都是 null

2：数据类型 [  ] 数组名 ={ 值 1, 值 2, 值 3, 值 4, 值 5};

例如： int[] arr = {1,2,3,4,5};

使用： 下标 数组每个元素对应的编号 从 0 开始 最多是 length-1

(1): 获取数组中的元素： 数组名 [ 下标 ] arr[0]

例如：int n = arr[2];// n= 3;

(2): 修改数组中的元素： 数组名 [ 下标 ] = 值 arr[0] = 10;

(3): 获取数组的长度： 数组名 .length arr.length

遍历 ： 使用循环从头到尾过一遍

1: 获取数组的长度： 数组名 .length arr.length

2: 循环遍历： for(int i=0;i<arr.length;i++){ 数组名 [ 下标 ] }

     for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); }

例如：冒泡排序

public class Test{
public static void main(String[] args){
int a = 10;
byte b = 10;
short s = 10;
long l = 10;
float f = 10.0f;
double d = 10.0;
char c = 'a';
boolean flag = true;
String name = "张三";
int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for(int i = 0; i < arr.length; i++){
System.out.print (arr[i] + " ");
}
System.out.println ();
// 获取数组中下标为5的元素
int num = arr[5];
System.out.println (num);
// 修改数组中下标为5的元素
arr[5] = 100;
System.out.println (arr[5]);
arr[5] = 5;
// 将数组从大到小进行排序
// 获取数组的长度
int length = arr.length;
// 冒泡排序
for(int k = 0; k < 9; k++){
for(int i = 0; i < length-(k+1); i++){
int temp = arr[i];
int temp1 = arr[i + 1];
if(temp<temp1){
// 交换位置
arr[i] = temp1;
arr[i + 1] = temp;
}
System.out.println ("i="+i+" temp:"+temp+" temp1:"+temp1);
}
for(int j = 0; j < arr.length; j++){
System.out.print (arr[j] + " ");
}
System.out.println ();
}
}
}

选择排序

public class Test2 {

    public static void main(String[] args) {
        int[] arr = {64, 25, 12, 2, 16};
        selectionSort(arr);
        System.out.println("排序后的数组：");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static void selectionSort(int[] arr) {
        int n = arr.length;
        //首先获取待排序数组arr的长度n。
        for (int i = 0; i < n - 1; i++) {
            //外层循环i从0到n-1，表示需要进行n-1轮选择操作。
            int min_num = i;
            //在每一轮选择操作中，首先假设第i个元素为最小元素，将其下标赋给min_num。
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[min_num]) {
                    min_num = j;
                //内层循环j从i+1到n，找到在未排序的部分中比当前最小元素还要小的元素，并将其下标赋给min_num。
                //如果找到了比当前最小元素更小的元素，则更新min_num的值。
                }
            }
            int temp = arr[min_num];
            arr[min_num] = arr[i];
            arr[i] = temp;
            //将当前最小元素和第i个元素进行交换,直至所有元素都被放到了正确的位置上。
        }
    }
}

*如何使用循环遍历数组中的元素：

在Java中，可以使用循环来遍历数组中的元素，常见的循环结构有for循环、while循环和foreach循环。以下是使用这三种循环结构来遍历数组的例子：

假设有一个整型数组 intArray

public class ArrayTraversalExample {
    public static void main(String[] args) {
        int[] intArray = { 1, 2, 3, 4, 5 };

        // 使用for循环遍历数组
        System.out.println("使用for循环遍历数组：");
        for (int i = 0; i < intArray.length; i++) {
            System.out.println("Element at index " + i + ": " + intArray[i]);
        }

        // 使用while循环遍历数组
        System.out.println("\n使用while循环遍历数组：");
        int j = 0;
        while (j < intArray.length) {
            System.out.println("Element at index " + j + ": " + intArray[j]);
            j++;
        }

        // 使用foreach循环（增强型for循环）遍历数组
        System.out.println("\n使用foreach循环遍历数组：");
        for (int element : intArray) {
            System.out.println("Element: " + element);
        }
    }
}

• for 循环适用于当你知道要遍历的次数时，通过控制循环变量的范围来遍历数组。
• while 循环适用于当你需要在不确定条件下遍历数组时，只要条件满足，就会一直执行循环。
• foreach 循环适用于遍历整个数组，不需要考虑索引，更加简洁方便。

3.继承概念：

1.关键字： extends

2.格式： class 子类名 extends 父类名 { }

3.继承的内容：

(1).子类继承了父类的属性以及方法

(2).在父类中定义的属性以及方法，子类都可以直接使用

(3).继承了父类的类型： 子类对象可以转成父类类型

4. 转型：

(1). 基本数据类型转型：

 强制转型：

      int num =(int)(1.5);// num = 1

      double d1 = 1.5;

      int i1 = (int)d1;// i1 = 1

自动转型：

      byte short int long 整数型

      byte b1=100;

      int i1=b1;

(2). 类转型： 自动转型,向上转型

子类类型对象的地址可以存在父类对象变量名中

将父类类型作为参数类型:这个参数可以接收所有的子类类型对象作为参数

例子：继承类的PK游戏

父类(Hero):

public class Hero{
String name;
String playerID;
int HP;
int AD;
int MP;
int LV;
int defends;
public void lvUp(){
LV++;
System.out.println ("-----恭喜" + name + "升级了，当前等级：" + LV + "----");
}
}

子类：

public class Guanyu extends Hero{
// 攻击的类型 是 Hero 类型 ，也就是刘关张的父类类型
public void skill_1(Hero hero){
System.out.println ("技能1：单刀赴会");
int num = (int) (AD * 0.8 + 50 + LV * 5);
System.out.println ("技能伤害：" + num);
System.out.println ("对"+hero.name+"成伤害：" + (num));
hero.HP -= num;
int n = 100;
int i = 50;
n -= i;// n=50;
n -= (i - n);//
// i-n=-50;
// n-=-50;
// n = n-(-50);
System.out.println (hero.name+"剩余血量：" + hero.HP);
}
}

public class Zhangfei extends Hero{
public void skill_1(Hero hero){
System.out.println ("技能1：画地为牢");
int num = (int) (AD * 0.7 + 20 + LV * 2);
System.out.println ("技能伤害：" + num);
System.out.println ("对" + hero.name + "造成伤害：" + (num - hero.defends));
hero.HP -= num - defends;
System.out.println (hero.name + "剩余血量：" + hero.HP);
}
}

public class Liubei extends Hero{
public void skill_1(Hero hero){
System.out.println ("技能1：双重射击");
int num = (int) (AD * 0.8 + 40 + LV * 5);
System.out.println ("技能伤害：" + num);
System.out.println ("对" + hero.name + "造成伤害：" + (num - hero.defends));
hero.HP -= num - hero.defends;
System.out.println (hero.name + "剩余血量：" + hero.HP);
}
}

进行PK：

import
java.util.
Random;
public class pkgame{
public static void main(String[] args){
Zhangfei zf1 = new Zhangfei ();
zf1.name = "张飞";
zf1.playerID = "10";
zf1.AD = 80;
zf1.HP = 4500;
zf1.MP = 200;
zf1.LV = 2;
Guanyu gy1 = new Guanyu ();
gy1.name = "关羽";
gy1.playerID = "20";
gy1.AD = 150;
gy1.HP = 4000;
gy1.MP = 250;
gy1.LV = 3;
Liubei lb1 = new Liubei ();
lb1.name = "刘备";
lb1.playerID = "30";
lb1.AD = 1600;
lb1.HP = 5500;
lb1.MP = 300;
lb1.LV = 4;
Random random = new Random ();
while(zf1.HP > 0 & gy1.HP > 0 & lb1.HP > 0){
int ri = random.nextInt (10);
if(ri == 0){
System.out.println ("------张飞对关羽使用技能1------");
zf1.skill_1 (gy1);
} else if(ri == 1){
System.out.println ("------关羽对张飞使用技能1------");
gy1.skill_1 (zf1);
} else if(ri == 2){
System.out.println ("------张飞对刘备使用技能1------");
zf1.skill_1 (lb1);
} else if(ri == 3){
System.out.println ("------刘备对张飞使用技能1------");
lb1.skill_1 (zf1);
} else if(ri == 4){
System.out.println ("------关羽对刘备使用技能1------");
gy1.skill_1 (lb1);
} else if(ri == 5){
System.out.println ("------刘备对关羽使用技能1------");
lb1.skill_1 (gy1);
} else if(ri == 6){
zf1.lvUp ();
} else if(ri == 7){
lb1.lvUp ();
} else if(ri == 8){
gy1.lvUp ();
} else if(ri == 9){
gy1.skill_1 (hy1);
}
}
System.out.println ("------PK结束------");
if(zf1.HP > 0){
System.out.println ("张飞胜利");
} else if(gy1.HP > 0){
System.out.println ("关羽胜利");
} else if(lb1.HP > 0){
System.out.println ("刘备胜利");
}
}
}