2022-07-25 第8组 韩文清

                                                                     多态

一.多态

1.多态是面向对象的特征之一，封装和继承是其中两个特征----三个特征都称之为抽象。

2.多态的概念：是同一个行为具有多个不同表现形式或形态的能力。

  举例：你的女朋友让你买点水果回来，不管买回来的是苹果还是西瓜，只要是水果就行，这就是               多态的体现。

  举例2：猫，狗，猪都可归纳成动物，每一种动物都必须要吃东西，所以我们可以统一设置他们必须吃，但是每一种动物习性都不一样，那就可以设置成它们自己特有的功能，多态对象只能调用父类中定义子类中重写的功能，并不能调用子类的特有功能。

3.多态存在的三个条件：继承 重写 父类对象指向子类引用

4.第一种多态形式（向上转型）-- --可以自动转（子转父类）

例：Animal animal=new Cat（）；

      父类   父类对象=new 子类（）；
 

5.第二种多态形式（向下转型）-- 加强转，但是转换会异常（父转子类）

例：Dog dog      = new    Animal；

    子类 子类对象 =new     父类；

*发生向下转型的前提是先发生向上转型，才能通过强转再转成子类对象

  *向下转型代码展示：

   父类创建一个eat方法：
package com.sunnaiyu.day;

public class Animal {
    public void eat(){
        System.out.println("animal在吃东西");
    }
}


       子类继承父类    ，  重写父类eat方法
public class Cat extends Animal{
    @Override
    public void eat() {

        System.out.println("cat在吃东西");
    }
    public void catchMouse(){
        System.out.println("cat抓老鼠");
    }
}


     子类继承父类，  子类创建一个look方法
public class Dog extends Animal {
    public void look(){
        System.out.println("狗可以看家");
    }
}


       
public static void main(String[] args) {
    Dog dog=new Dog();
    Cat cat=new Cat();
    Animal animal=new Animal();
    Animal animal=new Cat（）;       //向下转型
    Animal animal=new Dog();         //向下转型
    dog=(Dog)animal;                 //向上转型
}

二.关键字

1.instanceof（实例化）

   概念：判断某一个对象是不是某一个类的实例，返回值是boolean类型，后面写类名，不是对象    名。

2.object(无敌方法）

  public object show(Object obj){

     return true;

}

Object如果是形参，返回值是object，什么类型都行，但是需要加上if判断

三.匿名对象

1.语法：new 类名（）；

2.功能：和正常的有名字的对象功能是相同的，依然具备调用属性，方法的功能

3.使用场景:多数是用来在传参--实参，多数情况下配合构造器使用

4.优点：节约资源。

四.链表

1.单向链表:在维护一个节点的自身的值的同时，还要维护它的下一个值的指向

把数据添加到链表的尾部
public boolean add (Integer data){
        //把传入的数据构建成一个节点
        Node node=new Node(data,null);
        //如果现在链表是空的，我就是第一个节点
        if (first==null){
            first=node;
        }else{
            //如果链表不是空，那我就是最后一个节点
            //我应该是在原来的last节点后面
            //我是原来last节点的下一个节点
            last.setNext(node);
        }
        last=node;
        size++;
        return true;
    }

在指定位置添加元素
public boolean add(int index,Integer data){
    Node node=getNode(index);
    Node newNode=new Node(data,null);
    if(node !=null){
        Node next =node.getNext();
        newNode.setNext(next);
        node.setNext(newNode);
    }else{
        //如果要插入的位置是null，只有一种情况，就是整个链表都是空
        first =newNode;
        last=newNode;
    }
    size++;
    return  true;
}

默认删除头部的数据
public boolean remove(){
    if(size<0){
        return  false;
    }
    if(first!=null){
        first=first.getNext();
        size--;
    }
    return  true;
}

删除尾部的数据
public  boolean removeLast(){
    if(size<0){
        return  false;
    }
    if(size<2){
        first=null;
        last=null;
        size--;
        return  true;
    }
    if(last!=null){
        last=getNode(size-2);
        size--;
    }
    return  true;
}

修改指定下标的元素
public boolean set(int index,Integer data){
    Node node=new Node();
    node.setData(data);
    return true;
}

据下标获取指定的结点
//根据下标获取指定的数组
    public Integer get (int index){
        return getNode(index).getData();
    }

获取链表的长度
public int size(){
    return size;
}

2.双向链表：在维护一个节点的自身的值的同时，还要维护它的上一个和下一个值的指向

五.错题总结

1.private  final等修饰的类及内容不能被子类使用 

2.方法重载：允许在一个类中包含有方法名相同，

                     但参数列表不同的方法形式称之为。

3.方法重写：如果出现父类的方法无法满足子类的需求，需要对

                     父类方法进行。

4.Final关键字修饰变量成为最终变量，修饰方法表示最终方法，修饰类表示最终类

5.父类构造器不能被继承，因此不能被方法重写，但可以被方法子类方法调用

6.在继承关系中父类的构造方法是不可以被子类继承

7.方法重写中，子类方法的修饰符范围的要求是大于等于父类方法修饰符

8.Java继承中一个父类可以有多个子类，一个子类能继承一个父类

9.方法重载和方法重写的区别：

 overload(方法重载)同一个类中，

                                 相同方法名可以有方法参数及返回值；

 overide(方法重写)|有父子关系的类中

                                 子类可以重写父类同名方法，要求方法参数列表返回值必须相同；

10.Object类的作用和常用方法有

      所有类的父类，也叫根类

        1）关于比较 equals()和hashCode()

        2) 用于创建 clone()

        3) 用于转换 toString()

        4) 用于线程 wait()  nofity()

11.final都能修饰哪些元素， 以及修饰不同元素所表示的含义和特点

    final 修饰类是最终类  （不能子类）

    final 修改方法是最终方法 （不能方法重写）
    final 修改变量是常量 （不能修改）

学习心得：

今天学习了多态，它有两种多态形式（向上转型，向下转型），两种的区别在于一个是子转父类，可以自动转，另一种需要强转。然后学习了关键字（instanceof，object），匿名对象，链表。其中最难的是链表(今天学习了单向链表）下一次就是双向链表了，老师讲的时候一脸懵逼，后面学习双向链表的时候一定会更加努力！