GDPU Java 天码行空3 继承

一、实验目的：

1．掌握类的继承方法。
2．掌握变量的继承和覆盖。
3．掌握方法的继承、重载和覆盖。

二、实验原理

新类可从现有的类中产生，并保留现有类的成员变量和方法，并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。
语法格式：
类访问限定符 子类名 extends 父类名｛
……
｝

三、实验内容及要求：

1：使用继承构造动物类、猫类、狗类

自行设计每个类的成员属性、构造方法和成员方法，输出具有继承关系的类的属性和方法调用，分析它们的关系和运行逻辑

💖 动物类 Animal.java

//定义动物类
class Animal
{
	private String name;
	private int age;

	public Animal(String name, int age)
	{
		this.name = name;
		this.age = age;
	}

	public void speak()
	{
		System.out.println("这个动物发出声音。");
	}

	// Getters and Setters
	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public int getAge()
	{
		return age;
	}

	public void setAge(int age)
	{
		this.age = age;
	}
}

💖 猫类 Cat.java

//定义猫类，继承自动物类
class Cat extends Animal
{
	private String color;

	public Cat(String name, int age, String color)
	{
		super(name, age); // 调用父类的构造方法
		this.color = color;
	}

	@Override
	public void speak()
	{
		System.out.println("喵喵！");
	}

	public void climb()
	{
		System.out.println(getName() + "这只猫爬上了树。");
	}

	// Getters and Setters
	public String getColor()
	{
		return color;
	}

	public void setColor(String color)
	{
		this.color = color;
	}
}

💖 狗类 Dog.java

//定义狗类，继承自动物类
class Dog extends Animal
{
	private String breed;

	public Dog(String name, int age, String breed)
	{
		super(name, age); // 调用父类的构造方法
		this.breed = breed;
	}

	@Override
	public void speak()
	{
		System.out.println("汪汪！");
	}

	public void fetch(String item)
	{
		System.out.println(getName() + "这只狗捡回了" + item + "。");
	}

	// Getters and Setters
	public String getBreed()
	{
		return breed;
	}

	public void setBreed(String breed)
	{
		this.breed = breed;
	}
}

💖 测试代码 Main.java

//测试代码
public class Main
{
	public static void main(String[] args)
	{
		Cat myCat = new Cat("小花", 2, "花色");
		Dog myDog = new Dog("旺财", 3, "拉布拉多");

		System.out.println("我的猫的名字是" + myCat.getName() + "，年龄" + myCat.getAge() + "，颜色" + myCat.getColor() + "。");
		System.out.println("我的狗的名字是" + myDog.getName() + "，品种" + myDog.getBreed() + "，年龄" + myDog.getAge() + "。");

		myCat.speak(); // 应该输出 "喵喵！"
		myDog.speak(); // 应该输出 "汪汪！"

		myCat.climb(); // 应该输出 "小花这只猫爬上了树。"
		myDog.fetch("球"); // 应该输出 "旺财这只狗捡回了球。"
	}
}

🏆 程序运行结果：

我的猫的名字是小花，年龄2，颜色花色。
我的狗的名字是旺财，品种拉布拉多，年龄3。
喵喵！
汪汪！
小花这只猫爬上了树。
旺财这只狗捡回了球。

2：设计一个汽车类Vehicle

包含的属性有车轮个数wheels和车重weight。小汽车类Car是Vehicle类的子类，其中包含的属性有载人数loader。卡车类Trunk是Car类的子类，其中包含属性有载重量payload。每个类都有相关数据的输出方法。

💖 运行结果

输出相关数据
enter super class!
车型：小车
enter super class method...
车轮：4
车重：1500.0
品牌:
载人：4人
enter super class!
车型：卡车
车型：小车
enter super class method...
车轮：8
车重：7000.0
品牌:
载人：3人
载人：3人
载重量：25000.0
enter super class!
车型：小车
enter super class method...
车轮：4
车重：2000.0
品牌:
载人：4人
车型：小车
enter super class method...
车轮：4
车重：2000.0
品牌:
载人：4人
enter super class!
车型：卡车
车型：小车
enter super class method...
车轮：9
车重：8000.0
品牌:
载人：4人
载人：4人
载重量：30000.0

