精华内容
下载资源
问答
  • 创建类数组

    千次阅读 2019-05-16 16:03:57
    今天做的一道题要创建类(类名为id)的数组,开始时只写了 id[] ID=new id[10]; 结果运行时一直出错,后来想了想发现正确的格式应为 id[] ID=new id[10]; for(int i;i<10;i++) ID[i]=new id(); ...

    今天做的一道题要创建类(类名为id)的数组,开始时只写了

    • id[] ID=new id[10];

    结果运行时一直出错,后来想了想发现正确的格式应为

    • id[] ID=new id[10];
    • for(int i;i<10;i++)
      • ID[i]=new id();

     

    展开全文
  • java对象数组 创建对象数组,初始化对象数组

    万次阅读 多人点赞 2019-07-30 16:34:15
    当需要一个的多个对象时,应该用该的对象数组来表示,通过改变下标值就可以访问到不同的对象。 对象数组的定义和使用: 对象数组的定义与一般数组的定义类似,但是需要为每一个元素实例化。 对象数组的声明形式...

    对象数组的概念:
    如果一个数组中的元素是对象类型,则称该数组为对象数组。
    当需要一个类的多个对象时,应该用该类的对象数组来表示,通过改变下标值就可以访问到不同的对象。
    对象数组的定义和使用:
    对象数组的定义与一般数组的定义类似,但是需要为每一个元素实例化。
    对象数组的声明形式是:
    类名 对象数组名 [ ];
    为对象数组分配内存空间:
    对象数组名=new 类名[数组长度];//注意 :此处不是构造方法了
    可以将对象数组的声明和创建用一条语句来完成。例如:定义一个学生类对象数组,可以用下面的语句定义:Student stu[ ]=new Student[30]; stu [ ]是对象数组名,它所表示的数组一共有30个元素,每一个元素都是Student类的对象名,还没有实例化,所以还必须为每一个元素实例化。比如如下的过程:
    for(int i=0;i<stu.length;i++)
    stu[i]=new Student();
    实例化以后就可以使用每一个元素对象。
    设计一个雇员类,并创建雇员类的对象数组,输出每个雇员的信息

    //设计一个雇员类,并创建雇员类的对象数组,输出每个雇员的信息
    class Employee {   //雇员类
     private String id;  //编号
     private String name; //姓名
     private int age;     //年龄
     private String vocation; //职务
     public Employee(){} //构造方法一
     public Employee(String id,String name,int age,String vocation){
      set(id,name,age,vocation);
     }
     //设置属性的方法
     public void set(String id,String name,int age,String vocation){
      this.id=id;
      this.name=name;
      this.age=age;
      this.vocation=vocation;
     }
     public String toString() {
      String mess=id+","+name+","+age+","+vocation;
      return mess;
     }
    }
    public class Example4  {
     public static void main(String[] args) {
      Employee 雇员[]=new Employee[3];
      int i;
      for(i=0;i<雇员.length;i++)//为对象数组中每一个元素实例化
      雇员[i]=new Employee();//如果没有写构造方法一,而这样写,会出错
      //因为类中有有参的构造方法,系统就不会在默认给无参的构造方法了,
      //所以当类中写了有参的构造方法后,要用无参的构造方法时必须写出来
      
      //每一个对象元素分别初始化
      雇员[0].set("0001","张文军",50,"总经理");
      雇员[1].set("0002","李琦",45,"副经理");
      雇员[2].set("1016","张丽",28,"秘书");
      for (Employee employee:雇员)
       System.out.println(employee.toString());
     }
    }
    

    在这里插入图片描述
    普通型for循环和增强型for循环
    普通型

    a={1,2,3,4,5};
    for(int i=0;i<a.length;i++) {
     System.out.println9(a[1]);
    }
    

    增强型

    for(int element:a) {
    System.out.println(element);
    }
    

    两者结果相同,但是增强型更为简洁

    对象数组还可以采用初始化的方法创建。创建形式是:
    类名 对象数组名[ ]={对象列表};

    设计一个雇员类,创建雇员类的对象数组并初始化,输出每个雇员的信息,仍然沿用上面的Employee类,程序如下

    class Employee {   //雇员类
     private String id;  //编号
     private String name; //姓名
     private int age;     //年龄
     private String vocation; //职务
     public Employee(){} //构造方法一
     public Employee(String id,String name,int age,String vocation){
      set(id,name,age,vocation);
     }
     //设置属性的方法
     public void set(String id,String name,int age,String vocation){
      this.id=id;
      this.name=name;
      this.age=age;
      this.vocation=vocation;
     }
     public String toString() {
      String mess=id+","+name+","+age+","+vocation;
      return mess;
     }
    }
    public class Example11 {
     public static void main(String[] args) {
      //先创建3个雇员对象
      Employee employee1=new Employee("0001","张文军",50,"总经理");
      Employee employee2=new Employee("0005","李琦",45,"副经理");
      Employee employee3=new Employee("1016","张丽",28,"秘书");
      //声明对象数组并直接初始化
      Employee 雇员1[]={employee1,employee2,employee3};
      output(雇员1);//输出雇员信息
      System.out.println("------------------");//分割线
      //声明对象数组并直接初始化,初始化元素直接调用
      //构造方法创建对象
      Employee 雇员2[]={new Employee("0001","张文军",50,"总经理"),
      new Employee("0005","李琦",45,"副经理"),
      new Employee("1016","张丽",28,"秘书")};
      output(雇员2);
     }
     //定义方法用于输出雇员信息,注意方法是private,static
     private static void output(Employee 雇员[]){
      for(Employee employee:雇员)
       System.out.println(employee.toString());
     }
    }
    

    在这里插入图片描述

    展开全文
  • C++数据结构数组类创建

    千次阅读 2018-08-18 20:30:23
    在C或C++的原生数组里,有一点不好的就是数组越界是察觉... 数组类创建我们还是按照顺序表的思路,创建一个Array,实现基本的操作,再创建StaticArray与DynamicArray一个静态一个动态数组类数组存储位置及大...

        在C或C++的原生数组里,有一点不好的就是数组越界是察觉不到,代码也不会提醒,至于越界产生的bug什么时候引发系统问题,我们也无从知晓。在这里我们可以创建一个数组类,内部包含数组长度、数组越界访问时能主动发现。

        数组类的创建我们还是按照顺序表的思路,创建一个Array类,实现基本的操作,再创建StaticArray与DynamicArray一个静态一个动态数组类,数组存储位置及大小,均在这两个子类完成,同时提供数组类对象间的赋值。

    首先我们来看下父类Array,采用类模板方式,继承自MyObject类,并完成基本的数组操作

    #ifndef __ARRAY_H__
    #define __ARRAY_H__
    
    #include "MyObject.h"
    #include "MyException"
    
    namespace MyLib
    {
    template <typename T>
    class Array : public MyObject
    {
    protected:
        T* m_array;	//指针
    public:
    	
        virtual bool set(int index, const T& e)	//设置固定位置的值
        {
    	bool ret = ( (0 <= index)&&(index <length()) );
    	if (ret)
    	{
    	    m_array[index] = e;
    	}
    	else
    	{
    	    THROW_EXCEPTION(IndexOutOfBoundsException, "Index Out Of Bounds Array");
    	}
    	return ret;
        }
    
        virtual bool get(int index, T& e)	//获取固定位置的值
        {
        	bool ret = ( (0 <= index)&&(index < length()) );
    	if (ret)
    	{
    	    e = m_array[index];
    	}
    	else
    	{
    	    THROW_EXCEPTION(IndexOutOfBoundsException, "Index Out Of Bounds Array");
    	}
        }
    
        T& operator[](int index)	//重载[]操作符,使得类能想数组那样使用
        {
    	bool ret = ( (0 <= index)&&(index < length()) );
    	if (ret)
    	{
    	    return m_array[index];
    	}
    	else
    	{
    	    THROW_EXCEPTION(IndexOutOfBoundsException, "Index Out Of Bounds Array");
    	}
        }
    
        T operator[](int index) const	//重载const类的[]
        {
    	return const_cast<Array<T>&>(*this)[index];
        }
    
        virtual int length() = 0;	//提供一个获取数组长度的纯虚函数,在子类中实现
    };
    
    }
    #endif	//__ARRAY_H__

    StaticArray类,继承自父类,数组空间由在栈提供

    #ifndef __STATIC_H__
    #define __STATIC_H__
    
    #include "Array.h"
    
    namespace MyLib
    {
    template <typename T, int N>
    class StaticArray : public Array<T>
    {
    private:
        T array[N];		//分配数组空间
        int m_length;	//数组长度
    
    public:
        StaticArray()
        {
    	m_array = array;
    	m_length = N;
        }
    
        StaticArray(const StaticArray<T, N>& obj)	//重写拷贝构造函数
        {
    	m_array = array;
    	for (int i=0; i<obj.m_length; i++)
    	{
    	    m_array[i] = obj[i];
    	}
    	m_length = obj.m_length;
        }
    
        StaticArray<T, N>& operator= (const StaticArray<T, N>& obj)	//重写赋值构造函数
        {
    	if (this != &obj)
    	{
    	    for (int i=0; i<m_length; i++)
    	    {
    		m_array[i] = obj[i];
    	    }
    	}
    	return *this;
        }
    
        int length()	//将继承自父类Array的length()函数实现
        {
    	return m_length;
        }
    };
    }
    #endif	//__STATIC_H__

    下边是DynamicArray子类,与StaticArray类似,只是数组的空间所在的位置是在堆空间上

    #ifndef __DYNAMICARRAY_H__
    #define __DYNAMICARRAY_H__
    
    #include "Array.h"
    
    namespace MyLib
    {
    template <typename T>
    class DynamicArray : public Array<T>
    {
    private:
        int m_length;
    public:
        DynamicArray(int length)
        {
    	m_array = new T[length];	//构造函数中指定数组长度,并分配堆空间
    	if (m_array)
    	{
    	    m_length = length;
    	}
    	else
    	{
    	THROW_EXCEPTION(NoEnoughtMemoryException, "No Enought Memory to Create DynamicArray...");
    	}
        }
    
        DynamicArray(const DynamicArray<T>& obj)	//重写拷贝构造函数
        {
    	T* array = new T[obj.m_length];
    	if (array)
    	{
    	    m_array = array;
                m_length = obj.m_length;
    	    for (int i=0; i<m_length; i++)
    	    {
    		m_array[i] = obj[i];
    	    }
    	}
    	else
    	{
    	    THROW_EXCEPTION(NoEnoughtMemoryException, "No Enought Memory to Create DynamicArray...");
    	}
    
        }
    
        DynamicArray<T>& operator=(const DynamicArray<T>& obj)	//重写赋值构造函数
        {
    	if (this != &obj)
    	{
    	    for (int i=0; i<m_length; i++)
    	    {
    		m_array[i] = obj[i];
    	    }
    	}
    	return *this;
        }
    
        void resize(int length)		//重定义数组大小
        {
    	T* array = new T[length];
    
    	if (array)
    	{
                int len = m_length < length ? m_length : length;
    	    for (int i=0; i<len; i++)
    	    {
    	    	array[i] = m_array[i];
    	    }
    
    	    T* temp = m_array;
    	    m_array = array;
    	    m_length = length;
    
    	    delete[] temp;
    	}
    	else
    	{
    	    THROW_EXCEPTION(NoEnoughtMemoryException, "No Enought Memory to Create DynamicArray...");
    	}
        }
    
        int length()	//实现继承自父类的length()函数
        {
    	return m_length;
        }
    };
    }
    
    #endif	//__DYNAMICARRAY_H__

    上边就把Array、StaticArray、DynamicArray实现完了,这里我们将他们都实现在头文件中,也可以分开到源文件中,下边我们在main函数中调用一下

    #include <iostream>
    
    #include "StaticArray.h"
    #include "DynamicArray.h"
    
    using namespace std;
    using namespace MyLib;
    
    int main()
    {
        cout << "StaticArray..........." << endl;
        StaticArray<int, 10> list1;
    
        for (int i=0; i<list1.length(); i++)
        {
        	list1[i] = i;	//设置数组元素
        }
        for (int i=0; i<list1.length(); i++)
        {
        	cout << list1[i] << " " ;
        }
    
        cout << endl << "DynamicArray.........." << endl;
        DynamicArray<int> list2(10);	
        for (int i=0; i<list2.length(); i++)
        {
        	list2[i] = i;	//设置数组元素
        }
        for (int i=0; i<list2.length(); i++)
        {
        	cout << list2[i] << " ";
        }
        cout << endl;
    
        system("pause");
    
        return 0;
    }

    编译执行

    到这里我们的数组类就创建完成了,也可以按照需求增减功能。

    展开全文
  • JAVA“数组创建与调用

    千次阅读 2017-07-16 19:57:25
    JAVA“类”数组的创建与调用...先看这样一个类数组创建注:bookFeature 是一个类错误1:class bookList { private int bookNum=0; final int MAXSIZE=1001; public bookList(){ bookNum=0; bookFeature[] List=

    JAVA“类”数组的创建与调用和C++相比是不同的。

    先看这样一个类数组的创建

    注:bookFeature 是一个类

    错误1:

    class bookList {
        private int bookNum=0;
        final int MAXSIZE=1001;
        public bookList(){
            bookNum=0;
            bookFeature[] List=new bookFeature[MAXSIZE];
            }
        }

    这里在构造方法bookList()里定义了bookFeature[] List=new bookFeature[MAXSIZE];

    这样是不行的,JAVA要求对每个变量都要初始化,必须在构造方法里加上这样一行代码:

    
    1
    2
    for(int i=0;i<MAXSIZE;i++){
                List[i]=new bookFeature();

    这样是否就行了呢?接下来看错误2

    错误2:

    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class bookList {
        private int bookNum=0;
        final int MAXSIZE=1001;
        bookFeature[] List;
        public bookList(){
            bookNum=0;
            bookFeature[] List=new bookFeature[MAXSIZE];
            for(int i=0;i<MAXSIZE;i++){
                List[i]=new bookFeature();
            }
        }

    这里先定义了 bookFeature[] List;再在构造方法,这样也是不行的,这里数组变量必须放在对象中。

    两种错误都会报错 java.lang.NullPointerException
    这里写图片描述
    记住数组在JAVA中是对象!!!

    下面给出正确的类数组的声明

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    import java.util.*;
    class bookList {
        private int bookNum=0;
        final int MAXSIZE=1001;
        bookFeature[] List=new bookFeature[MAXSIZE];
        public bookList(){
            bookNum=0;
            for(int i=0;i<MAXSIZE;i++){
                List[i]=new bookFeature();
            }
        }
    展开全文
  • C++创建类对象方法和动态对象数组

    千次阅读 2019-03-17 08:04:10
    创建类对象的方法 C++中有两种创建对象的方法,一种是直接声明,另一种则是使用new关键字,虽然作用相同,但是它们底层的存储方式却完全不同。在此之前,我们先了解一下C++程序的存储形式。 C++程序的内存格局通常...
  • C# Array---创建数组

    2020-05-14 10:33:39
    除了使用C# 语法 "[ ]" 创建数组之外,还可以使用静态方法 CreateInstance() 创建数组。 举个例子: Array intArray1 = Array.CreateInstance( typeof(int), 5 ); for(int i = 0; i < 5; i++) { intArray1....
  • C# 创建类的对象数组

    万次阅读 2019-02-12 22:52:32
    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;...namespace _0606_创建类的对象数组 { class Program { static void Main(string...
  • python怎么创建对象数组

    千次阅读 2020-12-22 14:37:43
    Numpy内置了从头开始创建数组的函数:zeros(shape)将创建一个用指定形状用0填充的数组。默认的dtype是float64。 下面是几种常用的创建方法: #coding=utf-8 import numpy as np a = np.array([1,2,3,4,5]) ...
  • Java自定义类数组创建和赋值

    千次阅读 2018-11-27 10:20:37
    //Person public class Person{ private String id; private Student[] studentVo; public String getId() { return id; } public void setId(String id) { this.id ...
  • 创建自定义的对象数组

    千次阅读 2016-11-30 22:09:29
    源代码public class Student{ ... // 静态变量的访问可以不用创建类的实例就可就可使用类名.属性 >的方法访问 String name; // 学生姓名 Student( ){ // 无参构造函数 System.out.println("创建学生成功。。");
  • Java中创建对象数组

    千次阅读 2021-01-16 16:52:24
    1.对象数组的概念: 如果一个数组中的元素是对象类型,则称该数组为对象数组。...以创建Student的对象数组为例 Student[] stu = new Student[20]; //创建20个学生对象 对学生的每一个数组元素进行
  • Java自定义类数组的初始化 先创建一个A类型 public class A { private int id; public A() { } public A(int id) { this.id = id; } public int getId() { return id; } public void setId(int id)...
  • Java自定义类数组创建和使用

    万次阅读 2016-03-11 19:28:14
    简单介绍Java自定义类数组的创建和使用,具体代码如下: 第一步:创建类 // 顶点表结点 private class VertexNode { char vertex; // 顶点域,存储顶点信息 VertexNode firstedge; // 边表头指针 } 第二步:...
  • 首先说说内存申请函数: malloc、calloc、realloc返回一个 void 指针,C++不允许将 void 指针赋值给其他任何指针,必须强转。...new 与 malloc函数相比,其主要的优点是, new 不只是分配了内存,它还创建了对象。 new
  • Python创建结构体和类数组

    千次阅读 2020-08-25 22:31:09
    Pygame的精灵看的头疼,就...# 使用类创建结构体 class Bullet(object): class Struct(object): def __init__(self, x, y, L): self.x = x self.y = y self.L = L def make_struct(self, x, y, L): self.x = x
  • c++ 动态数组类创建和简单运用

    千次阅读 2018-09-20 21:15:43
    #include #include using namespace std; class Point{ ...//创建数组对象 points.element(0).move(5,0);//访问数据元素的成员 points.element(1).move(15,20);//访问数据元素的成员 return 0; }
  • 使用new和delete创建二维数组,作业习题中的一道,希望能有所帮助
  • 创建对象数组

    千次阅读 2019-02-05 01:11:36
    名称 对象数组名[] = null; 对象数组名 = new 名称[长度]; StudentOfSoftware students[] = null; students=new StudentOfSoftware[5]; 二,定义并开辟数组 同样先构造了一个Studen...
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定...什么是类数组...
  • java创建自定义数组 错题笔记 学习动态规划做例题hdu 2602遇到的问题:创建自定义后,新建一个自定义数组,向数组赋值时报如下错误: java.lang.NullPointerException: Cannot assign field "val" because...
  • 在C++中,我们可以通过new来声明动态数组,示例如下: int* ptr = new int [10]; 通过这一行代码,我们即可实现声明一个int类型,元素个数为10个的指针,ptr指向当前动态数组的第一个元素,若想要访问动态数组的...
  • c++之创建动态数组

    千次阅读 2020-07-22 13:42:42
    C++中用new动态创建二维数组的格式一般是这样: TYPE (*p)[N] = new TYPE [][N]; 其中,TYPE是某种类型,N是二维数组的列数。采用这种格式,列数必须指出,而行数无需指定。在这里,p的类型是TYPE*[N],即是指向一...
  • 如何在java中创建泛型数组

    千次阅读 2019-06-18 15:54:43
    所有的这些都源于Java中泛型一个的特性但也是一个weakness:它是使用擦除实现的,因此除非实施一些显式机制(type-checking),否则“泛型”不知道它们在运行时创建的类型参数,故无法提供 type-safety。...
  • Java 创建泛型类型的数组

    万次阅读 2015-05-10 09:56:32
    1.不能像下面这样直接利用泛型变量创建数组:  T[] a = new T[]; 但可以先创建一个Object类型的数组,再强制类型转化为泛型数组:  T[] a = (T[]) new Object[length]; 这条语句是对的,因为对于没有限定的类型...
  • 如何创建对象的数组

    千次阅读 2017-03-12 15:47:37
    创建对象我们都很熟悉,但是创建对象的数组(也就是相当于创建一个“int”类型的数组,而这个的元素是一个一个的对象)呢?可能在看到我解释的那么多后,你觉得应该是一个道理,但是事实上真的是如此吗?  假如...
  • numpy数组创建数组类型

    千次阅读 2019-03-28 19:53:22
    numpy数组—基础ndarray创建1)创建ndarray数组—array方法2)创建数组方法总结ndarray数据类型1)astype方法2)astype方法传参形式 Numpy的全名是numerical Python,是高性能的科学计算和数据分析基础包,是很多...
  • C ++ | 数组(Array)_4

    千次阅读 2018-12-06 11:55:22
    数组的例子 对于此程序,请使用以下 来练习: 使用 Dog 创建动物收容所名册。在 Dog 中添加一个构造函数。 狗的初始名称是 " Unknown "; 声明并定义函数: printRoster(roster,SIZE); ...
  • 以三维数组为例 先申请1个一维数组空间: mat = [None]*d1 d1是第一维的长度。...以上是创建的“数组”其实是list,不是严格意义的数组。 用numpy array创建2*3*4数组: 原始方法 先创建含2个元素(第一维)
  • C#中创建对象数组

    2021-02-01 11:14:16
    定义一个学生,使用多种形式的构造函数实现初始化学生对象,要求有姓名,班级 分数 // 封装方法求平均数,对分数升序,降序排列 namespace _20210201day4作业 { class Program { class student { private string ...
  • c++自己实现一个数组类

    千次阅读 2018-07-06 14:00:26
    //数组元素的类型可以是,即数组元素为对象,这儿是用=号直接赋值的,因此这儿是调用了赋值函数,并没有调用拷贝构造函数 point[i] = array.point[i]; } } } void setData(int len) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 998,477
精华内容 399,390
关键字:

如何创建类的数组