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()+"胜利了");
}
}
/*********************************************************/
相关推荐
在编程世界中，类与继承是面向对象编程（OOP）的核心概念，它们构成了许多现代编程语言的基础。本文将深入探讨这两个概念，并结合实际应用场景，帮助你更好地理解它们。 首先，我们来谈谈“类”。在OOP中，类可以...
c++继承与派生总结 面向对象的程序设计中提供了类的继承机制，允许...以原有的类为基础产生新的类，我们就说新类继承了原有类的特征，也就是说从原有类派生了新类。 类的派生机制的好处在于：代码的重用和可扩充性。
封装继承多态总结
总结来说，这个实验报告通过实际编程练习，帮助我们巩固了Java中抽象类和抽象方法的定义，以及类的继承和多态性这两个核心概念。通过设计和实现学生管理类，我们可以更深入地理解这些概念在实际问题解决中的应用。
C++继承与派生类是面向对象编程的重要概念，它们允许我们创建新的类，这些类可以从现有的类（称为基类或父类）继承属性和行为。在这个实验中，我们将深入理解这两个概念，并通过实际编程练习来巩固它们。 一、继承...
- 示例代码中，`Vehicle` 类的成员 `Maxspeed` 和 `Weight` 被 `Bicycle`、`Car` 和 `MotorCycle` 派生类继承，且能够通过派生类的 `Show` 方法进行访问。 3. 构造函数与析构函数的调用顺序： - 当创建派生类的...
本文将深入探讨类继承的实现、作用以及相关的Java特性。 1. 类继承的实现和作用： 类继承通过使用关键字`extends`来实现。例如，`class ChildClass extends ParentClass`表明ChildClass是ParentClass的子类。继承...
本篇文章将详细介绍C#中的类继承，包括如何实现继承、构造函数在继承中的作用、以及重载、重写和隐藏的概念。 #### 二、实现继承 在C#中，实现类的继承非常简单。只需在定义子类时，在类名后面加上冒号 `:`，紧...
例如，在这段代码中，`bulk_item` 类继承自 `item_base` 类，这意味着 `bulk_item` 类不仅拥有 `item_base` 类的所有成员，还可以添加新的成员或覆盖现有成员以实现更复杂的功能。 ### 代码解析 #### `item_base` ...
总结来说，"表面积和体积_抽象类Shape_shape类继承_"的主题展示了如何利用C++的面向对象特性来设计和实现一个计算几何形状表面积和体积的程序。通过抽象类`Shape`定义通用接口，然后由具体的形状类（如`Cube`、`...
1.继承及继承实例 2.方法重写（Overwrite） 3.super关键字 4.方法重载（Overload） 5.final修饰符 6.abstract修饰符 7.抽象类 8.接口 9.接口和抽象类对比 10.接口和抽象类使用场合实例 11.总结
这个文档总结概括了继承和抽象类的相关知识以及需要注意的事项
这里 `Student` 类继承了 `Person` 类，添加了一个新的属性 `grade` 并重写了 `sayHello` 方法。当我们创建一个 `Student` 对象时，它不仅具有 `Person` 的所有属性和方法，还增加了自己的特性。 最后，我们谈谈...
抽象类是一种不能被实例化的类，它用于定义共同接口，供其他类继承。在C#中，我们使用`abstract`关键字声明抽象类。例如，我们可能有一个`Animal`抽象类，其中包含一个抽象方法`MakeSound()`： ```csharp public ...
实验报告可能会涵盖以下内容：实验目的（理解并掌握类的继承）、实验步骤（定义`Shape`和`Circle`类，实现相关方法）、实验结果（展示代码运行输出，如圆形面积的计算）以及实验总结（类继承的概念及其在实际编程中...
**方法继承**是指在一个类继承另一个类时，子类会自动获得父类的所有非私有方法。如果子类没有对父类的方法进行覆盖，则子类可以直接调用这些继承而来的方法。下面通过几个方面来详细介绍方法继承： 1. **可见性...
"Java继承总结" Java中的继承是面向对象三大特性之一，在知识点上存在许多重要的细节。下面将对Java继承的基本概念、语法格式、继承关系、方法重写、自动转型等进行详细的总结和分析。 一、继承的基本概念 继承是...
一个基本类可以被其他类继承，以便复用已有的代码和功能。 **特点**： 1. **实例化**：基本类可以直接实例化为对象。 2. **继承性**：基本类可以被其他类继承，但一个类只能继承一个父类。 3. **方法实现**：基本类...