大数据 -- java基础8 接口

1、接口:interface关键字
    (1)语句定义格式:

 interface 接口名{}

    (2)接口是如何实现的呢?
        接口不能直接实例化,需要一个关键字供其他类实现该接口:implements
        使用多态的形式进行实现,由具体的子类进行实例化,其实这是多态的一种,叫做接口多态。

    (3)也可以用一个抽象类去实现。


    到目前为止,我们学过了三种多态的表现实现:
        (1)具体的类中的多态  (最后才是具体类的多态)
        (2)抽象类中的多态    (其次是抽象多态)
        (3)接口中的多态     (今后大数据开发最常见的是接口多态)
    
    
2、接口中成员的特点:
    (1)成员变量:
        只能是常量,并且是静态的。 JVM在真正运行之前会自动补齐修饰符:public static final

    (2)构造方法:
        接口中没有构造方法。所以直接实现接口的类都继承Object类,完成构造方法的初始化。    

      (3)成员方法:
        接口中的方法只能是抽象方法。  JVM在真正运行之前会自动补齐修饰符:public abstract

//创建一个接口
interface Animal{
    public static final int age = 30;  //默认修饰符: public static final,可以不写

//    Animal(){       //不能有构造方法
//
//    }

    public abstract void show();  //默认修饰符: public abstract,可以不写
}


//定义猫类,继承Object类(Object是所有类的父类),实现Animal接口
class Cat extends Object implements Animal{
    @Override
    public void show() {
        System.out.println("猫会跳舞");
    }
}


//测试类
public class InterfaceDemo {
    public static void main(String[] args) {
        //接口类多态
        Animal animal = new Cat();
        animal.show();
    }
}

   注意:
        (1)当一个具体的类实现接口的时候,必须实现接口中所有的抽象方法。
        (2)当一个抽象类实现接口的时候,可以选择不实现接口中的方法,也可以选择性的实现。

   类与类,类与接口,接口与接口的关系
        (1)类与类:
               存在的是继承关系,只能进行单继承,不可以进行多继承,但是可以是多层继承。
        (2)类与接口:
               存在的是实现关系,可以是单实现,也可以是一次性实现多个接口,也可以在继承一个类的同时,实现多个接口。
        (3)接口与接口:
               存在的是继承关系,可以进行单继承,也可以进行多继承。

interface Inter1{ 
   
}

interface Inter2{  
  
}

interface Inter3 extends Inter1,Inter2{       //接口可以继承多个接口

}

public class Demo extends Object implements Inter1,Inter2{   //类可以在继承一个类的同时实现多个接口    
}


3、将来我们更多的面向接口开发会将代码进行分类开发,这样会提高我们开发效率和排错效率。
     通常情况下,会在一个包里分4层:
        bean: 一般存放的是将来要new的实体类。
        controller: 一般是数据的入口类。
        dao: 具体对数据做操作的地方,放在dao层,这一层一般情况下,都是对数据库做操作的。
        service: 一般在这里面放的是接口,和实现类。

4、方法的形式参数是引用数据类型时:
    (1)类:当类作为方法的形式参数时,实际需要的是该类的对象。
    (2)抽象类:当抽象类作为方法的形式参数时,实际需要的是该类子类实现对象的地址值,利用多态的形式创建。
    (3)接口:当接口作为方法的形式参数时,实际需要的是该接口的实现类对象的地址值,利用接口多态的方式创建。

//创建一个抽象的人类
abstract class Person {

    public abstract void study();

}


//创建一个人类2接口
interface Person2 {

    public abstract void playGame();

}


//创建一个学生类继承人类,实现人类2接口
class Student extends Person implements Person2 {

    @Override
    public void study() {
        System.out.println("好好学习天天向上");
    }

    @Override
    public void playGame() {
        System.out.println("天天玩英雄联盟");
    }

}



//创建一个Demo类
class StudentDemo {

    // 1) 当看到一个方法的参数是一个类的类型时,实际传的是该类对象的地址值
    public void fun(Student stu) {     //Student stu = new Student();
        stu.study();
    }


