JAVA开发之旅（九）###面向对象（多态）###

###面向对象（多态）###

1.多态：即为对象的多种形态（集成是多态实现的基础）

    1）引用的多态：父类的引用可以指向本类的对象

                                  父类的引用可以指向子类的对象

    2）方法的多态：创建本类对象时，调用的方法为本类方法

                                  创建子类对象时，调用的方法为子类重写的方法或者继承的方法

public class Animal {
	public void eat() {
		System.out.println("动物饿了就吃。。。");
	}
}

public class Dog extends Animal {
	public void eat() {
		System.out.println("狗狗爱吃骨头。。。");
	}
}

package duotai.example;

public class Cat extends Animal {

}

public class Initail {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal d1 = new Animal();
		Animal d2 = new Dog();//父类的引用是可以指向子类对象的	
		Animal c1 = new Cat();
		d1.eat();
		d2.eat();
		c1.eat();
	}
}

 

2.Java中引用类型的转换

   1）向上类型转换（隐式/自动类型转换），是小类型到大类型的转换

   2）向下类型转换（强制类型转换），是大类型到小类型

   3）instanceof运算符：用来解决引用对象的leix类型，避免类型转换的安全性问题

 

例如：（我们已经引用上面的动物的例子）

public class Initail {

	public static void main(String[] args) {
		// TODO Auto-generated method stub	
		Dog dog = new Dog();
		Animal animal = dog;//自动类行 提升向上转换
		if(animal instanceof Dog) {
			Dog dog2 = (Dog) animal;//向下类型转换 强制类型转换
		}else {
			System.out.println("无法进行类型转换为Dog类型");
		}
		if(animal instanceof Cat) {
		Cat cat = (Cat)animal;//1 编译时Cat类型强制转换不会报错 2 运行时为Dog类型无法运行
		}else {
			System.out.println("无法进行类型转换为Cat类型");
		}
	}
}

 

3. Java中的抽象类

   1）语法定义：抽象类前shiy使用abstract关键字修饰，则该类为抽象类

   2）应用场景：a、在某些qing情况下，某个父类只是知道其子类应该包括怎样的方法，但无法准确知道这些子类如何实现这些方法

                             b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类模版，从而避免了子类设计的随意性

   3）作用：限制规定子类必须实现某些方法，但不关注实现的细节

   4）使用规则：a、abstract定义抽象类

                             b、abstract定义抽象方法，只有声明，不需要实现

                             c、包含抽象方法的类是抽象类

                             d、抽象中可以包含普通方法，也可没有抽象方法

                             e、抽象类不能直接创建，可以定义引用变量

 

例：

public abstract class Animal {
	public abstract void eat();
	public abstract void sleep();
}

public class Dog extends Animal {
	public void eat() {
		System.out.println("狗狗爱吃骨头。。。");
	}
	public void sleep() {
		System.out.println("狗狗困了就睡觉。。");
	}
	public void LookDoor() {
		System.out.println("狗狗可以看门哟。。");
	}
}

public class Cat extends Animal {
	public void eat() {
		System.out.println("喵喵爱吃鱼。。。。");
	}
	public void sleep() {
		System.out.println("喵喵困了就睡觉。。");
	}
	public void playGame() {
		System.out.println("喵喵爱玩毛线球。。");
	}
}

public class Initail {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Animal d = new Dog();
		Animal c = new Cat();
		d.eat();
		d.sleep();
		System.out.println("------------");
		c.eat();
		c.sleep();
	}
}

 

4. Java中的接口：接口可以理解成一种特殊的类，由全局常亮和公共抽象方法所组成

   1）接口的概念：类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方                                  法的实现细节，它只规定这些类里必须提供某些方法。

   2）接口的定义：和类定义不同，定义接口不在使用class关键字，而是使用interface关键字

 

   3）语法格式：

                           [ 修饰符 ] interface 接口名 [ extends 父接口1，父接口2... ]

                          {

                           零到多个常量定义... ...

                           零到多个抽象方法的定义 ... ...

                          }

      PS:接口就是用来被继承、被实现、修饰符一般建议用 public，不能使用private 和 protect 修饰接口    

    4）接口定义

                         常量：接口中的属性是常量，即使定义时不添加 public static final 修饰符，系统也会自动加上

                         方法：接口中的智能是抽象方法，总是使用，即使定义时不添加 public abstract 修饰符，系统也会自动加上

    5）接口的使用：一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活                                         的，通过实现多个接口可以做补充

