一.构造函数
实例化对象需要如下的语法：
（1）数据类型
（2）对象名称 =
（3）new
（4）数据类型（）
数据类型（），这是一个构造方法。
疑问： 我们在类中没有定义任何构造函数，为什么还可以调用？？
答：原因是在整个java中为了保证程序的正确运行，所以就算用户没有定义任何构造方法，也会在编译之后默认增加一个：无参数的构造方法。
例子：构造函数的调用
class Person
{
private String name;
private int age;
private double height;
public Person(){
//显示的把无参数的构造方法定义出来
System.out.println("我试构造方法");
}
}
public class stringtest {
public static void main(String[] args){
Person per = null; //声明一个变量
per = new Person(); //使用关键字new 实例化对象
}
}
构造函数是在使用关键字new 实例化对象的时候调用的。
构造函数的特点：
（1）没有任何的返回值
（2）方法的名称和类名称相同
普通方法和构造方法的区别
构造方法：没有返回值，方法名称和类名称相同，#只有在实例化新对象的时候调用一次
普通方法：在实例化对象之后可以任意的调用
构造方法的作用：
范例：观察代码
class Person{
private String name;
private int age;
private double height;
public Person(){ //显示的把无参数的构造方法定义出来
System.out.println("我是构造方法！");
}
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
public void setHeight(double height){
this.height=height;
}
public double getHeight(){
return this.height;
}
public void getInfo(){
System.out.println("名字："+name+" 年龄："+age+" 身高："+height);
}
}
public class Demo{
public static void main(String[] args){
Person per=null;//声明一个变量
per=new Person();//使用关键字new实例化对象
per.setName("SMITH");
per.setAge(12);
per.setHeight(140);
per.getInfo();
}
}
上面代码我们使用setter方法来设置类的属性值，那么如果有很多个属性，再使用setter来初始化的时候就显得工作量很大，于是我们使用有参数的构造方法来初始化值。
范例：使用构造方法来为属性初始化值
class Person{
private String name;
private int age;
private double height;
//有参数的构造方法
public Person(String name,int age,double height){
this.name=name;
this.setAge(age);
this.height=height;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
if(age<0){
this.age=10;
}else{
this.age=age;
}
}
public int getAge(){
return this.age;
}
public void setHeight(double height){
this.height=height;
}
public double getHeight(){
return this.height;
}
public void getInfo(){
System.out.println("名字："+name+" 年龄："+age+" 身高："+height);
}
}
public class Demo{
public static void main(String[] args){
Person per=null;//声明一个变量
per=new Person();//使用关键字new实例化对象
per.setName("SMITH");
per.setAge(12);
per.setHeight(140);
per.getInfo();
}
}
上面我们定义了一个有参数的构造方法，但是在编译的时候提示找不到了默认提供的无参数构造方法，原来是当我们显示的定义了有参数的构造方法之后，无参数的构造方法JVM就不在默认提供了，但是在代码中我们再调用无参数构造方法，显然找不到。所以在提供有参数的构造方法之后，无参数的构造方法也要显示的定义出来
范例：显示的提供无参数的构造方法
class Person{
private String name;
private int age;
private double height;
//有参数的构造方法
public Person(String name,int age,double height){
this.name=name;
this.setAge(age);
this.height=height;
}
public Person(){};//显示的定义无参数的构造方法
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
if(age<0){
this.age=10;
}else{
this.age=age;
}
}
public int getAge(){
return this.age;
}
public void setHeight(double height){
this.height=height;
}
public double getHeight(){
return this.height;
}
public void getInfo(){
System.out.println("名字："+name+" 年龄："+age+" 身高："+height);
}
}
public class Demo{
public static void main(String[] args){
Person per=null;//声明一个变量
per=new Person();//使用的无参数的构造方法
per.setName("SMITH");
per.setAge(12);
per.setHeight(140);
per.getInfo();
}
}
上面的代码定义了一个有参数的构造方法，但是没使用，接下来我们来使用有参构造方法初始化属性值。
范例：使用有参数的构造方法初始化属性
class Person{
private String name;
private int age;
private double height;
//有参数的构造方法
public Person(String name,int age,double height){
this.name=name;
this.setAge(age);
this.height=height;
}
public Person(){};//显示的定义无参数的构造方法
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
if(age<0){
this.age=10;
}else{
this.age=age;
}
}
public int getAge(){
return this.age;
}
public void setHeight(double height){
this.height=height;
}
public double getHeight(){
return this.height;
}
public void getInfo(){
System.out.println("名字："+name+" 年龄："+age+" 身高："+height);
}
}
public class Demo{
public static void main(String[] args){
Person per=null;//声明一个变量
per=new Person("张三",23,178);//使用的无参数的构造方法
per.getInfo();
}
}
上面的代码使用有参数的构造方法简化了属性初始化的工作，之前要使用setter方法一个一个的调用，现在不需要了。那么构造方法也是方法的范畴，可以实现方法的重载。
范例：构造方法的重载
class Person{
private String name;
private int age;
private double height;
//有参数的构造方法
public Person(String name,int age,double height){
this.name=name;
this.setAge(age);
this.height=height;
}
public Person(String name,int age){
this.name=name;
this.setAge(age);
}
public Person(String name){
this.name=name;
}
public Person(){};//显示的定义无参数的构造方法
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
if(age<0){
this.age=10;
}else{
this.age=age;
}
}
public int getAge(){
return this.age;
}
public void setHeight(double height){
this.height=height;
}
public double getHeight(){
return this.height;
}
public void getInfo(){
System.out.println("名字："+name+" 年龄："+age+" 身高："+height);
}
}
public class Demo{
public static void main(String[] args){
Person per=null;//声明一个变量
per=new Person();//使用的无参数的构造方法
per.getInfo();
}
}
构造方法的重载，在开发中要遵循一个原则：构造方法的顺序要按照参数的个数做升序或者降序排列。方便代码的阅读。
二.匿名对象
匿名对象就是：没有栈内存指向的对象。
匿名对象的使用：
class Person{
private String name;
private int age;
private double height;
//有参数的构造方法
public Person(String name,int age,double height){
this.name=name;
this.setAge(age);
this.height=height;
}
public Person(String name,int age){
this.name=name;
this.setAge(age);
}
public Person(String name){
this.name=name;
}
public Person(){};//显示的定义无参数的构造方法
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
if(age<0){
this.age=10;
}else{
this.age=age;
}
}
public int getAge(){
return this.age;
}
public void setHeight(double height){
this.height=height;
}
public double getHeight(){
return this.height;
}
public void getInfo(){
System.out.println("名字："+name+" 年龄："+age+" 身高："+height);
}
}
public class Demo{
public static void main(String[] args){
//-------------------------------------匿名对象的使用---------------------
new Person("李四",123,78.0).getInfo();//匿名对象
}
}
匿名对象在什么时候使用？？
一个对象要多次使用则声明为有名对象
一个对象只使用一次则声明为匿名对象，匿名对象使用之后立即变为垃圾。
总结：
·构造方法：
|-没有返回值
|-方法名和类名相同
|-是在实例化新对象的时候调用
|-如果没有定义有参数构造方法的时候，jvm会默认提供一个无参数的构造方法
|-如果定义了有参数的构造方法，无参数的构造方法就不会被默认提供，那么
就应该显示的定义出无参数的构造方法
|-构造方法可以实现重载
|-构造方法的编写顺序是按照参数的个数升降序排序
·匿名对象：
|-没有栈内存指向，并且只能使用一次
|-如果一个对象要被多次使用的时候声明为有名对象，否则声明为匿名对象
