###面向对象(多态)###
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####