java面向对象--继承与多态

最新推荐文章于 2023-05-01 21:30:56 发布

zan1012206253

最新推荐文章于 2023-05-01 21:30:56 发布

阅读量144

点赞数

本文链接：https://blog.csdn.net/zan1012206253/article/details/118083979

版权

1.1自定义包语法：

package <包名>

注意：声明一个包的语句必须写在类中的第一行。

如：创建hero类，将该类存放到com.java.oriented.dato.figure包中，具体操作如下：

package com.java.oriented.dato.frgure;

public class hero{
     //类中的相关操作
}

1.2包的导入语法

import <包名>.<类名>

3.2继承

3.2.1 继承概述
继承是面向对象程序设计的一个重要特征，它是通过继承原有类派生出子类，进而构造出更为复杂的子类。
子类既有新定义的行为特征，又继承了原有类的行为特征。
父类与子类存在着包含与被包含的关系，是一种is-a的关系。
在Java中继承可以在现有类的基础上进行功能的扩展，这样能够更加快速地开发出新类，使新类不仅可以复用当前类的特征和行为，而且还可以定义自己的特征和行为。
通过继承可大幅度提高代码的复用性，减少代码量，便于程序的后期维护。
Java继承语法：

[修饰符] class 子类名  extends 父类名{
  //类定义部分
}

父类也称作基类或超类

3.2.2 继承的实现
示例：定义父类武器，以及子类圣剑和长矛

public class Weapon { //父类  武器
	String name;//武器名
	int attackValue;//攻击值
 
    	//构造方法
	public Weapon(String name, int attackValue) {
	    System.out.println("--执行武器父类Weapon的构造方法--");
		this.name = name;
		this.attackValue = attackValue;
	}
	//攻击方法
	public void attack(){
		System.out.println("武器名:"+name+"\t"+"攻击
			值:"+attackValue);
	}
}

public class Sword extends Weapon{ //圣剑  子类
	public Sword(String name, int attackValue) {
		super(name, attackValue);
	}
}
public class Spear extends Weapon{ //圣剑  长矛
	//构造方法
	public Spear(String name,int attackValue) {
		super(name, attackValue);
	}
}
public class ExtendsTest { // 测试类
 	public static void main(String[] args){
 		Sword word = new Sword("圣剑",300);
 		word.attack();
 		Spear spear = new Spear("长矛",250);
 		spear.attack();
 	}
}

3.3 重载和重写
3.3.1 重载
方法重载是让类以统一的方式处理不同类型数据的一种手段。
Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
方法重载也是多态的一种体现。
方法重载的规则：

方法名称必须相同。

参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。

方法的返回类型可以相同也可以不相同。

仅仅返回类型不同不足以成为方法重载。
————————————————
版权声明：本文为CSDN博主「明金同学」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44893902/article/details/106051922

示例：在Book类中定义3个互为重载的方法，它们分别计算不同情形下图书的价格。

public class Book {
	//定义3个重载方法
	public float  getPrice(){	
		return 100;
	}
	public  float getPrice(int page){
		return (float)(page*0.1);
	}
	public  float  getPrice(int page ,float discount){
		return (float) (page*discount);
	}
	public static void main(String[] args) {
		Book book=new Book();//创建Book对象
		System.out.println("default图书价格:"+book.getPrice());
		System.out.println("根据页数计算图书价格:"+book.getPrice(268));	
    		System.out.println("根据页数和折扣计算图书格:"+book.getPrice(360,0.2f));
	}
}

3.4 多态
从一定角度来看，封装和继承几乎都是为多态而准备的。

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

在编译时，可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法。

3.4.1 多态应用
示例：指向子类的父类引用在执行重写方法时所体现的多态性

//父类 人物
public class Figure {
	protected String name;
	public void attack(){
		//此处不进行具体的攻击操作，不同职业的英雄攻击方式不同
	}
	public  void run(){		
		System.out.println("在奔跑");
	}
}
 
//子类 战士
public class Warrior  extends  Figure{
	//重写父类的attack()方法
	public void attack(){
	            System.out.println(this.name+"正在物理攻击......");
	}
}

//子类 法师
public class Master extends Figure {
	//重写父类的attack()方法
	public void attack(){		
		System.out.println(this.name+"正在魔法攻击......");
	}	
	public static void main(String[] args) {
	     Figure master=new Master();
	     master.name="恶魔巫师";
	     Figure warrior=new Warrior();
	     warrior.name="撼地神牛";
	     master.attack();
	     warrior.attack();
	}
}

3.4.2 引用变量的强制类型转换

示例：调用父类引用的方法没有在父类进行定义


//子类 法师
public class Master extends Figure {
	//重写父类的attack()方法
	public void attack(){		
	            System.out.println(this.name+"正在魔法攻击......");
	}
	//子类特有的轰炸功能
	public void bomb(){
	            System.out.println(this.name+“正在魔法轰炸......");
	}	
	public static void main(String[] args) {
	     Figure figure=new Master();
	     figure.name="恶魔巫师";
                       figure.attack();
	     figure.bomb(); //此处编译出错
	}
}

分析：

引用变量只能调用其编译时类型的方法，而不能调用运行时类型的方法，即使实际所引用的对象确实包含该方法。

如果需要让引用变量调用运行时类型的方法，则必须将其强制类型转换为运行时类型，强制类型转换需借助于类型转换运算符。

————————————————
版权声明：本文为CSDN博主「明金同学」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44893902/article/details/106051922