java类继承程序_Java类的继承

之前讲到面向对象编程就是面向现实世界，所以在生活中我们也有很多继承的例子，最简单的就是父母和子女的继承，还有就是我们生活中的包含关系，比如鞋子包含马丁靴，雪地靴，绑带凉鞋等等，然后java中很多情况下都会用到类的继承，那么问题来了，为什么要用到类的继承？

1.提高代码的重用性

2.提高程序的扩展性

现在简单介绍一下怎么敲出继承

1.Java类继承类的语法格式

Java中类继承类的关键字：extends

格式：

public class 类名(子类、派生类、超类) extends 类名(父类、基类) {

}

注意：

1.子类就是当前这个类，父类就是我们要复用的那个类；

2.java中只支持单继承;c++支持多继承

3.一个类若没有显示继承其他类，则该类默认继承Object，任何一个类都有一个始祖类

Object，所有类的超类。

4.子类能继承到父类属性和父类所有的普通方法。

5.子类可以定义父类中没有定义过的属性和方法

2.访问修饰符的作用是用来定义属性和方法的访问权限。

访问修饰符同类中 同包中 不同包中不同包但有继承关系的子类中

public 可以 可以可以可以

protected 可以 可以不可以可以

默认的 可以 可以不可以不可以

private 可以 不可以 不可以不可以

3.方法重写

1.需要使用方法重写

父类中存在这个方法，但是子类也有这个方法，但是子类方法的具体实现和父类中

的方法不同，此时就需要使用方法重写。

2.实现方法重写的条件：

1.必须要存在继承关系；

2.子类在重写父类中的方法时，子类方法的访问修饰符>=父类方法的访问修饰符。

3.子类在重写父类中的方法时，子类方法的返回值类型，方法名,参数都必须要和父 类的完全一致。

3.调用重写的方法

根据new关键字后的类名来决定，如果类名是子类的，则优先执行子类的方法， 若子类没有这个方法，才会调用父类中的方法。

4.在重写的方法中使用super关键字来调用父类中的方法，使父类的方法和子类的方法都 执行实现

4.自动转型(必须要有继承关系)

1.子类的类型—>父类的类型

小范围的数据—>大范围的数据

byte(8bit),short(16bit),int(32bit),long(64bit)

2.格式

自动转型的格式一：

父类名 对象名 = new 子类构造方法(参数值,...);

自动转型的格式二：

public 返回值类型 方法名(父类名 对象名){

对象名.方法名();

}

注意：使用自动转型后，无法调用子类特有的属性和方法。

因为Java的编译机制的问题：Java在编译的是编译的是文件

5.下面上实例

public class Monster {

public int blood;

private String name;

public void setName(String n){

name=n;

}

public String getName(){

return name;

}

public void pk(Monster c){

c.blood=c.blood-6;

System.out.println(name+"使用阿瓦索命,"+c.getName()+"减少6滴血");

if(c.blood<=0){

System.out.println(name+" win!");

}

}

}

import java.util.Random;

public class Competitor extends Monster {

public int blood;

private String name;

private Random rand;

public int num;

public void setName(String n) {

name = n;

}

public String getName() {

return name;

}

public void pk(Monster c) {

rand = new Random();

num = rand.nextInt(3);

System.out.println(num);

if (num == 0) {

c.blood--;

System.out.println(name+"使用河豚炸弹,"+c.getName()+"减少1滴血");

} else if (num == 1) {

c.blood = c.blood - 5;

System.out.println(name+"使用空中支援,"+c.getName()+"减少5滴血");

} else if (num == 2) {

c.blood = c.blood - 10;

System.out.println(name+"使用无敌沙嘴炮,"+c.getName()+"减少10滴血");

}

if (c.blood <= 0) {

System.out.println(name + " win!");

}

}

}

public class Competition {

/**

* @param args

* 鲁班和暴君进行PK，直到一方的血量为0时结束战斗，输出谁胜利了

如果鲁班胜利，鲁班和鲁班进行PK，直到一方的血量为0时结束战斗，输出谁胜利了

如果暴君胜利，暴君和大龙进行PK，直到一方的血量为0时结束战斗，输出谁胜利了

技能 攻击力1~10

类和对象的以及类的继承的技术点都要使用上来。

*/

public static void main(String[] args) {

Monster lu1=new Competitor();

Monster lu2=new Competitor();

Monster mo1=new Monster();

Monster mo2=new Monster();

lu1.setName("鲁班1号");

lu1.blood=10;

mo1.setName("暴君");

mo1.blood=20;

System.out.println(mo1.getName()+"pk"+lu1.getName());

while(lu1.blood>0 && mo1.blood>0){

lu1.pk(mo1);

mo1.pk(lu1);

if(lu1.blood<=0){

mo2.setName("大龙");

System.out.println(mo1.getName()+"PK"+mo2.getName());

mo2.blood=21;

while(mo2.blood>0 && mo1.blood>0){

mo1.pk(mo2);

mo2.pk(mo1);

}

}

else if (mo1.blood<=0){

lu2.setName("鲁班2号");

System.out.println(lu2.getName()+"PK"+lu1.getName());

lu2.blood=9;

while(lu1.blood>0 && lu2.blood>0){

lu2.pk(lu1);

lu1.pk(lu2);}

}

}

}

}

输出结果：

简单介绍一下：

public void pk(Monster c) {

rand = new Random();

num = rand.nextInt(3);

System.out.println(num);

if (num == 0) {

c.blood--;

System.out.println(name+"使用河豚炸弹,"+c.getName()+"减少1滴血");

} else if (num == 1) {

c.blood = c.blood - 5;

System.out.println(name+"使用空中支援,"+c.getName()+"减少5滴血");

} else if (num == 2) {

c.blood = c.blood - 10;

System.out.println(name+"使用无敌沙嘴炮,"+c.getName()+"减少10滴血");

}

if (c.blood <= 0) {

System.out.println(name + " win!");

}

}

这个是Competitor类的pk方法，是重写(override)父类Monster类的pk方法

6.使用

集成数的层次不可太多

集成数的上层为抽象层

(1)定义了下层子类都用友的相同属性和方法，并且尽可能默认实现，从而提高重用性

(2)代表系统的接口，描述系统所能提供的服务

继承关系最大的弱点：打破封装

精心设计专门用于被继承的类

(1)对这些类必须提供良好的文档说明

(2)尽可能的封装父类的实现细节，把代表时间细节的属性和方法定义为private类型

(3)如果某些实现细节必须被子类访问，定义为protected类型

(4)把不允许子类覆盖的方法定义为final类型

(5)父类的构造方法不允许调用可被子类覆盖的方法

(6)如果某些类不是专门为了继承而设计，那么随意继承它是不安全的

7.继续更新，谢谢