Java学习（4）接口

发表于 | 分类于

久违去打球，一下午都好好的，晚上夜场崴脚了，也是好久没崴过脚了，这种疼痛感还挺怀念的。上午在看接口部分知识，接下来准备跳过内部类（也是粗略看了看），来看持有对象，集合框架。然后是IO、泛型和String类，再接着就开始看sql和spring，我觉得基础部分已经粗略会用了，接下来在深入一下看看查漏补缺。

哦对，今天对java中“工厂”这个概念很特别，在下边程序中有提到，多温习一下。

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*
    9.2   接口
    接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。
    一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属
    于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

    除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。
    一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，
    接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
 */

import thinkInJava08_Polymorphic.demo01.Note;

interface Instrument {
    // 这个是常量 final＆static
    int VALUE = 5;

    // 没有方法体
    void play(Note n);

    void adjust();
}

class Wind implements Instrument {
    public void play(Note n) {
        System.out.println(this + " 演奏 " + n);
    }

    @Override
    public String toString() {
        return " Wind ";
    }

    @Override
    public void adjust() {
        System.out.println(this + " 调整 ");
    }
}

class Percussion implements Instrument {
    @Override
    public void play(Note n) {
        System.out.println(this + " 演奏 " + n);
    }

    @Override
    public String toString() {
        return " Percussion ";
    }

    @Override
    public void adjust() {
        System.out.println(this + " 调整 ");
    }

}

class Stringed implements Instrument {
    @Override
    public void play(Note n) {
        System.out.println(this + " 演奏 " + n);
    }

    @Override
    public String toString() {
        return " Stringed ";
    }

    @Override
    public void adjust() {
        System.out.println(this + " 调整 ");
    }

}

class Brass extends Wind{
    @Override
    public String toString() {
        return " Brass ";
    }
}
class Woodwind extends Wind{
    @Override
    public String toString() {
        return " Woodwind ";
    }
}



public class Music5 {


    static void tune(Instrument i ){
        i.play(Note.MIDDLE_C);
    }

    // 还是很赞叹这种写法
    static void tuneALL(Instrument[] e){
        for (Instrument i:e)
            tune(i);
    }

    public static void main(String[] args) {
        Instrument[] orchesyra = {
                new Wind(),
                new Percussion(),
                new Stringed(),
                new Brass(),
                new Woodwind()
        };
        tuneALL(orchesyra);
    }

}
/*OUTPUT:
 Wind  演奏 MIDDLE_C
 Percussion  演奏 MIDDLE_C
 Stringed  演奏 MIDDLE_C
 Brass  演奏 MIDDLE_C
 Woodwind  演奏 MIDDLE_C
*/

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
/*
9.4 Java中的多重继承
可以继承任意多个接口，并向上转型为每个接口，因为每一个接口都是一个独立类型。
下面的例子展示了一个具体类组合数个几口之后产生了一个新类。
 */
interface CanFight{
    void fight();
}
interface CanSwim{
    void swim();
}
interface  CanFly{
    void fly();
}
class ActionCharacter{
    public void fight(){
        //
    }
}
class Hero extends ActionCharacter implements CanFight,CanFly,CanSwim{
    @Override
    public void swim() {

    }

    @Override
    public void fly() {

    }
}

public class Adventure {
    public static void t(CanFly x){x.fly();}
    public static void u(CanSwim x){x.swim();}
    public static void v(CanFight x){x.fight();}
    public static void w(ActionCharacter x){x.fight();}

    public static void main(String[] args) {
        Hero h = new Hero();
        t(h);
        u(h);
        v(h);
        w(h);
    }
}

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
78
79
80
81
82
/*
9.9节 接口与工厂

接口时实现多重继承的途径，而生成遵循某个接口的对象的典型方式
就是工厂方法设计模式（“工厂”是个方法）。这与直接调用的构造器不同，
我们再工厂对象上调用的是创建方法，而该工厂对象将生成接口的某个实
现的对象。理论上，通过这种方式，我们的代码将完全与接口的实现分离，
这就使得我们可以透明地将某个实现替换为另一个实现。
下面实例展示了工厂放法的结构：

 */
interface Service{
    void method1();
    void method2();
}
// 这里接口 是怎么回事  返回类型为Service的一个方法 “工厂方法”么？
interface ServiceFactory{
    Service getService();
}

class Implementation1 implements Service{
    Implementation1(){}

    @Override
    public void method1() {
        System.out.println("接口1 的 方法1");
    }

    @Override
    public void method2() {
        System.out.println("接口2 的 方法2");
    }
}

class Implementation1Factory implements ServiceFactory{
    @Override
    public Service getService() {
        return new Implementation1(); // 工厂 方法返回后 向上转型
    }
}

class Implementation2 implements Service{
    @Override
    public void method1() {
        System.out.println("接口2 的 方法1");
    }

    @Override
    public void method2() {
        System.out.println("接口2 的 方法2");
    }
}
class Implementation2Factory implements ServiceFactory{
    @Override
    public Service getService() {
        return new Implementation2(); // 工厂 方法返回后 向上转型
    }
}

public class Factories {
    public static void serviceConsumer(ServiceFactory fact){
        Service s = fact.getService(); // 向上转型
        s.method1();
        s.method1();
    }

    public static void main(String[] args) {
        serviceConsumer(new Implementation1Factory());
        // 接口完全在内部改变
        serviceConsumer(new Implementation2Factory());
    }

}

/*OUTPUT：
接口1 的 方法1
接口1 的 方法1
接口2 的 方法1
接口2 的 方法1
*/

总结小感

在招工作得这段时间，我有点动摇，是不是专注于开发岗位太一根筋了，还有销售和教练我觉得都可以尝试，爸妈再说得考公务员也在心里潜伏好久，所以有时候莫名会很烦躁。既然决定找研发就先做出来，九月份还没结束还得努力啊！

今天碰到一个高中时期打篮球的大哥，以前被虐的服服帖帖，但是今天在一起打球的时候，虽然仍然被虐但心态有所改变，我是一个体系球员，全场有队友配合我们队伍会很厉害，但是个人能力却有限，单挑的话不是特别强。说这些，就是像提一下，篮球也好其他事也罢，随着长大看待这些事的方式和心态都有所变化，我希望这种变化能更趋向理智与成熟，给自己加加油💪！