模块十一--接口/抽象方法/多态--尚硅谷Javase笔记总结

模块十一重点：

1.会定义接口

2.会在接口中定义抽象方法，默认方法，静态方法，成员变量

3.会调用接口中的成员

4.知道多态的前提

5.会利用多态的方式new对象

6.要知道使用多态的好处

7.会在多态的前提下，向下转型

8.会利用instanceof判断类型

第一章.接口：

1.接口的介绍

2.接口的定义以及使用（重点！）

2.1接口的介绍：

1.接口：是一个引用数据类型，是一种标准，规则

2.关键字：

a.interface 接口

public interface 接口名{

}

b.implements 实现

实现类 implements 接口名{

}

3.接口中可以定义的成员：

a.jdk7以及之前：

抽象方法：public abstract->即使不写public abstract，默认也有

成员变量：public static final 数据类型变量名=值->即使不写public static final，默认也有

final是最终的，被final修饰的变量不能二次赋值，所以我们一般将final修饰的变量视为常量

b.jdk8：

默认方法：public default 返回值类型方法名(形参){

}

静态方法：public static 返回值类型方法名(形参){

}

c.jdk9开始：

私有方法：

private的方法

2.2接口的使用

1.定义接口：

public interface 接口名{

}

2.实现：

public class 实现类类名 implements 接口名{

}

3.使用：

a.实现类实现接口

b.重写接口中的抽象方法

c.创建实现类对象（接口不能直接new对象）

d.调用重写的方法

java 复制代码

package xyf_interface0204;

public interface USB {
    public abstract void open();
    public abstract void close();
}

java 复制代码

package xyf_interface0204;

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");

    }
}

java 复制代码

package xyf_interface0204;

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.open();
        mouse.close();
    }
}

3.接口中的成员：

3.1抽象方法（重点）

1.定义格式：

public abstract 返回值类型方法名(形参);

2.注意:

不写public abstract默认也有

3.使用：

a.定义实现类，实现接口

b.重写抽象方法

c.创建实现类对象，调用重写的方法

3.2默认方法

1.格式：public default 返回值类型方法名(形参){

方法体

return 结果

}

2.使用：

a.定义实现类，实现接口

b.默认方法可重写，可不重写

c.创建实现类对象，调用默认方法

java 复制代码

package xyf_a_interface_0205;

public interface USB {
    //默认方法
    public default void methodDef(){
        System.out.println("我是默认方法");
    }
}

java 复制代码

package xyf_a_interface_0205;

public class Mouse implements USB{
    @Override
    public void methodDef() {
        System.out.println("我是重写接口中的默认方法");
    }
}

java 复制代码

package xyf_a_interface_0205;

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.methodDef();
    }
}

3.3静态方法

1.定义格式：

public static 返回值类型方法名(形参){

方法体

return 结果

}

2.使用：

接口名直接调用

java 复制代码

package xyf_a_interface_0205;

public interface USB {
    //默认方法
    public default void methodDef(){
        System.out.println("我是默认方法");
    }

    //静态方法
    public static void methodSta(){
        System.out.println("我是接口中的静态方法");
    }
}

java 复制代码

package xyf_a_interface_0205;

public class Mouse implements USB{
    @Override
    public void methodDef() {
        System.out.println("我是重写接口中的默认方法");
    }
}

java 复制代码

package xyf_a_interface_0205;

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.methodDef();

        System.out.println("===============");

        USB.methodSta();
    }
}

默认方法和静态方法->可以作为临时加的一个小功能来使用（直接在接口中添加这个小功能，在实现类中不需要重写，就可以直接在测试类调用）

3.4成员变量

1.格式：

public static final 数据类型变量名=值

2.相关知识点：final

final代表最终的，被它修饰的变量，不能二次赋值，可以视为常量

3.特点：

不写public static final 默认也有

4.使用：

接口名直接调用

5.注意：

a.被static final修饰的成员变量需要手动赋值

b.我们习惯上会将sttaic final修饰的成员变量名大写

java 复制代码

package xyf_b_interface_0205;

public interface USB {
    public static final int NUM1=100;
    int NUM2=200;//不写public static final默认也有
    //int num3;//被static final修饰的成员变量需要手动赋值

}

java 复制代码

package xyf_b_interface_0205;

public class Mouse implements USB{

}

java 复制代码

package xyf_b_interface_0205;

