面向对象之多态及接口、ArrayList类

面向对象之多态

1.多态的含义

1.同一个对象，在不同时刻表现出来的不同形态
多态分两种：
(1) 编译时多态（设计时多态）：方法重载。
(2) 运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态

2.方法重载和方法重写

1.方法重写
在两个类中，方法名相同，参数列表相同，返回值类型相同
2.方法重载
在一个类中，方法名相同，参数列表不同，与返回值类型无关

3. 多态的前提和体现

运行时多态存在的三个必要条件：
一、要有继承或实现关系（包括接口的实现）；
二、要有重写；
三、父类引用指向子类对象

package com.itfjenghua;

public class Animal {
    public int age=40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}
----------------------------------
package com.itfjenghua;

public class Dog extends Animal {
    public String name="feng";
    public int age=10;
    public void show(){
        System.out.println("狗抓老鼠");
    }
    @Override
    public void eat(){
        System.out.println("狗吃肉");
    }



}
---------------------------------
package com.itfjenghua;

public class Test {
    public static void main(String[] args) {
        Animal a =new Dog();
        a.eat();//狗吃肉
        //a.show();
        //Aniaml类中没有show方法所以报错，方法编译看左边，运行看右边
        System.out.println(a.age);//40
       // System.out.println(a.name);
        //成员方法编译看左边，运行看右边

    }
}

4.转型

1.向上转型
父类引用指向子类对象就是向上转型
2.向下转型
格式：子类型 对象名 = (子类型)父类引用;

package com.fenghua01;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();//没有方法体，加关键字abstract为抽象方法

}
--------------------------------
package com.fenghua01;

public  class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    @Override//方法重写
    public  void eat(){
        System.out.println("狗吃肉");
    }

//子类特有方法
    public void show(){
        System.out.println("奥特曼打小怪兽");
    }
}
---------------------------------
package com.fenghua01;

public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }//抽象方法不能实例具体化，使用子类继承通过子类对象实例化实现

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
----------------------------------
package com.fenghua01;

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.eat();
        Dog d =(Dog)a;
        //向下转型
        d.show();
        System.out.println("------------");
        //调用子类特有方法
        a = new Cat("加菲",22);
        //多态形式向上转型
        System.out.println(a.getName()+","+a.getAge());
        //加菲,22
    }
}

5.多态形式获取成员

通过子类创建对象获取父类对象类型
//有父类引用指向子类对象
Animal a = new Cat();
获取的是父类的成员，不能访问子类成员

访问的是成员变量时，执行也是父类的成员变量
访问方法是父类方法，执行的是子类中重写的方法

6.抽象

1.抽象关键字abstract
2.抽象方法
没有方法体，且被abstract修饰的方法为抽象方法
注：抽象方法只能存在抽象类
3.抽象类
被abstract修饰的类为抽象类
注：抽象类不能被实例化，想要获取抽象类的实例，只能通过子类来创建

抽象类中可以有非抽象方法，有抽象方法的类必须抽象类

4.子类继承抽象类
1.普通子类
必须重写父类中所有的抽象方法
2.抽象子类
可以不重写

7.接口

1、什么是接口？
接口就是一种公共的规范标准
2、声明接口的关键字
interface
3、接口被类实现的关键字
implements
普通子类
必须重写接口中所有的方法（抽象的方法：特殊抽象方法，可以不适用abstract关键字修饰）
抽象的子类
可以不对接口中方法重写
4.接口不能被实例化，只能通过已知实现类初始化对象
参照多态的方式，通过实现类对象实例化，这叫接口多态。
多态的形式：具体类多态，抽象类多态，接口多态。

8.接口中成员的特点

1.接口中没有变量，只有常量
默认修饰符：public static final
2.接口没有构造方法
3.接口中的方法都是public abstract 修饰的没有方法体的方法，不能声明带有方法体的方法
4.一个类如果没有继承方法默认继承Object类

9.类与接口的关系

1.声明类的关键字是Class，声明接口的关键字是interface
2. 类是单继承，多实现；
接口是多继承

10.抽象类和接口的区别

1.抽象类是abstract修饰的类，接口是interface声明的
2.抽象类是对类的抽象，接口是对方法的抽象
3.抽象类中可以有变量，可以有常量，接口中只有常量
4.抽象类中有构造方法，接口中没有构造方法
5.抽象类中可以有带有方法体的方法，也可以有abstract修饰的没有方法体的抽象方法，接口只能有抽象方法

11ArrayList类概述

1、

• 集合：

  提供一种存储空间可变的存储模型，存储的数据容量可以发生改变

• ArrayList集合的特点

  底层是数组实现的，长度可以变化泛型的使用

• 泛型的使用

​ 用于约束集合中存储元素的数据类型

2、ArrayList的基本方法

​ 1）、remove()：删除指定元素，返回boolean

​ 2）、E remove(int index)：删除指定索引处的元素，返回被删除的元素

​ 3）、 E set(int index,E element)：修改指定索引处的元素，返回被修改的元素

​ 4）、E get(int index)：返回指定索引的元素

​ 5）、 int size()：返回集合中元素的个数

​ 6）、boolean add(E e)：将指定元素追加到此集合的末尾

​ 7）、add(int index,E element)：在此集合中的指定位置插入指定的元素

package com.itfenghua;

import java.util.ArrayList;

public class Demo01 {
    public static void main(String[] args) {
        ArrayList<String> arry=new ArrayList<>();
        arry.add("上杉绘梨衣");//[上杉绘梨衣]
        arry.add(0,"龙族");//[龙族,上杉绘梨衣]
        arry.add(0,"火影");//[火影,龙族,上杉绘梨衣]
        arry.add(1,"漩涡鸣人");//[火影,漩涡鸣人,龙族,上杉绘梨衣]
        arry.add("黑王");//[火影,漩涡鸣人,龙族,上杉绘梨衣,黑王]
        arry.remove("黑王");//[火影,漩涡鸣人,龙族,上杉绘梨衣]
        arry.remove(0);//[漩涡鸣人,龙族,上杉绘梨衣]
        arry.remove(0);//[龙族,上杉绘梨衣]
        arry.set(0,"龙族");//[龙族,上杉绘梨衣]
        arry.add("上杉绘梨衣");//[龙族,上杉绘梨衣,上杉绘梨衣]
        //获取第几个索引的元素
        arry.remove("上杉绘梨衣");//[龙族,上杉绘梨衣]
        //删除相同元素中的第一个元素
        String s = arry.get(1);
        System.out.println(s);//上杉绘梨衣
        System.out.println(arry.size());//2
        System.out.println(arry);//[龙族, 上杉绘梨衣]
    }
}

2.ArrayList存储字符串并遍历

package com.itfenghua;

import java.util.ArrayList;

public class Demo02 {
    public static void main(String[] args) {
        ArrayList<String> arry=new ArrayList<>();
        arry.add("上杉绘梨衣");
        arry.add(0,"龙族");
        for (int i = 0; i < arry.size(); i++) {
            String s = arry.get(i);
            System.out.println(s);
            //龙族
            //上杉绘梨衣
        }

    }
}