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、关于回合制的问题。 这个不能怪我~ 对于一个不打暴力游戏的妹子来说～ 不知道回合制是２个人
单挑是正常的～ 一直以为他们４个是群殴～
经过吴大神的指点，我懂了，原来回合制是这么一回事～
好吧，附上练习代码：
/***************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()+"胜利了");
}
}
/*********************************************************/
相关推荐
c++继承与派生总结 面向对象的程序设计中提供了类的继承机制，允许...以原有的类为基础产生新的类，我们就说新类继承了原有类的特征，也就是说从原有类派生了新类。 类的派生机制的好处在于：代码的重用和可扩充性。
封装继承多态总结
JAVA中的继承学习总结JAVA中的继承学习总结
1、实验名称：类的继承、多态的应用 2、代码内容：学生管理类 3、【实验目的】 （1）进一步熟悉抽象类和抽象方法的定义 （2） 进一步掌握集成和多态的实现方式。
1.继承及继承实例 2.方法重写（Overwrite） 3.super关键字 4.方法重载（Overload） 5.final修饰符 6.abstract修饰符 7.抽象类 8.接口 9.接口和抽象类对比 10.接口和抽象类使用场合实例 11.总结
这个文档总结概括了继承和抽象类的相关知识以及需要注意的事项
NULL 博文链接：https://java--hhf.iteye.com/blog/1699633
Java方法继承、方法重载、方法覆盖总结。比较具体细致地描述他们之间的连系与区别，需要的同学可以看看。
{实验报告需单独下载，不过源代码里有注释} ...总结：先建立一个抽象类shape，然后建立一个核心类求体积（面积*高），再建立各种实例图形（对抽象类的继承），直接可输出图形体积，即实现了代码的复用。
C++中类的总结，适合毕业找工作，或新手突击C++用
内容主要为：C++语言简介、面向对象的基本概念、类和对象进阶、运算符重载、类的继承与派生、多态与虚函数、输入/输出流、文件操作、函数模板与类模板九个章节的相关知识点总结，其中包括知识点介绍，知识点分析，...
} 创建接口的步骤 2-2 接口使用示例 总结 封装、继承和多态是面向对象的主要特征 继承可提高代码的重用性，使用extends关键字来实现。除了构造方法之外，父类的所有 方法和属性都被子类的对象继承 多态性是不同的...
目录 前言准备总结继承的n种方式原型式继承原型链式继承借用构造函数(类式继承)组合继承寄生组合式继承结束语 前言 准备 总结 继承的n种方式 原型式继承原型链式继承借用构造函数(类式继承)组合继承寄生组合...
通过代码举例总结的的方式，对c++的类对象在MinGW编译器中存储的机制，以及继承、多态等c++特性的实现机制。
今天我主要谈谈Javascipt中模拟“类”的方法及js中继承的总结和回顾。 js中实现“类”与继承，既是重点，又是难点。很多同学可能都对js中“类”与继承都有所了解，但是深入剖析的时候，感觉力不从心、模棱两可。 ...
定义在一个类内部的类叫内部类，包含内部类的类...内部类可以声明public、protected、private等访问限制，可以声明为abstract的供其他内部类或外部类继承与扩展，或者声明为static、final的，也可以实现特定的接口。
Java设计一个银行帐户类，成员变量包括账号、储户姓名、开户时间、身份证号码、存款余额等帐户信息，成员方法包括存款、取款操作。
php5 类与对象 个人总结与简单的例子，类与对象1. PHP 类与对象 2. PHP 类的继承 extends 关键字 3. PHP 构造方法 __construct() 4. PHP 析构方法 __destruct() 5. PHP final 关键字 6. PHP 类的接口 interface...
本文实例总结了JavaScript类的继承操作。分享给大家供大家参考，具体如下： 一、类式继承 首先要做的是创建构造函数。按惯例，其名称就是类名，首字母应该大写。在构造函数中，创建实例属性要用关键字this 。类的...