------<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);
}
}