💖 结果分析

• 创建了一个Car类的实例，车型为“小车”，车轮个数为4，车重为1500.0，载人数为4人。
• 创建了一个Truck类的实例，车型为“卡车”，车轮个数为8，车重为7000.0，载人数为3人，载重量为25000.0。
• 接着又创建了一个Car类的实例，车型为“小车”，车轮个数为4，车重为2000.0，载人数为4人。
• 再次创建了一个Car类的实例，车型为“小车”，车轮个数为4，车重为2000.0，载人数为4人。
• 最后创建了一个Truck类的实例，车型为“卡车”，车轮个数为9，车重为8000.0，载人数为4人，载重量为30000.0。

3：this、super和super()的使用

(1) 程序功能：程序功能：说明this、super super()的用法。程序首先定义Point（点）类，然后创建点的子类Line（线）。最后通过LineDemo测试类输出线段的长度。程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。在子类Line 的setLine方法中，因为参数名和成员变量名相同，为给成员变量赋值，使用this 引用，告诉编译器是为当前类的成员变量赋值。在length 和toString 方法中使用父类成员变量时，使用super 引用，告诉编译器使用的是父类的成员变量。

💖 点类 Point.java

//文件名：Ponit.java
class Point
{
	protected int x, y;

	Point()
	{
	}

	Point(int a, int b)
	{
		setPoint(a, b);
	}

	public void setPoint(int a, int b)
	{
		x = a;
		y = b;
	}
}

💖 线类 Line.java

// Line.java
class Line extends Point
{
	protected int x, y;

	Line(int a, int b)
	{
		super(a, b);
		setLine(a, b);
	}

	public void setLine(int x, int y)
	{
		this.x = x + x;
		this.y = y + y;
	}

	public double length()
	{
		int x1 = super.x, y1 = super.y, x2 = this.x, y2 = this.y;
		return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
	}

	public String toString()
	{
		return "直线端点：[" + super.x + "," + super.y + "][" + x + "," + y + "]直线长度：" + this.length();
	}

	public int getX()
	{
		return x;
	}

	public int getY()
	{
		return y;
	}

	public void setX(int x)
	{
		this.x = x;
	}

	public void setY(int y)
	{
		this.y = y;
	}
}

💖 测试类 LineDemo.java

// LineDemo.java
public class LineDemo
{
	public static void main(String args[])
	{
		Line line = new Line(50, 50);
		System.out.println("\n" + line.toString());
	}
}

🏆 运行结果

直线端点：[50,50][100,100]直线长度：70.71067811865476

😴 结果分析

勾股定理计算两点间的欧几里得距离

4. 分析程序运行结果

💖 源代码

文件名：Test.java

class A
{
	int sum, num1, num2;

	public A()
	{
		num1 = 10;
		num2 = 20;
		sum = 0;
	}

	void sum1()
	{
		sum = num1 + num2;
		System.out.println("sum=" + num1 + "+" + num2 + "=" + sum);
	}

	void sum2(int n)
	{
		num1 = n;
		sum = num1 + num2;
		System.out.println("sum=" + num1 + "+" + num2 + "=" + sum);
	}
}

class B extends A
{
	int num2;

	public B()
	{
		num2 = 200;
	}

	void sum2()
	{
		sum = num1 + num2;
		System.out.println("sum=" + num1 + "+" + num2 + "=" + sum);
	}

	void sum2(int n)
	{
		num1 = n;
		sum = num1 + num2;
		System.out.println("sum=" + num1 + "+" + num2 + "=" + sum);
	}

	void sum3(int n)
	{
		super.sum2(n);
		System.out.println("sum=" + num1 + "+" + num2 + "=" + sum);
	}
}

public class Test
{
	public static void main(String arg[])
	{
		B m = new B();
		m.sum1();
		m.sum2();
		m.sum2(50);
		m.sum3(50);
	}
}

🌸 运行结果

sum=10+20=30
sum=10+200=210
sum=50+200=250
sum=50+20=70
sum=50+200=70