黑马程序员---Java基础--08天(面向对象之三多态)

最新推荐文章于 2023-08-11 09:43:04 发布

MsLinux386

最新推荐文章于 2023-08-11 09:43:04 发布

阅读量421

点赞数

分类专栏： Java基础文章标签： class function hibernate user string

本文链接：https://blog.csdn.net/MsLinux386/article/details/7599705

版权

Java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

---------------------- android培训、java培训、期待与您交流！ ----------------------

1.面向对象(多态-概念)

2.面向对象(多态-扩展性)

/*
多态:可以理解为事物存在的多种体现形态.


人:男人 女人


动物:猫 狗.
猫 x = new 猫();
动物 x = new 猫();


1.多态的体现
	父类的引用指向了自己的子类对象.
	父类的引用也可以接受自己的子类对象.
2.多态的前提
	必须是类与类之间有关系,要么继承要么实现.
	通常还有一前提,就是存在覆盖.
3.多态的好处
	多态的出现大大的提高程序扩展性.
4.多态的弊端
	提高了扩展性,但是只能使用父类的引用访问父类中的成员
5.多态的应用
6，多态的出现代码中的特点(多态使用的注意事项)
*/


/*动物,
猫,狗
*/


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 KanJia()
	{
		System.out.println("看家");
	}
}


class Pig extends Animal
{
	public void eat()
	{
		System.out.println("饲料");
	}
	public void gongDi()
	{
		System.out.println("拱地");
	}
}
//-----------------------------------------
class  DuoTaiDemo
{
	public static void main(String[] args) 
	{
		Animal a = new Cat();
		a.eat();


		function(new Cat());
		function(new Dog());
		function(new Pig());


	}
	public static void function(Animal a)
	{
		a.eat();
	}
	/*
	public static void function(Cat c)//
	{
		c.eat();
	}
	public static void function(Dog d)
	{
		d.eat();
	}


	public static void function(Pig p)
	{
		p.eat();
	}
	*/
}

3.面向对象(多态-转型)

/*
第二个问题：如何使用子类特有方法。
*/
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 kanJia()
	{
		System.out.println("看家");
	}
}




class Pig extends Animal
{
	public void eat()
	{
		System.out.println("饲料");
	}
	public void gongDi()
	{
		System.out.println("拱地");
	}
}
class  DuoTaiDemo2
{
	public static void main(String[] args) 
	{
		//Animal a = new Cat();//类型提升.向上转型.
		//a.eat();
		
		//如果想要调用猫的特有方法时,如何操作?
		//强制将父类的引用.转成子类类型,向下转型.
		//Cat c = (Cat)a;
		//c.catchMouse();
		//千万不要出现这样的操作,就是将父类对象转成子类类型.
		//我们能转换的是父类应用指向了自己的子类对象时,该应用可以提升,也可以被强制转换.
		//多态自始至终都是子类对象在做着变化.


		Animal a = new Animal();
		Cat c=(Cat)a;


		
		毕姥爷 x = new 毕老师();


		x.讲课();


		毕老师 y = (毕老师)x;




		y.看电影();


		function(new Dog());
		function(new Cat());
	}
	public static void function(Animal a)
	{
		a.eat();


		if(a instanceof Cat)
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog d = (Dog)a;
			d.kanJia();
		}
		//instanceof :用于判断对象的类型.对象instanceof类型(类类型 接口类型)
	}
}

4.面向对象(多态-示例)

/*
基础班学生:学习,睡觉
高级班学生:学习,睡觉


可以将这两类事物进行抽取.
*/
abstract class Student
{
	public abstract void study();
	public void sleep()
	{
		System.out.println("躺着睡");
	}


}
class DoStudent
{
	public void doSome(Student stu)
	{
		stu.study();
		stu.sleep();
	}
}
class BaseStudent extends Student
{
	public void study()
	{
		System.out.println("base study");
	}
	public void sleep()
	{
		System.out.println("坐着睡");
	}
}
class AdvStudent extends Student
{
	public void study()
	{
		System.out.println("Adv study");
	}
	
}


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


//		BaseStudent bs = new BaseStudent();
//		bs.study();
//		bs.sleep();
//		AdvStudent as = new AdvStudent();
//		as.study();
//		as.sleep();
	}
}

5.面向对象(多态中成员的特点)

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


