Java基础进阶第三天单例模式、继承、final

亦凉 2021-09-17 08:54 147阅读 0赞

# **今日任务** #

## 1、能够理解单例设计模式 ##

## 2、能够独立使用继承 ##

## 3、能够独立使用final关键字 ##

# **1. 代码块** #

## 1.1.代码块的概念和格式 ##

代码块，就是使用大括号括起来的一段代码；

书写格式：

{
        代码；
    }

## 1.2.代码块的分类 ##

### 1.2.1. 静态代码块 ###

静态代码块，就是使用static修饰的代码块，直接写在类中的代码块；

class Demo{
          static{
              System.out.pintln("静态代码块")
          }
    }

![2400330-48b9cbcf3f05a4d3.png][]

2.png

静态代码块的执行顺序：

![2400330-66c45499e927e882.png][]

3.png

注意：一般在开发中，静态代码块都要写在类的下面；

作用：  
因为在类加载完成时，静态代码块已经执行结束，所以某些需要提前完成的工作，可以放在静态代码块中执行；

### 1.2.2. 构造代码块 ###

构造代码块，也是直接写在类中的代码块；在构造代码块前面不需要任何的关键字修饰；

class Demo{
          {
              System.out.pintln("构造代码块")
          }
    }

![2400330-b0400d3889c842ed.png][]

5.png

构造代码块执行顺序：

![2400330-1801c3acb13121cb.png][]

6.png

应用：

原来凡是创建对象执行构造函数，都要执行构造代码块，所以如果某些操作在所有构造函数中都存在，那么可以提取到构造代码块中；

![2400330-0a60b7ff2ad57642.png][]

7.png

![2400330-9586149fe923de0f.png][]

8.png

### 1.2.3. 局部代码块 ###

局部代码块的写法和构造代码块一模一样；不同的时，局部代码块只能写在局部位置（函数中）；

class Demo{
          public static void main（String[] args）{
             {
                 System.out.pintln("局部代码块")
              }
          }
    }

局部代码块的作用，就是用来限定部分代码的使用范围的；

![2400330-f1058bf2fb12b79a.png][]

10.png

# 2. 类中可以书写的成员 #

class Demo{
            //静态成员变量
            static int a = 10;
            //非静态成员变量
             int b =20;
            //静态方法
             static void show(){
                System.out.pintln("静态方法")
            }
             //非静态方法
            void func(){
                System.out.pintln("非静态方法")
            }
           //构造方法
             Demo(){
                System.out.pintln("构造方法")
            }
            //静态代码块
             static {
                System.out.pintln("静态方法")
            }
          {
              System.out.pintln("构造代码块")
          }
    }

# **3. 类加载和对象创建的过程** #

面试题：

class Demo {
        int x;
        int y = 3;
        static int z = 10;
        static {
            System.out.println("z=" + z);
        }
    
        Demo() {
            System.out.println("x=" + x);
            System.out.println("y=" + y);
        }
    }
    
    class DemoTest2 {
        public static void main(String[] args) {
            Demo d = new Demo();
        }
    }

## 3.1.类加载过程 ##

**1、JVM发现要使用一个类，首先要到方法区中找；如果找到了，就直接使用，如果没有找到，才会去找这个类的class文件，然后加载；**  
**（在找class文件时，是根据classpath配置的地址去找；如果没有配置，就在当前目录找）**  
**2、在硬盘上找到class文件后，就开始加载这个class，根据书写顺序，先后将静态成员加载到静态区域，非静态成员加载到非静态区域；**  
**3、接下来为所有的静态成员变量分配变量空间，同时赋默认值；**  
**4、接下来根据书写的顺序为静态成员变量显示赋值，同时执行静态代码块；**  
**上面的步骤都执行完毕，类加载完成；**

## 3.2.对象的创建过程 ##

**1、首先JVM在堆内存中开辟空间；**  
**2、在对象空间中为类中的所有非静态成员变量分配空间，赋默认值；**  
**3、调用相应的构造函数进栈；**  
**4、在执行构造函数中的代码之前，先要执行隐式三步：**  
**a) super（）：调用父类构造函数**  
**b) 给对象空间中的非静态成员变量显示赋值**  
**c) 执行构造代码块**  
**5、完成隐式三步后，接下来开始执行构造函数中的代码；**  
**构造函数结束出栈，对象创建完成；**

