精华内容
下载资源
问答
  • java在类的定义中创建自己的对象?

    千次阅读 2020-01-14 17:45:28
    书上经常看到这样的例子 ...我想知道的是,A是一个,而main方法是A类中的一个方法,为什么可以main方法里创建一个自己的对象?那是不是也可以使用aa.main(参数)的形式来调用它?请高人解...

    在书上经常看到这样的例子

    public class A(){
        int yy=0;
    
    public static void main(String[] agrs){
        A aa=new A();
        }
    }

    我想知道的是,A是一个类,而main方法是A类中的一个方法,为什么可以在main方法里创建一个自己的对象?那是不是也可以使用aa.main(参数)的形式来调用它?请高人解释。
    public static void main(String[] agrs)

    我知道这是程序主入口
    我想知道的是为什么可以这样在类的内部创建自己的对象,那不是无限循环创建对象了吗?


    回答一:

    你主要的疑惑是,为什么类中的方法可以创建它本身。

    类和方法的写法都是一种  声明, 所谓声明,就是说是对行为的描述,而不是要真正执行它。

    例如

    class 小狗{
        public void 吃饭(){
          小狗 abc = new 小狗();                                                                                  
        }
    }

    这里声明 一个叫小狗 的 类, 他有一个方法,吃饭()。到这里没有任何问题, 我只是描述了一个类,和吃饭的行为。这个时候系统什么都没发生, 因为只是声明而已。说的是小狗  “可以” 吃饭, 但并不是声明完就必须立即调用 吃饭()。但这样的话,谁去调用他呢, 我可以写另一类 比如person类,但是谁去调用person呢?说来说去就必须有一个不需要创建对象也能调用的方法。java里面就是main方法(这个main方法只需要放到任意一个类中即可)。

    public static void main(String[] args) {
        小狗 a = new 小狗();
        a.吃饭();
    }

    当你用java执行这个类时,系统会寻找main方法作为入口执行。流程如下

    1  进入 main方法,调用 小狗   a=  new 小狗(), 这样系统才真正创建一个小狗 类(class)的 一个实例(instance),2  然后调用 a.吃饭(),  这个时候系统执行了吃饭的方法, 即又创建了abc, 一个新的小狗,3 程序结束, 返回。

    系统寻找main的时候不关心main是否在哪个类里,所以实际上main和他的宿主在生命周期上没有关联。之所以写在这个类里只是不需要import类,图方便而已。上面2中,创建a小狗, 吃饭()调用后,创建了abc小狗, 两者并没有什么关系

    回答二:

    1. java是纯面向对象的,所有的方法都要写在类里面,main函数也是。
    2. 但是main只是程序的入口,在那儿个类里面都无所谓,很多需要main函数做入口的项目都单独写个类放main函数
    3. main是静态函数,你在其它静态函数里创建一个这个类的对象也是可以的,静态函数是类的方法,不是对象的方法。
    4. 建议你看看内存机制。

    回答三:

    main方法作为java程序的入口方法。它同时被static修饰是一个静态的方法!
    静态的方法就是不需要将类实例化就可以直接使用类名调用到方法或者属性。而非静态的就需要将此类实例化之后才能够调用到方法或者属性。也就是静态方法的执行不依赖于实例对象
    它的执行过程是:当程序载入时,读取了该java文件,将静态方法读到到了内存中的静态方法保存区域,将classA读到了类的区域,注意:这时候的classA并没有创建实例对象,内存中只是有了创建classA的机器了。接下来main方法作为程序的入口方法被执行(这是只有方法没有实例对象),方法中调用了classA的机器生产了一个A对象,再将A对象装载到内存中。

    展开全文
  • Java创建对象详解:Java创建对象的几种方法

    万次阅读 多人点赞 2019-05-10 20:01:32
    Java 对象的生命周期包括创建、使用和清除,本文详细介绍对象的创建, Java 语言中创建对象分显式创建与隐含创建两种情况。 显式创建对象 对象的显式创建方式有 4 种。 1. 使用 new 关键字创建对象 这是常用的创建...

    对象是对类的实例化。对象具有状态和行为,变量用来表明对象的状态,方法表明对象所具有的行为。Java 对象的生命周期包括创建、使用和清除,本文详细介绍对象的创建,在 Java 语言中创建对象分显式创建隐含创建两种情况。

    显式创建对象

    对象的显式创建方式有 4 种。

    1. 使用 new 关键字创建对象
    这是常用的创建对象的方法,语法格式如下:
    类名 对象名=new 类名();

    2. 调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法
    在 Java 中,可以使用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法来创建对象,代码格式如下:
    java.lang.Class Class 类对象名称=java.lang.Class.forName(要实例化的类全称);
    类名 对象名=(类名)Class类对象名称.newInstance();

    调用 java.lang.Class 类中的 forName() 方法时,需要将要实例化的类的全称(比如 com.mxl.package.Student)作为参数传递过去,然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。

    3. 调用对象的 clone() 方法
    该方法不常用,使用该方法创建对象时,要实例化的类必须继承 java.lang.Cloneable 接口。 调用对象的 clone() 方法创建对象的语法格式如下:
    类名对象名=(类名)已创建好的类对象名.clone();

    4. 调用 java.io.ObjectlnputStream 对象的 readObject() 方法

    下面创建一个示例演示常用的前三种对象创建方法。示例代码如下:

    public class Student implements Cloneable
    {   
        //实现 Cloneable 接口
        private String Name;    //学生名字
        private int age;    //学生年龄
        public Student(String name,int age)
        {    //构造方法
            this.Name=name;
            this.age=age;
        }
        public Student()
        {
            this.Name="name";
            this.age=0;
        }
        public String toString()
        {
            return"学生名字:"+Name+",年龄:"+age;
        }
        public static void main(String[] args)throws Exception
        {
            System.out.println("---------使用 new 关键字创建对象---------");
           
            //使用new关键字创建对象
            Student student1=new Student("小刘",22);
            System.out.println(student1);
            System.out.println("-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------");
           
            //调用 java.lang.Class 的 newInstance() 方法创建对象
            Class cl=Class.forName("Student");
            Student student2=(Student)cl.newInstance();
            System.out.println(student2);
            System.out.println("-------------------调用对象的 clone() 方法创建对象----------");
            //调用对象的 clone() 方法创建对象
            Student student3=(Student)student2.clone();
            System.out.println(student3);
        }
    }
    
    

    对上述示例的说明如下:

    使用 new 关键字或 Class 对象的 newInstance() 方法创建对象时,都会调用类的掏造方法。
    使用 Class 类的 newInstance() 方法创建对象时,会调用类的默认构造方法,即无参构造方法。
    使用 Object 类的 clone() 方法创建对象时,不会调用类的构造方法,它会创建一个复制的对象,这个对象和原来的对象具有不同的内存地址,但它们的属性值相同。
    如果类没有实现 Cloneable 接口,则 clone。方法会抛出 java.lang.CloneNotSupportedException 异常,所以应该让类实现 Cloneable 接口。

    程序执行结果如下:

    ---------使用 new 关键字创建对象---------
    学生名字:小刘,年龄:22
    -----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------
    学生名字:name,年龄:0
    -------------------调用对象的done()方法创建对象----------
    学生名字:name,年龄:0
    

    隐含创建对象

    除了显式创建对象以外,在 Java 程序中还可以隐含地创建对象,例如下面几种情况。
    ①String strName=“strValue”,其中的“strValue”就是一个 String 对象,由 Java 虚拟机隐含地创建。
    ②字符串的“+”运算符运算的结果为一个新的 String 对象,示例如下:
    String str1=“Hello”;
    String str2=“Java”;
    String str3=str1+str2; //str3引用一个新的String对象
    ③当 Java 虚拟机加载一个类时,会隐含地创建描述这个类的 Class 实例。

    **提示:**类的加载是指把类的 .class 文件中的二进制数据读入内存中,把它存放在运行时数据区的方法区内,然后在堆区创建一个 java.lang.Class 对象,用来封装类在方法区内的数据结构。

    无论釆用哪种方式创建对象Java 虚拟机在创建一个对象时都包含以下步骤:

    1. 给对象分配内存。
    2. 将对象的实例变量自动初始化为其变量类型的默认值。
    3. 初始化对象,给实例变量赋予正确的初始值。

    注意: 每个对象都是相互独立的,在内存中占有独立的内存地址,并且每个对象都具有自己的生命周期,当一个对象的生命周期结束时,对象就变成了垃圾,由 Java 虚拟机自带的垃圾回收机制处理。

    展开全文
  • 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());
     }
    }
    

    在这里插入图片描述

    展开全文
  • 有时候需要在Java的外部的一个方法中创建一个内部对象,下面用一个简单的小例子来说明一种实现方法。 public class Out { public Out(){ System.out.println("外部类创建"); } class In{ public ...

    有时候需要在Java的外部类的一个方法中创建一个内部类的对象,下面用一个简单的小例子来说明一种实现方法。

    public class Out {
    	
    	public Out(){
    		System.out.println("外部类创建");
    	}
    	
    	class In{
    		public In(){
    			System.out.println("内部类创建");
    		}
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		Out out = new Out();
    		Out.In in = out.new In();
    	}
    
    }
    
    在eclipse中的测试截图如下所示:



    展开全文
  • Java中创建对象数组

    千次阅读 2021-01-16 16:52:24
    1.对象数组的概念: 如果一个数组的元素是对象类型,则称该数组为对象数组。...以创建Student对象数组为例 Student[] stu = new Student[20]; //创建20个学生对象 对学生的每一个数组元素进行
  • java的定义和对象创建

    千次阅读 2018-12-28 17:23:27
    就像建筑物与设计图纸,通过一份设计图纸,可以构造处建筑物,而Java开发人员编写代码时,实际上是编写代码,对象只有程序运行时才存在。  当用户创建一个Java程序时,可以通过声明来定义。通常,这些里...
  • 1.非静态内部条件下不能逐步创建对象,要先创建一个外部对象,再创建内部对象。 个人理解:因为还没加载即还没分配内存,内部所有非静态成员都没分配内存,不可能直接创建一个非静态内部对象。 2.静态...
  • Java如何创建内部类对象的方法

    千次阅读 2019-07-31 15:43:49
    如下,OuterClass是外部的,InnerClass是内部的, /******************************************************************************* * @project: IDS_AutoView_2019 * @package: ...
  • Java类加载及对象创建过程详解

    千次阅读 多人点赞 2019-06-27 08:00:00
    加载过程 加载的五个过程:加载、验证、准备、解析、初始化。 ... 在Java生成一个代表这个java.lang.Class对象,作为方法区域数据的访问入口。 验证 验证阶段作用是保证Class...
  • javaScript创建对象和Java创建对象的区别

    千次阅读 多人点赞 2018-03-27 09:26:52
    Java和js创建对象的区别
  • java非静态内部如何创建对象实例

    千次阅读 2018-11-13 22:37:03
    java非静态内部如何创建对象实例: public class A { public class NestA { } } A的外部创建NestA的方法如下 A a = new A(); A.NestA nestA = a.new NestA();   接下来我们通过实际的项目经历给大家...
  • java内部如何创建对象

    千次阅读 2016-11-04 09:08:08
    转载来自大牛博客:http://blog.csdn.net/huangbiao86/article/details/6364218 静态内部可以直接创建对象new B.C(); 如果内部不是静态的,那就得这样 B b = new B(); B.C c = b.new C();
  • java中创建类对象的各种方法

    千次阅读 2018-01-18 00:15:50
    加上整理复习汇总java基础知识,刚好写下来记录创建java对象的方法,又称为java类的实例化,有很多种,列举如下:一、使用Spring管理创建学过Spring框架的同学都知道,我们可以利用依赖注入来创建对象,...
  • Java抽象不能创建对象

    万次阅读 2017-03-06 14:35:21
    抽象和接口都能创建对象,只是后边的new不能是new他们自己,但可以new他们的实现(必须是,不能是抽象和接口), 人们使用抽象和接口只是为了说明要干什么事,而让他们的实现去根据自己的需要去实现这些...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 比如说,我A类中创建了一个对象数组。想B类中去使用这个A类中的数组。那么有两种方式 1 继承 直接让B去继承这个A,那么B类中就可以对这个数组进行操作 如下图 这是Child,有个数组childs。长度是40; ...
  • 1、在类中设置一个static的int变量,每次创建一个对象时,count加1。 staic int count=0; Person(){++count;} 2、 同时要让对象的id递增,只需把count加1的结果赋给id即可。 id=++count; 3、 为了让count...
  • java加载顺序和创建对象时的调用顺序的加载顺序创建对象的过程注意 的加载顺序 有父子关系的类在加载时 先调用父类静态初始化块,静态属性,但不包括静态方法,然后再是,子类静态初始化块,静态属性,但...
  • Java中使用枚举创建对象

    万次阅读 2018-06-08 18:07:55
    创建无参对象public enum Direction { FRONT ,BEHIND,LEFT,RIGHT; }创建有参对象public enum Directions{ FRONT("前") { @Override public void show() { System.out.println("前"); ...
  • 下面我们详细了解Java程序new一个普通对象时,HotSpot虚拟机是怎么样创建这个对象的,包括5个步骤:相应加载检查过程、在Java堆中为对象分配内存、分配后内存初始化为零、对对象进行必要的设置、以及执行对象...
  • 为什么java中自己的不用创建对象就可以直接用方法
  • Java对象创建的流程

    千次阅读 2019-05-07 22:05:39
    文章目录Java对象创建的流程1.Java普通对象创建1.1new指令1.2分配内存1.3初始化1.4对象的初始设置1.5\方法2.Java对象内存布局2.1对象头2.2实例数据2.3对齐填充 1.Java普通对象创建 这里讨论的仅仅是普通Java...
  • Java中类加载过程和对象创建过程

    千次阅读 2015-11-21 21:47:26
    1, JVM会先去方法区找有没有相应的.class存在。如果有,就直接使用;如果没有,则把相关的.class加载到方法区 2, .class加载到方法区时,会分为两部分加载:先加载非静态内容,再加载静态内容 3, 加载...
  • java 泛型实例化创建对象

    千次阅读 2020-06-01 17:43:35
    //定义泛型抽象 public abstract class TObjectFactory<T> { protected abstract T getTable(); } //继承使用 public class TableFactory<Table,Value> extends TObjectFactory<Table>{ ...
  • 什么是Java对象引用? Java中都有哪些类型的对象引用? Java中提供的Java对象引用主要有什么目的? 通过本文,你就能很清楚得了解Java对象引用
  • 可以看完这个图就懵了,以下是创建对象的六个步骤: 1、判断是否能常量池中能找到符号引用,并检查是否已被加载、解析、初始化(即判断元信息是否存在) 如果没有则双亲委派模式下,使用当前加载器以...
  • Java中如何创建一个枚举Enum

    千次阅读 2019-12-10 15:22:21
    从jdk5出现了枚举后,定义一些字典值可以使用枚举类型。 枚举常用的方法是 ...获取枚举类中的常量的名称使用枚举对象.name() 枚举类中重写了toString()方法,返回的是枚举常量的名称; 其实toString()和va...
  • 一, 不能创建对象抽象(abstract)不能创建对象。这个大家应该都知道,所以这里就不班门弄斧了。 简单回顾需要注意的几点: 包含抽象方法的,必须声明为抽象。 声明为抽象,不一定非要包含抽象...
  • 在Java中创建对象的全过程

    千次阅读 2016-08-11 16:17:54
    一、对象创建在语言层面上,常仅仅是一个new关键字而已,而在虚拟机,又是怎样的呢? 虚拟机遇到一条new指令时,首先将去...对象所需内存的大小在类加载完成后便可完全确定。内存分配有两种方式:“指针碰撞”(B
  • 创建实现Java的接口对象

    千次阅读 2019-02-01 12:39:32
    接口是不能实例化的,即不能new一个接口出来,但是可以创建一个接口实现对象; 必须要重写接口的方法 Jiekou jiekou = new Jiekou() { @Override public void s() { } };   接口的使用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,133,276
精华内容 853,310
关键字:

java在类中创建对象

java 订阅