编程语言
首页 > 编程语言> > 2022-7-27 第二组 程梓杭 Java（10）内部类与饿汉式与懒汉式与双链表

2022-7-27 第二组 程梓杭 Java（10）内部类与饿汉式与懒汉式与双链表

作者：互联网

今日学习内容：内部类与饿汉式与懒汉式与双链表

一、块

二、static，外部类，内部类，匿名内部类

三、单例设计模式之饿汉式与懒汉式

四、双链表

知识点一：

块：

又称代码块，是直接写在类下的由{}包裹的代码。块适用于static修饰。
当其他类调用该类时，写在该类下的块也会执行，执行顺序：静态最优先，父类次优先，结构体最次优先。

知识点二:

1、static：

static是Java提供的静态修饰词。static可以修饰变量与方法成为类变量和类方法（静态变量和静态方法）。
静态变量有两种引用方式：类名引用和对象名引用。当静态变量发生变化时，该类实例化的所有对象的该静态成员变量也会发生相同的变化。
静态方法可以通过类名引用（在static修饰下变成了属于类而非具体对象的方法）（非静态方法需要通过对象引用）

2、外部类：

一般来说，外部类是定义在已设置主类的.java文件下的类。当在主类内部定义了一个内部类，主类成为了相对意义上的外部类。

3、内部类：

内部类是定义在.java文件主类内部的类，分为静态内部类和非静态内部类。
静态内部类和非静态内部类之间的区别主要如下：

点击展开 
内部原理的区别：
静态内部类是属于外部类的类成员，是一种静态的成员，是属于类的，就有点类似于private static Singleton instance = null；
非静态内部类，是属于外部类的实例对象的一个实例成员，也就是说，每个非静态内部类，不是属于外部类的，是属于外部类的每一个实例的，创建非静态内部类的实例以后，非静态内部类实例，是必须跟一个外部类的实例进行关联和有寄存关系的。
创建方式的区别： 创建静态内部类的实例的时候，只要直接使用“外部类.内部类()”的方式，就可以，比如new School.Teacher()；创建非静态内部类的实例的时候，必须要先创建一个外部类的实例，然后通过外部类的实例，再来创建内部类的实例，new School().Teader()
通常来说，我们一般都会为了方便，会选择使用静态内部类

知识点三：

1、设计模式：

所谓设计模式，是程序员们总结的行之有效的设计方式，包含诸多规则，有诸多设计模式。单例设计模式就是其中之一。
单例设计模式要求一个类只能有一个对象，不容许创建新对象。

2、饿汉式：

饿汉式取迫不及待的意思，在类创建之初就创建了一个private权限的对象，并且将构造方法也设置为private避免调用构造方法构造新对象。因为需要在主类中调用本类对象，所以还需要设置一个调用方法。

点击查看 
public class Text{
    private static final Text text = new Text();

    private Text(){}

    public static Text getInstance(){
        return text;
    }
}
//定义了一个Text文本类，然后定义了一个私有的text文本对象，私有化了构造方法，公开了text的调用方法。
//于是我们得到了一个只能查看，不能再创建的文本。
3、懒汉式：

懒汉式取懒惰（不着急）的意思，在类创建时并未构造对象而是在主类访问本类时进行构造。关于懒汉式的写法，并不单一，不同写法有不同的优缺点。这里提供了其中两种写法。

点击查看第一种写法 
public class Emperor {
    private static Emperor emperor;
    private static String name;

    private Emperor() {
    }

    public static Emperor getInstance(String name) {
        if ( emperor == null ) {
            emperor = new Emperor();
            emperor.name = name;
        }
        id++;
        return Emperor.emperor;
    }
//创建了一个皇帝类,私有化了对象（未创建）和对象名，私有化了构造方法。
//当使用公有化调用方法时，根据传入姓名在无对象时创建对象，否则直接返回对象。
点击查看第二种写法 
public class SingletonPatternLazyInnerClass {

    private SingletonPatternLazyInnerClass(){}

