梅雨季导致皮肤过敏，痒到晚上睡不着。但我一定会坚持的。
 
题目：5.建立一个对象数组，内放5个学生的数据（学号，成绩），设立一个函数max，用指向对象的指针做函数参数，在max函数中找出5个学生中成绩最高者，并输出其学号；
 
Note：重点记住对象数组的初始化写法，只有友元函数才能访问类的私有成员数据；
 代码：
 
class Student
{
  public:
    Student(int n, float s):num(n),score(s){}  //声明并定义构造函数；
    friend void max(Student *);                //声明max为类的友元函数，否则max无法访问private成员；
  private:
    int num;
    float score;
};

void max(Student *s)
{
  int index;
  int m;
  m=s[0].score;
     for(int i=0; i<5;i++)
      {
          if(s[i].score>m)
          {
             m=s[i].score;
             index=i;
          }
      }cout<<"成绩最高的学生的学号为："<<s[index].num<<endl;
    }

int main()
{
  int i;
  const int num=5;
  Student stud[num]={Student(1,34),Student(2,67),Student(3,98),Student(4,75),Student(5,49)};//定义一个对象数组并赋值；
  Student *p;                                     //指向Student类的指针，使其指向数组stud的首地址；
  p=stud;                                         //数组名即为数组首地址，不需&；
  max(p);
  return 0;
}

 
 
kotlin 定义对象数组
 

  

   
  
 
 
 
 我最初打算写这篇文章是因为我在玩一些反射代码，并认为自己发现了一些有趣的东西。 las，绝对不是这样。 相反，它只是Kotlin的基本功能，我不需要使用或关注。 尽管这篇文章并没有表明我希望的样子，但我仍然认为这是一篇很好的小文章，可以使这个主题更加清晰。 
 
 
 在Java中，存在基本类型及其包装版本的概念。 由于自动装箱和拆箱，类型可以在其原始版本和包装版本之间互换。 换句话说，在大多数情况下，您可以使用long代替Long或使用Long代替long 。 如果您没有注意到最后一句中的大写字母在哪里，那么我想它可能看起来很混乱。 该句中的措辞也很关键。 更具体地说，声明“在大多数情况下”。 
 
 
 尝试互换原始数组和包装的（ Object ）数组时，自动装箱和拆箱不起作用。 例如， 
 
 public class PrimitiveArrays { 
   public static void main(String args[]) { 
     Long[] longArray = new Long[] {1L, 2L, 3L}; 
     takesInPrimitiveLongArray(longArray); 
   } 
   static void takesInPrimitiveLongArray( long [] array) {}  } 
 
 
 这不起作用，尝试对其进行编译会产生以下错误： 
 
 error: incompatible types: Long[] cannot be converted to long [] 
     takesInPrimitiveLongArray(longArray); 
 
 
 出于相同的原因，将方法切换为采用Long[]并传入long[]也会导致编译失败。 这并不是大多数Java开发人员都会感兴趣的东西，但有助于为本文的实际内容奠定基础。 
 
 
 Kotlin需要为您提供Java原始数组的等效功能。 但是，Kotlin不允许您使用与Java相同的语法来定义数组。 在Kotlin中，初始化数组如下所示： 
 
 val array = Array<Long>( 3 )  // or  val array: Array<Long> = arrayOf( 1 , 2 , 3 ) 
 
 
 您可以看到Array使用泛型这一事实应突出表明它不是原始数组。 在Java和Kotlin中，这都是事实，即泛型类型不能是基元。 否则，可以将其切换为Array<long> ，我们都会很高兴。 上面的代码向下编译为Long[]的对象数组，而不是原始的long[] 。 
 
 
 这种情况在阵列上是很独特的。 单独使用的Kotlin Long可以编译为JVM字节码中的Long或long 。 编译的类型取决于字段的可为空性。 数组更明确，因此编译时它们的类型不会改变。 
 
 
 为了避免这种情况，Kotlin提供了一些选择，这些类在向下编译为JVM字节码时变为原始数组。 
 
 
 这些类包括： 
 
 
 Kotlin 
 Java 
 字节数组 
 字节[] 
 字符数组 
 字符[] 
 短数组 
 短[] 
 整数数组 
 int [] 
 长数组 
 长[] 
 双数组 
 双[] 
 FloatArray 
 浮动[] 
 布尔数组 
 布尔值[] 
 
 
 对于无符号类型的数组，还有其他类。 
 
 
 这些类也可以在Kotlin和Java之间互换，而无需任何额外的努力。 
 
 
 作为最后的证据向您展示Kotlin中原始数组与包装式/对象数组之间的区别，我想向您展示一些Kotlin代码，这些代码已转换为Java对应的代码： 
 
字节数组
 
 
 使用Intellij的Kotlin字节码反编译器，该代码段反编译为： 
 
字节数组
 
 
 首先，请注意，Kotlin为您的阵列提供了有用的初始化功能。 对于原始数组和对象数组。 其次，它们是如何编译的。 例如， LongArray变为long[]而Array<Long>变为Long[] 。 
 
 
 现在，您可以看到这些数组之间的差异。 但是，我没有提到您应该利用哪个。 您应该像Java一样使用基本类型。 这是由于自动装箱和拆箱会对应用程序产生性能影响。 
 
 
 对于较小的工作负载，结果可能微不足道。 另一方面，对于性能至关重要的应用中的较大阵列，此可能很小的更改可能会产生明显的影响。 有关此主题的更多信息，请参见此处 。 
 
 
 如果需要在数组中存储空值，则仍然需要引用回包装/对象数组。 在大多数情况下，我认为您应该能够使用原始数组，但是总会有很多时候无法使用原始数组。 话虽这么说，大多数时候我们都只使用List ，所以这些都不重要。 
 
 
 现在，您应该对LongArray类的原始数组与Array<Long>类的对象数组之间的区别有了更好的了解。 如果没有，那么我让你失败了，对此我表示歉意。 
 
 

  
翻译自: https://www.javacodegeeks.com/2019/07/kotlin-primitive-object-arrays.html
 
 
kotlin 定义对象数组

定义一个student类，在主类中定义一个student数组stu[10];需要对每个对象stu[i]都new Student();
 
public class Student {
    int number;
}
 
public class Example4_21 {
    public static void main(String[] args){
        Student stu[] = new Student[10];
        for (int i = 0; i <stu.length ; i++){
            stu[i] = new Student();
            stu[i].number = 101+i;
        }
        for (int i = 0; i<stu.length ; i++)
        {
            System.out.print(" "+stu[i].number);
        }
    }
}

var student = new Object();
student.name = "Lanny";
student.age = "25";
student.location = "China";
var json = JSON.stringify(student); 

或

var students = [];
students[students.length] = new Object();
students[students.length].name = "Lanny";
students[students.length].age = "25";
students[students.length].location = "China";
var json = JSON.stringify(students);