梳理5-----面向对象：封装、继承、多态

一、封装

1. 方法---对象

      

2.

（1）基础数据类型  （沒有方法）

       存在栈里面

（2）引用数据类型  （需要new）（String类型特殊，也可以直接赋值）（有 方法 ）（封装）

                            

 

只定义 不赋值（ int ) ( String ）

 

 3. 权限修饰符

4. 构造方法

不要返回值

5. 方法的重载

 6. getter setter

      

7. 方法中的变量 = 局部变量

（sout打印不出来）

二、继承（extends）

1. 重写

2. 子类构造

(1) super.方法 

(2) 构造son，必须先构造father（也先构造一个顶级父类 Object）

(3) 若father的构造方法仅一个含参构造，则son

              

(4) 类的加载顺序

 静态代码段：

      

                                     

(5) 

5. 引用类型比较内容

①

               

原因：father1 father2是引用，这里比较的是地址

② 特殊

                         

“a”会被当做常量 放在永久代

             

        

          

 ③ 重写equals方法 + instanceof

6.  instanceof （是实例）

                  

 

A instanceof B  ：A是不是B的实例？

 

 为了使用子类的一些方法，强转成子类

 不知道传进来的是什么，所以参数类型设置为Object

7.  Object的 toString() 和 hashCode

 （1）toString()  

                ①

                                 

　　　　　　　　　

                              

               ②   转换成字符串

                                     

                     重写了

                                                    

                                                             

                                                                          

                

 （2） hashCode()

          用于区分对象

三、多态（前提：继承、重写、父类引用指向子类对象）

1. 父类引用指向子类对象

Father son = new Son("name");

      这就是多态

     

                                           

2. 接口 和  抽象类

（1）抽象类 + 抽象方法

                抽象方法必须被实现                

（2）接口--所有的方法都是抽象方法

                     

实现接口需要实现其所有方法。

多态应用

/**
 * @author sr
 * @date 2021/1/18
 */
public interface Super {
    /**
     * 添加数据
     * @param data
     */
    void add(Integer data);

    /**
     * 删除结点
     * @param index
     */
    public void delete(int index);

    /**
     * 修改
     * @param index
     * @param newData
     */
    void upDate(int index,Integer newData);

    /**
     * 打印
     */
    void print();

    /**
     * 查
     * @param index
     * @return
     */
    Integer get(int index);

}

/**
 * @author sr
 * @date 2021/1/18
 */
public class SuperLink implements Super{
    private Node head;

    /**
     * 头插法
     * @param data
     */
    @Override
    public void add(Integer data){
        Node newHead = new Node(data,null);
        newHead.setNext(head);
        head = newHead;
    }

    /**
     * 删除结点
     * @param index
     */
    @Override
    public void delete(int index){
        if (index == 0){
           Node node = getNode(index);
           head = node.getNext();
        }else {
            Node node = getNode(index - 1);
            node.setNext(node.getNext().getNext());
        }
    }

    /**
     * 修改指定结点的值
     * @param index
     * @param newData
     */
    @Override
    public void upDate(int index, Integer newData){
        Node node = getNode(index);
        node.setData(newData);
    }

    /**
     * 查找指定节点的值
     * @param index
     * @return
     */
    @Override
    public Integer get(int index){
        return getNode(index).getData();
    }


    /**
     * 查找指定结点
     * @param index
     * @return
     */
    public Node getNode(int index){
        Node node = head;
        for (int i = 0; i < index; i++) {
            node = node.getNext();
        }
        return node;
    }


    /**
     * 打印链表的全部
     */
    @Override
    public void print(){
        Node node = head;
        while (node != null){
            System.out.println(node.getData());
            node = node.getNext();
        }
    }
}

/**
 * @author sr
 * @date 2021/1/18
 */
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();
        animal.breath();

        //SuperLink和SuperArray同时implement Super
        //需要修改s时，只需要修改 new SuperArray() 即可
        Super s = new SuperLink();

        s.add(2);
        s.add(3);
        s.add(4);
        s.add(5);
        s.add(6);

        s.print();

    }
}