Java——多态，引用数据类型强转，组合模式

多态
在程序中同一个方法，由于参数类型不同导致不同效果的现象就叫多态。例如：动物都有叫的这个行为，但是不同的动物发出的叫法不同，猫类发出的猫叫，狗类发出的狗叫。
新一个动物类Animal，让Dog类，Cat类继承Animal程序中的代码如下：
public class Animal {
private String name;

public String getName() {
    return name;
}

private  void setName(String name) {
    this.name = name;
}
/***
 * 父类方法
 */
public void show() {
    System.out.println("我是一个父类方法，我的名字："+getName());
}
/***
 * 
 */
protected void speak() {
    System.out.println("我是所有动物的父类");
}

}
class Dog extends Animal {
/**
* 重写父类方法
*/
public void show() {
System.out.println(“我是子类dog类”);

}
class Cat extends Animal {
/**
* 重写父类方法
*/
public void show() {
System.out.println(“我是子类Cat”);
}
}
新建一个Test类，用于测试数据
public class Test {

public static void main(String[] args) {
    Animal animal=new Dog();
    animal.show();
    Animal animal1=new Cat();
    animal1.show(); 
}
}

结果：
我是子类dog类
我是子类Cat
父类变量引用不同的子类对象，当调用show方法是，将父类引用的两个不同子类对象分别传入，结果打印出不同的结果。
引用类型的强制转换
之前学过基本数据类型的转换，其中所有的基本数据类型都能自动转换成String类型，但是如果浮点型转换成数值型时，我们就需要强制转换，格式是（要转换的类型）当前类型；例如：int a=(int)13.4f;
引用类型跟数据类型转换使用方式差不多。但是引用类型必须是在继承关系中。
例如：
public class Test {

public static void main(String[] args) {
    double d=13.4;
    //转换时会失去精度
    long l =(long)d;
    System.out.println(l);
    int in=4;
    //Cannot cast from int to boolean
    //不能从int 转换成boolean,除此之外其他数据类型可以互转
    //boolean b=(boolean)in;
    //之前讲过所有的引用类型的最大父类都是Object
    Object obj="ceshi";
    //String继承在Object，所以可以进行强制转换
    String str=(String)obj;
    System.out.println(str);

//定义一个objPri变量,编译时类型为Object,实际是Interger
Object objPri = new Integer(5);
//java.lang.Integer cannot be cast to java.lang.String
//报错：Integer不能转换成String，因为Integet跟String并没有实际的继承关系
String stt=(String)objPri;
}
}
上边代码中Integer转换时报错，我们需要通过instanceof运算符来判断是否可以转换。
代码修改为：
if(objPri instanceof String) {
String stt=(String)objPri;
}
instanceof 前一个参数是引用类型的变量，后一个参数是一个类，用于判断前面的对象跟后边的的类，或者子类，实现的类。如果是则返回true否则返回false。
使用继承应注意的问题
1.父类的数据尽量不让子类去访问，应该把所有的父类数据用private修饰
2.不要让子类可以随意访问、修改父类的方法。该用protected让子类去继承，用private自己使用，用public所有类调用。
3.尽量不要在构造方法中调用要被自己重新的方法。因为子类重写完成后，父类里里面的方法会报错。
例如：
class Base {
//构造方法
Base(){
test();
}
// test方法
void test(){
System.out.println(“这是父类test方法”);
}
}

public class Sub extends Base{
private String name;
public void test(){
System.out.println(“这是子类test方法,name的长度是:”+name.length());
}

public static void main(String[] args) {
    Sub sub=new Sub();//空指针错误
}

}
如何使用继承关系
1、子类需要额外的增加属性（变量）。
2、子类需要额外的增加行为（包括新的方法或者重写父类方法），

使用组合复用代码
组合模式应用场景
　　组合模式是一种部分-整体模式，一般运用树状结构问题中，比如之前的包的创建，一个包下可以有多个文件，文件夹下可以有文件也可有文件夹，文件夹下有文件夹和文件夹。

public void fly() {
    System.out.println("我在天空飞翔。。。");
}

}
/*
* 狼类
*/
class Wolf extends Animal{

public void run() {
    System.out.println("我在大地中奔跑。。。");
}

}
/*
* 继承测试
*/
public class Test {

public static void main(String[] args) {
    Bird b= new Bird();
    b.breath();
    b.fly();
    Wolf w=new Wolf();
    w.breath();
    w.run();
}

}
结果
心脏跳动、、、
吸一口气，呼一口气，呼吸中。。。
我在天空飞翔。。。
心脏跳动、、、
吸一口气，呼一口气，呼吸中。。。
我在大地中奔跑。。。

以上代码我们可以看到新的狼类和鸟类继承动物类后直接获得了父类的方法，子类不需要在进行创建，我们现在用组合模式重新修改如下：

/*
* 动物类
*/
class Animal{
private void beat() {
System.out.println(“心脏跳动、、、”);
}
public void breath() {
beat();//调用自己的私有方法
System.out.println(“吸一口气，呼一口气，呼吸中。。。”);
}
}
/*
* 鸟类
*/
class Bird{
private Animal a;
//将原来父类的方法组合到子类中，成为子类的一个组合部分
public Bird(Animal a) {
this.a=a;
}
//重新定义一个自己的breath方法
public void breath() {
//直接复用Anmal提供的breath方法来实现自己的方法
a.breath();
}
public void fly() {
System.out.println(“我在天空飞翔。。。”);
}
}
/*
* 狼类
*/
class Wolf{
private Animal a;
//将原来父类的方法组合到子类中，成为子类的一个组合部分
public Wolf(Animal a) {
this.a=a;
}
//重新定义一个自己的breath方法
public void breath() {
//直接复用Anmal提供的breath方法来实现自己的方法
a.breath();
}
public void run() {
System.out.println(“我在大地中奔跑。。。”);
}
}
/*
* 组合测试
*/
public class Test {

public static void main(String[] args) {
    Animal a =new Animal();
    Bird b= new Bird(a);
    b.breath();
    b.fly();
    Animal a1 =new Animal();
    Wolf w=new Wolf(a);
    w.breath();
    w.run();
}

}
结果：
心脏跳动、、、
吸一口气，呼一口气，呼吸中。。。
我在天空飞翔。。。
心脏跳动、、、
吸一口气，呼一口气，呼吸中。。。
我在大地中奔跑。。。

修改后的代码可以看到狼类和鸟类都是有动物类组合而成，运行后的效果跟之前的一样。
组合的使用场景：
两个类之间有明确的的整体、部分的关系。比如：北京总公司，山东分公司，总公司由子公司组成，总公司一个整体，子公司是总公司的一部分。

Java——多态，引用数据类型强转，组合模式

猜你喜欢