黑马程序员_面向对象(2)

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

   

     面向对象特征之三：多态

   1，什么是多态：

          多态，顾名思义，就是多种形态。在java语言中体现如下：

      类中多个方法的重载叫多态，父子类中方法的覆盖也叫多态。

      因此多态有两种体现：一个是方法的重装，一个是方法的覆盖。

     多态有方法的多态和对象的多态（一个对象多种形态）。
     多态的前提：将子类对象当作父类对象来看，
     体现在代码上就是Animal a=new Dog(....);
      所有的多态可以归结为两个定理：
           (1).可以把子类对象当作父类对象来看，一旦这样做了，就只能去调用父类中原有定义的属性和方法，
也就是子类中扩展的方法或属性就不能调用了。
           (2).当我们把子类对象当作父类对象来看的时候，如果子类覆盖了父类中的方法，在调用的时候实际调

用的是子类覆盖后的方法。

 

 (1).多态的体现
   父类的引用指向了自己的子类对象，这就是多态的体现。
 (2).多态的前提
    必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提就是存在覆盖。
 (3).多态的好处以及弊端
    多态的出现大大的提高了程序的扩展性。只能使用父类的引用访问父类中的成员。

以下代码体现多态的应用：

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 kanJia(){
		System.out.println("看家");
	}
}
class Pig extends Animal{
	public void eat(){
		System.out.println("饲料");
	}
	public void gongDi(){
		System.out.println("拱地");
	}
}

public class ToObjectDemo07 {

	public static void main(String[] args) {
		//Cat c=new Cat();
		//c.eat();
		
		//Dog d=new Dog();
		//d.eat();
		//Animal a=new Cat();
		//function(a);
		//a=new Dog();
		//function(a);
		//a=new Pig();
		//function(a);
		Animal a=new Cat();//类型提升，向上转型。
		a.eat();
		//如果想要调用猫特有的方法时，如何操作？
		//强制将父类的引用，转换成类类型。向下转型。
		Cat c=(Cat)a;
		c.catchMouse();
		//千万不要出现这样的操作，将父类对象转成子类类型。
		//我们能转换的是指向了子类对象的父类引用。
		//多态自始至终都是子类对象在做着变化。
	}
	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 void function(Pig p){
		p.eat();
	}
	*/
}

Object类：

  java中所有对象的直接或者间接父类，就是传说中的上帝类。
  该类中定义的肯定是所有对象都具备的功能。
  java认为所有的对象都具备比较性。
  Object类中已经提供了对对象是否相同的比较方法。
  如果自定义类中也有比较相同的功能，没有必要重新定义，只要沿袭父类中的
  功能，建立自己特有的比较内容即可，这就是覆盖

class Demo{
	private int num;
	Demo(int num){
		this.num=num;
	}
	public boolean compare(Demo d){
		return this.num==d.num;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Demo))
			return false;
		Demo d=(Demo)obj;
		return this.num==d.num;
	}
}

	

public class ToObjectDemo10 {

	public static void main(String[] args) {
	Demo d1=new Demo(4);
	Demo d2=new Demo(6);
	//Demo d3=d1;
	System.out.println(d1.compare(d2));//false
	//System.out.println(d1.equals(d3));//true  比较的是地址值。
	
	}

}

面向对象内部类及其访问规则：

 1.内部类可以直接访问外部类中的成员，包括私有。
    之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用1，格式  
    外部类名.this
   2.外部类要访问内部类，必须建立内部类对象。
     当内部类被static修饰后，，只能直接访问外部类中的静态成员了。出现了访问局限。
     在外部其他类中如何直接访问静态内部类的非静态成语呢？
     new Outer.Inner().function();
     在外部其他类中如何直接访问静态内部类的静态成员呢?
    Outer.Inner.function();
    注意：当内部类中定义了静态成员，该内部类必须是静态的。
    当外部类中的静态方法访问内部类时，内部类必须是静态的。
    当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为
    内部事物在使用外部事物的内容。

class Outer{
	private int x=3;
	 class Inner{//内部类,成员内部类可以被各种修饰符修饰。还可以被静态修饰。
		//就称其为静态内部类，
		int x=4;
		void function(){
			int x=6;
			System.out.println("inner :"+this.x+Outer.this.x+x);
			//Outer.this代表了Outer中的成员。
		}
	}
	void method(){
		System.out.println(x);
		Inner in=new Inner();
		in.function();
	
	}
	
	public static void show(){
		new Outer().new Inner().function();
	}
}

public class ToObjectDemo11 {

	public static void main(String[] args) {
		Outer out=new Outer();
		out.method();
		//直接访问内部类中的成员,私有修饰的不能访问。
		Outer.Inner in=new Outer().new Inner();
		in.function();
		Outer.show();

	}

}