例：

public abstract class Animal {
	public abstract void eat();
	public abstract void sleep();
}

public interface LookDoor {
	public void lookDoor();
}

public class Menwei implements LookDoor {

	@Override
	public void lookDoor() {
		// TODO Auto-generated method stub
		System.out.println("工作是看门");
	}
}

public class Dog extends Animal implements LookDoor{
	public void eat() {
		System.out.println("狗狗爱吃骨头。。。");
	}
	public void sleep() {
		System.out.println("狗狗困了就睡觉。。");
	}
	@Override
	public void lookDoor() {
		// TODO Auto-generated method stub
		System.out.println("狗狗可以看门咯。。。");
	}
}

public class Cat extends Animal {
	public void eat() {
		System.out.println("喵喵爱吃鱼。。。。");
	}
	public void sleep() {
		System.out.println("喵喵困了就睡觉。。");
	}
}

public class Initail {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal d = new Dog();
		Animal c = new Cat();
		d.eat();
		d.sleep();
		System.out.println("---------");
		c.eat();
		c.sleep();
		System.out.println("---------");
		LookDoor d1 = new Dog();
		LookDoor m = new Menwei();
		d1.lookDoor();
		m.lookDoor();
	}
}

 

 

补：

    接口在使用过程中，还经常与匿名内部类配合使用

    匿名内部类：没有名字的内部类

    多用于关注实现而不关注实现类的名称

    语法格式：

                     Interface i = new Interface（）｛

                            public void method(){

                                  System.out.println("匿名内部类实现接口方式");

                            }

                     };

例：

实现方式1：

实现方式2:

 

总结例题：

              需求：  乒乓球运动员和篮球运动员。
                            乒乓球教练和篮球教练。
                            为了出国交流，跟乒乓球相关的人员都需要学习英语。
              请用所学知识：分析，这个案例中有哪些抽象类，哪些接口，哪些具体类代码中的注释

 

package athlete;

public abstract class Athlete {//建立运动员抽象类
	public abstract void Practise();//运动员需要训练
	public abstract void Competition();//运动员需要比赛
}

public interface StudyEnglish { //学习英语接口
	public void studyEnglish();
}

public abstract class Coach {
	public abstract void Teach();//教练需要教学
}

public class BasketCoach extends Coach {//篮球教练

	@Override
	public void Teach() {
		// TODO Auto-generated method stub
		System.out.println("篮球教练每天都要给运动员传球");
	}
}

public class BasketMan extends Athlete {//篮球运动员

	@Override
	public void Practise() {
		// TODO Auto-generated method stub
		System.out.println("篮球运动员每天都要训练投篮");
	}

	@Override
	public void Competition() {
		// TODO Auto-generated method stub
		System.out.println("篮球运动员的目标是进军NBA");
	}
}

public class PpCoach extends Coach implements StudyEnglish{//乒乓球教练

	@Override
	public void Teach() {
		// TODO Auto-generated method stub
		System.out.println("乒乓球教练每天都要给运动员发球");
	}

	@Override
	public void studyEnglish() {
		// TODO Auto-generated method stub
		System.out.println("乒乓球教练必须学习英语以便出国交流");
	}
}

public class PpMan extends Athlete implements StudyEnglish{//乒乓球运动员

	@Override
	public void Practise() {
		// TODO Auto-generated method stub
		System.out.println("乒乓球运动员每天都要的训练抽球");
	}
	@Override
	public void Competition() {
		// TODO Auto-generated method stub
		System.out.println("乒乓球运动员目标要拿奥运会冠军");
	}
	@Override
	public void studyEnglish() {
		// TODO Auto-generated method stub
		System.out.println("乒乓球运动员必须学习英语以便出国交流");
	}
}

//测试类
public class Initail {
	public static void main(String[] args) {
		Athlete Bplayer = new BasketMan();
		Athlete Pplayer = new PpMan();
		Coach Bcoach  = new BasketCoach();  
		Coach Pcoach  = new PpCoach();  
		Bplayer.Practise();
		Bplayer.Competition();
		Bcoach.Teach();
		System.out.println("-----------------");
		Pplayer.Practise();
		Pplayer.Competition();
		Pcoach.Teach();
		System.out.println("-----------------");
		StudyEnglish P1 = new PpMan();
		StudyEnglish P2 = new PpCoach();
		P1.studyEnglish();
		P2.studyEnglish();
	}
}

 

 

 

 

####END####