## 3.3.练习 ##

下列代码执行结果是什么？为什么？

代码一：

class Demo 
    {
        static Demo demo = new Demo();
    
        Demo(){
            System.out.println("构造函数");
        }
    }
    class Test
    {
        public static void main(String[] args) 
        {
            new Demo();
        }
    }

![2400330-05bf747e8a9a5561.png][]

12.png

代码二：

class Demo 
    {
        Demo demo = new Demo();
    
        Demo(){
            System.out.println("构造函数");
        }
    }
    class Test
    {
        public static void main(String[] args) 
        {
            new Demo();
        }
    }

![2400330-a71db205efd2aad8.png][]

13.png

## **4. 单例设计模式** ##

## 4.1.单例设计（singleton）模式介绍 ##

### 4.1.1. 设计模式： ###

就是对一些常见问题进行归纳总结，并针对具体问题给出一套通用的解决办法（强调的是解决问题的思想）；在开发中，只要遇到这类问题，就可以直接使用这些设计模式解决问题；  
最早起源于建筑领域，在建筑领域把一些问题和经验进行归纳总结，形成一套可以用来在建筑领域解决大多数问题的方案；  
后来计算机领域借鉴了建筑领域的设计模式，把计算机领域中经常遇到的问题进行归纳和总结，形成计算机领域23中设计模式；

### 4.1.2. 单例（单态、原子）设计模式： ###

在程序运行中，一个类最多只能有一个对象；

//需求：模拟月亮，不管哪里调用的月亮，都是同一个对象；
    class Moon//描述月亮
    {
        /*
            要创建对象，有两个条件：new关键字；构造函数；
            要保证单例，就不能让别人随便创建对象；
            在这两个条件中，new关键字程序员无法控制；
            就只能考虑不让别人使用构造函数；
            要想别人不能随意使用构造函数，就需要将构造函数私有化；
        */
        private Moon(){}
        /*
            私有化构造函数，确实可以避免随意创建对象；
            但是还是得有一个对象；
            而构造函数私有化后在别的地方无法创建对象，
            就只有在本类中创建这个唯一的对象;
            创建的对象需要有一个变量接收，以后其他地方需要这个对象，
            通过这个变量就可以获取这个对象了；
            因为在使用这个变量之前还没有对象，所以这个变量必须是静态的；
            为了保证数据的安全，不被外界修改，必须将他封装起来（也就是私有化）
        */
        private static Moon moon = new Moon();
        /*
            要想外界还能访问到被封装的数据，必须向外提供一个公开的访问方法
            而且只有访问这个方法之后才会有对象，所以这个方法应该是静态的
        */
        public static Moon getMoon(){
            return moon;
        }
    }
    class Test
    {
        public static void main(String[] args) 
        {
            Moon m1 = Moon.getMoon();
            Moon m2 = Moon.getMoon();
            System.out.println(m1);
            System.out.println(m2);
            System.out.println(m1 == m2);
        }
    }

## 4.2.单例设计模式的代码模板 ##

总结实现单例的步骤：  
1、私有化构造函数；  
2、在本类中创建唯一实例对象；  
3、对外提供公开的访问方法，获取这个对象

![2400330-f1af9df1e26890a6.png][]

14.png

这种方式叫做饿汉式；  
这种实现方式有点问题：  
这种方式，只要使用到这个类，就一定会创建对象，会造成内存的浪费；  
好处是：保证对象的唯一性；

![2400330-ece1978a1ae0e3d8.png][]

15.png

解决办法：懒汉式

![2400330-9f6eeada16663828.png][]

16.png

原理：

![2400330-5baf35fc520f0fd8.png][]

17.png

懒汉式的问题：  
多线程环境下，不能保证每次获取的都是同一个对象；  
好处：避免内存浪费；

## 4.3.单例设计总结 ##

**设计模式**：针对某一类问题的通用的解决办法；  
**单例设计模式**：解决程序运行中一个类最多只能有一个实例对象的问题；

**单例实现的步骤**：  
1、私有构造函数，避免其他类可以直接创建单例类的对象；  
2、在本类中创建唯一实例，使用静态成员变量保存；为保证安全性，私有化这个成员变量；  
3、对外提供一个公开的静态方法，供其他类获取本类的唯一实例；

