java构造器简析

java构造器简析

一. 什么是构造器

在日常生活中,盖房子需要工具和工人，工人使用工具来修建一个房子。在Java中，构造器就好比工具，而new关键字就是工人，通过new关键字和构造器结合来创建对象。使用构造器初始化对象，并且可以通过这个方法为对象分配内存来做一些其他的初始化工作，或者其他的操作。

1.1构造器的使用

构造器的语法组成：

类修饰符  类的名称（参数列表）
	{
		//方法体
	}

• 构造器可以使用的修饰符有public,protected,default,private,不写即为default类型

• 构造器的名称必须要和类名称相同

• 不能有返回类型，void也不行

• 构造器的参数可有可无，可以有一个也可以多个
  如下代码：

  public class test
   	{
   		//创建一个构造器
   		public void test()
   		{
   			//方法体
   		}
   	}
  

【解析】这段代码编译运行时没错，因为test()在这里被认为是一种方法，而不是构造器。
如下：（一个完整的构造器）

public class test
	{
		private String s;
		public test(String s){
			this.s=s;
		}
		public String getMes(){
			return s;
		}
		public static void main(){
			test t=new test("Hello！！！");
			String s=t.getMes();
			System.out.println(s);
		}
	}

1.2被修饰的构造器

使用不同修饰符修饰的构造器具有不同的效果：
public : 最常见，能够让所有类访问到
pricate : 只在自己的类里面能够访问
示例：

class apple{
		//声明一个私有成员变量
		private String s;
		private apple(){
			System.out.println("构造器运行了");
		}
		public static apple getTest(){
			return new apple();
		}
		public String getS(){
			return s;
		}
		public void setS(String s){
			this.s=s;
		}
	}
	public class testAplle{
		public static void main(){
			apple a=apple.getTest();
			a.setS("给私有的成员变量赋值"）;
			String s=a.getS();
			System.out.println(s);
		}
	}

1.3构造器方法与普通方法的区别

主要是功能，修饰符，返回值和命名上的区别

• 构造器是为了创建一个类的对象实例，也可以在创建对象的时候使用
• 方法是为了执行相应的方法体，即Java代码
• 构造器可以被修饰为public,protected,default,private类型，但不能被修饰为abstract,final,native,static,synchronized
• 方法可以有零个或多个参数
• 在创建一个类的时候可以不定义构造器，编译器会自动为这个类添加一个没有参数的构造器
• 方法可以修饰为除了protected,native的修饰符
• 构造器没有返回值，也没有void型
• 方法没有返回值或任何类型的返回值
• 构造器的名称要和类的名称相同
• 方法的名称可以任意起，但要注意标识符的命名规则，也应使其更有意义

二.如何实例化一个对象

实例化就是实实在在的创建一个对象，用new来完成。
new 构造器的名称（参数列表）

三.构造器的使用

3.1构造器的调用

在本类调用或在同包下的另一个类调用，或是在子类中调用父类的构造器。
【示例1】本类中调用

public class test{
		private String str;
		public String getStr(){
			return str;
		}
		public void setStr(String str){
			this.str=str;
		}
		public static void main(){
			test a=new test ();
			a.setStr("给私有的成员变量赋值");
			String s=a.setStr();
			System.out.println(s);
		}
	}

【示例2】子类调用父类

class fruit{
		private String color;
		public String getColor(){
			return color;
		}
		public String setColor(String color){
			this.color=color;
		}
		public fruit(){
			System.out.println("父类的无参构造器运行了");
		}
	}
	public class apple extends fruit{
		public apple(){
			super();
		}
		public static void main(){
			fruit f=new apple();
			f.setColor("给私有成员变量赋值");
			String s1=f.getColor();
			System.out.println(s1);
		}
	}

3.2构造器重载

即重新加载，要求：

• 重载的方法名称相同但参数列表不同

• 没有返回值

• 构造器不能被继承

• 重载的修饰符只有public,private,protected3个
  【示例】

   public class bike {
   	private String color;
   	private int size;
   	public String getColor(){retutn color;}
   	public void setColor( String color ）{this.color=color;}
   	public int getSize(){return size;}
   	public void getSize(int size) {this.size=size;}
   	public bike(){System.out.println("无参数的构造器运行了");}
   	public bike(String color,int size){this.color=color;this.size=size;}
   	public static void main(){
   		bike b1=new bike();
   		b1.setColor("黄色的自行车");
   		b1.setSize(26);
   		String color1=b1.getColor();
   		int size1=b1getSize();
   		System.out.println(color1+" : "+size1);
   		bike b2=new bike("绿色的自行车",28);
   		String color2=b2.getColor();
   		int size2=b2.getSize();
   		System.out.println(color2+" : "+size2);
   	}
   }
  

3.3父子类间构造器的调用流程

可以用super（参数）来指定参数来调用有参数的构造器

3.4如何自定义构造器

自定义后，不论是否有参数，系统都不在提供默认的无参构造器

四.什么是单子模式

单子模式：某一个类在同一时刻只允许有一个对象。把构造器修饰为private类型，用一个public类型的方法返回对该对象的引用。
【示例】单子模式

class aceing {
		private static aceing ace;
		private aceing(){System.out.println("aceing中的无参构造器调用了");}
		public static aceing getAceing(){
			if(ace==null){ace=new aceing();}
			return ace;		
		}
		public void showMes(){System.out.println("执行aceing 类的方法");}
		public static void main(){
			aceing a=aceing.getAceing();
			a.showMes();
		}
	}

：：getAceing方法可以看成是一个工厂方法，如果要获得对该类的引用，就需要调用返回类进行引用。

五.构造器在程序中是何时运行的

静态块和静态变量初始化完毕后，执行构造器方法里的方法体。构造器方法执行完毕后，创建对象，并调用该对象的方法。
【示例】有继承关系的构造器是何时运行的

    //bike类描述的是自行车
    	class bike {
    		//父类静态块
    		ststic { System.out.println("父类的静态块语句执行") ; }
    		//bike的成员变量
    		public String color;
    		//无参构造器
    		public bike(){ System.out.println("bike类的无参构造器被调用了");}
    		//有参构造器
    		public bike(String color){
    			this.color=color;
    			System.out.println("父类bike的构造器方法被执行");
    		}
    		//父类方法
    		public void show(){System.out.println("该类的其他方法被执行");}
    	}
    	//该类描述公路赛车
    	class aceing extends bike{
    		static {System.out.println("子类的静态块语句执行");}
    		public int size;
    		public aceing (){
    			super("黄色");
    			this.size=size;
    			System.out.println("子类aceing的无参构造器调用了");
    		}
    		//子类方法重写了父类的方法
    		public void show(){ System.out.println(color+" : "+size); }
    
    		public static void main(){
    			aceing a1=new aceing();
    			a1.show;
    		}
    	}