黑马程序员--------构造方法

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1.构造方法

1.构造：实例化一个对象；new Student();

2.构造方法：是在"实例化一个对象"时，由JVM自动调用的一个方法；

3.每个类，都必须至少有一个构造方法。我们可以不定义构造方法，编译器，会自动添加一个。

4.构造方法的格式：

1)."方法名"：必须与"类名"一致，包括大小写；

2)."返回值类型"：对于构造方法，不能定义"返回值类型"，甚至是void。

3)."形参" : 可以有，可以没有。如果没有形参，小括号一定要写。

4)."修饰符"：也可以有，后面会讲到，现在不需要加。

5.构造方法的特点：

1).它是在创建此类对象时，由JVM自动调用的一个方法；

当实例化之后，我们不能手动调用构造方法。

2).它不能有返回值；但可以写return;语句，表示结束方法的执行；

3).它一般是用来：初始化成员变量的。也可以做一些其它在实例化此类对象之前

需要做的一些准备工作。

4).每个类都必须有一个构造方法，如果我们不定义，编译器会自动添加一个--无参的，任何事情都不做的。

如果我们定义了构造方法，那么系统就不会自动添加了。

class Student{

//如果我们不定义任何构造方法，编译器会隐式的添加一个如下的构造方法：无参，什么事情都不做

Student(){

}

}

1.1构造方法代码体现

/*

需求：为了描述事物更准确，发现事物对应的很多对象一创建时，

就有了，一些初始化的数据。在类中该如何完成的。

通过Java中的另一个小技术完成：就是构造函数。对象本身就是构造出来，

构造时，需要做一些动作这些应该定义在函数内。

构造函数（Constructor）有什么用？可以对对象创建进行初始化。

构造函数怎么在代码中体现呢？

1，没有返回值类型。因为构造对象，创建完就结束，需要结果。void也不要写，因为要有区别与一般函数。

2，构造函数名称和类名一致。

3，没有具体的返回值。

接下来，按照以上三点，在Person类中定义一个构造函数。

对象一创建就具备了姓名。

发现了问题？

没有学习构造函数时，对象也创建出来了。那么该对象是否有被构造呢？或者说是否有调用构造函数呢？

是的。必须调用！

那么类中那个构造函数是什么呢？

class Person
{
//Person(){}//默认的空参数构造函数。
}

main()
{
Person p = new Person();//这就已经调用了Person类中的空参数的构造函数。
//类中有定义该构造函数吗？有的。只要定义一个类，
//该类中默认就有一个空参数的构造函数，是编译器编译时添加到class文件中。
//注意：如果在类中自定义了构造函数，那么默认的空参数构造函数编译器就不添加了。
//原理：没有定义对象的初始化过程，编译器会添加一个默认的初始化过程。
//      如果定义了指定的对象初始化过程，默认的就不添加了。
}

构造函数的细节：

1，一个类中可以有多个构造函数，它们的存在是以重载的形式体现的。

2，构造函数中也是有return语句的，用于结束初始化动作的。

3，构造函数是否能被private修饰呢？能，作用：其他程序无法创建该类的对象。

class Person
{
private Person(){}
}
main()
{
Person p = new Person();//创建对象无法初始化。
}

构造函数和一般函数的区别？

1，写法不一样。不重要。

2，运行上有差别，对象一创建就会调用对应的构造函数。

一般方法是对象创建后，才会调用所需的一般函数。

问：有了构造函数初始化姓名，那么还需要setName方法吗？

需要，因为对象创建后，如果需要对数据进行修改，可以通过set完成。

3，构造函数在对象创建时，仅调用一次(初始化动作只做一次，而且先执行)。一般方法可以被对象调用多次。

class Person
{
//Person(){}
void Person(){}//这是一般函数。但不要这些书写，因为一般函数名称有规范。
}

main()
{
Person p = new Person();
}

*/