**单例的两种实现方法**：  
**饿汉式**：在加载类的同时就创建了这个类的唯一实例；  
好处：可保证这个类的实例的唯一性；  
弊端：如果只是使用这个类，但是暂时不需要它的对象，也会创建唯一实例，造成内存的浪费；

**懒汉式**：在第一次调用获取实例的方法时才创建对象；  
好处：第一次调用获取实例的方法时才创建对象，可以避免内存的浪费；  
弊端：多线程环境下不能保证实例的唯一性；

# **5. 面向对象：继承** #

继承财产；
    
                        继承皇位；
    
                        继承传统；
    
                        继承都是发生在两类事物之间的，这两类事物都有关系，现实生活中是父子关系；

## 5.1.java中的继承 ##

**概念：**  
java中的继承，是使用extends关键字在两个类之间建立的一种关系；

**写法：**

class  Fu{}
    class  Zi extends Fu{}//表示Zi类继承里Fu类；
    在继承关系中，被其他类继承的类，叫做父类（超类），如本例中的Fu类；
    继承其他类的类，叫做子类（派生类），如本例中的Zi类；

**作用：**  
继承中子类可以直接拥有父类的成员；

**继承演示：**  
案例：使用java代码描述人和学生的信息；

![2400330-94a2702db830e4c0.png][]

18.png

![2400330-d514e6ff2420a839.png][]

19.png

问题：

![2400330-511d5a0c6f2f8e68.png][]

20.png

要解决这种应该是自身所有的属性和行为重复的问题，应该使用继承；

![2400330-1153f70cf27bcf57.png][]

21.png

结论：使用继承可以提高代码的复用性；  
使用继承可以在两个类中建立一种关系；

**使用注意：**  
1、继承中，父类的私有成员可以被子类继承，但是不能直接被访问使用；  
2、继承中的两个类，应该有关系；  
只有子类描述的事物是 父类描述的事物的特例的时候，才可以使用继承；

虽然在语法上，可以使用extends关键字在任意两个类之间建立继承关系，但是在开发中，只能是二者之间具有“是” 的关系的时候才使用继承；  
如果两个类不具有这种“是”的关系，那么就应该找他们共同的父类，然后将共同的信息放到共同的父类中，然后让两个类分别继承父类；  
鱼和 苹果 ， 不具有 “是” 的关系，但是有共同的父类，都属于食物，所以可以建立一个食物类，然后让他们分别继承食物类；

## 5.2.java类的继承特点 ##

### 5.2.1. 单一继承 ###

就是一个类只能直接继承一个父类；

![2400330-f72840c9cc312228.png][]

22.png

如果可以继承两个父类，那么当这两个父类中都具有共同的属性或行为时，在子类中调用，就不清楚到底会调用哪个（调用的不确定性）

### 5.2.2. 多重继承 ###

java中继承中，父类可以再继承其他类，叫做多重继承；

![2400330-ac48d3645e800a55.png][]

23.png

**一个类只能直接继承一个父类，但是可以有多个子类；**

**一个类的父类还可以继承父类；**

![2400330-4bd73457d59ae9f3.png][]

24.png

## 5.3.继承中的成员变量的特点 ##

### 5.3.1. 子类直接拥有父类非私有成员变量 ###

### 5.3.2. 子类中存在和父类中同名的成员变量，在子类中直接使用的是子类中定义的； ###

![2400330-d22e95fd30fc064c.png][]

25.png

![2400330-be2c39e2395c874b.png][]

26.png

一般开发中，如果父类定义了某个成员变量，子类中一般不需要再定义；

## 5.4.继承中的成员方法 ##

### 5.4.1. 子类直接拥有父类非私有成员方法 ###

### 5.4.2. 子类中可以定义和父类中同样的成员方法，直接调用的是子类中定义的函数 ###

![2400330-84c3a2398c101fbe.png][]

27.png

![2400330-e1405f21a26313bf.png][]

28.png

结论：  
**如果子类中没有定义和父类中一样的成员变量和函数，直接调用，使用的是父类中定义的成员；**  
**如果子类中定义了和父类中一样的成员变量和函数，直接调用，使用都是子类中定义的成员；**  
**此时要使用父中定义的成员，需要通过super关键字调用；调用的格式是：**  
**super.成员变量；**  
**super.成员函数名（参数）；**

