对象的上转型对象，接口回调

最新推荐文章于 2024-01-24 16:36:57 发布

原创最新推荐文章于 2024-01-24 16:36:57 发布 · 1k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#java #转型 #对象

Java 专栏收录该内容

7 篇文章

订阅专栏

本文详细介绍了Java中的继承和接口的概念。通过实例演示了如何创建上转型对象，解释了对象在进行向上转型后能访问哪些成员。此外，还介绍了接口的基本语法及其实现方式，并通过具体案例展示了接口回调的过程。

初学者。

A类是B类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中，则称对象a是对象b的上转型对象。

一般来说，有两种方法：

A a;
a = new B();

或：

A a;
B b = new B();
a = b;

上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。举个例子比较清楚：

class animal
{
	int m = 100;
	void print(String s)
	{
		System.out.println(s);
	}
}
class people extends animal
{
	double m = 25.5;
	void print(String s)
	{
		System.out.println("Look," + s);
	}
}
public class first
{
	public static void main(String args[])
	{
		/* 还可以 animal monkey;
		 *        people p = new people();
		 *        monkey = p;
		 */
		animal monkey;
		monkey = new people();
		
		System.out.println(monkey.m);   //对象monkey操作的是父类中的变量m
		monkey.print("I don't know.");  //对象monkey调用的是父类中的print()
	}
}

输出：

100
Look,I don't know.

接口

接口声明：interface 接口的名字

接口体中只有抽象方法，未修饰方法默认为public abstract 方法。接口中只有常量，不能有变量。未加final关键字修饰的，默认为常量。

一个类可以使用implements实现一个或者多个接口（这和类的继承不同。java中类只能单继承）。一个类实现接口，必须重写该接口中所有的方法，且必须遵守重写规则，不可以降低方法权限。

公共接口可被任何一个类实现，友好接口只能被同一个包中的类声明实现。

如果一个类声明实现一个接口，并没有重写接口中所有的方法，则这个类必须是abstract类。

举个例子(包括接口回调）：

interface Favourite
{
	void FavouriteFood();
	void FavouriteSport();
}
class Lee implements Favourite
{
	public void FavouriteFood()   //接口中的方法默认public abstract,重写不能降低权限
	{
		System.out.println("Lee最爱牛肉");
	}
	public void FavouriteSport()
	{
		System.out.println("Lee最爱篮球");
	}
}
class Wang implements Favourite
{
	public void FavouriteFood()
	{
		System.out.println("Wang最爱米饭");
	}
	public void FavouriteSport()
	{
		System.out.println("Wang最爱足球");
	}
}
public class third
{
	public static void main(String args[])
	{
		//下面将进行接口回调，感觉跟一般对象调用方法时差不多
		Favourite m1 = new Lee();
		Favourite m2 = new Wang();
		m1.FavouriteFood();
		m2.FavouriteFood();
		m1.FavouriteSport();
		m2.FavouriteSport();
	}
}

输出：

Lee最爱牛肉
Wang最爱米饭
Lee最爱篮球
Wang最爱足球

另外，补充一下方法重载与方法重写。

class Aaaa
{
	double f(double x, double y)
	{
		return x + y;
	}
}
class Bbbb extends Aaaa
{
	double f(int x, int y)   //由于方法f（）中参数发生了变化，这是方法重载。方法重写的话，方法类型，方法名以及方法中参数都要与父类保持一致
	{
		return x * y;
	}
}
public class val
{
	public static void main(String args[])
	{
		Bbbb b = new Bbbb();
		System.out.println(b.f(3, 5));
		System.out.println(b.f(3.0, 5.0));
	}

}

输出：