黑马程序员_java面向对象(二)

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

一：多态

      ①多态的体现
         父类的引用指向了自己的子类对象
         父类的引用也可以接受自己的子类对象
      ②多态的前提
         必须是类与类之间有关系，要么继承、要么实现
         通常还有一个前提：存在覆盖
      ③多态的好处
         多态的出现打打的提高了程序的扩展性
      ④多态的弊端
         虽然提高了扩展性,但是只能使用父类的引用去访问父类中的成员

abstract class Student
{
	abstract public void show();
	public void sleep()
	{}
}

class BaseStudent extends Student
{
	public  void show()
	{
		System.out.println("base student");
	}
	public void sleep()
	{
		System.out.println("躺着睡。。");
	}
}

class AdvStudent extends Student
{
	public  void show()
	{
		System.out.println("advanced student");
	}
	public void sleep()
	{
		System.out.println("座着睡。。");
	}
}

class DuotaiDemo1
{
	public static void main(String[] args)
	{
		//BaseStudent bs=new BaseStudent();
		//bs.show();
		//bs.sleep();

		//StudentDo(new BaseStudent());
		//StudentDo(new AdvStudent());

		DoStudent ds=new DoStudent();
		ds.studentDo(new BaseStudent());
		ds.studentDo(new AdvStudent());
	} 

    /*  //将此方法做成一个工具类
		public static void StudentDo(Student s)
		{
			s.show();
			s.sleep();
		}	
	*/	
}

class DoStudent
{
	public static void studentDo(Student s)
	{
		s.show();
		s.sleep();
	}	
}

 

二：多态的应用及注意事项

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

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

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

class Fu
{
	static int num_1=5;
	int num_2=30;
	public void method1()
	{
		System.out.println("fu_method_1");
	}

	public void method2()
	{
		System.out.println("fu_method_2");
	}

	public static void method4()
	{
		System.out.println("fu_method_4");
	}

}

class Zi extends Fu
{
	static int num_1=8;
	int num_2=20;
	public void method1()
	{
		System.out.println("zi_method_1");
	}

	public void method3()
	{
		System.out.println("zi_method_3");
	}

	public static void method4()
	{
		System.out.println("zi_method_4");
	}
}

class DuotaiDemo2
{
	public static void main(String[] args)
	{
		//多态情况
		Fu f=new Zi();
		f.method1();    //zi_method_1
		f.method2();    //fu_method_2  子类没有那就继承父类
		//f.method3();   成员函数在多态调用时，编译看左边(父类没有method3()方法,所以编译失败),运行看右边
		f.method4();    //fu_method_4  在多态中静态成员函数的特点：无论编译和运行,都参考左边(父类)   
		
		//在多态中成员变量的特点：无论编译和运行,都参考左边(引用型变量所属的类)
		System.out.println(f.num_1);  //5
		System.out.println(f.num_2);  //30 

		System.out.println("----------------");

		//非多态情况
		Zi z=new Zi();
		z.method1();    //zi_method_1
		z.method2();    //fu_method_2
		z.method3();    //zi_method_3
		z.method4();    //zi_method_4
		System.out.println(z.num_1);  //8
		System.out.println(z.num_2);  //20
	}
}   

 

abstract class Animal
{
	abstract void eat();
}

class Cat extends Animal
{
	public void eat()
	{
		System.out.println("eat fish");
	}

	public void catchMouch()
	{
		System.out.println("catch mouch");
	}
}

class Dog extends Animal
{
	public void eat()
	{
		System.out.println("eat bone");
	}

	public void lookHome()
	{
		System.out.println("look home");
	}
}

class Pig extends Animal
{
	public void eat()
	{
		System.out.println("eat  siliao");
	}

	public void gongDi()
	{
		System.out.println("gogn di");
	}
}

class  DuotaiDemo
{
	public static void main(String[] args) 
	{
		function( new Cat() );
	    // Animal a=new Cat(); 类型提升,向上转型
		//  Cat c=(Cat)a; (强制将父类的引用转成子类类型,向下转型)

		/*
			千万不要出现如下操作,即将父类对象转成子类类型
			Animal a=new Animal();
			Cat c=(Cat)a;  这是错误的

			多态至始至终都是子类对象在做着变化
			我们能转换的是父类引用指向了自己子类的对象时,该引用可以被提升,也可以被强制转型
		*/
	}