public class Test {
    public static void main(String[] args) {
        System.out.println(USB.NUM1);
        System.out.println(USB.NUM2);
    }
}

4.接口的特点

1.接口可以多继承->一个接口可以继承多个接口

public initerfaceInterfaceA extendsInterfaceB，InterfaceC{}

2.接口可以多实现->一个实现类可以实现一个或者多个接口

public class InterfaceImp1 implements InterfaceA,InterfaceB{}

3.一个子类可以继承一个父类的同时实现一个或者多个接口

public class Zi extends Fu implements InterfaceA,InterfaceB{}

4.注意：

继承也好，实现接口也罢，只要是父类中或者接口的抽象方法，子类或者实现类都要重写

当一个类实现多个接口时，如果接口中的抽象方法 有重名且参数一样的，只需重写一次

java 复制代码

package xyf_c_interface_0205;

public interface InterfaceA {
    public abstract void method();
}

java 复制代码

package xyf_c_interface_0205;

public interface InterfaceB {
    public abstract void method();
}

java 复制代码

package xyf_c_interface_0205;

public class InterfaceImpl implements InterfaceA,InterfaceB{
    @Override
    public void method() {
        System.out.println("重写的method方法");
    }
}

当一个类实现多个接口时，如果多个接口中默认方法有重名的，且参数一样的，必须重写一次默认方法

java 复制代码

package xyf_c_interface_0205;

public interface InterfaceA {
    //抽象方法
    public abstract void method();
    //默认方法
    public default void methodDef(){
        System.out.println("我是接口A中的默认方法");
    }

}

java 复制代码

package xyf_c_interface_0205;

public interface InterfaceB {
    public abstract void method();
    /*public default void methodDef(){
        System.out.println("我是接口B中的默认方法");
    }*/
    public default void methodDef(int a){
        System.out.println("我是接口B中的默认方法");
    }
}

java 复制代码

package xyf_c_interface_0205;

public class InterfaceImpl implements InterfaceA,InterfaceB{
    @Override
    public void method() {
        System.out.println("重写的method方法");
    }

    /*@Override
    public void methodDef() {
        System.out.println("重写后的默认方法");
    }
     */
}

java 复制代码

package xyf_c_interface_0205;

public class Test01 {
    public static void main(String[] args) {
        InterfaceImpl anInterface = new InterfaceImpl();
        anInterface.methodDef();
        anInterface.methodDef(10);
    }
}

5.接口和抽象类的区别：

相同点：

a.都位于继承体系的顶端（姑奶奶！），用于被其它类实现或者继承

b.都不能new

c.都包含抽象方法，其子类或者实现类都必须重写这些抽象方法

不同点：

a.抽象类：一般作为父类使用，可以有成员变量，构造，成员方法，抽象方法等

b.接口：成员单一，一般抽取接口，抽取的都是方法，视为功能的大集合

c.类不能多继承，但是接口可以

第二章.多态（重点）

1.面对对象三大特征：封装继承多态

2.怎么学：

a.不要从字面意思上理解多态，要从形式上掌握

b.要知道多态的好处

c.要知道多态的前提

1.多态的介绍：

1.前提：

a.必须有子父类继承或者接口实现关系（父类：接口类，子类：接口的实现类）

b.必须有方法的重写（没有重写，多态没有意义），多态主要玩的是重写方法

c.new对象：父类引用指向子类

Fu fu=new Zi( )->理解为大类型接收了一个小类型数据->比如： double b=10

2.注意：

多态下不能直接调用子类特有功能

java 复制代码

package xyf_a_polymorphic_0205;

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗狗吃骨头");
    }
    //特有方法
    public void protect(){
        System.out.println("狗狗会看门");
    }
}

java 复制代码

package xyf_a_polymorphic_0205;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("咪咪吃鱼");
    }
    //特有方法
    public void hunt(){
        System.out.println("咪咪捉老鼠");
    }

}

java 复制代码

package xyf_a_polymorphic_0205;

public class Test01 {
    public static void main(String[] args) {
        //原始方式
        Dog dog = new Dog();
        dog.eat();//重写的
        dog.protect();//特有的

        Cat cat = new Cat();
        cat.eat();//重写的
        cat.hunt();//特有的

        System.out.println("=============");
        //多态形式new对象
        Animal animal = new Dog();//相当于double b=10;
        animal.eat();//重写的animal接受的是dog对象，所以调用的是dog中的eat
        //animal.protect();多态前提下，不能直接调用子类特有成员

        Animal animal1 = new Cat();
        animal1.eat();//Cat重写的
    }
}

