多态应用+工厂数据模型+final关键字

一、定义

多态跟属性无关，多态指的是方法的多态，而不是属性的多态。

二、案例带入,工厂模型

        简单工厂模式的实现，它是解决大量对象创建问题的一个解决方案。将创建和使用分开，工厂负责创建，使用者直接调用即可。简单工厂模式的基本要求是

• 定义一个static方法，通过类名直接调用
• 返回值类型是父类类型，返回的可以是其任意子类类型
• 传入一个字符串类型的参数，工厂根据参数创建对应的子类产品

1、Girl01:

public class Girl01 extends Love{
    public void love(){
        System.out.println("Lovin' the feelin' the turbulence go when we turn up\n" +
                "当我们爱上彼此时，爱就像湍湍激流\n" +
                "When we land, we can roll out\n" +
                "到达陆地时，我们才能脱身\n" +
                "Show you somethin' you ain't know about\n" +
                "告诉你一些你不知道的\n"
                  );
    }
}

 

2、Girl02:

public class Girl02 extends Love{
    public void love(){
        System.out.println("Love me back, love\n" +
                "我祈求你能够为爱归来\n" +
                "Love me back, no\n" +
                "回到我身边，再爱我一次\n" +
                "Love me back, love\n" +
                "你是否愿意为爱归来，亲爱的\n" +
                "Love me back, no\n" +
                "再爱我一次吧，好不好\n"");
    }
}

3、Girl03:

public class Girl03 extends Love{
    public void love(){
        System.out.println("Es gibt sie doch diese liebe\n" +
                "爱，真实存在\n" +
                "Diese eine mit der man sie teilt\n" +
                "爱，可以分享\n" +
                "Ich spür sie noch diese liebe\n" +
                "爱，我可以再次感受到\n" +
                "Und ich weiß das du sie mit mir teilst\n" +
                "我知道，你赋予我爱\n");
    }
}

4、Love为父类：

public class Love {
        public void love(){
                System.out.println("最爱的人是你");
        }
}

5、多态的应用：建立工厂数据模型

public class LoveStore {
    public static Love getLove(String loversname){
        Love er = null;

        String LoveStore;
        if("星".equals(loversname)){
           er = new Girl01();
        }
        if ("月".equals(loversname)){
            er = new Girl02();
        }
        if ("日".equals(loversname)){
            er = new Girl03();
        }
        return er;

    }
}

6、在测试类Test中使用：

public class Test {
    public static void main(String[] args) {
        //Child c = new Child();+
        //Girl g = new Girl();
       // Boy b = new Boy();
       // g.play(c);
        Man m = new Man();
        Love er = LoveStore.getLove("月");
        m.takelove(er);
    }
}

7、运行结果：

二、final关键字

1、修饰变量

public class Test {
public static void main(String[] args) {

//final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
final int A = 10;//final修饰基本数据类型
//A = 20;报错：不可修改值


final Dog d = new Dog();//final修饰引用数据类型，那么地址值不可改变
//d = new Dog();----->地址值不可改变
//d对象的属性依然可以改变：
d.age = 10;
d.weight = 13.7;

final Dog d2 = new Dog();
a(d2);

//b(b2);
}
public static void a(Dog d){
    d = new Dog();
    }
public static void b(final Dog d){//d被final修饰，指向不可以改变
// d = new Dog();
    }
}

2、修饰方法

final修饰方法，那么这个方法不可以被该类的子类重写：

3、修饰类

        final修饰类，代表没有子类，该类不可以被继承：

        一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）

4、实例证明

        JDK提供的Math类：看源码发现：

（1）使用Math类的时候无需导包，直接使用即可：

（2）Math类没有子类，不能被其他类继承了

（3）里面的属性全部被final修饰，方法也是被final修饰的，只是省略不写了

               原因：子类没有必要进行重写。

（4）外界不可以创建对象：

                Math m = new Math();

（5）发现Math类中的所有的属性，方法都被static修饰

                那么不用创建对象去调用，只能通过类名.属性名 类名.方法名 去调用