java的面向对象及多态

多态的定义： 就是一种事物的多种形态

多态的前提： 1. 有类的封装 2. 有类与类之间，继承关系的存在， 3. 父类引用指向子类对象。

练习 代码实现多态关系

创建 一个Animal 动物类
再创建一个 Cat 类。继承于 Animal 类。
	猫类和动物类，都实现吃饭的方法。

在测试类中，创建 Cat 类的对象。
	但是要父类引用，指向子类对象的方式。
	调用cat 类的方法。

4， 多态关系中，成员访问的特点。

多态关系中：成员访问的特点：

成员变量： 编译看左边，运行看左边		跟着父类走
成员方法： 编译看左边，运行看右边 		跟着子类走
静态方法： 编译看左边，运行看左边		跟着父类走
		
	public class Animal {
		public String name  = "神秘动物";
		public  int age;
		public static void sleep(){
			System.out.println("动物会睡觉！");
		}
		public void eat(){
			System.out.println("动物会吃东西！");
		}
	}

	/**
	 * 猫类，继承于动物类。
	 */
	public class Cat extends Animal {
		public String name  = "小花猫";
		public int age;
		public static void sleep(){
			System.out.println("猫会睡觉！");
		}
		public void eat(){
			System.out.println("猫喜欢吃鱼！");
		}
	}


	public class Test1 {
		public static void main(String[] args) {
			Cat c = new Cat();  // 猫是一只 猫
			System.out.println(c.name);
			c.eat();
			c.sleep();
				
			//父类引用创建子类对象的方式，创建对象，称之为多态。
			Animal a =  new Cat();	//把猫添加到动物引用。	猫是一只动物
			System.out.println(a.name);
			a.eat();
			a.sleep();
			
		}
	}

5，利用多态的特点，实现方法的重写。

当我们想使用父类的 属性的时候，可以用多态，或创建父类对象。
当我们想使用父类里面的静态方法的时候， 可以使用多态，或创建父类对象
当我们想使用子类中重写的方法的时候， 可以用多态，或创建本类对象

 当我们既向用父类的属性，和静态方法	！
 又想使用自己特有的方法的时候	！
 可以多态的形式创建对象——> 
							父类引用指向子类对象。

6，封装一个父类 father 一个子类，son
子类重写父类的方法。 print 打印方法。 手抄 int num =10
子类里面有独有的方法内容。 打印机打印。 int num = 2000;

	测试的是  多态创建对象的情况下， 成员方法访问特点。

	public class Father{		//封装的类
		int num = 10;
		public void print(){
			System.out.println("使用手抄的形式打印");
		}
	}
	public class Son extends Father{	//产生继承关系
		int num = 2000;
		public void print(){	//方法的重写
			System.out.println("使用打印机的方式打印");
		}		
	}
	public class Test{
		public static void main(String[] args){
			Father f = new Son();		//多态的形式创建对象，父类引用指向子类对象
			f.print();
			System.out.println("每小时可以打印份数为："+ f.num);
		}
	}

练习： 超人的练习

	定义一个普通人的类。
			String name = "andy";
			封装一个谈生意的方法。谈10块钱的小单子 talk			
	定义一个超人的类，继承于 普通人的类，
			String name ="SuperMan";
			重写谈生意的方法，谈一个亿的大生意  talk		
			超人类特有方法，会飞 fly
	测试类，测试多态情况下的对象，访问成员方法。
	
	public class Test2{
		public static void main(String[] args){
			Man m = new SuperMan();
			m.talk();
			m.fly();
			System.out.println(m.name);
		}
	}
	class Man{
		String name = "小帅";
		public void talk(){
			System.out.println(name+"谈10块钱的大单子");
		}
	}
	class SuperMan extends Man{
		String name = "超人";
		public void talk(){
			System.out.println(name+"谈1个亿的小单子");
		}
		public void fly(){
			System.out.println("飞出去，谈小单子！");
		}
	}

7，多态向上转型和向下转型的问题

	多态的形成，本身就是父类引用指向子类对象
		就是向上转型的操作		右侧的对象，向上转型为左侧的引用。
	
	向下转型： 类似于基本数据类型的强制转换。
			把父类，强制转化为子类对象。

Animal a = new Cat(); //猫类向上转型为动物类
Cat c = (Cat) a; //动物类向下转型为猫类