2.多态下成员访问特点

2.1成员变量：

看等号左边是谁，先调用谁的变量

java 复制代码

package xyf_a_polymorphic_0205;

public class Fu {
    int num=1000;
}

java 复制代码

package xyf_a_polymorphic_0205;

public class Zi extends Fu{
    int num=100;
}

java 复制代码

package xyf_a_polymorphic_0205;

public class Test02 {
    public static void main(String[] args) {
        Fu fu=new Zi();
        System.out.println(fu.num);
    }
}

2.2成员方法：

看new的是谁，先调用谁的成员方法，子类没有找父类

java 复制代码

package xyf_a_polymorphic_0205;

public class Fu {
    int num=1000;
    public void method(){
        System.out.println("我是父类中的method方法");
    }
}

java 复制代码

package xyf_a_polymorphic_0205;

public class Zi extends Fu{
    int num=100;
    public void method(){
        System.out.println("我是子类中重写的的method方法");
    }
}

java 复制代码

package xyf_a_polymorphic_0205;

public class Test02 {
    public static void main(String[] args) {
        Fu fu=new Zi();
        System.out.println(fu.num);//父类中的num变量
        fu.method();//子类中重写的method方法
    }
}

3.多态的好处（为什么学多态）

1.问题:若使用原始方式new对象（等号左右一样），既能调用重写的，又能调用继承的，还能调用自己特有的成员，但是多态方式new对象，只能调用重写的，不能直接调用子类特有的成员，那为何还要用多态

2.多态方式和原始方式new对象的优缺点：

原始方式：

a.优点：既能调用重写的，还能调用父类非私有的，还能调用自己特有的

b.缺点扩展性差

java 复制代码

package xyf_a_polymorphic_0205;

public abstract class Animal {
    public abstract void eat();
}

java 复制代码

package xyf_a_polymorphic_0205;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("咪咪吃鱼");
    }
    //特有方法
    public void hunt(){
        System.out.println("咪咪捉老鼠");
    }

}

java 复制代码

package xyf_a_polymorphic_0205;

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗狗吃骨头");
    }
    //特有方法
    public void protect(){
        System.out.println("狗狗会看门");
    }
}

java 复制代码

package xyf_a_polymorphic_0205;

public class Test03 {
    public static void main(String[] args) {
        /*
        double b=10;
        b=100L;
         */
        Animal animal=new Dog();
        animal.eat();

        animal=new Cat();
        animal.eat();
        System.out.println("===================");

        Dog dog=new Dog();
        method(dog);

        Cat cat=new Cat();
        method(cat);


    }
    /*
    形参传递父类类型，调用此方法父类类型可以接收任意它的子类对象
    传递哪个子类对象，就指向哪个子类对象，就调用哪个子类对象重写的方法
     */

    //父类通过多态的动态绑定，能 "代理执行" 所有子类的重写方法
    public static void method(Animal animal){
             animal.eat();
    }
}

用父类类型做形参，相当于给方法提供了一个"通用路口"，这个入口能接受所有子类对象，并且会根据传入的具体子类对象，自动执行该子类的重写方法

4.多态中的转型：

4.1向上转型：

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

好比是：double b=1;

4.2向下转型

1.向下转型：好比强转，将大类型强制转为小类型

2.表现方式：

父类类型对象名1=new 子类对象( )->向上转型->double b=1;

子类类型对象名2=(子类类型)对象名1->向下转型->int i=(int)b;

3.想要调用子类特有功能，我们就需要向下转型

java 复制代码

package xyf0205_polymorphic_b;

public abstract class Animal {
    public abstract void eat();
}

java 复制代码

package xyf0205_polymorphic_b;



public class Cat extends Animal {
    @Override
    public void eat() {

        System.out.println("咪咪吃鱼");
    }
    //特有方法
    public void hunt(){

        System.out.println("咪咪捉老鼠");
    }

}

java 复制代码

package xyf0205_polymorphic_b;



public class Dog extends Animal {
    @Override
    public void eat(){

        System.out.println("狗狗吃骨头");
    }
    //特有方法
    public void protect(){

        System.out.println("狗狗会看门");
    }
}

java 复制代码

