无法创建接口的实例_什么是接口?

接口

接口概述

接口,是java语言中一种类型,是方法的集合,如果说 类的内部封装了成员变量,构造 方法,和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法,默认方法和静态方法

接口是对功能的扩展们也是声明规则的一种方式 狭义的角度来看,接口指的就是java的关键字,interface

class 类名{}
interface 接口名{}

接口的出现,打破了java中只支持单继承的[局限性] 接口和类之间的关系,实现关系,可以单实现,也可以多实现

问题:生活中的USB接口体现的是什么思想? 功能的[拓展] 1.USB鼠标 2.USB键盘 3.USB移动硬盘

生活中的接口也体现了一种[规则]的思想 1.电脑厂商设计USB接口的时候是长方形的 2.USB鼠标键盘硬盘在设计USB接口的时候也是长方形的

开始写接口

1.接口的定义,他与定义类的方式相似,但是使用interface关键字,他也会被编译成class文件 ,但是一定要明确它并不是类,而是另外一种引用数据类型

public class 类名.java --> .class
public interface 类名.java -->.class

引用数据类型: 类 , 数组, 接口

2.接口的使用,他不能直接创建对象,但是可以被实现(implements,类似于被继承) ,一个实现接口的类(可以看做是接口的子类),需要实现接口中所有的抽象方法,创建 该类对象,就可以调用方法了,否则 必须把它也变成一个抽象类

定义格式

public interface 接口名称{
    //抽象方法
    //默认方法
    //静态方法
}

含有抽象方法 : 使用abstract关键字修饰,可以省略,没有方法体,该方法供子类实现使用

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

含有默认方法和静态方法:

默认方法: 使用default修饰,不可省略,供子类调用或重写

静态方法:使用static修饰,供接口直接使用

    public interface InterFaceName {
        public default void method(){
            //执行语句
        }

        public static void method() {
            //执行语句
        }
    }

特点: 1.接口不能实例化 2.接口中定义的方法只能是抽象方法 原因:即使不写abstract,系统也会默认加上这个关键字 注意接口与类之间的关系是实现关系,通过implements关键字进行实现

接口的特点

● 定义接口使用的是interface关键字

interface Inter{}

● 类和接口之间是实现关系,用implements关键字表示

class InterImp implements Inter {}

● 接口不能实例化

如果接口允许实例化,就可以调用内部的抽象方法,调用没有方法体的抽象方法没有意义

● 接口有没有其他的方式实例化呢? 1. 直接创建实现类对象使用 2.使用多态的形式创建

Inter i = new InterImp();

基本的实现

类和接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的 子类.实现的动作类似继承,格式相仿,只是关键词不同,实现使用implements关键字.

非抽象子类实现接口:

1.必须重写接口中所有抽象方法 2.继承了接口的默认方法,可以直接调用,也可以重写

实现格式

class 类名 implements 接口名 {
    //重写接口中抽象方法[必选]
    //重写接口中默认方法[可选]
}

抽象方法的使用

必须全部实现,代码如下:

定义接口:

public interface LiveAble{
    //定义抽象方法
    public abstract void eat();    
    public abstract void sleep();

}

定义实现类:

public class Animal implements LiveAble{

        @Override
        public void eat () {
            System.out.println("吃东西");
        }

        @Override
        public void sleep () {
            System.out.println("睡觉");
        }         
    }

定义测试类:

public class InterfaceDemo {
        public static void main (String []args){
            //创建子类对象
            Animal a = new Animal();
            //调用实现后的方法
            a.eat();
            a.sleep();
        }
    }

    //输出结果:
    //吃东西, 睡觉

默认方法的使用

可以继承,可以重写,二选一,但是只能通过实现类的对象来调用

继承默认方法,代码如下

定义接口:

public interface LivaAble{
    public default void fly (){
        System.out.println("天上飞");
    }
}

定义实现类:

public class Animal implements LiveAble {
    // 继承，什么都不用写，直接调用
}

定义测试类:

public class InterFaceDemo{
    public static void main (String [] args) {    
     //创建子类对象
        Animal a = new Animal();
     //调用默认方法
        a.fly();   //输出天上飞
     }  
}

重写默认方法,代码如下

定义接口:

public interface LivaAble{
    public default void fly (){
        System.out.println("天上飞");
    }
}

定义实现类:

public class Animal implements LiveAble {
    @Override
    public void fly() {
        System.out.println("自由自在的飞");
        }
}

定义测试类:

public class InterFaceDemo{
    public static void main (String [] args) {    
     //创建子类对象
        Animal a = new Animal();
     //调用重写方法
        a.fly();   //输出自由自在的飞
     }  
}

静态方法的使用

静态与.class文件相关,只能使用接口名调用,不可以通过实现类的类名或者实现类的对象调用

代码如下:

定义接口:

public interface LivaAble{
    public static void run (){
        System.out.println("跑起来");
    }
}

定义实现类:

public class Animal implements LiveAble {
    //无法重写静态方法
}

定义测试类:

public class InterFaceDemo{
    public static void main (String [] args) {    
     //Animal.run()//  [错误] 无法继承方法,也无法调用
     LiveAble.run();// 输出跑起来  
     }  
}

接口的多实现

对于接口而言,一个类是可以实现多个接口的,这叫做接口的多实现,并且一个类只能 继承一个父类,同时实现多个接口

实现格式:

可选操作
class 类名 [extends 父类名 ] implements 接口名1,接口名2,接口名3... {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【不重名时可选】
}

抽象方法

接口中,有多个抽象方法时,实现类必须重写所有抽象方法,如果抽象方法有重名的 只需要重写一次,代码如下:

定义多个接口:

