首页 > 其他分享> 文章详细

2022-7-26 第一小组甘源册学习笔记

2022-07-26 20:02:23 阅读：102 来源： 互联网

标签：node Node 26 return 甘源册接口 2022 抽象类 public

知识点掌握情况
学习心情(心路历程)
1.抽象
2.接口
- 2.1接口的声明
3.匿名实现类
今日总结
算法

知识点掌握情况

抽象类(理解) 接口(了解)

学习心情(心路历程)

今天收获颇丰,知识的储备量又增加了 (≧∇≦)(≧∇≦)

1.抽象

Java中有了抽象类和接口

1.1抽象方法：

特点：没有方法体（连{}都没有）
存在的意义：约定——自定义的规则（约定大于配置，配置大于编码）、
定义的规则：
- 约定了返回值
- 约定了访问权限
- 约定了参数列表
- 需要在重写的时候去定义方法体
抽象方法必须在一个抽象类里
抽象方法不能被私有化（private），其他的可以——(开发中：抽象方法都是public)
抽象方法不能被final修饰（用final修饰的方法不能被重写）

1.2抽象类：

当我们定义了一个抽象类，抽象类中的结构
- 属性
- 普通的成员方法
- 构造器
- 抽象方法
- 常量（final）
抽象类中可以没有抽象方法
- 抽象类中没有抽象方法，就毫无意义
抽象类不能被实例化
抽象类不能创建对象
抽象类构造器存在的意义
- 为了约定子类的构造器必须要和父类的构造器匹配
一个类如果继承了一个抽象类，就必须重写抽象类的所有的抽象方法
抽象类不能被final修饰（final修饰的类不允许被继承）

1.3 abstract关键字

修饰
- 类
- 方法

1.4总结

重写方法必须是public或者protected（因为如果是private，不能被子类继承，子类便无法实现该方法，）默认情况其实就是public

抽象类不能被直接实例化的，不能够创建对象，需要依靠子类才用向上转型的方式处理

	Animal animal=new Person(); //Animal 抽象类  Person子类
       Person person = new Person();
       person =(Person) animal;

抽象类必须有子类，使用extends继承，一个类只能继承一个抽象类
子类（如果不是抽象类）则必须重写抽象类中的所有抽象方法（如果子类没有实现父类的抽象方法，必须将子类定义为abstract）

2.接口

比抽象类更高级的抽象更高级的抽象类；

2.1接口的声明

使用interface关键字

接口中能定义

抽象方法，不能有属性，不能有方法。静态的常量，（JDK1.7之前）
默认方法和静态的方法（JDK1.8之后）

    //静态方法
    public static void breath(){
    }
    //默认方法
    public default   void eat(){
    }
    //静态常量
    public static final String NAME="第卅派";
    //抽象方法
    public abstract void show();

默认方法（写在接口中的成员方法）与成员方法没区别
接口中结构的特点
- 接口中的默认方法是public abstract，省略
- 接口中的常量默认是public static final ，省略
- 接口中的结构必须是public
接口可以被一个类去实现，这个类就叫实现类
一个类继承类B的同时可以去实现接口A——这个类就可以叫父类B的子类（接口A实现类）
如果一个类实现了一个接口，那他就需要重写接口中的所有抽象方法
接口和继承的区别
- 可以实现多个接口，但是只能继承一个类
- 开发中：一件事情可以通过实现接口和继承来解决问题，优先使用接口
面试题
- 继承抽象类和实现接口的异同。
  - 同：都是需要重写所有的抽象方法
  - 异：抽象类只能单继承，接口可以多实现
- 抽象类和接口的区别。
- 在Java中只有单继承？
  - 在Java中是存在多接触的，发生在接口之间
  - Java类之间是单继承
接口存在的意义：
- 约定：
- 面向接口编程，面向切面编程，面向对象编程

		//向上实现
		Biology biology=new Demo();// Biology 接口  Demo 实现类

3.匿名实现类

        Abstr01 abstr01=new Abstr01() {
            @Override
            public void show() {

            }
        };//抽象类
		// 接口指向——>匿名实现类
        Inter01 inter01=new Inter01() {
            @Override
            public void eat() {
                
            }
        };//接口

今日总结

抽象abstract关键字
1. 抽象类的特点
2. abstract能修饰那些结构
3. 抽象方法的特点
接口 JDK1.7~JDK1.8的有什么改变
面试题：继承类和实现接口的异同。抽象类和接口的区别
多态的补充说明
匿名实现类
重点：结合多态，参数的传递，配合instanceof的使用
能够使用多态表示对象的时候，尽量使用多态
栈和队列——建立在两个最基础的数据结构的基础上建立两个受限制的链表

以下两个类里所调用的方法的类，在上一篇博客中

队列

package com.gyc.afternoon;

public class Queue {
    private SuperLinked superLinked=new SuperLinked();

    public SuperLinked getSuperLinked() {
        return superLinked;
    }

    public void setSuperLinked(SuperLinked superLinked) {
        this.superLinked = superLinked;
    }

    //入队
    public void add(Integer integer){
        superLinked.add(integer);
    }
    //出队
    public Integer poll(){
        //1.判断队列是否为空
        try {

        //2.找到队列的头
        if (superLinked.getSize()!=0){
            superLinked.deleteFirst();
            return  superLinked.getNode(0).getData();
        }else {
            System.out.println("队列为空");
            return null;
        }
        }catch (NullPointerException e){
            System.out.println("队列已清空为空");
            return null;
        }
        //3.把队伍的头删掉
        //4.返回删除的值
    }

