Java面向对象笔记 • 【第3章 继承与多态】

3.1.1 自定义包
如果在程序中没有声明包，类将被存放在default的包中，该方式不被提倡。

语法：

package  包名
包命名规范：

包的命名规范应当体现出项目资源良好的划分

自定义标签类所在包命名规范：公司名称.开发组名称.项目名称

例如：com.java.explorer

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

3.1.2 包的导入

语法：

import  包名.类名

示例：

import java.util.*; //导入java.util包中所有的类
import java.util.ArrayList; //导入java.util包中的ArrayList类

示例：在Hero类中使用Tree类，Hero类与Tree类不在同一个包中

package com.java.oriented.dota.scene;
public class Tree {
	public void clear(){		
	      //具体业务逻辑
	}
}
 
package com.java.oriented.dota.figure;
//由于Tree类与Hero类不在同一个包中，所以需要使用import关键字导入包
import com.java.oriented.dota.scene.Tree;
public class Hero {
	public void eatTree(Tree tree){
	              //调用树对象的clear()方法，吃掉的树在地图中消失
	             tree.clear();
	}

}

3.1.3 包的访问权限
一个包中具有缺省访问权限的成员只能在同一个包中被引用。

如果一个包中的成员的访问权限为 public，那么这些成员才能被其他包中的类所引用。

以上“成员”特指类、属性和方法。

public成员可以被其他包中的类访问，public类中的protected成员可以被由它派生的在其他包中的子类访问。

package com.java.oriented.dota.scene;
public class Tree {
	void clear(){  //去掉public	
	      //具体业务逻辑
	}
}
 
package com.java.oriented.dota.figure;
//由于Tree类与Hero类不在同一个包中，所以需要使用import关键字导入包
import com.java.oriented.dota.scene.Tree;
public class Hero {
	public void eatTree(Tree tree){
	              //调用树对象的clear()方法，吃掉的树在地图中消失
	             tree.clear();
	}
}
 

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();
 	}
}

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

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

方法名称必须相同。

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

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

仅仅返回类型不同不足以成为方法重载。

注意：

参数列表不同包括：个数不同、类型不同和顺序不同。

仅仅参数变量名称不同是不可以的。

跟成员方法一样，构造方法（构造器）也可以重载。

声明为final的方法不能被重载。

声明为static的方法不能被重载，但是能够被再次声明。

示例：在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.3.2 重写
在子类中可以根据需要对从父类中继承来的方法进行重写。

重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型。重写方法不能使用比被重写的方法更严格的访问权限。

重写方法不能声明抛出比被重写方法范围更大的异常类型。

重写是外壳不变，核心变。也就是说方法名不变，参数不变，具体实现可以改变。一般是在父类中声明方法，在子类中重写。重载是方法名不变，但参数一定要变。而且重载的方法一般都写在一个类中。

提醒：

重写是子类对所继承父类相同方法的一种更改，这个更改需要遵循格式按照父类的格式。

子类重写方法的访问权限，抛出异常等等，都需在父类方法的控制范围之内，但其内部的具体实现可以不同。

子类重写方法的返回值可以为父类中被重写方法返回值的子类型；如果方法参数若为子类类型，则它们是重载而不是重写。

示例：在子类鸵鸟中重写父类飞鸟的飞翔方法
 

public class Bird { // 父类  飞鸟
	//Bird类的fly()方法
	public void fly(){
	         System.out.println("我在蓝天白云间自由的飞翔...");
	}
}
public class Ostrich extends Bird{// 子类  鸵鸟
	public  void fly(){ //重写父类方法
	               System.out.println("我只能在陆地上拍拍翅膀奔跑...");
	}
	public  void prey(){ //捕食方法
		fly();
		System.out.println("执行捕食方法");
	}
	public static void main(String[] args) {
		Ostrich ostrich=new Ostrich();
		ostrich.prey(); //调用ostrich对象的prey()
	}
}

3.3.3 重写覆盖问题

子类方法的覆盖使子类“隐藏”了父类中的方法。

如果需要访问被子类覆盖的方法，则可使用super关键字指明调用父类被覆盖的实例方法。

示例：子类鸵鸟捕食时将使用父类飞鸟的飞翔功能。
 

public class Ostrich extends Bird{
	public  void fly(){
		System.out.println("我只能在陆地上拍拍翅膀奔跑...");
	}
	//捕食方法
	public  void prey(){
		//在prey()方法中使用super关键调用父类的fly()方法
		super.fly();
		System.out.println("执行捕食方法");
	}
	public static void main(String[] args) {
		//创建Ostrich对象
		Ostrich ostrich=new Ostrich();
		ostrich.prey();//调用ostrich对象的fly()
	}

}