Java学习笔记--面向对象高级（接口）

1 初识接口

1.1 接口的定义

1.2 接口使用

1.3 练习

test1.Animal

package com.itstudy.test1;

public abstract class Animal {
    private String name;
    private String color;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public abstract void eat();
}

test1.AnimalAdapter

package com.itstudy.test1;

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

    public AnimalAdapter(String name, String color) {
        super(name, color);
    }

    @Override
    public void eat() {

    }
}

test1.Swim (interface)

package com.itstudy.test1;

public interface Swim {
    public abstract void swimming();
}

test1.Dog

package com.itstudy.test1;

public class Dog extends AnimalAdapter implements Swim {
    public Dog() {
    }

    public Dog(String name, String color) {
        super(name, color);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void swimming() {
        System.out.println("狗正在狗刨");
    }
}

test1.Frog

package com.itstudy.test1;

public class Frog extends AnimalAdapter implements Swim {
    public Frog() {
    }

    public Frog(String name, String color) {
        super(name, color);
    }

    @Override
    public void eat() {
        System.out.println("青蛙吃虫子");
    }


    @Override
    public void swimming() {
        System.out.println("青蛙正在蛙泳");
    }
}

test1.Rabbit

package com.itstudy.test1;

public class Rabbit extends AnimalAdapter{
    public Rabbit() {
    }

    public Rabbit(String name, String color) {
        super(name, color);
    }

    @Override
    public void eat() {
        System.out.println("兔子吃胡萝卜");
    }
}

test1.Test

package com.itstudy.test1;

import com.itstudy.test2.Inter;

public class Test {
    public static void main(String[] args) {
    /*
    练习 编写带有接口和抽象类的标准 Javabean 类
            青蛙  属性：名字，颜色  行为：吃虫子，蛙泳
            狗   属性：名字，颜色  行为：吃骨头，狗刨
            兔子 属性：名字，颜色  行为：吃胡萝卜
     */
        //创建对象
        Frog frog = new Frog("青蛙", "绿色");
        System.out.println(frog.getName() + " " + frog.getColor());
        frog.eat();
        frog.swimming();

        Dog dog = new Dog("狗", "棕色");
        System.out.println(dog.getName() + " " + dog.getColor());
        dog.eat();
        dog.swimming();


        Rabbit rabbit = new Rabbit("兔子", "白色");
        System.out.println(rabbit.getName() + " " + rabbit.getColor());
        rabbit.eat();
        //rabbit.swimming();//兔子不能调用游泳接口，因为没有实现Swim接口


    }
}

2 接口中成员的特点 （JDK7以前）

test2.Student

ackage com.itstudy.test2;

public class Student {
    String name;
    public void show(){
        System.out.println("student");
    }
}

test2.Inter (interface)

package com.itstudy.test2;

public interface Inter {
    //成员变量：只能是常量。默认修饰符：public static final
    //规则：某一些关键字是灰色的，表示当前可以省略不写
    public static final int A = 10;

    //构造方法：没有
    //因为接口不能创建对象，而且接口里面所有的成员变量都是常量已经有真实的数据了
   // public Inter(){}

    //成员方法：只能是抽象方法。默认修饰符：public abstract



}

test2.Test

package com.itstudy.test2;

public class Test {
    public static void main(String[] args) {
        /*
        接口中成员的特点
            成员变量：只能是常量。默认修饰符：public static final
            构造方法：没有
            成员方法：只能是抽象方法。默认修饰符：public abstract
            JDK7 以前：接口中只能定义抽象方法
        */
        System.out.println(Inter.A);//能通过Inter.调用，说明A前面一定有static修饰
    }
}

找编译class文件如下图所示：

选择文件夹：out\production\oop-interface\com\itstudy\test2

通过javap 文件名 对此文件进行反编译

由图中可知

3 接口和类之间的关系

3.1 概念

test3.Person

package com.itstudy.test3;

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

    public Person() {
    }
    public Person(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 void show(){
        System.out.println("name:"+name+",age:"+age);
    }
    public abstract void aaa();
}

test3.Inter1 (interface)

package com.itstudy.test3;

public interface Inter1 {
    public abstract void method1();
    public abstract void method2();