class Person
{
//属性：姓名，年龄。
private String name;
private int age;
//一初始化，既没有姓名，又没有年龄。
Person()
{

}
//	Person(int a)
//	{
//		if(a<0)
//			return;
//		age = a;
//	}

//定义构造函数，对象一创建就具备姓名。
Person(String n)
{
//将接收到的值赋值给对象的name
name = n;
}

//一初始化既有姓名，又有年龄。
Person(String n,int a)
{
name = n;
age = a;

}

//行为。
public void speak()
{
System.out.println("name="+name+",age="+age);
}
}

class PersonDemo2
{
public static void main(String[] args)
{

Person p1 = new Person();

//		Person p = new Person("lisi");//对象创建时，必须会调用对应的构造函数，因为对象需要初始化。

//		Person p2 = new Person("wangwu",23);

}
}

1.2构造方法之间的调用引出的this

1.2.1this关键字：

1.类中可以定义：成员属性、成员方法；

2.当实例化一个类的对象时，在堆空间，会产生此类对象的空间，内部包含了所有"成员属性"。

"成员方法"的字节码会被存储在"方法区"；

3.实例化多个对象，在堆中：每个对象都有独立的"成员属性"的空间，但"方法区中的方法的字节码"空间，

只有一个；

4.如果方法内部需要访问"成员变量"，那么JVM就要区分是哪个对象调用的此方法，那么就会去访问哪个对象的

成员属性。区分的方式：this

5.每个类都有一个隐式的this变量；

当实例化此类的一个对象时，由JVM自动为其赋值，赋值为：当前对象的引用；

6.我们可以显示的使用this去访问"本类的--成员属性、成员方法";

7.有两种情况，必须的显示的使用this关键字：

1).局部变量覆盖成员变量时；

2).在一个构造方法内调用另一个构造方法

1.2.2 this在代码中的体现

class Student{

String name;
int age;
int num = 10;

void show(){
System.out.println(this.name + "," + this.age);//this可以调用本类的成员属性
}
void fun(){
show();//OK的，可以这样直接调用
this.show();//OK的，也可以这样调用；
}
void fun2(){
int num = 20;//局部变量覆盖同名的成员变量，这个是可以的。
System.out.println("num = " + num);//此时访问的num 就是局部的num
System.out.println("this.num = " + this.num);//此时可以通过this关键字，显示的访问被覆盖的成员变量num
}

}
class Demo
{
public static void main(String[] args)
{
Student stu1 = new Student();
stu1.name = "刘德华";
stu1.age = 20;

Student stu2 = new Student();
stu2.name = "张学友";
stu2.age = 22;

Student stu3 = new Student();
stu3.fun2();

}
}

1.3super关键字

1.3.1特点

1).每个类都有的一个隐式的变量；

2).存储的是父类对象的引用；是实例化子类对象时，由JVM自动为其赋值的；

3).super可以访问父类的成员变量、成员方法、构造方法；

4).使用super()调用父类的构造方法的注意事项：

A.super()调用父类构造方法的语句，只能出现在子类的某个构造方法内；

B.使用super(实参)可以调用父类带参数的构造方法；

C.super()调用父类的构造方法时，这条语句必须出现在子类构造方法的第一条有效语句；

5).什么时候必须使用super:

A.子类成员覆盖了父类成员时，可以使用(super.父类成员)访问父类的被覆盖的成员；

B.如果父类中没有无参构造方法，子类的每个构造方法都必须的使用super(实参)调用父类中带参的构造方法；

1.3.2 super代码应用

class Fu
{
int num = 10;
Fu(){
System.out.println("Fu的构造方法");
}
Fu(int n){
System.out.println("Fu的构造方法........."+n);
}
void show(){
System.out.println("Fu的show()");
}
}
class Zi extends Fu
{
Zi(){

super(22);//调用父类有参的构造方法

System.out.println("Zi的构造方法");

}
Zi(String n){
System.out.println("Zi的带参的构造方法");
}

void fun(){
System.out.println("访问父类的成员变量：" + super.num);
System.out.println("调用父类的成员方法：");

}
}
class SuperDemo
{
public static void main(String[] args)
{
Zi z = new Zi();

}
}