	public static void function(Animal a)
	{
		a.eat();
	    //当想调用子类的方法时,可以这样处理
		if(a instanceof Cat)  //a==Cat,错误的处理方式, a为对象,此时可以使用instanceof 来处理
		{
			Cat c=(Cat)a;
			c.catchMouch();

			//等价于  Animal a=new Cat();
			//		  Cat c=(Cat)a
			//		  c.catchMouch();
		}
		else if(a instanceof Dog)
		{
			Dog d=(Dog)a;
			d.lookHome();
		}
		else if(a instanceof Pig)
		{
			Pig p=(Pig)a;
			p.gongDi();
		}
	}
}

 

三：内部类及匿名内部类

       内部类的访问规则：
          ①内部类可以直接访问外部类中的成员，包括私有成员
             之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式：外部类名.this
          ②外部类要访问内部类，必须建立内部类对象

          ③在外部的其它类中如何访问内部类,访问格式：
              外部类名.内部类名 变量名= 外部类对象 . 内部类对象,eg：
             Outer.Inner in=new Outer().new Inner();
          ④当内部类在成员位置上,就可以被成员修饰符所修饰,如
              private 将内部类在外部类中进行封装
              static 内部类就具备static的特性(此时静态内部类就只能访问外部类的静态成员了)

             a:在外部其它类中,如何直接访问static内部类的非静态成员?
                   new  Outer.Inner().function();
             b:在外部其它类中,如何直接访问static内部类的静态成员?
                   Outer.Inner.function();

             注意：当内部类中定义了静态成员，该内部类必须是static的
                       当外部类中的静态成员访问内部类时，内部类必须是静态的

class Outer
{
	private  int x=3;

	class Inner
	{
		int x=4;
		public void function()
		{
			int x=5;
			//内部类可以直接访问外部类中的成员，包括私有成员
			System.out.println("innner_1="+x);  //输出：5

			System.out.println("innner_1="+this.x);  //输出：4

			System.out.println("innner_1="+Outer.this.x);  //输出：3
		}
	}

	void method()
	{
		//外部类要访问内部类，必须建立内部类对象
		Inner in=new Inner();
		in.function();
	}
}

class InnerClassDemo
{
	public static void main(String[] args)
	{
		//直接访问内部类中的成员
		Outer.Inner in=new Outer().new Inner();
		in.function(); //程序输出  inner=3
	}
}

 

     内部类定义在局部时
          ①不可以被成员修饰符修饰
          ②可以直接访问外部类中的成员，因为还持有外部类中的引用
             但是不可以访问它所在局部中的变量，只能访问被final修饰的局部变量

 

     匿名内部类：
          ①匿名内部类其实就是内部类的简写格式
          ②定义内部类的前提：
                内部类必须是继承一个类或者实现接口
          ③匿名内部类的格式：
              new 父类或接口()
              {
                   定义子类的内容;
              }
           ④其实匿名内部类就是一个匿名子类对象,而且这个对象有些胖,可以理解为带内容的对象
           ⑤匿名内部类中定义的方法最好不要超过3个

abstract class AbsInner
{
	abstract void show();
}
class Outer
{
	private int x=3;
	/*
		class Inner extends AbsInner
		{
			void show()
			{
				System.out.println("x=="+x);
			}
		}	
	*/
	public void function()
	{
		//new Inner().show();      方法①

		//AbsInner ai=new Inner(); 方法②
		//ai.show();

		AbsInner ai=new AbsInner()  //注意不要少打了 " () "
		{
			void show()
			{
				System.out.println("x=="+x);
			}
			void show1()
			{
				System.out.println("hello");
			}
		};   //这一步等价于方法②
		ai.show();
		//ai.show1();  

		/*
			虽然子类对象有show1()方法,但是由于是多态,父类引用,
			而父类AbsInner没有show1()方法 所以编译不通过
		*/		
	}
}

class InnerClassDemo3
{
	public static void main(String[] args)
	{
		Outer out=new Outer();
		out.function();
	}
}

 

 

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