    public abstract void bbb();
}

test3.Inter2 (interface)

package com.itstudy.test3;

public interface Inter2 {
    public abstract void function1();
    public abstract void function2();
    public abstract void bbb();
}

test3.Interimpl

package com.itstudy.test3;

public class Interimpl extends Person implements Inter1, Inter2 {
    //如果一个类实现了多个接口，那么就要重写多个接口中所有的抽象方法
    //注意点：
    //      1.如果父类Person也是一个抽象类的话，那么在子类中，需要把所有的抽象方法进行重写，要么子类也是一个抽象类
    //      2.如果多个接口中出现了重复的抽象方法，此时我们只有重写一次就可以
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void bbb() {

    }

    @Override
    public void function1() {

    }

    @Override
    public void function2() {

    }

    @Override
    public void aaa() {

    }


}

test3.MyInter(interface)

package com.itstudy.test3;

public interface MyInter extends Inter1, Inter2 {

}

test3.MyInterimpl

package com.itstudy.test3;

public class MyInterimpl implements MyInter {
  /*  接口和接口的关系:
    继承关系，可以单继承，也可以多继承

    注意点：
           1.如果有一个接口A继承了多个接口，此时相当于是把多个接口中的抽象方法全部继承下来了
             在以后，实现类实现接口A的时候，就要把所有的抽象方法进行重写

  */
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void function1() {

    }

    @Override
    public void function2() {

    }

    @Override
    public void bbb() {

    }
}

test3.Test

package com.itstudy.test3;

public class Test {
    public static void main(String[] args) {
        /*
            类和类的关系:
                    继承关系，只能单继承，不能多继承，但是可以多层继承

            类和接口的关系:
                    实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
                  注意点：
                      1.如果父类Person也是一个抽象类的话，那么在子类中，需要把所有的抽象方法进行重写，要么子类也是一个抽象类
                      2.如果多个接口中出现了重复的抽象方法，此时我们只有重写一次就可以

            接口和接口的关系:
                    继承关系，可以单继承，也可以多继承
                     注意点：
                           1.如果有一个接口A继承了多个接口，此时相当于是把多个接口中的抽象方法全部继承下来了
                             在以后，实现类实现接口A的时候，就要把所有的抽象方法进行重写
        */
    }
}

3.2 练习

test4.Person

package com.itstudy.test4;

//因为现在我不想让外界去直接创建人的对象
//因为直接创建顶层父类人的对象没有意义
//所以我就把他写为抽象的，不让外界去创建对象
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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;
    }
}

test4.Athlete -- 运动员

package com.itstudy.test4;

public abstract class Athlete extends Person{
    public Athlete() {
    }

    public Athlete(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

test4.coach -- 教练

package com.itstudy.test4;

public abstract class coach extends Person{
    public coach() {
    }

    public coach(String name, int age) {
        super(name, age);
    }
    public abstract void teach();
}

test4.Basketballathlete

package com.itstudy.test4;

public class Basketballathlete extends Athlete{
    public Basketballathlete() {
    }

    public Basketballathlete(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员正在学打篮球");
    }
}

test4.Basketballcoach

package com.itstudy.test4;

public class Basketballcoach extends coach{
    public Basketballcoach() {
    }

    public Basketballcoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练正在教打篮球");
    }
}

test4.SpeskEnglish (interface)

package com.itstudy.test4;

public interface SpeskEnglish {
    void spekEnglish();
}

test4.Tabletennisathlete

package com.itstudy.test4;

public class Tabletennisathlete extends Athlete implements SpeskEnglish {
    public Tabletennisathlete() {
    }

    public Tabletennisathlete(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员正在学打乒乓球");
    }

    @Override
    public void spekEnglish() {
        System.out.println("乒乓球运动员正在说英语");
    }
}

test4.Tabletenniscoach

package com.itstudy.test4;

public class Tabletenniscoach extends coach implements SpeskEnglish {
    @Override
    public void teach() {
        System.out.println("乒乓球教练正在教打乒乓球");
    }