## **5.5.方法的重写（override）** ##

### 5.5.1. 重写的概念 ###

在子类中定义和父类中相同的函数，直接调用函数时，实际使用的是子类中的函数，这种情况叫做方法的重写（覆写）；  
一般开发中，如果父类的功能不满足子类需要，子类都会重写父类的函数；

### 5.5.2. 重写的应用 ###

需求：描述手机这类事物。原始的手机和现代的手机

![2400330-b5b213985bc84764.png][]

29.png

![2400330-109430755c111de3.png][]

30.png

### 5.5.3. 重写的注意事项 ###

1、子类重写的函数要和父类中的**函数名**要相同；

![2400330-503f984eaeaad0eb.png][]

31.png

2、子类重写的函数要和父类中的**函数参数列表**要相同；

![2400330-cf73a14f3fa601dc.png][]

32.png

3、子类重写的函数要和父类中的**函数返回值类型**相同；

![2400330-9b99f4b8ffd94625.png][]

33.png

4、子类重写的函数要和父类中的**函数的访问方式**相同  
（也就是说，父类的方法是静态的，重写的方法也必须是静态的；父类的方法不是静态的，重写的方法也必须不是静态的）；

![2400330-2cbaa51fb9e7258d.png][]

34.png

5、子类重写的函数，**访问权限不**能比父类的低；（可以和父类的访问权限不同，但是不能比父类访问权限低）

![2400330-dc7aca5ea72006ce.png][]

35.png

**直接将父类中的函数复制粘贴到子类中，然后修改方法体的代码，可以保证不会出现格式上的问题；**

## 5.6.继承中构造方法的使用 ##

### 5.6.1. 子类实例化的过程 ###

继承中类的加载顺序，是先加载父类，然后再加载子类；

![2400330-8c0363d3e9600578.png][]

36.png

![2400330-a1e7470037852684.png][]

37.png

1、**为什么任何一个类（不包含Object）的构造函数中都需要一个super() 语句？**  
因为除了Object类以外，所有类都会继承一个父类；继承父类，那么子类实例化时就需要给父类中的成员变量显示赋值，就需要用到父类中的构造函数；

2、**如果父类中没有无参构造函数，子类如何实例化？**  
super()表示调用父类无参构造函数；如果父类中没有无参构造函数，就会报错；

![2400330-afde2819cda2a05c.png][]

38.png

如何解决这个问题呢？  
1、在父类中添加一个无参构造函数；

![2400330-13b8c9f854e0102f.png][]

39.png

2、在子类的构造函数中显示的调用父类有参构造函数；  
在子类中调用父类的构造函数，需要使用super关键字；格式是：super(参数);

![2400330-21abe64e578f8d2d.png][]

40.png

在子类构造函数中使用super调用父类构造函数需要注意，这个super语句必须写在构造函数的第一行；

![2400330-dce645b4ae63b893.png][]

41.png

3、**子类构造函数中，this() 和 super() 能否同时存在？**  
不能；因为他们都要写在构造函数的第一行；  
所以如果一个构造函数中有this（）语句，就没有super()语句,super（）存在于this调用的那个构造函数里面；

4、**如果一个类的构造函数全部私有了，还可以有子类吗？**  
不能；因为在子类的构造函数中一定要调用父类的构造函数；而一旦一个类的构造函数都私有了，就只能在本类中使用，其他类（也包括子类）都无法使用；

## 5.7.继承总结 ##

**继承的概念**：通过extends关键字在两个类之间建立的一种关系；其中继承其他类的类叫做子类（派生类），被其他类继承的类叫做父类（超类）；  
继承关系，一般用来表示子类和父类的 是的关系，即子类描述的事物是 父类描述的事物的一个特例；

**继承的格式**：  
class Fu\{\}//父类  
class Zi \*\*extends \*\*Fu\{\}//子类

**继承的作用**：子类可以直接拥有父类成员；其中，私有成员和构造函数不参与继承；

**java中类继承的特点**：只支持单一继承和多重继承，不支持多继承（一个类不能同时继承多个类）

**继承中成员变量的特点**：  
子类中可以直接使用父类中定义的非私有的成员变量；  
如果子类中定义了和父类中相同的成员变量，直接调用，实际使用的是子类中定义的成员变量；要使用父类中定义的成员变量，需要使用关键字super，格式是：super.变量名；