    private static class SingletonHolder{
        private static final SingletonPatternLazyInnerClass INSTANCE = new SingletonPatternLazyInnerClass();
    }

    public static SingletonPatternLazyInnerClass getInstance(){
        return SingletonHolder.INSTANCE;
    }
}
//创建了一个“单例模式懒汉内部类”类，私有化了对象构造方法。公开了一个对象调用方法，但是返回了内部类对象。
//创建了内部类，内部类创建了私有化最终对象（不可更改），经由外部内对象调用方法传出。

知识点四：

双链表：

双链表结点模型、链表概念模型（2）如下图：
image
image
image

双链表代码示例：

点击查看 
public class DoubleLinkList{
    private Node head;      // 头结点
    private Node tail;      // 尾指针
    private Integer length; // 链表有效长度

    private class Node{
        private Integer data;     // 数据域
        private Node prior; // 指针域 前
        private Node next;  // 指针域 后

        public Node(){}
        public Node(Integer data){
            this.data = data;
        }
    }

    public DoubleLinkList(){
        this.head = new Node();
        this.length = 0;
    }

    public Integer getLength(){
        return this.length;
    }

    public Boolean isEmpty(){
        return this.length == 0;
    }

    /**
     * 尾插
     * @param data 插入的数据
     */
    public void addNode(Integer data){
        Node tmp = this.head;
        while(tmp.next != null)
            tmp = tmp.next;
        Node newNode = new Node(data);
        tmp.next = newNode;
        newNode.prior = tmp;
        this.length++;
    }

    /**
     * 根据下标删除节点
     * @param index
     */
    public void deleteNode(Integer index){
        if(index < 0 || index >= this.length)
            return;
        Node tmp = this.head;
        while(tmp.next != null && index-- != 0)
            tmp = tmp.next;
        Node delNode = tmp.next;
        delNode.next.prior = tmp;
        tmp.next = delNode.next;
        this.length--;
    }

    /**
     * 通过下标查询节点并返回数据
     * @param index
     * @return
     */
    public Integer selectNode(Integer index){
        if(index < 0 || index >= this.length)
            return null;
        Node tmp = this.head;
        while(tmp.next != null && index-- != 0)
            tmp = tmp.next;
        return tmp.next.data;
    }

    /**
     * 通过下标进行修改节点
     * @param index
     * @param newData
     */
    public void updateNode(Integer index, Integer newData){
//        if(index < 0 || index >= this.length)
//            return;
        Node tmp = this.head;
        while (tmp.next != null && index-- != 0)
            tmp = tmp.next;
        if(index == 0) {
            tmp.next.data = newData;
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        Node tmp = this.head;
        while (tmp.next != null){
            tmp = tmp.next;
            stringBuilder.append(tmp.data).append(" ");
        }
        return stringBuilder.append("\n").toString();
    }

    public static void main(String[] args) {
        DoubleLinkList doubleLinkList = new DoubleLinkList();
        System.out.println(doubleLinkList);
        doubleLinkList.addNode(1);
        doubleLinkList.addNode(2);
        doubleLinkList.addNode(3);
        doubleLinkList.addNode(4);
        System.out.println(doubleLinkList);

        doubleLinkList.deleteNode(4);
        doubleLinkList.deleteNode(0);
        doubleLinkList.deleteNode(4);
        System.out.println(doubleLinkList);

        System.out.println(doubleLinkList.selectNode(3));
        System.out.println(doubleLinkList.selectNode(2));
        System.out.println(doubleLinkList);

        doubleLinkList.updateNode(0, 10);
        doubleLinkList.updateNode(100, 10);
        System.out.println(doubleLinkList);
    }
}

一些思考：

当学习到的知识杂乱时，简单的思维导图或许收益甚小，可以考虑画一颗模糊的知识树，将新学的知识作为树枝找到它应在的位置。例如上述涉及的数据结构和设计模式完全不在同一枝干上，需要在学习前中后对背后相关的概念加以理解。

标签：tmp,10,27,doubleLinkList,private,next,static,饿汉,public
来源： https://www.cnblogs.com/ybuczh/p/16526761.html