Java-Python对比学习之构造器

构造器 

构造器是一种特殊的方法，方法的本质是类中的函数，所以构造器还是一种特殊的函数。 

---

既然是方法，此方法的作用是什么？ 既然是特殊的方法，特殊的地方究竟是哪里呢？

在学习过的python中有没有类似的构造器呢？他们的作用是相同的吗？在后面一一解答.

---

在初次学习python的过程中并没有接触到构造器这一概念，但存在一个类的---构造方法，"__init__()"。

 Java篇

Java中构造器的相关知识

1.构造方法有两类：

        不带参数的构造方法

public  class Puppy {
    public  Puppy(){
        System.out.println("无参数构造器");
    }
    public static void main(String[] args) {
        Puppy myPuppy = new Puppy();
    }
}

//输出结果： 无参数构造器

        带有参数的构造方法

public  class Puppy {
    public  Puppy(int age,String name ){
        System.out.println(age);
        System.out.println(name);
    }

    public static void main(String[] args) {
        Puppy hisPuppy = new Puppy(16,"lion");
    }
}
//输出：
//16
//lion

总结：

1.创建格式：

权限修饰符 类名 () {

                                //code 

                               } 

2.两个注意：

        注意类名一致

        注意权限修饰符不能错用成 void访问控制符

2.构造器是类所必须的吗？ 

没有构造器，类也能正常构建并使用，难道Java构造器真的不是必须的吗？

显式构造函数：自定义类的初始属性

隐式构造函数：java提供的默认空构造函数

事实上，没有构造器，编译器会提供默认的为空构造函数 代码等价于上面第2处的注释代码

既然如此，构造函数起的作用是什么呢？

构造器是为类服务的，一个类是由属性和方法构成的，而方法是属性的调用.

那么是不是构造器就创建了整个对象呢？

不是，构造器只是用来初始化变量的

初始化变量是指让某个变量从类创建后就存在

例如 "人的胎记"

那究竟是谁创建了整个对象呢？

简单来说使用new关键词时，对象就被创建了

Puppy mypuppy = new Puppy 

执行这一语句相当于：

创建对象Puppy并交给构造器初始化属性然后返回给对象

接着Puppy和myPuppy关联起来

 3.一个类中只能有一个函数吗?

---

        清楚了类中的构造器作用 那么一个类中只能有一个构造函数吗？ 如果有多个作用一样吗？

有必要用多个构造函数吗？如果有必要，作用是什么？

---

public  class Puppy {
    public  Puppy(){
        System.out.println("hello");
    }
    public  Puppy(String name){
        System.out.println("hello"+name);
    }
    public   Puppy(int age){

        System.out.println("年龄"+age);

    }
    public static void main(String[] args) {
        Puppy myPuppy = new Puppy();
        Puppy hisPuppy = new Puppy("tom");
        Puppy herPuppy = new Puppy(19);
    }
}

 

 结论：

1.没有参数类型只能有一个

2.有参数类型 同一个参数只能有一个

//关于构造重载等问题后续学习后添加到笔记内容

 4.既然是函数,能用返回值吗？

public  class Puppy {
    int ns;
 public Puppy(){
     n = 2;
     return n;
 }
    public static void main(String[] args) {
        Puppy myPuppy = new Puppy();
    }
}

 

 构造器是不允许有显式return的的，那隐式return呢？自己有return吗？

总结：

构造器不允许显式return，但自己内部会有返回值  返回的是该类的实例 

关于return还有一点：正常的函数 使用return可以提前退出函数，那么构造方法里面是否也可以呢？

public  class Puppy {
    int age;
    public  Puppy(int num_age){
        if (age == 0){return;}//如果age为0 退出初始化构造
        this.age = num_age;
        int num =20;
        System.out.println(num);
    }
    public int getAge(){
        this.age = age;
        return this.age;
    }
    public static void main(String[] args) {
        Puppy myPuppy = new Puppy(3);
        System.out.println(myPuppy.getAge());
    }
}
//最后输出的结果是0

 事实证明 return是可以退出构造的

 5.类中的方法可以调用，构造器可以被调用吗？

        构造器是不可以被类调用的，原因其实在上面已经提过了