**继承中一般函数的特点**：  
子类中可以直接使用父类中定义的非私有的一般函数；  
如果子类中定义了和父类中一样的函数，直接调用，实际使用的是子类定义的函数；要使用父类中定义的一般函数，需要使用关键字super，格式是：super.函数名(参数);

**方法重写的概念**：在继承中，如果子类中定义了和父类中一样的函数，则子类对象实际使用的是子类中定义的函数，这种情况叫做函数的重写；

子类重写父类函数需要注意的事项：  
1、子类中重写的函数，函数名、参数列表、返回值类型和是否静态，必须和父类中函数相等；  
2、子类中重写的函数，访问权限不能比父类中函数低；

**继承中子类实例化的特点**：  
1、子类实例化时，实际只创建子类一个对象；  
2、子类对象中会为父类中的非静态成员变量分配空间；  
3、在执行子类的构造函数时，必须要先调用父类的构造函数，作用是给父类的成员变量显示赋值；  
4、子类调用父类的构造函数，需要使用super关键字，格式是：super(参数);并且super语句必须在子类构造函数的第一行；  
**5、**子类构造函数中调用其他构造函数的this语句不能和调用父类构造函数的super语句共存；

**super小结**：super，表示父类；作用是区分子类和父类的成员，以及在子类的构造函数中调用父类构造函数；

# **6. final关键字** #

## 6.1.final简介 ##

final：表示最终的，最后的，主要用来修饰类、函数和变量；  
final修饰类，直接写在class关键自前面，表示这个类不能被继承；  
final修饰函数，直接写在函数的返回值类型前面，表示这个函数不能被重写，但是可以被继承；  
final修饰变量，表示这个变量的值不能被修改；

## 6.2.final演示 ##

### 6.2.1. 修饰类 ###

![2400330-d0a78751c366e728.png][]

42.png

### 6.2.2. 修饰函数 ###

![2400330-ef75d29a5755ce50.png][]

43.png

### 6.2.3. 修饰变量 ###

![2400330-43ee725af3cd5133.png][]

44.png

因为被final修饰的变量的值不可改变，所以java中都使用它表示常量；  
如果是常量，变量名的写法是：所有字母全部大写，多个单词之间使用下划线连接；

final int USER_AGE = 10;

被修饰的变量只是直接保存在变量中的值不能被修改，所以如果修饰的变量的数据类型是引用数据类型，那么这个引用不能修改，但是引用指向的对象中的数据可以修改；

![2400330-07a8f36a93b7afdd.png][]

45.png

![2400330-029c95b2af27b00e.png][]

46.png

## 6.3.final总结 ##

final：最终的，最后的；可以修饰类、变量和函数；  
修饰类，表示该类不可被继承；格式是直接写在class关键字前面；  
修饰函数，表示继承这个类的子类中不能重写这个函数；格式是直接写在函数的返回值类型前面  
修饰变量，表示该变量的值不可改变；格式是直接写在变量的数据类型前面；  
注意：如果修饰的是引用类型的变量，则变量中保存的引用不可改变，但是引用指向的堆内存中的数据可以改变；

