java之8天 多态

多态

/**
 * 多态: 可以理解为事物存在的多种体现形态
 * 
 * 人:男人 女人 动物 : 猫,狗
 * 
 * 猫 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 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 gondDi(){
		System.out.println("拱地");
	}
}
 
 
public class DuotaiDemo {
	public static void main(String[] args) {
		Cat c=new Cat();
		c.eat();
		Dog d=new Dog();
		d.eat();
		
		function(new Cat());
		function(new Dog());
		function(new Pig());
		
		
		// 父类的引用指向指向子类的对象
		Animal ac=new Cat();  //类型提升,向上转型  将猫转型 成父类型
		function(ac);
		
		Animal ad=new Dog();
		function(ad);
		
		//如果想要调用猫的特有方法时
		//强制父类的引用,装成子类型
		Cat cc=(Cat)ac;     //向下转型
		cc.catchMouse();
		
		
	}
	/*public static void function(Cat c){
		c.eat();
	}
	public static void function(Dog d){
		d.eat();
	}
	//一年后 养猪了 
	public static void function(Pig p){
		p.eat();
	}
	*/
	 
	//提高代码的扩展性   可以将下面的封装成一个 工具类 专门用来操作这一类对象的
	public static void function(Animal a){
		a.eat();
		
		//instanceof  :在子类是有限的时候可以判断 . 判断后 然后在应用其 特定的方法.
		if(a instanceof Cat)
			((Cat) a).catchMouse();
		else if(a instanceof Dog)
			((Dog) a).kanJia();
		else if(a instanceof Pig)
			((Pig) a).gondDi();
	}

//多态中成员的特点

/**
 * 多态中成员的特点 
 * 非静态成员函数: 成员函数在多态调用时,编译看着左边,运行看右边.
 * 
 * 成员变量: 都参考左边(应用类型所属的类)
 * 静态成员函数: 无论编译和运行 都参考左边
 * 
 */
class Fu {
	int num=5;
	static int num1=5;
	static final int num2=5;
	void method1() {
		System.out.println("Fu_method1");
	}

	void method2() {
		System.out.println("Fu_method2");
	}
	
	//静态
	static void method4() {
		System.out.println("Fu_method4");
	}
}

class Zi extends Fu {
	int num=8;
	static int num1=8;
	static final int num2=8;
	void method1() {
		System.out.println("Zi_method1");
	}

	void method3() {
		System.out.println("Zi_method3");
	}
	//静态
	static void method4() {
		System.out.println("Zi_method4");
	}
}

public class DuotaiDemo1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//方法
		Fu f=new Zi();
		f.method1();       //打印   Zi_method1
		f.method2();      //打印   Fu_method2
		//f.method3();编译失败
		f.method4();
		
		Zi z=new Zi();
		z.method1();       //打印   Zi_method1
		z.method2();      //打印   Fu_method2
		z.method3();     //打印   Zi_method3
		z.method4();
		
		
		//变量 
		Fu ff=new Zi();
		System.out.println(ff.num);     // 5
		System.out.println(ff.num1);    // 5
		System.out.println(ff.num2);    // 5
		
		Zi zz=new Zi();
		System.out.println(zz.num);    // 8
		System.out.println(zz.num1);  // 8
		System.out.println(zz.num2); // 8
		
		

	}

接口的特点

/**
 * 需求:
 * 电脑运行实例:
 * 电脑运行基于主板.
 * 
 * 多态应用
 * 接口:降低耦合性,提高程序的扩展性.提供了规则  
 */

class MainBoard1{
	public void run(){
		System.out.println("mainboard run");
	}
	//升级一
	public void userNetCard(NetCard1 c){
		c.open();
		c.close();
	}
}
//升级 一:要上网  怎么办?
class NetCard1{
	/**
	 * 发现 耦合性很高,如果要听音乐 ,需要 取下这个网卡 
	 */
	public void open(){
		System.out.println("NetCard open");
	}
	public void close(){
		System.out.println("NetCard close");
	}
}

//升级二 :要听音乐 (主板厂商 召集个功能卡开发商 开会 ,定义PCI插槽规则)
interface PCI{
	public void open();
	public void close();
}

class MainBoard{
	public void run(){
		System.out.println("mainBoard run");
	}
	
	public void userPCI(PCI p){  //接口的引用 执行 子类的对象
		if(p!=null){
			p.open();
			p.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");
	}
}



//测试
public class DuoTaiDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MainBoard1 mb1=new MainBoard1();
		mb1.run();
		//升级一
		mb1.userNetCard(new NetCard1());
		
		//升级二
		MainBoard mb=new MainBoard();
		mb.run();
		mb.userPCI(null);
		mb.userPCI(new NetCard());
		mb.userPCI(new SoundCard());
	}

}

多态的应用三:

/**
 * 需求: 数据库的操作
 * 数据是:用户信息
 * 1.连接数据库
 * 2.操作数据库 JDBC  HIBERNATE
 * 	 CRUD
 * 3.关闭数据库连接
 */
//升级三
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.关闭连接 
	 */
	}
	
}

//升级 1: 公司数采用  hibernate框架
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 DuoTaiDemo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		UserInfoByJDBC ui=new UserInfoByJDBC();
		ui.add(user);
		ui.delete(user);
		
		//升级 1: 公司要求采用  hibernate框架   发现修改代码的时候还是挺麻烦的
		UserInfoByHibernate uh=new UserInfoByHibernate();
		uh.add(user);
		uh.delete(user);
		
		//采用多态
		UserInfoDao ud=new UserInfoByHibernate();
		ud.add(user);
		ud.delete(user);
	}

}

Object中 几个 常用的方法

/**
 *Object 是所有对象的直接或者间接父类.该类定义的肯定是所有对象 所有具备的功能
 *
 *Object 中已经提供了对象是否相同的比较方法,我们只需要重写
 */
class Demo //extends Object
{
	Demo(){
		super();//默认调用 Object
    }  
	private int num;
	
	Demo(int num){
		this.num=num;
	}
	public boolean compare(Demo d){
		return this.num==d.num;
	}

	//使用Object 的比较方法
	public boolean equals(Object obj){ // Object obj=new Demo();
		if(!(obj instanceof Demo)) //判断类型
			return false;
		Demo d=(Demo)obj;  //向下转型
		return this.num==d.num;
	}
	
	public String toString(){
		return "Demo"+num;
	}
}
class Person{
	
}

public class ObjectDemo {
	public static void main(String[] args) {
		System.out.println("========equals===========");
		Demo d1=new Demo(4);
		Demo d2=new Demo(5);  
		Demo d3=d1;
		
		System.out.println(d1.equals(d2));
		System.out.println(d1==d2);
		System.out.println(d1==d3);
		
		Person p=new  Person();
		System.out.println(d1.equals(p));
		
		System.out.println("========toString===========");
		System.out.println(d1.toString()); //打印 d1所属类型  和 在内存地址中的值
		System.out.println(Integer.toHexString(d1.hashCode())); 
		
		Class c=d1.getClass();
		System.out.println(c.getName());
		System.out.println(c.getName()+"@"+Integer.toHexString(d1.hashCode()));
		
		System.out.println(d1.toString());
		
	}

}