JAVA之旅(六)——单例设计模式,继承extends,聚集关系,子父类变量关系,super,覆盖

释放双眼,带上耳机,听听看~!

JAVA之旅(六)——单例设计模式,继承extends,聚集关系,子父类变量关系,super,覆盖

JAVA之旅(六)——单例设计模式,继承extends,聚集关系,子父类变量关系,super,覆盖

一.单例设计模式

  • 什么是设计模式?

JAVA当中有23种设计模式,解决某一问题最有效的方法

  • 单例设计模式

解决一个类在内存中只存在一个对象

想要保证对象唯一该怎么做》

  • 1.为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象
  • 2.还为了让其他程序访问到该类对象,只好在本类中自定义一个对象
  • 3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式

这三步怎么怎么实现呢?

  • 1.将构造函数私有化
  • 2.在类中创建一个本类对象
  • 3.提供一个方法可以获取到该对象

然后我们的代码就出来了


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1/**
2 * 单例模式
3 *
4 * @author LGL
5 *
6 */
7public class Single {
8
9    // 将构造函数私有化
10    private Single() {
11
12    }
13
14    // 在类中创建一个本类对象
15    private static Single s = new Single();
16
17    // 提供一个方法可以获取到该对象
18    public static Single getInstance() {
19
20        return s;
21    }
22}
23
24

当然,我们还有一种写法——懒汉式


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1/**
2 * 单例模式
3 * 懒汉式
4 * @author LGL
5 *
6 */
7public class Single {
8
9    private static Single s = null;
10
11    public Single() {
12        // TODO Auto-generated constructor stub
13    }
14
15    public static Single getInstance() {
16        if (s == null)
17            s = new Single();
18
19        return s;
20
21    }
22}
23
24

也有这么一种写法


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1/**
2 * 单例模式
3 * 饿汉式
4 *
5 * @author LGL
6 *
7 */
8public class Single {
9
10    private static Single s = new Single();
11
12    public Single() {
13        // TODO Auto-generated constructor stub
14    }
15
16    public static Single getInstance() {
17        return s;
18
19    }
20}
21
22

单例模式的写法多种多样,只要掌握这个思想就可以了

饿汉式的特点:single类一进内存就已经创建好了对象
懒汉式的特点:对象是方法被调用时才初始化,也叫作对象的延迟加载

Single类进内存还没有存在,只有调用了getInstance()方法时才建立对象,这就叫做延迟加载

我们一般用饿汉式,因为他安全,简单

二.继承

面向对象的思想中的一个思想,继承,我们可以这样去理解,我们可以定义一个学生类,他有名字和年龄,还有一个学习的方法


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1/**
2 * 学生
3 * @author LGL
4 *
5 */
6class Student {
7
8    String name;
9
10    int age;
11
12    void study() {
13        System.out.println("学习");
14    }
15}
16

然后我们可以再定义一个工人类


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2/**
3 * 工人
4 * @author LGL
5 *
6 */
7class Worker {
8
9    String name;
10
11    int age;
12
13    void work() {
14        System.out.println("工作");
15    }
16}
17

他同样有名字和年龄还有一个工作的方法

这个时候我们可以发现,他们都存在相同的关系,他们都是人,人都具备年龄和姓名,所以我们可以将学生和工人的共性提取出来描述,只要让学生和工人与单独描述的类有关系就行,也就是继承


1
2
3
4
5
6
7
8
9
10
11
12
1/**
2 * 人
3 *
4 * @author LGL
5 *
6 */
7class Person {
8    String name;
9
10    int age;
11}
12

这个Person就叫做父类,超类,基类

然后我们的工人和学生就可以这样去写


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
1
2/**
3 * 学生
4 *
5 * @author LGL
6 *
7 */
8class Student extends Person {
9
10    void study() {
11        System.out.println("学习");
12    }
13}
14
15/**
16 * 工人
17 *
18 * @author LGL
19 *
20 */
21class Worker extends Person {
22
23    void work() {
24        System.out.println("工作");
25    }
26}
27

