毕向东——JAVA基础——多态、接口、抽象

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/yaocong1993/article/details/79971383

    本篇文章讲得内容其实很简单,虽然在课程视频中讲了一天,就是为了让学生更好的体会继承、接口、多态的应用。

    主要包括:多态时调用的成员到底指父类还是子类中的成员(3);类型转换(1);将类中共同的方法抽取为接口或抽象类,提高了程序的可拓展性(1、2、4、5),当有新类创建时,在main函数中改动较少。    

1、可扩展性、类型转换

abstract class Animal
{
	abstract void eat();
}

class Cat extends Animal
{
	public void eat()
	{
		System.out.println("吃鱼");
	}
	public void catchMouse()
	{
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal
{
	public void eat()
	{
		System.out.println("啃骨头");
	}
	public void seeHouse()
	{
		System.out.println("看家");
	}
}

class AnimalDemo
{
	public static void function(Animal a)//多态,提高扩展性
	{
		a.eat();
	}

	public static void main(String[] args) 
	{
			Animal a=new Cat();//类型提升,向上转型
			function(a);
			//调用子类特有方法
			Cat c=(Cat)a;//向下转型,强制将父类引用转换为子类类型
			c.catchMouse();
	}
}

2、多态练习

/*
基础班学生:吃饭,睡觉
高级班学生:吃饭,睡觉
将两类事物的共同功能进行抽取
*/

abstract class Student 
{
	public abstract void study();
	public void sleep()
	{
		System.out.println("躺着睡");
	}
}

class BaseStudent extends Student
{
	public void study()
	{
		System.out.println("学基础课");
	}
	public void sleep()
	{
		System.out.println("坐着睡");
	}
}

class AdvStudent extends Student
{
	public void study()
	{
		System.out.println("学进阶课");
	}
}

class DoStudent
{
	public void doSome(Student stu)
	{
		stu.study();
		stu.sleep();
	}
}

class StudentDemo
{
	public static void main(String[] args) 
	{
		DoStudent s=new DoStudent();
		s.doSome(new BaseStudent());
		s.doSome(new AdvStudent());
	}
}

    比4、5更进一步,把抽象类中方法覆盖后,又将其运行封装在一起。需要这样做吗?

3、多态中成员的特点

    在多态中,非静态方法成员:编译时看引用变量所属类中的方法,如该方法不存在,则编译失败;运行时看对象所属类的方法,如有覆盖,运行子类方法。

    对于变量和静态方法,均看引用变量所属类。

class Fu
{
	int num=1;
	void method_1()
	{
		System.out.println("fu method1");
	}
	void method_2()
	{
		System.out.println("fu method2");
	}
	static void method_4()
	{
		System.out.println("fu method4");
	}
}

class Zi extends Fu
{
	int num=2;
	void method_1()
	{
		System.out.println("zi method1");
	}
	void method_3()
	{
		System.out.println("zi method3");
	}
	static void method_4()
	{
		System.out.println("zi method4");
	}
}

class DuotaiDemo 
{
	public static void main(String[] args) 
	{
		Fu f=new Zi();

		f.method_1();//调用子类method_1方法
		f.method_2();//调用父类method_2方法
		//f.method_3();//编译失败

		System.out.println(f.num);//打印父类中的num值1

		Fu f1=new Zi();
		f1.method_4();//调用父类method_4方法
		Zi z1=new Zi();
		z1.method_4();//调用子类method_4方法
	}
}

4、主板示例

//接口降低了耦合性,提高了程序扩展性
/*
需求:电脑运行实例
电脑运行基于主板。
*/

interface PCI
{
	public void open();
	public void close();
}

class MainBoard
{
	public void run()
	{
		System.out.println("run");
	}
	public void usePCI(PCI p)//接口型引用指向其子类对象,多态
	{
		if(p!=null)
		{
			p.open();
			p.close();
		}
	}
}

class NetCard implements PCI
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}

class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("soundcard open");
	}
	public void close()
	{
		System.out.println("soundcard close");
	}
}

class MainBoardDemo
{
	public static void main(String[] args) 
	{
		MainBoard mb=new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
	}
}

5、数据库操作

/*需求:数据库操作
数据是用户信息
1、连接数据库 JDBC Hinbernate
2、操作数据库
	CRUD增删改查
3、关闭数据库连接
*/

//两种连接方式功能相同,抽象为接口
interface UserInfoDao
{
	public void add(User user);
	public void delete(User user);
}

class UserInfoByJDBC implements UserInfoDao
{
	public void add(User user)
	{
	//JDBC连接数据库
	//使用sql添加语句添加数据
	//关闭连接
	}
	public void delete(User user)
	{
	//JDBC连接数据库
	//使用sql添加语句删除数据
	//关闭连接
	}
}

class UserInfoByHinbernate implements UserInfoDao
{
	public void add(User user)
	{
	//Hinbernate连接数据库
	//使用sql添加语句添加数据
	//关闭连接
	}
	public void delete(User user)
	{
	//Hinbernate连接数据库
	//使用sql添加语句删除数据
	//关闭连接
	}
}

class  DBOperate
{
	public static void main(String[] args) 
	{
		UserInfoDao ui=new UserInfoByJDBC();
		//连接方式发生变化时,main类只改new后面的对象
		ui.add(user);
		ui.delete(user);
	}
}

    4、5中两个以上类功能相同,将其功能抽取为接口,通过接口引用可以操作实现该接口的类的具体对象的功能。

    提高了程序的拓展性,在主方法中只用修改接口引用所指向的对象。

6、二次分发,学堂在线JAVA程序设计,郑莉老师

    也不知道自己写的合不合适,以后再来看吧。

/*二次分发double dispatching:
 * 对于交通工具,声明一个抽象类Vehicle及两个子类Bus和Car;
 * 对于司机,声明一个抽象类Driver及两个子类FamaleDriver和MaleDriver;
 * 在Driver类中声明了抽象方法drives,在两个子类中对该方法进行覆盖;
 * drives接收一个Vehicle类的参数,当不同类型的交通工具被传送到此方法时,
	可以输出具体的交通工具;
 * 所有类都放在drive包中。	
*/
public class DriverTest {

	public static void main(String[] args) {
		Driver fd=new FamaleDriver();
		Driver md=new MaleDriver();
		Bus b=new Bus();
		Car c=new Car();
		
		fd.drives(c); //A famale driver drives a car.
		md.drives(b); //A male driver drives a bus.
	}

}

abstract class Driver{
	String type="driver";
	public void drives(Vehicle v){
		System.out.print("A "+type+" drives a ");
		v.print();
	}
}

class FamaleDriver extends Driver{
	public FamaleDriver(){
		type="famale driver";
	}
}

class MaleDriver extends Driver{
	public MaleDriver(){
		type="male driver";
	}
}

abstract class Vehicle{
	public abstract void print();
	
}

class Bus extends Vehicle{
	public void print(){
		System.out.println("bus");
	}
}

class Car extends Vehicle{
	public void print(){
		System.out.println("car");
	}
}
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页