编程语言
首页 > 编程语言> > 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