class  DuoTaiDemo4
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		System.out.println(f.num);//5


		Zi z = new Zi();
		System.out.println(z.num);//8


		f.method1();//zi
		f.method2();//fu
		//f.method3();


		Fu f = new Zi();
		System.out.println(f.num);//5
		f.method4();//Fu


		Zi z = new Zi();
		z.method4();


/*
在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法.如果有,编译通过,如果没有编译失败.
在运行时期:参阅对象所属的类中是否有调用的方法.
简单总结就是:成员函数在多态调用时,编译看左边,运行看右边.


在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类).


在多态中,静态成员函数的特点:
无论编译和运行,都参考左边.
*/


	}
}

6.面向对象(多态的主板示例)

/*
需求:
电脑运行实例,
电脑运行基于主板.
*/


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


class MainBoard 
{
	public void run()
	{
		System.out.println("MainBorad run");
	}
	public void usePCI(PCI p)//PCI p = new NetCard();//接口型引用指向自己的子类对象.


	{
		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 MainBorad
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void useNetCard(NetCard c)
	{
		c.open();
		c.close();
	}
} 
class NetCard
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}
*/
class  DuoTaiDemo5
{
	public static void main(String[] args) 
	{
		MainBorad mb = new MainBorad();
		mb.run();
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
	}
}

7.面向对象(多态的扩展示例)

/*
需求:数据库的操作.
数据是:用户信息.
1.连接数据库.JOBC Hibernate
2.操作数据库
增删改查 insert delete alter select
3.关闭数据库连接
*/
interface UserInfoDao
{
	public void add(User user);
	public void delete(User user);
}
class UserforByJDBC implements UserInfoDao
{
	public void add(User user)
	{
		1,JDBC连接数据库。;
		2，使用sql添加语句添加数据。;
		3，关闭连接。
	}
	public void delete(User user)
	{
		1,JDBC连接数据库。;
		2，使用sql添加语句删除数据。;
		3，关闭连接。
	}
}
class UserInfoByHibernate implements UserInfoDao
{
	public void add(User user)
	{
		1,Hibernate连接数据库。;
		2，使用sql添加语句添加数据。;
		3，关闭连接。
	}
	public void delete(User user)
	{
		1,Hibernate连接数据库。;
		2，使用sql添加语句删除数据。;
		3，关闭连接。
	}
}
class DBOperate 
{
	public static void main(String[] args) 
	{
		//UserInfoByJDBC ui = new UserInfoByJDBC();
		//UserInfoByHibernate ui = new UserInfoByHibernate();


		UserInfoDao ui = new UserInfoByHibernate();
		ui.add(user);
		ui.delete(user);
	}
}

8.面向对象(Object类-equals())

9.面向对象(Object类toString())

/*
Object:是所有对象的直接或者间接父类,传说中的上帝.
该类中定义的肯定是所有对象都具备.




Object类中已经提供了对对象是否相同的比较方法.


如果自定义类中也有比较相同的功能,没有必要重新定义.
只要沿袭父类中的功能,建立自己特有比较内容即可.这就是覆盖.
*/
class Demo
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Demo))
		{
			return false;
		}
		Demo d = (Demo)obj;
		return this.num == d.num;
	}
	/*
	public boolean compare(Demo d)
	{
		return this.num == d.num;
	}
	*/
	public String toString()
	{
		System.out.println("demo="+num);
	}
}
class  
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo(4);
		System.out.println(d1);//输出语句打印对象时,会自动调用对象的toString方法.打印对象的字符串表现形式.


		Demo d2 = new Demo();
		System.out.println(d2.toString());
		//Demo d2 = new Demo(5);


		
		//Class c = d1.getClass();
		//System.out.println(c.getName());
		//System.out.println(c.getName+"@@"+Integer.toHexString(d1.hasCode()));
		//System.out.println(d1.toString());
		//Person p = new Person();
		//System.out.println(d1.equals(p));
	}
}

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima

MsLinux386

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员---Java基础--08天(面向对象之三多态)

---------------------- android培训、java培训、期待与您交流！ ----------------------1.面向对象(多态-概念)2.面向对象(多态-扩展性)/*多态:可以理解为事物存在的多种体现形态.人:男人女人动物:猫狗.猫 x = new 猫();动物 x = new 猫();1.多态
复制链接

扫一扫