[2400330-48b9cbcf3f05a4d3.png]: /images/20210809/b9c8d124f17a4d34b79af4969b3d3ea7.png
[2400330-66c45499e927e882.png]: /images/20210809/c705136725a742c9a2623b63fc625ee1.png
[2400330-b0400d3889c842ed.png]: /images/20210809/41c175ee30a440e890d57958b061e676.png
[2400330-1801c3acb13121cb.png]: /images/20210809/2018040d5076408b83f7d1e79ae74b02.png
[2400330-0a60b7ff2ad57642.png]: /images/20210809/e1a04e2c743c492c8f1571b9d7526a4f.png
[2400330-9586149fe923de0f.png]: /images/20210809/24d0f25c4534415e951880b4ffd40a68.png
[2400330-f1058bf2fb12b79a.png]: /images/20210809/ebe3c5520acc4492b19230d666a3a56e.png
[2400330-05bf747e8a9a5561.png]: /images/20210809/4aefea18338c4b478cd3d4337faa3869.png
[2400330-a71db205efd2aad8.png]: /images/20210809/f1e5bf407c6e44b5aa0391cc35c03591.png
[2400330-f1af9df1e26890a6.png]: /images/20210809/8e2009e26e794ffd976cabd961872b0d.png
[2400330-ece1978a1ae0e3d8.png]: /images/20210809/68136287d2a1499bbfcfc7bce87cd921.png
[2400330-9f6eeada16663828.png]: /images/20210809/86bd19c348344c79bd37c1b49a77c53b.png
[2400330-5baf35fc520f0fd8.png]: /images/20210809/8032b87e48e24578b9298e9a9dd99ff4.png
[2400330-94a2702db830e4c0.png]: /images/20210809/cd5f2e93a07e41b593098a10e3b7203a.png
[2400330-d514e6ff2420a839.png]: /images/20210809/125b4386ffcf4ceb850f167be6ef3baa.png
[2400330-511d5a0c6f2f8e68.png]: /images/20210809/93477f62b2a74cefbd509f016d69f453.png
[2400330-1153f70cf27bcf57.png]: /images/20210809/4df24e2531de49db93734bc9edb063bf.png
[2400330-f72840c9cc312228.png]: /images/20210809/91556f39d7dc4ffb9e5b52d7a88ad8a0.png
[2400330-ac48d3645e800a55.png]: /images/20210809/4b7f76e05b3647e78938b3fc1cdf1ce7.png
[2400330-4bd73457d59ae9f3.png]: /images/20210809/1b2fdb9eb0a74bbb88a9f3fcecbe5818.png
[2400330-d22e95fd30fc064c.png]: /images/20210809/804fa9f753904b349a440d8516938f07.png
[2400330-be2c39e2395c874b.png]: /images/20210809/cba8b90ac13840749e7ded738ad2fc4d.png
[2400330-84c3a2398c101fbe.png]: /images/20210809/c74ca65b348241049d920b061ccf6aab.png
[2400330-e1405f21a26313bf.png]: /images/20210809/5afbcff280804a3c8f01aba0e9c30879.png
[2400330-b5b213985bc84764.png]: /images/20210809/e770370a41874d92b2ad33a598fcbc73.png
[2400330-109430755c111de3.png]: /images/20210809/07ca67c8f3524d4c842a32cbbc9eb3e0.png
[2400330-503f984eaeaad0eb.png]: /images/20210809/1422eae310af4546b85bd8087f33524e.png
[2400330-cf73a14f3fa601dc.png]: /images/20210809/48f3505598a84b17a17733f2d84d845b.png
[2400330-9b99f4b8ffd94625.png]: /images/20210809/004866edbe31455a9deff5de8b478172.png
[2400330-2cbaa51fb9e7258d.png]: /images/20210809/425daabf489d497cab11bb55a796dea1.png
[2400330-dc7aca5ea72006ce.png]: /images/20210809/428c18ef79c74d0fbdee2354803a6d01.png
[2400330-8c0363d3e9600578.png]: /images/20210809/cfff836ebe9f431690b3599f15ca897b.png
[2400330-a1e7470037852684.png]: /images/20210809/a15524e0ecc743e6815d5cefccc71aa7.png
[2400330-afde2819cda2a05c.png]: /images/20210809/17b900c62c194c0289fff9a232ae036c.png
[2400330-13b8c9f854e0102f.png]: /images/20210809/c7b96db521494a4787688ce6fe9809c6.png
[2400330-21abe64e578f8d2d.png]: /images/20210809/82766d555c424847bc10e7cd0f284c75.png
[2400330-dce645b4ae63b893.png]: /images/20210809/5b538794f5844c3791bdbd71c825f157.png
[2400330-d0a78751c366e728.png]: /images/20210809/960fbdcd19564fd89cfe0c2b33f9023c.png
[2400330-ef75d29a5755ce50.png]: /images/20210809/8ae12114085e43b9a4351a2f3aedad53.png
[2400330-43ee725af3cd5133.png]: /images/20210809/b95e6919cffe43ecadd84345c83ec912.png
[2400330-07a8f36a93b7afdd.png]: /images/20210809/4dda861cb025422e880574fd3b2303e6.png
[2400330-029c95b2af27b00e.png]: /images/20210809/17036c323baf4d458008373f9b211ffd.png