java方法重写与重载基础入门.docx
《java方法重写与重载基础入门.docx》由会员分享，可在线阅读，更多相关《java方法重写与重载基础入门.docx（20页珍藏版）》请在冰豆网上搜索。
java方法重写与重载基础入门
1父类中没有构造方法
/*
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A:
在父类中加一个无参构造方法
B:
通过使用super关键字去显示的调用父类的带参构造方法
C:
子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。
注意事项：
this（...）或者super（...）必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。
*/
classFather{
/*
publicFather（）{
System.out.println（"Father的无参构造方法"）;
}
*/
publicFather（Stringname）{
System.out.println（"Father的带参构造方法"）;
}
}
classSonextendsFather{
publicSon（）{
super（"随便给"）;
System.out.println（"Son的无参构造方法"）;
//super（"随便给"）;
}
publicSon（Stringname）{
//super（"随便给"）;
this（）;
System.out.println（"Son的带参构造方法"）;
}
}
classExtendsDemo7{
publicstaticvoidmain（String[]args）{
Sons=newSon（）;
System.out.println（"----------------"）;
Sonss=newSon（"林青霞"）;
}
}
2继承的成员方法的关系
/*
继承中成员方法的关系:
A:
子类中的方法和父类中的方法声明不一样，这个太简单。
B:
子类中的方法和父类中的方法声明一样，这个该怎么玩呢?
通过子类对象调用方法：
a:
先找子类中，看有没有这个方法，有就使用
b:
再看父类中，有没有这个方法，有就使用
c:
如果没有就报错。
*/
classFather{
publicvoidshow（）{
System.out.println（"showFather"）;
}
}
classSonextendsFather{
publicvoidmethod（）{
System.out.println（"methodSon"）;
}
publicvoidshow（）{
System.out.println（"showSon"）;
}
}
classExtendsDemo8{
publicstaticvoidmain（String[]args）{
//创建对象
Sons=newSon（）;
s.show（）;
s.method（）;
//s.fucntion（）;//找不到符号
}
}
3方法重写与重载
/*
方法重写：
子类中出现了和父类中方法声明一模一样的方法。
方法重载：
本类中出现的方法名一样，参数列表不同的方法。
与返回值无关。
子类对象调用方法的时候：
先找子类本身，再找父类。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
案例：
A:
定义一个手机类。
B:
通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。
按照我们基本的设计，我们把代码给写出来了。
但是呢?
我们又发现新手机应该是手机，所以，它应该继承自手机。
其实这个时候的设计，并不是最好的。
因为手机打电话功能，是手机本身就具备的最基本的功能。
所以，我的新手机是不用在提供这个功能的。
但是，这个时候，打电话功能就没有了。
这个不好。
最终，还是加上这个功能。
由于它继承了手机类，所以，我们就直接使用父类的功能即可。
那么，如何使用父类的功能呢?
通过super关键字调用
*/
classPhone{
publicvoidcall（Stringname）{
System.out.println（"给"+name+"打电话"）;
}
}
classNewPhoneextendsPhone{
publicvoidcall（Stringname）{
//System.out.println（"给"+name+"打电话"）;
super.call（name）;
System.out.println（"可以听天气预报了"）;
}
}
classExtendsDemo9{
publicstaticvoidmain（String[]args）{
NewPhonenp=newNewPhone（）;
np.call（"林青霞"）;
}
}
4方法重写注意事项
/*
方法重写的注意事项
A:
父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:
子类重写父类方法时，访问权限不能更低
最好就一致
C:
父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
子类重写父类方法的时候，最好声明一模一样。
*/
classFather{
//privatevoidshow（）{}
/*
publicvoidshow（）{
System.out.println（"showFather"）;
}
*/
voidshow（）{
System.out.println（"showFather"）;
}
/*
publicstaticvoidmethod（）{
}
*/
publicvoidmethod（）{
}
}
classSonextendsFather{
//privatevoidshow（）{}
/*
publicvoidshow（）{
System.out.println（"showSon"）;
}
*/
publicvoidshow（）{
System.out.println（"showSon"）;
}
publicstaticvoidmethod（）{
}
/*
publicvoidmethod（）{
}
*/
}
classExtendsDemo10{
publicstaticvoidmain（String[]args）{
Sons=newSon（）;
s.show（）;
}
}
5成员变量的原则
/*
看程序写结果：
A:
成员变量就近原则
B:
this和super的问题
this访问本类的成员
super访问父类的成员
C:
子类构造方法执行前默认先执行父类的无参构造方法
D:
一个类的初始化过程
成员变量进行初始化
默认初始化
显示初始化
构造方法初始化
结果：
fu
zi
30
20
10
*/
classFu{
publicintnum=10;
publicFu（）{
System.out.println（"fu"）;
}
}
classZiextendsFu{
publicintnum=20;
publicZi（）{
System.out.println（"zi"）;
}
publicvoidshow（）{
intnum=30;
System.out.println（num）;//30
System.out.println（this.num）;//20
System.out.println（super.num）;//10
}
}
classExtendsTest{
publicstaticvoidmain（String[]args）{
Ziz=newZi（）;
z.show（）;
}
}
6静态代码块
/*
看程序写结果：
A:
一个类的静态代码块,构造代码块,构造方法的执行流程
静态代码块>构造代码块>构造方法
B:
静态的内容是随着类的加载而加载
静态代码块的内容会优先执行
C:
子类初始化之前先会进行父类的初始化
结果是：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
*/
classFu{
static{
System.out.println（"静态代码块Fu"）;
}
{
System.out.println（"构造代码块Fu"）;
}
publicFu（）{
System.out.println（"构造方法Fu"）;
}
}
classZiextendsFu{
static{
System.out.println（"静态代码块Zi"）;
}
{
System.out.println（"构造代码块Zi"）;
}
publicZi（）{
System.out.println（"构造方法Zi"）;
}
}
classExtendsTest2{
publicstaticvoidmain（String[]args）{
Ziz=newZi（）;
}
}
7定义学生类
/*
学生案例和老师案例讲解
学生：
成员变量；姓名，年龄
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
老师：
成员变量；姓名，年龄
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
*/
//定义学生类
classStudent{
//姓名
privateStringname;
//年龄
privateintage;
publicStudent（）{
}
publicStudent（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
}
//定义老师类
classTeacher{
//姓名
privateStringname;
//年龄
privateintage;
publicTeacher（）{
}
publicTeacher（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
}
classExtendsTest3{
publicstaticvoidmain（String[]args）{
//创建学生对象并测试
//方式1
Students1=newStudent（）;
s1.setName（"林青霞"）;
s1.setAge（27）;
System.out.println（s1.getName（）+"---"+s1.getAge（））;
//方式2
Students2=newStudent（"林青霞",27）;
System.out.println（s2.getName（）+"---"+s2.getAge（））;
//对应的老师测试我不想了，留给你们自己练习。
}
}
8学生类的构造方法
/*
学生案例和老师案例讲解
学生：
成员变量；姓名，年龄
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
老师：
成员变量；姓名，年龄
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
看上面两个类的成员，发现了很多相同的东西，所以我们就考虑抽取一个共性的类：
人：
成员变量；姓名，年龄
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
学生继承人
老师继承人
*/
//定义人类
classPerson{
//姓名
privateStringname;
//年龄
privateintage;
publicPerson（）{
}
publicPerson（Stringname,intage）{//"林青霞",27
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
}
//定义学生类
classStudentextendsPerson{
publicStudent（）{}
publicStudent（Stringname,intage）{//"林青霞",27
//this.name=name;
//this.age=age;
super（name,age）;
}
}
//定义老师类
classTeacherextendsPerson{
}
classExtendsTest4{
publicstaticvoidmain（String[]args）{
//创建学生对象并测试
//方式1
Students1=newStudent（）;
s1.setName（"林青霞"）;
s1.setAge（27）;
System.out.println（s1.getName（）+"---"+s1.getAge（））;
//方式2
Students2=newStudent（"林青霞",27）;
System.out.println（s2.getName（）+"---"+s2.getAge（））;
//补齐老师类中的代码并进行测试。
}
}
9动物类构造方法
/*
猫狗案例讲解
先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。
猫：
成员变量：
姓名，年龄，颜色
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
eat（）
palyGame（）
狗：
成员变量：
姓名，年龄，颜色
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
eat（）
lookDoor（）
共性：
成员变量：
姓名，年龄，颜色
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
eat（）
把共性定义到一个类中，这个类的名字叫：
动物。
动物类：
成员变量：
姓名，年龄，颜色
构造方法：
无参，带参
成员方法：
getXxx（）/setXxx（）
eat（）
猫：
构造方法：
无参，带参
成员方法：
palyGame（）
狗：
构造方法：
无参，带参
成员方法：
lookDoor（）
*/
//定义动物类
classAnimal{
//姓名
privateStringname;
//年龄
privateintage;
//颜色
privateStringcolor;
publicAnimal（）{}
publicAnimal（Stringname,intage,Stringcolor）{
this.name=name;
this.age=age;
this.color=color;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
publicStringgetColor（）{
returncolor;
}
publicvoidsetColor（Stringcolor）{
this.color=color;
}
publicvoideat（）{
System.out.println（"不要睡了,该吃饭了"）;
}
}
//定义猫类
classCatextendsAnimal{
publicCat（）{}
publicCat（Stringname,intage,Stringcolor）{
super（name,age,color）;
}
publicvoidplayGame（）{
System.out.println（"猫玩英雄联盟"）;
}
}
//定义狗类
classDogextendsAnimal{
publicDog（）{}
publicDog（Stringname,intage,Stringcolor）{
super（name,age,color）;
}
publicvoidlookDoor（）{
System.out.println（"狗看家"）;
}
}
//测试类
classExtendsTest5{
publicstaticvoidmain（String[]args）{
//测试猫
//方式1
Catc1=newCat（）;
c1.setName（"Tom"）;
c1.setAge（3）;
c1.setColor（"白色"）;
System.out.println（"猫的名字是：
"+c1.getName（）+";年龄是：
"+c1.getAge（）+";颜色是：
"+c1.getColor（））;
c1.eat（）;
c1.playGame（）;
System.out.println（"---------------"）;
//方式2
Catc2=newCat（"杰瑞",5,"土豪金"）;
System.out.println（"猫的名字是：
"+c2.getName（）+";年龄是：
"+c2.getAge（）+";颜色是：
"+c2.getColor（））;
c2.eat（）;
c2.playGame（）;
//作业：
测试狗
}
}
升级会员 