    @Override
    public void spekEnglish() {
        System.out.println("乒乓球教练正在说英语");
    }
}

test4.Test

package com.itstudy.test4;

public class Test {
    public static void main(String[] args) {
      /*
      练习 编写带有接口和抽象类的标准 Javabean 类
        我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。
        为了出国交流，跟乒乓球相关的人员都需要学习英语。
        请用所有知识分析，在这个案例中，哪些是具体类，哪些是抽象类，哪些是接口？
            乒乓球运动员：//
                    姓名，年龄，学打乒乓球，说英语
            篮球运动员：
                    姓名，年龄，学打篮球
            乒乓球教练：
                    姓名，年龄，教打乒乓球，说英语
            篮球教练：
                    姓名，年龄，教打篮球

        */
        Tabletennisathlete taba = new Tabletennisathlete("张三", 20);
        System.out.println(taba.getName() + " " + taba.getAge());
        taba.study();
        taba.spekEnglish();

    }

}

4 接口的新特性

4.1 新特性

4.2 JDK8以后接口中新增的方法

test5.InterA

package com.itstudy.test5;

public interface InterA {
    public abstract void method1();
    public abstract void method2();

    //新增默认的方法
    //public default 返回值类型 方法名(参数列表){方法体}

    public default void function(){
        System.out.println("InterA接口中新增的默认方法~");
    }

}

test5.InterB

package com.itstudy.test5;

public interface InterB {
    public default void function(){
        System.out.println("InterB接口中新增的默认方法~");
    }
}

test5.InterImple

package com.itstudy.test5;

public class InterImple implements InterA, InterB {
    @Override
    public void method1() {
        System.out.println("实现类重写的method1方法~");
    }

    @Override
    public void method2() {
        System.out.println("实现类重写的method2方法~");
    }

    @Override
    public void function() {
        System.out.println("实现类重写了默认方法~");
    }
}

test5.Test

package com.itstudy.test5;

public class Test {
    public static void main(String[] args) {
        /*
        JDK8 以后接口中新增的方法
            允许在接口中定义默认方法，需要使用关键字 default 修饰
                作用：为了接口升级时，代码不报错
            接口中默认方法的定义格式：
                格式：public default 返回值类型 方法名 (参数列表) { }
                范例：public default void show () {}
            接口中默认方法的注意事项：
                1.默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉 default 关键字
                2.public 可以省略，default 不能省略
                3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写
        */

        //创建实现类的对象，并调用默认方法
        InterImple ii = new InterImple();
        ii.function();
    }
}

输出结果：

实现类重写了默认方法~

4.3 JDK9新增的私有方法

Test7.Inter

package com.itstudy.test7;

public interface Inter {
    public default void login(){
        check();
        System.out.println("执行登录的逻辑......");
    }
    public default void register(){
        check();
        System.out.println("执行注册的逻辑......");
    }

    //jdk8
/*    public default void check(){
        System.out.println("检查网络.......");
        System.out.println("检查用户名和密码的格式......");
        System.out.println("检查用户名是否存在......");
    }*/

    //jdk9:新增了私有的方法   //私有方法，其他类无法调用
    //普通的私有方法：private 返回值类型 方法名 (形参){方法体}
    //静态的私有方法：private static 返回值类型 方法名 (形参){方法体}
    default void check(){
        System.out.println("检查网络.......");
        System.out.println("检查用户名和密码的格式......");
        System.out.println("检查用户名是否存在......");
    }
}

Test7.InterImpl

package com.itstudy.test7;

public class InterImpl implements Inter{

}

Test7.Test

package com.itstudy.test7;

public class Test {
    public static void main(String[] args) {
        /*
         * JDK9 接口中的私有方法：
         *     第一种：普通的私有方法
         *     作用：为了抽取默认方法中重复代码而出现的
         *     格式：private 返回值类型 方法名 (参数列表) { }
         *     范例 1：private void show () {}
         *
         *     第二种：静态的私有方法
         *     作用：为了抽取静态方法中重复代码而出现的
         *     格式：private static 返回值类型 方法名 (参数列表) { }
         *     范例 2：private static void method () {}
         *
         * */

        InterImpl interImpl = new InterImpl();
        interImpl.check();
    }
}

4.4 小结