他们是Person的子类,继承是源于生活,所以工人不能继承学生,没有伦理性,千万不要为了获取其他类的功能,简化代码而继承,必须是类与类之间有所属关系才可以继承,is a 的关系
继承的优点

  • 1.提高代码的复用性
  • 2.让类与类之间产生关系,有了这层关系才有了多态的特性

JAVA语言中,java只支持单继承,不支持多继承

  • 为什么不能多继承?

因为多继承容易带来安全隐患,当多个父类中定义了相同的功能,当功能内容不同时,子类对象不确定运行哪一个,但是JAVA保留了这种机制,并用另一种体现形式来表示,多实现。

JAVA支持多层继承,也就是一个继承体系

如何使用一个继承体系的功能?

  • 想要使用体系,先查阅体系中父类的描述,因为父类中定义的是该体系中的共性内容,通过了解共性功能就可以知道该体系的基本功能,那么,这么体系已经可以基本使用了。
  • 那么集体调用时,要创建最子类的对象,为什么?一是因为有可能父类不能创建对象,二是创建子类对象可能使用更多的功能,包括基本的也包括特有的

简单的说一句:查阅父类功能,创建子类对象使用功能

三.聚集关系

这个概念可能很多人不是很熟悉,确实我们实际开发当中很少提到,我们对象和对象之间,不光有继承关系,还有组合关系,

  • 聚合

球员是球队中的一个,球队中有球员,这就是聚合关系

  • 组合

手是人身体的一部分,腿是身体的一部分,这就是组合关系,你说这和聚合没什么不同,那你就错了,要知道,球队少了个球员没事,人少胳膊少腿就有事哦,所以组合关系更加紧密一点

都是吧对象撮合在一起,像我们继承是秉承一个is a的关系,而聚集是has a的关系,谁里面有谁

这个关系我们就不多做赘述了

我们关系讲完了,现在应该可以用代码去表示表示了,这里我就用当继承关系时,子类和父类之间的变量关系来举例

四.子父类变量关系

我们来探索一下子父类出现后,类成员的特点

    1. 变量
  1. 2.函数
  2. 3.构造函数

我们一步步来分析

1.变量

我们撸一串代码


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
1//公共的   类   类名
2public class HelloJJAVA {
3    // 公共的 静态 无返回值 main方法 数组
4    public static void main(String[] str) {
5        /**
6         * 子父类出现后,类成员的特点
7         */
8
9        Zi z = new Zi();
10        System.out.println("num1 = " + z.num1 + "\n" + "num2 = " + z.num2);
11    }
12}
13
14/**
15 * 父类
16 *
17 * @author LGL
18 *
19 */
20class Fu {
21
22    int num1 = 4;
23}
24
25/**
26 * 子类
27 *
28 * @author LGL
29 *
30 */
31class Zi extends Fu {
32
33    int num2 = 5;
34
35}
36

这样,是不是很容易知道输出的结果

但是我们那会这么简单,我们还有特殊情况


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
1//公共的   类   类名
2public class HelloJJAVA {
3    // 公共的 静态 无返回值 main方法 数组
4    public static void main(String[] str) {
5        /**
6         * 子父类出现后,类成员的特点
7         */
8
9        Zi z = new Zi();
10        System.out.println("num1 = " + z.num + "\n" + "num2 = " + z.num);
11    }
12}
13
14/**
15 * 父类
16 *
17 * @author LGL
18 *
19 */
20class Fu {
21
22    int num = 4;
23}
24
25/**
26 * 子类
27 *
28 * @author LGL
29 *
30 */
31class Zi extends Fu {
32
33    int num = 5;
34
35}
36

当子类和父类都有相同的变量的时候,现在该打印什么呢?

没错,打印了子类的值,为什么?因为输出的num前面其实默认带了一个this,如果我们要打印父类的值,需要加super,这是一个新的关键字了


1
2
3
4
1void show(){
2        System.out.println(super.num);
3    }
4

结果显而易见了

所以变量的特点:如果子类中出现非私有的同名成员变量时,子类要访问本类中的成员变量,用this,子类访问父类中的同名变量,用super,this和super的使用几乎一致,this代表的是本类对象的引用,super代表父类对象的引用