初始化值然后将值返回给对象 是和new关键词一起执行的

        不能被类调用那传入构造器的参数究竟怎么使用的呢？

1.通过this将类中的实例变量与传入的参数关联起成为类的属性(this.事先声明的全局变量="传入的参数")

2.成为类的属性被其他方法调用

来看看下面的代码

public  class Puppy {
    int age;
    int nums;
    public  Puppy(int num_age){
        this.age = num_age;//传入的参数和开始声明的实例变量关联了起来
        int num =20;//构造器中的局部变量 
        System.out.println(num);//输出局部变量
    }
    public void PuppyAgeGet(){
        System.out.println(this.age);
    }
    public static void main(String[] args) {
        Puppy myPuppy = new Puppy(7);//初始化对象 由于构造器中有输出所以会输出20
        System.out.println(myPuppy.age);//调用已经绑定参数的属性 所以输出7
        System.out.println(myPuppy.nums);
        //我们的nums参数没有指定 被默认初始化为0
        myPuppy.PuppyAgeGet();
        //传入的参数变为属性被方法调用
    }
}

更多变量知识在其他笔记中会有所说明

6、static、final、synchronized、native能修饰构造器吗？

7. 初始化时可以执行其他操作吗？

Python篇

1.python的"init"可以出现多个吗?

前面提到"__init__(self)"函数，他的作用类似构造器，这种以"__"开头和结尾的函数称为魔法函数

关于双前导和双末尾下划线的用法：

以双下划线开头和结尾的变量是不会被python解释器所修改的是内置在python中的变量

我们注意到，python中__init__(self)和我们java中的构造器有相似的地方 

class Puppy:
    def __init__(self):
        print("无参数构造器")

    def __init__(self, name):
        print("有参数构造器")


my_puppy = Puppy()
your_Puppy = Puppy("tom")
//报错提示
'''
Traceback (most recent call last):
  File "c:\Users\lh\Desktop\学习\python_work\作业\study.py", line 9, in 
    my_puppy = Puppy()
TypeError: __init__() missing 1 required positional argument: 'name'
'''

第一个函数实例化时缺少参数

当我们为其添加参数后，两个实例化输出的结果都是”有参数构造器“

由此可知：

Python __init(self)__方法只能出现一个，如果出现多个会执行最下面的那个(解释器由上而下执行)

2."init"能够return吗？

class Puppy:

    def __init__(self):
        self.name = "puppy"
        return self.name


puppy=Puppy()
puppy.name

 结果：

Traceback (most recent call last):
  File "c:\Users\lh\Desktop\学习\python_work\作业\study.py", line 10, in 
    puppy = Puppy()
TypeError: __init__() should return None, not 'str'

init的返回值只能是none而不能是字符串 

 3.init能被类或者实例对象调用吗？

与java构造器类似，init内的代码不能够被类或者实例对象调用，可以通过self 类似java中的this与实例化对象相互绑定，成为实例对象的属性。

python对参数的访问

class Puppy:

    def __init__(self, age):
        self.name = "puppy"
        self.age = age


puppy = Puppy(2)
print(puppy.age, puppy.name)
// 结果：2 puppy

python对构造器的访问(将传入参数绑定到类属性的过程)是通过self来执行 

4.java有new关键字，python没有是不是说明python对象的构造就是由init来实现的呢？

其实不是，python中其实也是有类似new关键字的

"__new__(cls,arg*)" new方法是一个静态方法

puppy = Puppy()

当解释器遇到Puppy()时调用内置函数__new__创建对象 然后调用__init__方法

当类中没有__init__方法时创建一个默认为空的__init__

当内部有__new__时继续创建对象 用new里面的属性返回给对象 覆盖了原先已经初始化的内容 这与出现多个init后处理原则相同

这样处理也体现了静态方法的特性

暂时总结这么多，等学的更深，用的更多再来添加补充，如果上面有错误不足，欢迎指正

---

//java为什么这样设计？python为什么没有呢？

---