类与继承总结
7.20.类与继承总结
一、Java继承的语法格式
继承关键字:extends
格式:
public class 子类名(超类,派生类) extends 父类名(基类){
属性;
方法;
}
注意:Java的继承是单继承,一个子类只继承一个父类
二、子类能继承什么
子类可以继承到父类所有属性和方法
子类能调用的方法:
1、子类与父类同包时:默认的、受保护的、公有的属性和方法能被子类的对象和子类的定义{}中
调用;
2、子类与父类不同包时:子类对象能调用公有的方法和属性;
子类定义{}时,能调用受保护的和公有的方法和
属性
注意:子类任何时候都不能调用父类中私有的方法和属性
Java的访问修饰符:private、默认的、受保护的、公有的
三、方法的重写
1、实现方法重写的条件:
1.必须存在有继承关系
2.返回数据类型、方法名、参数个数、参数类型、参数顺序必须与父类完全一致
3.子类重写方法时,方法的访问修饰符可以大于或等于父类的修饰符
2、如何调用
1.调用时,会优先调用子类中的方法,子类没有时才调用父类的;
2.如果想调用父类的方法,用super().方法名;
3.调用父类两个参数构造器时用 super(name,blood);
四、自动转型
父类 类名 = new 子类();//(大 -> 小)
Student stu = new UNStudent():
父类指向子类,相当于“is a ”的关系.就是一个大学生是一个学生,不能反过来
注意:1.当子类重写父类中方法的时候,调用子类中的方法;
2.当子类自动转型为父类的时候,通过父类类型变量的引用,只能调用已在父类中定义的
方法
五、多态的实现
多态:相同类型的对象调用相同的方法的时候,由于继承和重写机制,得到的结果不一定相同。
/*********************练习******************************/
1.回合制游戏:奥特曼和小怪兽要战斗,直到一方的血量为0的时候结束战斗,输出谁胜利了!
奥特曼除了可以打小怪兽外,还可以攻击其他的奥特曼对象。
小怪兽除了可以打奥特曼外,还可以攻击其他的小怪兽对象。
1.找出这个场景中的对象
2.找出每一个对象的特征和行为
3.根据类的格式和对象的特性与行为定义一个class
4.定义主函数的类,实例化对象和调用方法
解题思路
对象:>1个奥特曼,>1个怪兽
属性:姓名,血量
方法:战斗,血量减一
1.写一个Boss总类。因为奥特曼跟怪兽都有相同的属性跟方法,奥特曼类跟怪兽类继承这个Boss总类.
Boss 里面有姓名跟血量属性,有战斗方法
2.分别写一个奥特曼跟怪兽的类,继承Boss类,重写构造方法。
3.定义主函数,用直接转型,定义奥特曼、怪兽的属性,调用战斗方法,决胜负
问题及解决方法
(这个问题很多!本来还以为自己对的,才发错得有点不靠谱了~~yoxi~~)
一开始本来发现的问题:
1.继承时候,当自己重写父类的构造方法时,用super(name,blood);并且放到第一行
2.由于子类不能继承父类的private的属性和方法,所以子类中要重新定义属性,定义构造方法(如1)
后来发现的问题:
1、不用那么多类! 一个奥特曼类还能派生出其他奥特曼类吗?他们的名字都是相同的~!
要是说有一个星河战士就要写个奥特曼总类~~~ 星河战士去继承~
你能说其她爸是由你爸衍生出来的吗!?
这么简单的道理,换个名字就不懂了~ 说明造物主是伟大的!
2、关于回合制的问题。 这个不能怪我~ 对于一个不打暴力游戏的妹子来说~ 不知道回合制是2个人
单挑是正常的~ 一直以为他们4个是群殴~
经过吴大神的指点,我懂了,原来回合制是这么一回事~
好吧,附上练习代码:
/***************Boss总类********************************/
public class Boss {
//定义一个Boss类派生出超人跟怪兽
private String name;
private int blood;
//构造一个Boss初始值
Boss(String name,int blood){
this.name = name;
this.blood = blood;
}
//设置Boss姓名
public void setName(String name){
this.name = name;
}
//得到Boss姓名
public String getName(){
return name;
}
//设置Boss血量
public void setBlood(int blood){
this.blood = blood;
}
//得到Boss血量
public int getBlood(){
return blood;
}
//定义一个战斗方法
public void Fight(Boss Bo){
Bo.setBlood(Bo.getBlood()-1);
System.out.println(Bo.getName()+"被击中,血量减1");
}
}
/*****************Aotoman 子类********************************/
public class Aotoman extends Boss{
//定义FakeMoto的姓名血量属性
private String name;
private int blood;
//构造一个FakeAoto的初始值
Aotoman(String name,int blood){
super(name, blood);
}
}
/******************Monster 子类*******************************/
public class Monster extends Boss {
//定义Monster_2的姓名血量属性
private String name;
private int blood;
//构造一个Monster_2的初始值
Monster(String name,int blood){
super(name,blood);
}
}
/*************************************************/
public class Manager {
/**定义入口主函数
* @param args
*/
public static void main(String[] args) {
//实例化个2个Aotoman类的对象,用自动转型,继承Boss类中的方法
Boss Ao1 = new Aotoman("奥特曼1号",10);
//实例化个Aotoman类的对象,用自动转型,继承Boss类中的方法
Boss Ao2 = new Aotoman("奥特曼2号",10);
//实例化个Monster类的对象
Boss Mo1 = new Monster("怪兽1号",10);
//实例化个Monster_2类的对象,用自动转型,继承Monster类中的方法
Boss Mo2 = new Monster("怪兽2号",10);
//奥特曼1号跟怪兽1号战斗
System.out.println("第一场比赛"+Ao1.getName()+"和"+Mo1.getName()+"单挑");
while((Ao1.getBlood()>0)&&(Mo1.getBlood()>0)){
Ao1.Fight(Mo1);
Mo1.Fight(Ao1);
Mo1.Fight(Ao1);
}
System.out.println();
if(Ao1.getBlood()==0)
System.out.println(Ao1.getName()+"阵亡");
else
System.out.println(Ao1.getName()+"胜利了,晋级,准备下一轮比赛!");
if(Mo1.getBlood()==0)
System.out.println(Mo1.getName()+"阵亡");
else
System.out.println(Mo1.getName()+"胜利了,晋级,准备下一轮比赛!");
//奥特曼2号跟怪兽2号战斗
System.out.println();
System.out.println("第二场比赛"+Ao2.getName()+"和"+Mo2.getName()+"单挑");
while((Ao2.getBlood()>0)&&(Mo2.getBlood()>0)){
Ao2.Fight(Mo2);
Mo2.Fight(Ao2);
Mo2.Fight(Ao2);
}
System.out.println();
if(Ao2.getBlood()==0)
System.out.println(Ao2.getName()+"阵亡");
else
System.out.println(Ao2.getName()+"胜利了,晋级,准备下一轮比赛!");
if(Mo2.getBlood()==0)
System.out.println(Mo2.getName()+"阵亡");
else
System.out.println(Mo2.getName()+"胜利了,晋级,准备下一轮比赛!");
//怪兽1号跟怪兽2号
System.out.println();
System.out.println("最后一场比赛"+Mo1.getName()+"和"+Mo2.getName()+"单挑");
Mo1.setBlood(10);
Mo2.setBlood(10);
while((Mo1.getBlood()>0)&&(Mo2.getBlood()>0)){
Mo1.Fight(Mo2);
Mo2.Fight(Mo1);
Mo1.Fight(Mo2);
}
System.out.println();
System.out.println(Mo1.getName()+"胜利了,新一届冠军诞生了!");
if(Mo2.getBlood()>0)
System.out.println(Mo2.getName()+"胜利了,新一届冠军诞生了!");
}
}
/*************************************************/
原错误代码:
解题思路
对象:奥特曼,其他奥特曼,怪兽,其他怪兽
属性:姓名,血量
方法:战斗,血量减一
1.写奥特曼类
2.其他奥特曼继承奥特曼类,用重写的方法,其他奥特曼类(子类)除了战斗方法与奥特曼类(父类)
不同,其他都相同。
3.写怪兽和其他怪兽类,跟1.2点同理
4.定义主函数,定义属性,调用战斗方法,决胜负
/*********************Aotoman类**************************/
//定义一个Aotoman类
public class Aotoman {
private String name;
private int blood;
//构造一个奥特曼初始值
Aotoman(String name,int blood){
this.name = name;
this.blood = blood;
}
//设置奥特曼姓名
public void setName(String name){
this.name = name;
}
//得到奥特曼姓名
public String getName(){
return name;
}
//设置奥特曼血量
public void setBlood(int blood){
this.blood = blood;
}
//得到血量
public int getBlood(){
return blood;
}
//定义一个打怪兽方法
public void Fight(Monster Mo){
Mo.setBlood(Mo.getBlood()-1);
System.out.println(Mo.getName()+"被击中,血量减1");
}
//定义一个打其他奥特曼方法
public void Fight(Aotoman Ao){
Ao.setBlood(Ao.getBlood()-1);
System.out.println(Ao.getName()+"被击中,血量减1");
}
}
/************FakeAoto继承Aotoman类***************************/
//继承Aotoman类
public class FakeAoto extends Aotoman {
//定义FakeMoto的姓名血量属性
private String name;
private int blood;
//构造一个FakeAoto的初始值
FakeAoto(String name,int blood){
super(name, blood);
// this.name = name;
// this.blood = blood;
}
//定义一个打奥特曼方法
public void Fight(Aotoman Ao){
Ao.setBlood(Ao.getBlood()-1);
System.out.println(Ao.getName()+"被同类击中,血量减1");
}
}
/*********************Monster类**************************/
//定义一个Monster类
public class Monster {
private String name;
private int blood;
//构造一个怪兽初始值
Monster(String name,int blood){
this.name = name;
this.blood = blood;
}
//设置怪兽姓名
public void setName(String name){
this.name = name;
}
//得到怪兽姓名
public String getName(){
return name;
}
//设置怪兽血量
public void setBlood(int blood){
this.blood = blood;
}
//得到怪兽血量
public int getBlood(){
return blood;
}
//定义一个打奥特曼方法
public void Fight(Aotoman Ao){
Ao.setBlood(Ao.getBlood()-1);
System.out.println(Ao.getName()+"被击中,血量减1");
}
//定义一个打其他怪兽方法
public void Fight(Monster Mo){
Mo.setBlood(Mo.getBlood()-1);
System.out.println(Mo.getName()+"被击中,血量减1");
}
}
/**************Monster_2继承Monster类**************************/
//继承Monster类
public class Monster_2 extends Monster{
//定义Monster_2的姓名血量属性
private String name;
private int blood;
//构造一个Monster_2的初始值
Monster_2(String name,int blood){
super(name,blood);
}
//定义一个打怪兽方法
public void Fight(Monster Mo){
Mo.setBlood(Mo.getBlood()-1);
System.out.println(Mo.getName()+"被同类击中,血量减1");
}
/******************入口函数**********************/
public class Manager {
/**
* @param args
*/
//定义一个入口函数
public static void main(String[] args) {
// TODO Auto-generated method stub
//实例化个Aotoman类的对象
Aotoman Ao1 = new Aotoman("奥特曼1号",10);
//实例化个FakeAoto类的对象,用自动转型,继承Aotoman类中的方法
Aotoman Ao2 = new FakeAoto("奥特曼2号",10);
//实例化个Monster类的对象
Monster Mo1 = new Monster("怪兽1号",10);
//实例化个Monster_2类的对象,用自动转型,继承Monster类中的方法
Monster Mo2 = new Monster_2("怪兽2号",10);
//开始战斗,怪兽能打所有超人跟其他怪兽,超人能打所有怪兽和非己的超人
Mo1.Fight(Ao1);
Mo1.Fight(Mo2);
Mo2.Fight(Mo1);
Ao1.Fight(Ao2);
Ao1.Fight(Mo1);
Ao2.Fight(Ao1);
Mo1.Fight(Mo2);
for(int i=0;i<8;i++){
Ao1.Fight(Ao2);
}
System.out.println(Ao2.getName()+"阵亡");
while((Mo1.getBlood()>0)&&(Ao1.getBlood()>0)&&(Mo2.getBlood()>0)){
Mo1.Fight(Ao1);
Mo1.Fight(Mo2);
Mo2.Fight(Mo1);
Ao1.Fight(Mo1);
Mo1.Fight(Mo2);
}
//设置胜负
if(Mo1.getBlood()==0)
System.out.println(Mo1.getName()+"阵亡");
else
System.out.println(Mo1.getName()+"胜利了");
if(Mo2.getBlood()==0)
System.out.println(Mo2.getName()+"阵亡");
else
System.out.println(Mo2.getName()+"胜利了");
if(Ao1.getBlood()==0)
System.out.println(Ao1.getName()+"阵亡");
else
System.out.println(Ao1.getName()+"胜利了");
}
}
/*********************************************************/
更多推荐
类与继承总结
发布评论