不过我们也不会这么蛋疼在父类创建又在子类创建,我们来看第二个

2.函数

也就是方法,我们正常的应该是这样写的


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
1//公共的   类   类名
2public class HelloJJAVA {
3    // 公共的 静态 无返回值 main方法 数组
4    public static void main(String[] str) {
5        /**
6         * 子父类出现后,类成员的特点
7         */
8
9        Zi z = new Zi();
10        z.show1();
11        z.show2();
12    }
13}
14
15/**
16 * 父类
17 *
18 * @author LGL
19 *
20 */
21class Fu {
22    void show1() {
23        System.out.println("fu");
24    }
25
26}
27
28/**
29 * 子类
30 *
31 * @author LGL
32 *
33 */
34class Zi extends Fu {
35
36    void show2() {
37        System.out.println("zi");
38    }
39}
40

这是很正常的实现

我们当然要说一种特殊情况,子父类方法同名我们该怎么办?我们运行一下

这是子运行了,这种情况叫做覆盖(重写),这个特性的特点

  • 当子类出现和父类一模一样的函数时,当子类对象被调用了该函数,会运行子类函数的内容,如同父类的函数被覆盖一样,这种情况就是覆盖了

当子类继承了父类,沿袭了父类的功能到子类中,到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,这时没有必要定义新功能,而是使用覆盖特性,保留父类的功能定义并重写功能内容

  • 覆盖

1.子类覆盖父类,必须保证子类权限大于等于父类权限才可以覆盖,否则编译失败
2.静态只能覆盖静态(一般没人用)

  • 记住

重载:只看同名函数的参数列表
重写:字符类方法要一模一样 ,包括返回值类型

3.构造函数

最后一个特点了


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
1//公共的   类   类名
2public class HelloJJAVA {
3    // 公共的 静态 无返回值 main方法 数组
4    public static void main(String[] str) {
5        /**
6         * 子父类出现后,类成员的特点
7         */
8        Zi z = new Zi();
9
10    }
11}
12
13/**
14 * 父类
15 *
16 * @author LGL
17 *
18 */
19class Fu {
20    public Fu() {
21        System.out.println("fu");
22    }
23}
24
25/**
26 * 子类
27 *
28 * @author LGL
29 *
30 */
31class Zi extends Fu {
32    public Zi() {
33        System.out.println("zi");
34    }
35}
36

我们现在运行一下

你会疑问,我明明实例化的是子类,怎么父类也实例化了,因为子类构造函数的第一行默认有一个方法


1
2
1super();
2
  • 1

在对子类对象进行初始化时,父类的构造函数也会执行,那就是因为子类的构造函数默认第一行有一条隐式的语句super();他会访问父类中空参数的构造函数,而且子类中所有的构造函数默认第一行都是super()

  • 为什么子类一定要访问父类中的构造函数?

因为父类中的数据子类可以直接获取,所有子类建立对象的时候,需要先查看父类如何对这些数据进行初始化的,所有子类对这些对象初始化时,要先访问父类中的构造函数,如果要访问父类中指定的构造函数,可以手动定义super(xx,xx)的方式。

  • 注意

super语句一定定义在子类构造函数的第一行

  • 结论:

子类的所有的构造函数,默认都会访问父类中空参数的构造函数,因为子类每一个构造函数内的第一行都有一句隐式的super,当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句的形式指定要访问父类中的构造函数

当然,子类的构造函数也可以指定this来访问本类中的构造函数,子类中至少会有一个构造函数会访问父类中的构造函数,这个结论就是子类的实例化过程,逐级向上查找

父类也向上查找,他找的是JAVA中所有类的老爹——Object

行,我们本篇幅就闲到这里吧,概念多了,反而难以消化,我们要一点点的来

原文地址http://www.bieryun.com/2640.html

给TA打赏
共{{data.count}}人
人已打赏
安全技术

bootstrap栅格系统自定义列

2021-12-21 16:36:11

安全技术

从零搭建自己的SpringBoot后台框架(二十三)

2022-1-12 12:36:11

个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索