package xyf0205_polymorphic_b;

public class Test01 {
    public static void main(String[] args) {
        //多态new对象
        Animal animal=new Dog();
        animal.eat();//dog重写的
        //animal.protect();多态不能调用子类特有功能
        System.out.println("===================");
        //向下转型
        Dog dog=(Dog) animal;
        dog.eat();
        dog.protect();

    }
}

4.3转型当中可能会出现的问题

1.如果等号左右两边类型不一致，会出现类型转换异常（ClassCastException）

2.解决：

在向下转型之前，先判断类型

3.怎么判断类型：instanceof

判断结果是boolean型

4.使用：

对象名 instanceof 类型->判断的是关键字前面的对象是否符合关键字后面的类型

java 复制代码

package xyf0205_polymorphic_b;

public abstract class Animal {
    public abstract void eat();
}

java 复制代码

package xyf0205_polymorphic_b;



public class Cat extends Animal {
    @Override
    public void eat() {

        System.out.println("咪咪吃鱼");
    }
    //特有方法
    public void hunt(){

        System.out.println("咪咪捉老鼠");
    }

}

java 复制代码

package xyf0205_polymorphic_b;



public class Dog extends Animal {
    @Override
    public void eat(){

        System.out.println("狗狗吃骨头");
    }
    //特有方法
    public void protect(){

        System.out.println("狗狗会看门");
    }
}

java 复制代码

package xyf0205_polymorphic_b;

public class Test02 {
    public static void main(String[] args) {
        Dog dog=new Dog();
        method(dog);
        System.out.println("============");
        Cat cat=new Cat();
        method(cat);
    }
    public static void method(Animal animal){
        animal.eat();
/*
    这里会出现类型转换异常(ClassCastException)
    原因：当调用method，传递Cat对象时，animal代表的就是cat对象
         此时我们将代表cat对象的animal强转成了dog
         此时等号左右两边类型不一致了，所以出现了类型转换异常
 */
       /*
        Dog dog=(Dog) animal;
         dog.protect();
        */
        if(animal instanceof Dog){
            Dog dog=(Dog) animal;
            dog.eat();
            dog.protect();
        }
        if(animal instanceof Cat){
            Cat cat=(Cat) animal;
            cat.eat();
            cat.hunt();
        }


    }

}

5.综合练习：

分析：

java 复制代码

package xyf0205_polymorphic_c;

public class KeyBoard implements USB{
    @Override
    public void open() {
        System.out.println("键盘开启");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭");
    }

    //特有功能
    public void input(){
        System.out.println("Hi,请敲击哟^^");
    }
}

java 复制代码

package xyf0205_polymorphic_c;

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标开启");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }

    //特有方法
    public void click(){
        System.out.println("Hello，请点击^^");
    }
}

java 复制代码

package xyf0205_polymorphic_c;

public class NoteBook {
    //开机
    public void start(){
        System.out.println("开机");
    }
    //使用USB
    /*
    USB usb=mouse  多态
     */
    public void useUSB(USB usb){
        if(usb instanceof Mouse){//向下转型
            Mouse mouse=(Mouse) usb;
            mouse.open();
            mouse.click();
            mouse.close();
        }else{//向下转型
            KeyBoard keyBoard=(KeyBoard) usb;
            keyBoard.open();
            keyBoard.input();
            keyBoard.close();
        }
//            usb.open();
//            usb.close();
    }
    //关机
    public void stop(){
        System.out.println("关机");
    }
}

java 复制代码

package xyf0205_polymorphic_c;

public class Test01 {
    public static void main(String[] args) {
        /*
        非静态的成员方法（比如NoteBook类的useUSB），不能直接通过类名调用，
        必须创建类的对象，通过对象.方法名 () 的方式调用
         ------ 这就是为什么要先写NoteBook noteBook = new NoteBook();，
         再写noteBook.useUSB(mouse)。
         */
        NoteBook noteBook=new NoteBook();
        Mouse mouse=new Mouse();
        noteBook.start();
        noteBook.useUSB(mouse);
        noteBook.stop();

        System.out.println("=============");
        KeyBoard keyBoard = new KeyBoard();
        noteBook.start();
        noteBook.useUSB(keyBoard);
        noteBook.stop();
    }
}

java 复制代码

package xyf0205_polymorphic_c;

public interface USB {
    public abstract void open();
    public abstract void close();
}