    public static void main(String[] args) {
        Queue queue = new Queue();
        queue.add(12);
        queue.add(12421);
        queue.add(1231);
        queue.poll();
        queue.poll();
        queue.poll();
        queue.poll();
        queue.add(1223131);
        queue.add(222);

        System.out.println(queue.superLinked.getNode(0));
    }
}

栈


package com.gyc.afternoon;

//栈和队列
public class Stack {
    private SuperLinked superLinked=new SuperLinked();

    public void push(Integer integer){
        superLinked.add(integer);
    }
    //入栈    压栈
    public Integer pop(){
        try {
            if (superLinked.getSize()!=0){
                Node node = superLinked.getNode(superLinked.getSize()-1);
                superLinked.deleteLast();
                return node.getData();
            }else {
                System.out.println("列表为空");
                return null;
            }
        }catch (NullPointerException e){
            System.out.println("列表已经清空");
            return null;
        }
    }
    public Integer peek() {
        try {
            return superLinked.getNode(superLinked.getSize()-1).getData();
        }catch (NullPointerException e){
            System.out.println("d");
            return null;
        }
    }

    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(12);
        stack.push(1231);
        stack.push(12152);
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.push(122);
        stack.push(12241212);

        System.out.println(stack.peek());

        System.out.println(stack.superLinked.getNode(0));

    }
}

算法

符号表

Node类

class Node{
    private Integer key;
    private String value;
    private Node next;

    public Node() {
    }

    public Node(Integer key, String value, Node next) {
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public Integer getKey() {
        return key;
    }

    public void setKey(Integer key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
    @Override
    public String toString() {
        return  value+" ->";
    }
}

SymbolTable类


public class SymbolTable {
    private Node head;
    private Integer N=1;
    public void put(Integer key,String value){
        Node node = new Node(key, value, null);
        if (head==null){
            head=node;
            return;
        }
        Node node1=head;
        while (node1.getNext()!=null){
            if (node1.getKey()!=key) {
                node1 = node1.getNext();
                continue;
            }else {
                node1.setValue(value);
                return;
            }
        }
        node1.setNext(node);
        N++;
    }
    public String get(Integer key){
        Node node=head;
        for (Integer i = 0; i < N; i++) {
            if (node.getKey().equals(key)){
                return node.getValue();
            }
            node=node.getNext();
        }
        return "此键值对不存在";
    }
    public void delete(Integer key){
        Node node=head;
        for (Integer i = 0; i < N; i++) {
            if (node.getNext().getKey().equals(key)){
                Node node1=node.getNext().getNext();
                  node.setNext(node1);
                  N--;
                  return;
            }
            node=node.getNext();
        }
     }
    public Integer size(){
        return N;
    }
    public void bl(){
        Node node = head;
        while (node.getNext() != null) {
            System.out.print(node);
            node = node.getNext();
        }
        System.out.println(node);
    }

    public static void main(String[] args) {
        SymbolTable table = new SymbolTable();
        table.put(1,"乔峰");
        table.put(2,"虚竹");
        table.put(3,"段誉");
        System.out.println("插入完毕后，元素的个数为:"+table.size());
        table.put(2,"慕容复");
        System.out.println("替换完毕后，元素的个数为:"+table.size());
        System.out.println("替换完毕后，键2对应的值为:"+table.get(2));
        table.delete(2);
        System.out.println("删除完毕后，元素的个数为:"+table.size());
        table.bl();
    }

}

OrderSymbolTable类


package Symbol_table;

public class OrderSymbolTable {
    private Node head;
    private Integer N = 1;

    public OrderSymbolTable() {
    }

    public OrderSymbolTable(Node head, Integer n) {
        this.head = head;
        N = n;
    }

    public Node getHead() {
        return head;
    }

    public void setHead(Node head) {
        this.head = head;
    }

    public Integer getN() {
        return N;
    }

    public void setN(Integer n) {
        N = n;
    }

    public void put(Integer key, String value) {
        Node node = new Node(key, value, null);
        if (head == null) {
            head = node;
            return;
        }
        Node node1 = head;
        while (node1.getNext() != null) {
            if (node1.getNext().getKey() < key) {

                if (node1.getKey() != key) {
                    node1 = node1.getNext();
                    continue;
                } else {
                    node1.setValue(value);
                    return;
                }
            } else {
                Node node2 = node1.getNext();
                node1.setNext(node);
                node.setNext(node2);
                 N++;
                return;
            }
        }

        node1.setNext(node);
        N++;
    }

    public String get(Integer key) {
        Node node = head;
        for (Integer i = 0; i < N; i++) {
            if (node.getKey().equals(key)) {
                return node.getValue();
            }
            node = node.getNext();
        }
        return "此键值对不存在";
    }

    public void bl() {
        Node node = head;
        while (node.getNext() != null) {
            System.out.print(node);
            node = node.getNext();
        }
        System.out.println(node);
    }

    public static void main(String[] args) {
        OrderSymbolTable table = new OrderSymbolTable();
        table.put(1, "张三");
        table.put(2, "李四");
        table.put(4, "赵六");
        table.put(7, "田七");
        table.put(3, "王五");
        table.bl();

    }
}

标签：node,Node,26,return,甘源册,接口,2022,抽象类,public
来源： https://www.cnblogs.com/gycddd/p/16520404.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

2022-7-26 第一小组 甘源册 学习笔记