无法创建接口的实例

接口

接口概述

接口,是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{@Overridepublic void eat () {System.out.println("吃东西");}@Overridepublic 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 {@Overridepublic 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{@Overridepublic void showA() {System.out.println("showA");}@Overridepublic void showB() {System.out.println("showB");}@Overridepublic 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{@Overridepublic 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{@Overridepublic 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 葵花宝典{@Overridepublic void zg () {System.out.println("用锤子");
}class 林平之 implements 葵花宝典{@Overridepublic 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{@Overridepublic void smoking(){System.out.println("有故事的学生,抽烟"")}
}

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

MySQL
Oracle

包的概述和注意事项

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

总结:● 包就是文件夹,用来管理类文件的● package 包名;● 包名的定义规范,一般都是公司的域名倒着写itheima.comitcast.cncn.itcast.项目名com.itheima.gjpA. 按照功能划分(很少见)车载系统com.itheima.car.mp3com.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|✔|✔|✔|✔|权限最大,不跨项目都可访问|