java学习之类与对象篇——奥特曼打小怪兽

最新推荐文章于 2022-05-24 13:02:31 发布

LIAO_7053

最新推荐文章于 2022-05-24 13:02:31 发布

阅读量1.2k

点赞数 1

分类专栏： JAVA基础学习文章标签： JAVA基础学习类与对象继承方法重写奥特曼打小怪兽

本文链接：https://blog.youkuaiyun.com/LIAO_7053/article/details/80922988

版权

JAVA基础学习专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨Java面向对象编程，包括类与对象的概念，成员变量和方法，对象创建，封装，继承性，方法重写，多态性，抽象类和接口，并通过奥特曼打小怪兽的例子进行解释。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java学习之类与对象篇——奥特曼打小怪兽

初次接触Java，我们就被告知Java是一种面向对象的程序设计语言，那么什么是面向对象呢？什么又是对象呢？带着这些个疑问，我们开始了Java学习之旅。

1、面向过程与面向对象

面向过程：就是在分析解决问题的时候，把问题分成若干个步骤，然后用函数把这些步骤一一实现，使用的时候一个一个调用就可以了。

面向对象：就是把构成的问题事物按照一定规则分解成多个独立的对象，通过调用对象的方法来解决问题。

面向对象开发，就是不断创建对象，使用对象，指挥对象做事情；

面向对象设计：就是管理和维护对象之间的关系；

面向对象的主要特征：封装性、继承性、多态性。

2、类与对象

类：是一组相关属性和行为的集合，是对象的抽象（如学生类，手机类，球类）。

对象：是对象的抽象（如学生类，手机类，球类）。

对象：是该类事物的具体体现，由类创建出来的，是类的实例（如张三，小米，篮球）。

在Java中，类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。

3、类的定义

成员变量：用于描述对象的特征，也称为属性；

成员方法：用于对象的行为，可简称为方法。

4、对象的创建

格式：类名对象名 = new 类名()

5、对象的使用

成员变量：对象名.变量

成员方法：对象名.方法（）

6、类的封装

类的封装是指隐藏对象的属性和实现细节，即将其私有化（用private修饰），仅对外提供公共访问方式（public修饰，如setXxx(),和getXxx()）。

封装的好处：

a.隐藏实现细节，提供公共的访问方式；

b.提高了代码的复用性；

c.提高安全性。

7、继承性（接口与抽象类）

继承性主要描述类与类的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。

原有类被称作为父类，新创建出来的类称作子类。子类会拥有父类所有的可继承的属性和方法。继承的关键字为extends。

继承的好处：

a.提高了代码的复用性；

b.提高了代码的维护性；

c.让类与类之间产生了关系，是多态的前提。

Java继承的特征：

a.Java只支持单继承，不支持多继承，但多个类可以继承同一个类；

b.Java支持多层继承(继承体系)。

8、方法的重写

在继承关系中，子类会自动继承父类中的定义的方法，但有时候子类中需要对父类的方法进行一些修改，即对父类的方法进行重写。

方法重写的注意事项：

a.父类中私有方法不能被重写;

b.子类重写父类方法时，访问权限不能更低。

方法重写的应用：

当子类需要父类的功能，而子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

9、多态性

多态是指由于继承和重写机制，相同类型的对象调用相同的方法，由于参数类型不同而导致执行效果各异的现象。

多态前提和体现：

a.有继承关系；

b.有方法重写；

c.有父类引用指向子类对象。

多态的好处

a.提高了程序的维护性(由继承保证)

b.提高了程序的扩展性(由多态保证)

多态的弊端

不能访问子类特有功能

多态中的转型:

a.向上转型：子类引用的对象转换为父类类型,通俗地说,就是是将子类对象转为父类对象。(如Animal a=new Cat())；

b.向下转型：把父类对象转为子类对象；

l 向下转型的前提是父类对象指向的是子类对象（也就是说，在向下转型之前，它得先向上转型）;

l 向下转型只能转型为本类对象（猫是不能变成狗的）。（如Animal a = new Cat(); Cat c = ((Cat) a)

10、抽象类

在Java中，一个没有方法体的方法必须定义为抽象方法，抽象方法必须用abstract修饰，而一个类中包含抽象方法的时候，该类必须用必须用abstract修饰，而用abstract关键字修饰的类为抽象类。

