Java构造器（构造⽅法）详解
Java构造器（构造⽅法）详解
什么是构造器
构造器通常也叫构造⽅法、构造函数，构造器在每个项⽬中⼏乎⽆处不在。当你new⼀个对象时，就会调⽤构造器。构造器格式如下：[修饰符，⽐如public] 类名 (参数列表，可以没有参数){ //这⾥不能有return}
⽂章⽬录
Java构造器
构造器的注意事项：
1. 构造器的名称必须和类名⼀致
2. ⼀个类中可以定义多个构造器，但是构造器的参数列表必须不同(重载)
3. 如果我们没有⼿动定义构造器，则Java系统会提供⼀个默认的构造器给我们使⽤，⼀旦我们定义了构
造器，则系统会把默认的构造器
收回
4. 构造器的作⽤：实例化对象，给对象赋初始值
5. 代码游离块优先执⾏
怎么定义构造器
构造⽅法的名字必须和所在类的名字⼀致，没有返回值，但不能声明void，访问权限可以为任意，但是⼀般情况下使⽤public⽅法权限，构造⽅法中的参数可以根据需要⾃⾏定义，参数的不同的构造⽅法构成重载
public构造⽅法名(参数){
...
}
/*注意：
1.构造⽅法没有返回值类型
2.构造⽅法名必须和该类的类名保持⼀致，⼤⼩写都⼀样
例：
class Fu
{
public Fu(){}//⽆参的公有构造⽅法
public Fu(int i){}//参数类型为int的公有构造⽅法
......
}
public class Demo extends Fu
{
public Demo(){}//⽆参的公有构造⽅法
public Demo(int i){}//参数类型为int的公有构造⽅法
public Demo(int i,double d){}//参数类型为int和double的公有构造⽅法
...
}
构造器的使⽤
Java中构造⽅法的使⽤有两个地⽅，⼀个是跟在关键字new后⾯，类名加上⼀个⼩括号()，⼩括号内根据实际加上实参，另外⼀个是跟在关键字super或this后加上⼀个⼩括号()，⼩括号内根据实际添加实参，下⾯进⾏举例。
例1:
Demo demo = new Demo(); //这⾥是调⽤的是⼀个⽆参的构造⽅法，必须声明在⽅法中，最好声明在主⽅法
上⾯构造⽅法的参数根据实际添加实参，Jvm根据构造⽅法的参数不同加载不同的构造⽅法
例2：
public Demo(){
this(2);//这⾥调⽤参数为int类型的本类的构造⽅法
}
例3：
public Demo(){
super(1);//调⽤参数为int类型的⽗类的构造⽅法
}
注意：例2和例3中this或super调⽤构造⽅法只能出现在构造⽅法中，⽽且必须出现在第⼀⾏，所以⼀个构造⽅法中第⼀⾏只能为this或super调⽤构造⽅法，两者不能同时调⽤构造⽅法出现，⽽且注意this或super调⽤构造⽅法时，要留构造⽅法出⼝，意思就是最后调⽤的构造⽅法中没有再调⽤别的构造⽅
法！
构造器的继承
⼦类构造器会默认调⽤⽗类⽆参构造器，如果⽗类没有⽆参构造器，则必须在⼦类构造器的第⼀⾏通过 super关键字指定调⽤⽗类的哪个构造器，具体看下⽂例⼦。final类是不允许被继承的，编译器会报错。很好理解，由于final修饰符指的是不允许被修改，⽽继承中，⼦类是可以修改⽗类的，这⾥就产⽣冲突了，所以final类是不允许被继承的。
构造器、静态代码块、构造代码块的执⾏顺序，详见下⽂实例
⽆继承的情况下的执⾏顺序静态代码块：只在程序启动后执⾏⼀次，优先级最⾼构造代码块：任何⼀个构造器被调⽤的时候，都会先执⾏构造代码块，优先级低于静态代码块构造器：优先级低于构造代码块总结⼀下优先级：静态代码块 > 构造代码块 > 构造器
有继承的情况下的执⾏顺序：⽗类静态代码块：只在程序启动后执⾏⼀次，优先级最⾼ ⼦类静态代码块：只在程序启动后执⾏⼀次，优先级低于⽗类静态代码块 ⽗类构造代码块：⽗类任何⼀个构造器被调⽤的时候，都会执⾏⼀次，优先级低于⼦类静态代码块⽗类构造器：优先级低于⽗类构造代码⼦类构造代码块：⼦类任何⼀个构造器被调⽤的时候，都会执⾏⼀次，优先级低于⽗类构造器⼦类构造器：
优先级低于⼦类构造代码块总结⼀下优先级：⽗类静态代码块 > ⼦类静态代码块 > ⽗类构造代码块 > ⽗类构造器 > ⼦类构造代码块 > ⼦类构造器
实例
1.默认构造器
新建⼀个类，不提供任何构造器，编译器会默认提供⼀个⽆参构造器，这就是为什么没定义任何构造器，却可以new 某个对象()
public class People {}
//以上这个People类就可以直接通过new People()来实例化
2.禁⽌对象被外部创建
如果不希望People在外部通过new People()来实例化，只需要将构造器定义为private
public class People{
private People(){
}
}
3.构造器重载
重载可以简单理解为：同个⽅法名，不同的参数列表。如果希望People能在外部通过new People() 或 new People(“字符串”) 来实例化，则通过以下代码即可
public class People{
//通过new People()调⽤
public People(){
}
//通过new People("字符串")调⽤
public People(String str){
}
}
4.构造器的继承
定义⽗类构造器，由于该构造器⾃定义了⼀个带参构造器，覆盖了默认的⽆参构造器，所以不能直接 new Father() 调⽤了，除⾮再定义⼀个⽆参构造器
//⽗类构造器
public class Father{
//⾃定义带参构造器
public Father(String str){
System.out.println("⽗类的带参构造⽅法，参数为："+str);
}
}
定义⼦类构造器，继承Father，由于Father没有⽆参构造器，所以必须在⼦类构造器中通过 super(“字符串”)来调⽤，否则编译器会报错
//⼦类构造器
public class Son extends Father{
//⽆参构造器
public Son(){
//由于Father()没有⽆参构造器，所以必须在⼦类型构造器中通过super("字符串")来调⽤，否则编译器会报错。
//如果没定义这句，系统会默认调⽤super()
super("");
}
//带参构造器
public Son(String str){
//由于Father()没有⽆参构造器，所以必须在⼦类型构造器中通过super("字符串")来调⽤，否则编译器会报错。
//如果没定义这句，系统会默认调⽤super()
super(str);
}
}
5. 构造器、静态代码块、构造代码块的执⾏顺序
5.1⽆继承的情况
public class Father {
static{java接口有没有构造方法
System.out.println("⽗类的静态代码块，程序启动后执⾏，只会执⾏⼀次"); }
//⽗类⽆参构造⽅法
public Father(){
System.out.println("⽗类的默认构造⽅法");
}
//重载，⾃定义⽗类带参构造⽅法
public Father(String str){
System.out.println("⽗类的带参构造⽅法，参数为："+str);
}
{
System.out.println("⽗类构造代码块，每次调⽤构造⽅法都会执⾏的");
}
}
实例化Father
//实例化Father
public static void main(String[] args){
System.out.println("---------------------------------------");
Father father1 =new Father();
System.out.println("---------------------------------------");
Father father2 =new Father("阿马");
}
执⾏上述代码
⽗类的静态代码块，程序启动后执⾏，只会执⾏⼀次
-
--------------------------------------
⽗类构造代码块，每次调⽤构造⽅法都会执⾏的
⽗类的默认构造⽅法
---------------------------------------
⽗类构造代码块，每次调⽤构造⽅法都会执⾏的
⽗类的带参构造⽅法，参数为：阿马
5.2有继承的情况
定义⽗类Father
public class Father {
static{
System.out.println("⽗类的静态代码块，程序启动后执⾏，只会执⾏⼀次"); }
/
/⽗类⽆参构造⽅法
public Father(){
System.out.println("⽗类的默认构造⽅法");
}
//重载，⾃定义⽗类带参构造⽅法
public Father(String str){
System.out.println("⽗类的带参构造⽅法，参数为："+str);
}
{
System.out.println("⽗类构造代码块，每次调⽤构造⽅法都会执⾏的");
}
}
定义⼦类Son，继承⾃⽗类Father
//⼦类构造器
public class Son extends Father{
static{
System.out.println("⼦类的静态代码块，程序启动后执⾏，只会执⾏⼀次，先执⾏⽗类的，在执⾏⼦类的"); }
{
System.out.println("⼦类构造代码块，每次调⽤构造⽅法都会执⾏的");
}
//⽆参构造器
public Son(){
//这⾥没有指定调⽤⽗类的哪个构造⽅法，会默认调⽤super()，调⽤⽗类的⽆参构造器public Father()
}
//重载构造器，多传两个参数
public Son(String str1,String str2){
//必须写在构造器第⼀⾏，调⽤⽗类的带参构造器public Father(str)
super(str1);
System.out.println("⼦类带参构造器："+str2);
}
}
实例化Son
public static void main(String[] args){
System.out.println("-----------------------------------");
Son son1 =new Son();
System.out.println("-----------------------------------");
Son son2 =new Son("⼦类第⼀个参数","⼦类第⼆个参数");
}
执⾏上述代码
⽗类的静态代码块，程序启动后执⾏，只会执⾏⼀次
⼦类的静态代码块，程序启动后执⾏，只会执⾏⼀次，先执⾏⽗类的，在执⾏⼦类的
-----------------------------------
⽗类构造代码块，每次调⽤构造⽅法都会执⾏的
⽗类的默认构造⽅法
⼦类构造代码块，每次调⽤构造⽅法都会执⾏的
-----------------------------------
⽗类构造代码块，每次调⽤构造⽅法都会执⾏的
⽗类的带参构造⽅法，参数为：⼦类第⼀个参数
⼦类构造代码块，每次调⽤构造⽅法都会执⾏的
⼦类带参构造器：⼦类第⼆个参数

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。