Java学习（3）重载以及工厂概念

发表于 | 分类于

现在是傍晚时分，多云似乎又是要下雨了，天气渐冷。有了昨天晚上不想写博客的教训，那么今天就在吃晚饭前开始编辑！那么..我先去吃饭了…

明日方舟真好玩，真香…

===================================================

JAVA基础：多态（后期绑定）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

public class TestShapes {
    private static RandomShapeGenerator gen = new RandomShapeGenerator();

    public static void main(String[] args) {
        Shape[] s = new Shape[9];

        // 这样new是因为多态的支持 动态绑定后还能准确调用具体的方法
        for (int i = 0; i < s.length; i++) {
            s[i] = gen.next();
        }

        // 调用多态方法  这种写法很诧异！！！！
        for(Shape shp:s)
            shp.draw();
    }
}

// 工厂？？？
public class RandomShapeGenerator {
    private Random rand = new Random(47);
    public Shape next(){
        switch(rand.nextInt(3)){
            default:
            case 0:return  new Circle();
            case 1:return  new Square();
            case 2:return  new Triangle();
        }
    }
}

public class Shape {
    public void draw(){
        //
    }
    public void erase(){
        //
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("画了一个圆！");
    }

    @Override
    public void erase() {
        System.out.println("擦掉了这个圆！");
    }
}

public class Square extends  Shape{
    @Override
    public void draw() {
        System.out.println("画了一个正方形！");

    }

    @Override
    public void erase() {
        System.out.println("擦掉了这个正方形！");
    }
}

public class Triangle extends  Shape {
    @Override
    public void draw() {
        System.out.println("画了一个三角形！");
    }

    @Override
    public void erase() {
        System.out.println("删掉了这个三角形！");
    }
}

文中提到了“工厂”这样的概念

这个代码是为了理解：在编译时，编译器不需要获得任何特殊信息就能进行正确的调用。对draw()方法的所有调用都是通过动态绑定进行的

多态是一项让程序员“将改变的事物与未改变的事物分离开来”的重要技术

JAVA基础：用继承进行设计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

/*

8.5用继承进行设计


一条通用的准则是“用继承表达行为间的差异，并用字段表达状态上的变化”。

在这个例子中，两者都用到了：通过继承得到了两个不同的类，用于表达act()方法的差异；
而Stage通过运动组合使自己的状态发生变化。在这种情况下，这种状态的改变也就产生了行为的改变。

于此相反，我们不能在运行期间决定继承不同的对象，因为它要求在编译期间完全确定下来。
 */

class Actor{
    public void act(){
        //
    }
}

class HappyActor extends Actor {
    @Override
    public void act(){
        System.out.println("快乐的演员、");
    }
}

class SadActor extends Actor{
    @Override
    public void act() {
        System.out.println("悲伤的演员");
    }
}

// 很棒的类 调用chang后便会改变引用的对象 从happy到sad 很灵活
class Stage{
    private Actor actor =new HappyActor();
    public void change(){
        actor = new SadActor();
    }
    public void performPlay(){
        actor.act();
    }
}

public class Transmogrify {
    public static void main(String[] args) {
        Stage stage = new Stage();
        stage.performPlay();
        stage.change();
        stage.performPlay();
    }
}

JAVA基础：向下转型与运行时类型识别RTTI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

/*
8.5.2 向下转型与运行时类别识别
RTTI （runtime type information）


 */
class Userful{
    public void f(){
        System.out.println("我是小f");
    }
    public void g(){
        System.out.println("我是小g");
    }
}
class MoreUserful extends Userful{
    @Override
    public void f() {
        //
    }

    @Override
    public void g() {
        System.out.println("我是重载后的小g");
    }
    public void u(){
        System.out.println("小u被调用了！！！");
    }
    public void v(){
        //
    }
    public void w(){
        //
    }
}

public class RTTI {
    public static void main(String[] args) {
        Userful[] x = {
                new Userful(),
                new MoreUserful()
        };
        x[0].f();//我是小f
        x[1].g();//我是重载后的小g
        // 注意 后边的方法没有在基类中出现
        // ！x[1].u(); 这个语句是编译错误的！！！！！！！
        ((MoreUserful)x[1]).u();  // 强制转换 向下转型 RTTI
      //  ((MoreUserful)x[0]).u();   // 异常抛出！Exception in thread "main" java.lang.ClassCastException
    }
}

导出类中接口的扩展部分不能被基类访问，因此，一旦我们向上转型，就不能调用那些方法

向下转型就是用加括弧的形式来进行类型转换，不过也有会些细节要注意，看看代码。

关于昨天的坑

我觉得可以不补 详情自己看看书 不就在一边 手机里也有PDF ！！！！P139 P140

今日小感

= = 锻炼的肌肉好酸，早上起来腹肌要裂开了。对自己今天的用功程度不做评价，下午给妹妹补课也是很用心。写完这个小结还有几个小时才要睡觉，预习明天的接口内容，再做做英语题。

so… to be counti忘记了…