黑马程序员——第八天（Java面向对象-多态）

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

一.面向对象（多态-概念）

多态：可以理解为事物存在的多种体现形态

人：男人、女人

动物：猫、狗

猫 x = new 猫();
动物 x = new 猫();

函数：（多态性）

重载 覆盖 

二.面向对象（多态-扩展性）

1.多态的基本体现

父类的引用指向了自己的子类对象

父类的引用也可以接收自己的子类对象 

2.多态的前提

必须是类与类之间有关系，要么继承，要么实现

通常还有一个前提，存在覆盖

前期预先调用功能，后期定义子类去实现功能并把子类作为属性传进来

3.多态的好处
多态的出现打打的提高了程序的扩展性

4.多态的彼弊端

提高了扩展性，但是只能使用父类的引用访问父类的成员

5.多态的应用

6.多态的出现 代码中的特点（多态使用的注意事项）

 

/*
	动物
	猫狗

*/
abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	@Override
	public void eat(){
		System.out.println("吃鱼");
	}
	public void carchMouse(){
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal{
	@Override
	public void eat() {
		System.out.println("吃骨头");
	}
	public void KanJia(){
		System.out.println("看家");
	}
}

class Pig extends Animal{
	@Override
	public void eat() {
		System.out.println("饲料");
	}
	public void gong(){
		System.out.println("拱地");
	} 
}
public class DuoTaiDemo {
	public static void main(String[] args) {
		function(new Cat());
		function(new Dog());
		function(new Pig());
	}
	public static void function(Animal animal){//Animal animal = new Cat();/Dog()/Pig()
		animal.eat();
	}
}

三.面向对象（多态-转型）

		Animal animal = new Cat();//类型提升，向上转型
		animal.eat();
		//如果想要调用猫的特有方法，如何操作？
		//强制将父类的引用，转成子类类型，向下转型
		Cat cat = (Cat) animal;
		cat.carchMouse();
		//千万不要出现这样的操作，就是将父类对象转成子类类型
		//我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换
		//多态至始至终都是子类对象在做着变化

判断某一类型引用指向的对象 到底符合什么类型的时候 用instanceof

instanceof什么时候可以用呢？
用来判断所属类型 判断以后 就可以用这个所属类型的方法

1.子类是有限的（比如说人  ，  要么男人  要么女人）

2.当传的类型 需要进行其它操作

四.面向对象（多态-示例）

五.面向对象（多态中成员的特点）

在多态中(父类引用指向子类对象)，成员函数的特点：（非静态的方法）

在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败

在运行时期，参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。 

在多态中，成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边

静态   静态绑定

非静态 动态绑定

六.面向对象（多态的主板示例）

interface PCI{
	public void open();
	public void close();
}
class NetCard implements PCI{
	@Override
	public void open() {
		System.out.println("netcard open");
	}
	@Override
	public void close() {
		System.out.println("netcard close");
	}
	
}
class SoundCard implements PCI{
	@Override
	public void open() {
		System.out.println("SoundCard open");
	}
	@Override
	public void close() {
		System.out.println("SoundCard close");
	}
	
}
class MainBoard{
	public void run(){
		System.out.println("MainBoard run");
	}
	public void usePCI(PCI p){//PCI p = new NetCard(); 接口型引用指向自己的子类对象 （多态）
		if(p!=null){
			p.open();
			p.close();
		}
	}
}
class DuoTaiDemo5{
	public static void main(String[] args) {
		MainBoard mainBoard = new MainBoard();
		mainBoard.run();
		mainBoard.usePCI(null);
		mainBoard.usePCI(new NetCard());
		mainBoard.usePCI(new SoundCard());
	}
}
//接口的出现 增加了功能扩展   同时多态的应用提高了程序的扩展性
//Debug卡 02显卡   03内存  04网卡   08芯片坏了
//接口降低了耦合性  提高了可扩展性   提供了规则

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

/*
	需求：数据库的操作
数据是：用户信息
1.连接数据库	JDBC Hibernate(框架)
2.操作数据库.
	C	create
	R	read
	U	update
	D	delete
3.关机数据库连接

DAO	数据访问对象
D	data
A	access
O	object

*/
class User{
	
}
interface UserInfoDAO{
	public void add(User user);
	public void delete(User user);
}
class UserInfoByJDBC 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.关闭链接
	}
}



public class DBOperate {
	public static void main(String[] args) {
//		UserInfoByJDBC ui = new UserInfoByJDBC();
		UserInfoDAO ui = new UserInfoByHibernate();
		User user = new User();
		ui.add(user);
		ui.add(user);
	}
}

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

/*	
	构造函数的第一行  都是隐式的  super()语句
	都会去访问父类	extends Object  
	是类层次结构的根类 （上帝）每个类都使用Object作为超类
	该类中定义的肯定是所有对象都具备的功能   不断的抽取成 
	
	Java认为所有的对象 都具备比较性  比较两个对象是否相同 equals
	Object 类中已经提供了对象是否相同的比较方法
	如果自定义类中 也有比较相同的功能  没有必要重新定义
	只要沿袭父类中的功能，建立自己特有的比较内容即可，这就是覆盖
*/
class Demo1{// extends Object 
	/*public Demo1() {
		super();
	}*/
	private int num ;
	Demo1(int num){
		this.num = num;
	}
	public boolean compare(Demo1 d){
		return this.num == d.num;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Demo1))
			return false;
//			throw new RuntimeException("不是Demo1类型的变量");
		return this.num == ((Demo1)obj).num;
	}
} 
class Person{
}
public class ObjectDemo {
	public static void main(String[] args) {
		Demo1 d1 = new Demo1(4);
		Demo1 d2 = new Demo1(5);
		Person p = new Person();
		
//		System.out.println(d1.compare(d2));
		System.out.println(d1.equals(p));
	}
}

九.面向对象（Object类-toString()）

所有对象都应该能够变成字符串 并打印

toString()源码

getClass().getName() + '@' + Integer.toHexString(hashCode())

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