类与继承总结

最新推荐文章于 2024-08-12 15:45:48 发布
最新推荐文章于 2024-08-12 15:45:48 发布
阅读量98 收藏
点赞数
分类专栏： Java 文章标签： java

 

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()+"胜利了");
           
   
       
 }

}

/*********************************************************/

 

iteye_20972
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
抽象类和继承总结
没有到不了的明天
08-04 3679
继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有 继承的好处：可继承的属性和方法。                               提高了代表的可维护性                             提高了代码的复用性                             让类与类之间产...
继承与派生总结
06-19
c++继承与派生总结 面向对象的程序设计中提供了类的继承机制，允许...以原有的类为基础产生新的类，我们就说新类继承了原有类的特征，也就是说从原有类派生了新类。 类的派生机制的好处在于：代码的重用和可扩充性。
类的继承的总结
Beckyzhm的博客
07-21 184
类的继承的总结 类继承是为了提高代码的重用性！ 一、Java继承的语法格式： 继承的关键字：extends 格式： public class 类名(子类、超类、派生类) extends 类名(父类、基类) { } 注意：Java的继承是单继承（一个子类只能继承一个父类），表示extends后边只能加一个类名。 二、子类能继承到什么？又能使用什么？ ...
继承总结
u012106209的博客
07-08 96
1.为什么要用继承 因为子类中的属性和方法与总父类中方法与属性相似，为节省代码（子类多对象是更能体现），子类直接继承父类中的全部属性和   方法，虽然都继承了，但因为权限不一样，子类可能不能调用父类中的方法 2.继承 2.1继承关键字  extends 一个类只能继承一个父类 2.2继承基本格式 public class 类名（子类，超类，派生类） extends 类名（父类，基类...
类的继承总结
iteye_50的博客
07-21 123
一、Java继承的语法格式                 1.继承的关键字：extends           避免重写代码的麻烦               2.格式：                  public class  类名（子类、超类、派生类） extends  类名（父类、基类）{                   }                注：Java...
C++继承与派生总结
Qiao712的博客
06-22 1477
面向对象程序设计基于数据抽象、继承、动态绑定这三个基本概念。 OOP的核心思想：多态性(polymorphism) 继承(inheritance) 基类(base class) 直接基类(direct base) 间接基类(indirect base) 派生类(derived class) 虚函数(virtual function) 其解析过程发生在运行时，而不是编译时 类派生列表(class derivation list) 动态绑定(dynamic binding) 使用基类的引用或指针调用一个虚成员
C# 中类与继承等概念
热门推荐
CSDN
06-18 1万+
在C#中，类是面向对象编程的基本概念之一。类是一种模板或蓝图，用于定义对象的属性和行为。它是创建对象的基础，包含数据成员（字段）和函数成员（方法）。通过定义类，可以创建多个具有相似属性和行为的对象。类是面向对象编程中的基本概念之一，它是一种模板或蓝图，用于定义对象的属性和行为。类提供了一种组织和封装数据以及相关操作的方式，它将数据成员（字段）和函数成员（方法）封装在一起，形成一个独立的实体。通过类，可以创建多个具有相似属性和行为的对象。对象是类的实例，它可以使用类中定义的数据和函数来执行特定的任务。
C++类的继承
潜心钻研技术
02-07 2059
继承的概念和定义 概念 我们知道C++是一个面向对象的语言，继承是面向对象程序设计使代码可以复用的最重要的手段，使在逻辑上是继承关系的对象在用类来描述对象语言层面实现了代码复用，这样产生的新的类叫做派生类 例如用学生系统来举例 图中的学生管理系统建立了四个类用来描述 人、学生、老师、助教，但是我们发现学生、助教、老师这三个类都有人这个类的属性，在这个属性上才会多出来一些不同的特征，例如学生可能会有学号、班级…，于是学生从人继承部分属性就是类中的继承，人这个类叫做 父类 或者 基类 ，学生这个类别叫做 子类
java 继承总结篇
weixin_59094759的博客
12-10 890
文章目录 前言 一、继承是什么？ 二、继承关系与super关键字 1.继承关系 ​​​​​​2.super关键字 三、重载与重写 前言 java中创建的类,主要是为了抽象出一些现实事物, 这其中包括属性与方法. 而许多事物是互相有关联的, 具有相同部分的属性和方法, 因此java中出现了继承来提高代码的效率. 为开发提供了更加便利的途径. 一、继承是什么？ 和我们字面理解一样, 继承就是从上级获取其所有属性也包括方法, 同时也可以在该类中定义新的方...
8.类的继承
Cynan_Gattackon
03-29 8191
目录1.继承的定义2.继承的作用3. 继承的语法4. 类继承成员属性的访问权限5. 利用参数列表，初始化父类的私有成员6. 继承中的构造函数与析构函数7. 总结共继承的权限问题8.类中的隐藏问题9. 类中的多继承10.类中多级继承11. 菱形继承（引入：虚继承） 1.继承的定义 从父类中获取一些功能接口或 数据成员，如果该成员是共有或保护成员则子类可以直接访问，提高代码的复用性。 2.继承的作用 提高代码的复用性 有利于软件版本的升级 3. 继承的语法 class 类名: 继承方式 基类名（
python中类的继承
2301_77444219的博客
04-14 2038
类的继承是面向对象编程中的重要概念，它允许一个类（子类）获取另一个类（父类）的属性和方法。通过继承，子类可以重用父类的代码，并且可以在此基础上添加自己的特定属性和方法，从而实现代码的复用和扩展。在类的继承中，父类通常包含一些通用的属性和方法，而子类可以继承这些通用的特性。子类可以通过继承获得父类的属性和方法，并且可以根据需要进行修改或扩展。这种机制使得代码更具有灵活性和可维护性。通过类的继承，我们可以建立类之间的层次关系，形成类的继承链。
JavaScript OOP类与继承
10-29
总结来说，JavaScript的类和继承机制提供了一种组织和复用代码的方式，使得我们能够创建复杂的对象层次结构。通过类构造器、原型和继承，我们可以设计出具有封装性、继承性和多态性的对象，从而更好地应对实际项目的...
JavaScript类的继承操作实例总结
10-17
JavaScript中的类继承是实现面向对象编程的关键特性，它允许我们创建新的类，这些类可以从现有的类（称为基类或超类）中继承属性和方法。本文将深入探讨JavaScript中的类继承，包括类式继承、原型链继承以及使用...
java的继承总结.doc
12-21
"Java继承总结" Java中的继承是面向对象三大特性之一，在知识点上存在许多重要的细节。下面将对Java继承的基本概念、语法格式、继承关系、方法重写、自动转型等进行详细的总结和分析。 一、继承的基本概念 继承是...
继承和抽象类的总结
02-14
这个文档总结概括了继承和抽象类的相关知识以及需要注意的事项
（javaweb）请求响应postman
2301_79144798的博客
08-08 534
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 503
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 535
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
最新发布
supercool7的博客
08-12 797
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
Java基础：类与继承讲解
总结起来，Java基础类与继承是编程中至关重要的概念，通过理解和应用这些概念，程序员能够更好地设计和组织代码，实现更高效、可维护的面向对象编程。在实际项目中，熟练掌握类、对象、继承、封装和多态等概念有助于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值