    // 2) 当看到一个抽象类作为参数的类型时,实际需要的是该类子类实现对象的地址值,利用多态的形式创建
    public void fun2(Person person) {   //Person person = new Student();
        person.study();
    }


    // 3) 当看到一个方法的参数类型是一个接口的时候,实际上需要的是该接口的实现类对象的地址值,利用接口多态的方式创建
    public void fun3(Person2 person2) {  //Person2 person2 = new Student();
        person2.playGame();
    }

}



//测试类
public class StudentTest {
    public static void main(String[] args) {

        //创建Demo类对象
        StudentDemo stuDemo = new StudentDemo();

        // 1) 类作为形参
        Student stu = new Student();
        stuDemo.fun(stu);


        // 2) 抽象类作为形参
        //Person p = new Student();    //第一种方式   多态的形式
        //stuDemo.fun2(p);

        stuDemo.fun2(new Student());   //第二种方式   链式编程


        // 3) 接口作为形参
        //Person2 p = new Student();      //接口多态的形式
        //stuDemo.fun3(p);

        stuDemo.fun3(new Student());
    }
}


5、方法的返回值是引用数据类型时:
    (1)类: 当一个类作为方法的返回值时,实际返回的是该类对象的地址值。
    (2)抽象类: 当一个抽象类作为方法的返回值时,实际返回的是该抽象类的子类对象。
    (3)接口: 当一个接口作为方法的返回值时,实际返回的是实现该接口的类的对象。

//定义一个抽象类 -- 人类
abstract class Person {

    public abstract void study();

}


//定义一个玩游戏接口
interface PlayGame {

    public abstract void playLol();

}


//创建一个学生类, 继承人类,实现接口玩游戏
class Student extends Person implements PlayGame {

    @Override
    public void study() {
        System.out.println("好好学习天天向上");
    }

    @Override
    public void playLol() {
        System.out.println("天天玩英雄联盟");
    }

}



//创建一个Demo类
class StudentDemo {

    // 1) 当看到方法的返回值是一个类的类型时,实际返回的是该类对象的地址值。
    public Student fun() {
        //Student s = new Student();     //第一种方法
        //return s;

        return new Student();            //第二种方法
    }


    // 2) 当看到方法的返回值是一个抽象类的类型时,需要返回的是该抽象类的子类对象
    public Person fun2() {
        //Person p = new Student();      //第一种方法
        //return p;

        return new Student();             //第二种方法
    }


    // 3) 当看到方法的返回值是一个接口的类型时,需要的是实现该接口的类的对象
    public PlayGame fun3() {
        //PlayGame pg = new Student();
        //return pg;

        return new Student();
    }

}



//测试类
public class StudentTest {
    public static void main(String[] args) {

        //创建Demo类对象
        StudentDemo stuDemo = new StudentDemo();

        // 1) 方法Student做返回值
        Student stu = stuDemo.fun();
        stu.study();


        // 2) 抽象类Person做返回值
        Person p = stuDemo.fun2();   //Person p = new Student();
        p.study();


        // 3) 接口PlayGame做返回值
//        PlayGame pg = stuDemo.fun3();
//        pg.playLol();

        //链式编程
        stuDemo.fun3().playLol();
    }
}  

 
6、package、import、class它们三个之间有没有顺序呢?
      package: 到达的路径,所在文件的路径,它最终以包结束。    (在最前面)

      import: 导入外界你想要使用的类,它最终以你想要导入的那个类/.java结束。    (在package与class之间)
           要想导入某一包下所有的类: .* (开发不推荐)
           只要当你需要导入大于30个类的时候,可以考虑 .*

      class: 表示定义一个类,java的最基本的单位    (在import后面,即最后)
    

7、访问权限修饰符:
                   同一类下    同一包子类中,其他类     不同包的子类      不同包的其他类
    public             √                     √                                    √                           √
    protected       √                      √                                    √
    默认的           √                      √
    private           √
    (√ 代表可以访问)
    
    常见的修饰符组合:
        (1)成员变量:public static final
        (2)成员方法:
            1) public abstract
            2) public static
            3) public final

上一篇:oracle分析函数系列之sum(col1) over(partition by col2 order by col3):实现分组汇总或递增汇总


下一篇:Mybatis