抽象类的特点：

a.抽象类和抽象方法必须用abstract关键字修饰;

b.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类;

c.抽象类不能实例化

d.抽象类的子类要么是抽象类,要么重写抽象类中的所有抽象方法。

11、接口

如果一个类中的所有方法都是抽象方法，则可以将这个类用另外一种方法式来定义，即接口。在定义接口时，需要用到interface关键字来声明。

接口特点：

a.接口用关键字interface表示

格式：interface 接口名 {}

b.类实现接口用implements表示

格式：class 类名 implements 接口名 {}

c.接口不能实例化

由具体的子类实例化，其实这也是多态的一种，接口多态。

d.接口的子类,要么是抽象类,要么重写接口中的所有抽象方法。

下面我们来看看奥特曼打小怪兽的具体代码吧!

创建角色类（父类）

/*
 * 角色:
 * 属性:名字,血量,攻击力
 * 行为:攻击
 */
package com.Liao.Altman0627;

public class Role {
	private String name;
	private int volume;
	private int damage;

	public void setName(String n) {
		name = n;
	}

	public String getName() {
		return name;
	}

	public void setVolume(int n) {
		volume = n;
	}

	public int getVolume() {
		return volume;
	}

	public void setDamage(int n) {
		damage = n;
	}

	public int getDamage() {
		return damage;
	}

	public void attack(Role m, Role n) {
		n.setVolume(n.getVolume() - m.getDamage());
		System.out.println(n.getName() + "被" + m.getName() + "攻击了，");
		System.out.println(n.getName() + "掉血" + m.getDamage() + ",剩余血量" + n.getVolume());
	}
}

创建奥特曼类（继承角色类）

package com.Liao.Altman0627;

public class Altman extends Role {

}

创建怪兽类（继承角色类）

package com.Liao.Altman0627;

public class Monster extends Role {

}

创建Boss类（继承怪兽类）

package com.Liao.Altman0627;

public class Boss extends Monster {
	private int volume=1200;//定义私有属性：血量
	private int v=volume;
	
	public void setVolume(int n){
		volume=n;
	}
	
	public int getVolume(){
		return volume;
	}
	//重写攻击方法，Boss血量低于20%时，攻击力加倍
	public void attack(Role m, Role n) {
		if ((double)m.getVolume()/v> 0.2) {
			n.setVolume(n.getVolume() - m.getDamage());
			System.out.println(n.getName() + "被" + m.getName() + "攻击了，" + n.getName() + "掉血" + m.getDamage()+",剩余血量"+n.getVolume());
		} else {
			n.setVolume(n.getVolume() - 2 * m.getDamage());
			System.out.println(n.getName() + "被" + m.getName() + "攻击了，" + n.getName() + "掉血" + m.getDamage() * 2+",剩余血量"+n.getVolume());
		}
	}

}

主函数

package com.Liao.Altman0627;

public class Manager {

	public static void main(String[] args) {
		Altman alt=new Altman();//创建奥特曼对象
		Monster mon=new Monster();//创建小怪兽对象
		Boss boss=new Boss();//创建boss对象
		
		alt.setName("奥特曼");//命名
		mon.setName("小怪兽");
		boss.setName("终极boss");
		
		alt.setVolume(1000);//设置血量
		mon.setVolume(300);

	
		alt.setDamage(100);//设置攻击力
		mon.setDamage(20);
		boss.setDamage(50);
		//奥特曼打怪兽
		while(alt.getVolume()>0&&mon.getVolume()>0){
			alt.attack(alt,mon);
			if(mon.getVolume()<=0){
				System.out.println("小怪兽被打死了！");
				break;
			}
			mon.attack(mon, alt);
			if(alt.getVolume()<=0){
				System.out.println("奥特曼离我们而去了！");
				break;
			}
		}
		
		//奥特曼打boss
		while(alt.getVolume()>0&&boss.getVolume()>0){
			alt.attack(alt,boss);
			if(boss.getVolume()<=0){
				System.out.println("终极boss被打死了！");
				break;
			}
			boss.attack(boss, alt);
			if(alt.getVolume()<=0){
				System.out.println("奥特曼离我们而去了！");
				break;
			}	
		}
		
	}
}