Java点类的继承 java类的继承怎么写

转载

lazihuman 2023-07-19 10:40:18

文章标签 Java点类的继承 java类继承程序子类父类 System 文章分类 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类型