interface A {
 public abstract void showA();
 public abstract void show();
 }
 interface B {
 public abstract void showB();
 public abstract void show();
 }

定义实现类:

public class C implements A,B{

    @Override
    public void showA() {
    System.out.println("showA");
    }

    @Override
    public void showB() {
    System.out.println("showB");
    }

    @Override
    public void show() {
    System.out.println("show");
    }
 }

默认方法

接口中,有多个默认方法时,实现类都可继承使用,如果默认方法有重名的, 必须重写一次 代码如下:

定义多个接口:

interface A {
    public default void methodA(){}
    public default void method(){}
 }
 interface B {
    public default void methodB(){}
    public default void method(){}
 }

定义实现类:

public class C implements A,B{
    @Override
    public void method() {
    System.out.println("method");
    }
 }

静态方法

接口中,存在同名的静态方法并不会冲突,原因是只能通过各自接口名访问静态方法

优先级的问题:

当一个类,即继承父类,又实现多个接口时, 父类中的成员方法与接口中的默认方法重名 ,子类就近选择执行父类的成员方法,代码如下:

定义接口:

interface A {
    public default void methodA(){
    System.out.println("AAAAAAAAAAAA");
    }
}

定义父类:

class D {
    public void methodA(){
    System.out.println("DDDDDDDDDDDD");
    }
}

定义子类：

class C extends D implements A {
  // 未重写methodA方法
  }

  public class Test {
  public static void main(String[] args) {
  C c = new C();
  c.methodA();
  }
  }
  输出结果:
  DDDDDDDDDDDD

接口的多继承

一个接口能继承另一个或者多个接口, 这和类之间的继承比较相似,接口的继承 使用extends关键字, 子接口继承父接口的方法. 如果父接口中的方法有重名的 .那么子接口需要重写一次,代码如下:

定义父类接口:

interface A {
        public default void method(){
        System.out.println("AAAAAAAAAAAAAAAAAAA");
    }
  }
  interface B {
        public default void method(){
        System.out.println("BBBBBBBBBBBBBBBBBBB");
    }
  }

定义子接口:

interface D extends A,B{
    @Override
    public default void method() {
    System.out.println("DDDDDDDDDDDDDD");
    }
 }

子接口重写默认方法时,default关键字可以保留 子类重写默认方法时,default关键字不可以保留

其他成员特点

接口中 : 无法定义成员变量,但是可以定义常量,其值不可改变.默认使用public static final修饰

接口中,没有构造方法,不能创建对象

接口中没有静态代码块

看一段代码(扩展,规则)

public class DemoInterface{
    public static void main(String [] args){
           岳不群 小岳子 = new 岳不群 ();
           小岳子.zg();//用锤子

        }
    }

interface 葵花宝典 {
    //声明规则
    public abstract void zg();

}

class 岳不群 implements 葵花宝典{
    @Override
    public void zg () {
    System.out.println("用锤子");
}

class 林平之 implements 葵花宝典{
    @Override
    public void zg () {
    System.out.println("用牙签");
}

再来一段代码

public class DemoInterface{
        public static void main(String [] args){
             SmokeStudent ss = new SmokeStudent();
             ss.study();
             ss.smoking();

            }
        }

//定义学生类
class Student {     
        public void study () {
        System.out.println("学生学习");
    }
 //定义抽烟接口   
interface Smoke {
    //声明规则,并不是所有学生都具备抽烟的功能
    //抽烟功能就属于功能的一种[扩展].
    public abstract void smoking();

        }

//接口的出现,打破了Java中只支持单继承的局限性
//在有了亲爹的同时,还能有个干爹
class SmokeStudent extends Student implements Smoke{
    @Override
    public void smoking(){
        System.out.println("有故事的学生,抽烟"")
        }
}

面向接口编程思想(多态+接口)

MySQL
Oracle

包的概述和注意事项

包的作用是什么? 如何定义一个包 如何划分包?

总结:
    ● 包就是文件夹,用来管理类文件的
    ● package 包名;
    ● 包名的定义规范,一般都是公司的域名倒着写
            itheima.com
            itcast.cn
                cn.itcast.项目名
                com.itheima.gjp
        A. 按照功能划分(很少见)
            车载系统
            com.itheima.car.mp3
            com.itheima.car.video
            ...
        B. 按照模块划分(最常见的)
            com.itheima.gjp.domain-->(实体类)javabean类,用于封装数据的类
            com.itheima.gjp.utils-->工具类(收好了,以后可以说是自己写的)
            com.itheima.gjp.view-->视图层
            com.itheima.gjp.ctrl-->控制层
            com.itheima.gjp.services-->业务层
            com.itheima.gjp.dao-->数据库访问层(DataBase Object Access)
            ...

import class package的顺序关系是

package ->import ->class

ctrl+ shift+o  整理包的快捷键

导包的格式以及使用

引用不同包下的类文件(导包的方式)

格式: import 包名.类名

   *   代表通配符  ,(java.util.*)   导入了util包下面所有的类

分别导入比较省内存

如果自己写的类,和java的类名想通了 会优先使用我们自己写的类
那如果我们自己写的类和java一样了 ,还想使用java写好的类,怎么办?需要通过[全类名]方式创建对象了

[全类名]: 包名+类名

eg: 
    java.util.Scanner sc = new java.util.Scanner(System.in);

四种权限修饰符的概述和访问特点(基本就是private和public)

| |本类|同一个包下(子类和无关类)|不同包下(子类)|不同包下(无关类)|也就是| |---|---|---|---|---|---| |private|✔| | | |只能在本类当中访问| |default|✔|✔| | |(本类),同一个包下| |protected|✔|✔|✔| | |public|✔|✔|✔|✔|权限最大,不跨项目都可访问|