1.4重载

构造方法的重载：

1.构造方法是可以重载的：一个类中，可以定义多个构造方法。但形参列表不能完全相同；

2.构造方法中"形参"的作用：一般是用来初始化"成员变量"。

3.构造方法重载的意义：

1).方便程序员使用此类，在构造此类的对象时，非常的方便灵活。

--如果构造时有数据时，可以调用"带参"的构造方法，可以直接为成员属性赋值；

后期无需再调用set方法为成员属性赋值；

--如果构造时没有数据，也可以调用"无参"的构造方法；后期再通过调用set方法

为成员属性赋值；

4.注意：当我们定义了某个构造方法后，编译器将不会为我们的类添加任何的构造方法；

class Student
{
private String name;
private int age;

//可以编译通过，此方法，被当成是"普通成员方法"
void Student(){
System.out.println("我只是个普通成员方法");
}
//此方法，才是构造方法；
Student(){
System.out.println("Student类的无参构造方法......");
}
Student(String n){
name = n;//作用：相当于setName()方法
System.out.println("Student类的String的构造方法......");
}
Student(int n){
age = n;//作用：相当于setAge()方法
System.out.println("Student类的int的构造方法......");
}
Student(String name,int age){
this.name = name;
this.age = age;
}

//一些get和set方法；
void setName(String name){
this.name = name;

}
String getName(){
return this.name;
}
void setAge(int age){
this.age = age;
}
int getAge(){
return this.age;
}
}
class Demo
{
public static void main(String[] args)
{
Student stu = new Student();//调用无参的构造方法
stu.setName("张学友");
stu.setAge(22);

Student stu2 = new Student("张三");//调用String的构造方法
Student stu3 = new Student(20);//调用int的构造方法

Student stu4 = new Student("刘德华",20);
System.out.println(stu4.getName() + "----" + stu4.getAge());
}
}

1.5重写

1.在子类中，可以定义跟父类相同的方法，这时，子类的方法覆盖父类中相同的方法，这叫：方法的重写

2.重写的语法格式规则：

1.返回值类型 方法名 形参列表：必须全部一致;

2.子类的重写父类的方法时，"访问修饰符"可以跟父类相同，或者比父类更宽；宽--窄：public，protected，(默认)，private

3.如果返回值类型相同，但方法名和形参列表不同：编译通过。相当于方法重载。(但这不属于重载)

如果返回值类型不同，方法名和形参列表相同：编译错误。按照重写的语法规则检查。

4.父类中private的方法是不能被重写；

class Fu
{
private void fun(){
System.out.println("父类私有的fun()");
}
void show(){
}
}
class Zi extends Fu
{
void show(){
}
// 编译可以通过。但这绝不是重写；
private void fun(){
System.out.println("子类私有的fun()");
}
}
class Demo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

1.6 this和super以及重写和重载

方法重写和方法重载的区别?方法重载能改变返回值类型吗?

1.重写：Override:要存在"子父类关系"；子类定义了跟父类完全相同的方法：返回值类型 方法名形参列表完全相同，跟父类相同或更宽的访问修饰符；

重载：Overload:只在"同一个类中"，定义多个方法名相同，但形参列表不完全相同的方法。

2.方法重载，跟返回值类型无关；

this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

1.this：

1).每个类都有的一个隐式的变量；

2).存储是当前对象的引用，是实例化此类的对象时，由JVM自动为其赋值的；

3).this可以访问本类的成员变量、成员方法、构造方法；

4).使用this()调用本类其它构造方法的注意事项：

A.this()调用其它构造方法，这种语句只能出现在某个构造方法中；

B.如果调用带参的构造方法，可以使用this(实参)方式调用；

C.构造方法不能"递归调用";

D.this()调用其它构造方法时，这种语句必须出现在这个构造方法的第一行有效语句；

5).什么时候必须使用this:

