在书上经常看到这样的例子
 
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小狗， 两者并没有什么关系
 
回答二：
 
java是纯面向对象的，所有的方法都要写在类里面，main函数也是。
但是main只是程序的入口，在那儿个类里面都无所谓，很多需要main函数做入口的项目都单独写个类放main函数
main是静态函数，你在其它静态函数里创建一个这个类的对象也是可以的，静态函数是类的方法，不是对象的方法。
建议你看看内存机制。
回答三：
 
main方法作为java程序的入口方法。它同时被static修饰是一个静态的方法！
 静态的方法就是不需要将类实例化就可以直接使用类名调用到方法或者属性。而非静态的就需要将此类实例化之后才能够调用到方法或者属性。也就是静态方法的执行不依赖于实例对象
 它的执行过程是：当程序载入时，读取了该java文件，将静态方法读到到了内存中的静态方法保存区域，将classA读到了类的区域，注意：这时候的classA并没有创建实例对象，内存中只是有了创建classA的机器了。接下来main方法作为程序的入口方法被执行（这是只有方法没有实例对象），方法中调用了classA的机器生产了一个A对象，再将A对象装载到内存中。

对象数组的概念：
 如果一个数组中的元素是对象类型，则称该数组为对象数组。
 当需要一个类的多个对象时，应该用该类的对象数组来表示，通过改变下标值就可以访问到不同的对象。
 对象数组的定义和使用：
 对象数组的定义与一般数组的定义类似，但是需要为每一个元素实例化。
 对象数组的声明形式是：
 类名 对象数组名 [ ];
 为对象数组分配内存空间：
 对象数组名=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 对象的生命周期包括创建、使用和清除，本文详细介绍对象的创建，在 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 虚拟机在创建一个对象时都包含以下步骤：
 
给对象分配内存。
将对象的实例变量自动初始化为其变量类型的默认值。
初始化对象，给实例变量赋予正确的初始值。
 
注意： 每个对象都是相互独立的，在内存中占有独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成了垃圾，由 Java 虚拟机自带的垃圾回收机制处理。

面向对象中两个重要的概念：
 
1.类   ：对一类事物的描述，是抽象的、概念上的定义。比如做石膏像的模型
 2.对象：实际存在的该类事物的每个个体，因而也称实例(instance)。比如石膏像
 二者的关系：对象是由类派生的、创建的。一个类可以创建无穷多个对象，每个对象都属于类。
 
 1.创建类和创建类对象
 
1.创建类，类主要由类名，属性，方法组成,当然创建一个类时，属性和方法可以选择的。
class Person:
    def cry(self):  #类方法：跟函数的定义类似，但是self参数自带的，这也是类的方法和普通方法的区别。
        print("I can cry")
    def speak(self):
        print("I can speak:%s"%(self.word))

---------创建对象-----------------------------------------------------------------------
tom =Person()  #创建对象，直接类名(),不用像java中还要new，所以python更加简洁
tom.cry()     #调用对象的方法
tom.word="hahah"
tom.speak()
tom.age =18  #给对象添加属性 ，属性不用在类定义时声明，但这种方法给对象赋值麻烦，每个对象都要赋值。
tom.age =19  #上面已经给tom添加过age属性，再次属于调用，重新赋值。

----------执行结果-------------------------------------------------------------------------
'''
I can cry
I can speak:hahah
'''

2.给类初始化属性，在对象创建时就给对象设定了一些默认值。这样不用给每个对象都添加属性了,比如每个Person都是china,sex都是male.
 _init_(self)该类的方法有点类似java中类的构造器，可以给类的对象赋初始值。
------------------------------------------------------------------------------------------
class Person1:
    def __init__(self):  #_init_(self),主要给类初始化一些属性，对象创建时自动调用该方法执行
        self.country ="china"
        self.sex = "male"

    def speak(self):
        print("I am  from %s  ,wuwuwuwuu"%self.country)
-------------创建对象----------------------------------------------------------------------
jack = Person1()
jack.speak()
print(jack.country,jack.sex)

tom=Person1()
tom.speak()
print(tom.country,tom.sex)
--------------执行结果如下：----------------------------------------------------------------
'''
I am  from china  ,wuwuwuwuu
china male
I am  from china  ,wuwuwuwuu
china male
'''

3.属性虽然初始化了，但是固定死的，而实际每个对象的属性就不同。
  所以通过初始化时调用参数的形式,给每个对象赋不同的属性值

class Person2:
    def __init__(self,name,age): 
        self.age =age   #这种用法类似java中的this.age=age.self意思可以理解为当前对象
        self.name = name #表示将当前对象传进来的参数name的值赋给当前对象的属性name
        self.country = "china" #还是可以给类的每个对象都赋一个默认值。

    def speak(self):
        print("name=%s,age=%d"%(self.name,self.age))
-----------创建对象------------------------------------------------------------------------
p1 = Person2("allen",19)
p2 = Person2("sherry",22)
p3 = p2  #让p3=p2.对象的赋值

p1.speak()
p2.speak()

print("p1：",p1)  #直接打印对象 ，打印的是对象在内存中地址。
print("p2:",p2)
print("p3:",p3) #发现p3的地址跟p2的地址一样。

'''执行结果如下：
name=allen,age=19
name=sherry,age=22
p1： <__main__.Person2 object at 0x000001CBA3508BE0>
p2: <__main__.Person2 object at 0x000001CBA3508CF8>
p3: <__main__.Person2 object at 0x000001CBA3508CF8>
'''
 
总结：
 
__init__()方法，在创建一个对象时默认被调用，类似Java中构造器。不需要手动调用
__init__(self)中，默认有1个参数名字为self，必须写。如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,age,name).第一个self不需要手动传参。 
__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去
python中一个类中只能有一个__init__方法，不支持该方法的重载（类似java中构造器的重载）
每一个对象 都有自己 独立的内存空间，保存各自不同的属性
多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用 传递到方法内部
2.新式类与旧式（经典）类
 
 
 
object 是 Python 为所有对象提供的 基类，提供有一些内置的属性和方法，可以使用 dir 函数查看
 
 
新式类：以 object 为基类的类，推荐使用
 
经典类：不以 object 为基类的类，不推荐使用
 
 
在 Python 3.x 中定义类时，如果没有指定父类，会 默认使用 object 作为该类的 基类 —— Python 3.x 中定义的类都是 新式类
 
 
在 Python 2.x 中定义类时，如果没有指定父类，则不会以 object 作为 基类
 
 
 
新式类 和 经典类 在多继承时 —— 会影响到方法的搜索顺序
 
 
为了保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行！
 今后在定义类时，如果没有父类，建议统一继承自 object
 
class 类名(object):    
    pass

#尽量不要用下面这种老是写法，虽然不会报错，但是不推荐
class 类名:    
    pass
 
统一声明：关于原创博客内容，可能会有部分内容参考自互联网，如有原创链接会声明引用；如找不到原创链接，在此声明如有侵权请联系删除哈。关于转载博客，如有原创链接会声明；如找不到原创链接，在此声明如有侵权请联系删除哈。