A.局部变量覆盖成员变量；使用this访问被覆盖的成员变量；

B.在本类的一个构造方法中调用本类的另一个构造方法时。this()或this(实参)

2.super:

1).每个类都有的一个隐式的变量；

2).存储的是父类对象的引用；是实例化子类对象时，由JVM自动为其赋值的；

3).super可以访问父类的成员变量、成员方法、构造方法；

4).使用super()调用父类的构造方法的注意事项：

A.super()调用父类构造方法的语句，只能出现在子类的某个构造方法内；

B.使用super(实参)可以调用父类带参数的构造方法；

C.super()调用父类的构造方法时，这条语句必须出现在子类构造方法的第一条有效语句；

5).什么时候必须使用super:

A.子类成员覆盖了父类成员时，可以使用(super.父类成员)访问父类的被覆盖的成员；

B.如果父类中没有无参构造方法，子类的每个构造方法都必须的使用super(实参)调用父类中带参的构造方法；

注意：在一个构造方法中，不能同时使用this()和super()。因为它们都需要在第一行有效语句；

1.7子父类中构造函数的特点

1.7.1特点

当子父类都有构造函数时，发现结果为：

fu constructor run

zi constructor run

先执行了父类的构造函数，再执行子类的构造函数。

【这是为啥呢？】

因为子类的所有的构造函数中的第一行都有一句隐式语句 super(); //默认调用的是父类中的空参数的构造函数。

【子类中的构造函数为什么有一句隐式的super()呢？】

原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。

才可以更方便的使用父类中的内容。

【小结】

当父类中没有空参数构造函数时，子类的构造函数必须同构显示的super语句指定要访问的父类中的构造函数。

这就是传说中的子类实例化过程。

【实例化过程的细节】

1，如果子类的构造函数第一行写了this调用了本类其他构造函数，那么super调用父类的语句还有吗？

没有的，因为this()或者super(),只能定义在构造函数的第一行，因为初始化动作要先执行。

2，父类构造函数中是否有隐式的super呢？

也是有的。记住：只要是构造函数默认第一行都是super();

父类的父类是谁呢？super调用的到底是谁的构造函数呢？

Java体系在设计，定义了一个所有对象的父类Object ，

【总结】

类中的构造函数默认第一行都有隐式的super()语句，在访问父类中的构造函数。

所以父类的构造函数既可以给自己的对象初始化，也可以给自己的子类对象初始化。

如果默认的隐式super语句没有对应的构造函数，必须在构造函数中通过this或者super的形式明确调用的构造函数。

【问题】

1，this语句和super语句是否可以在同一个构造函数中出现呢？不行，因为必须定义在第一行。

2，为什么要定义在第一行呢？因为初始化动作要先执行。

1.7.2代码

class Fu extends Object
{
//	int count = 3;

Fu()
{
//super();
//显示初始化。
System.out.println("fu constructor run..A..");
}
Fu(int x)
{
//显示初始化。
System.out.println("fu constructor run..B.."+x);
}
}
class Zi extends Fu
{
Zi()
{
//super();
System.out.println("zi constructor run..C..");
}
Zi(int x)
{
this();
System.out.println("zi constructor run..D.."+x);
}
}

class ExtendsDemo3
{
public static void main(String[] args)
{
//		new Zi();
new Zi(6);

new Student("lisi",21);
}
}

//子类的实例化过程的应用。也是super调用的应用。
//什么时候用super调用父类中构造函数。只要使用父类的指定初始化动作，就在子类中通过super(参数列表)格式进行调用。

class Person
{
private String name;
private int age;
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void setName(String name)
{
this.name  = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age  = age;
}
public int getAge()
{
return age;
}
}

class Student extends Person
{
public Student(String name,int age)
{

//调用父类。使用父类的初始化动作。
super(name,age);
}
public void study()
{}
}

class Worker extends Person
{
public Worker(String name,int age)
{
//调用父类。使用父类的初始化动作。
super(name,age);
}
}