第十三课时

day 13

目录

接口
多实线
多继承
权限

1、接口

java7
1、常量
2、抽象方法

java8
默认方法
静态方法

java9
私有方法

接口中是可以定义 成员变量 ，但是必须用 public static final 关键字修饰。

从效果上看就相当于一个常量。

1 、接口中的常量 用public static final来修饰，是可以省略这三个关键字

2、相当是常量，因此只能初始化的生活进行赋值，后面不能更改

3 、建议命名格式用大写加下划线。

例一:
运行代码如下:
package demo01;
public class Demo01Interface {
int num = 5;

public void method() {
}

package demo01;
// public static final
public interface MyInterfaceConst {
public static final int NUM_OF_CLASS=5;//全大写要用下划线
1
}
运行结果:

2、多实现

1、接口中是没有静态代码块和构造方法的

2、一个类的直接父类只有一个，但是一个类可以实现多个接口

3、如果实现类，所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可

4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类必须是一个抽象类 （tip：Abs）

5、如果实现类 所实现的多个接口(接口A，接口B)中，存在重复的默认方法，那么实现类一定要对默认方法进行覆盖重写

6、一个类 如果直接父类当中的方法 和 接口当中的默认方法 产生了冲突，优先使用父类中的方法

例二:
运行代码如下:
package demo02;//多实现
public class Demo02Interface {
public static void main(String[] agrs) {
Zi zi = new Zi();
zi.method();
}
package demo02;

public interface MyInterface {
public default void method() {
System.out.println(“我是接口里面的默认方法”);
}
package demo02;

public interface MyInterfaceA {
/* 错误写法：接口中不能有静态代码块
static {
}
*/

/* 错误写法：接口中不能有构造方法
public MyInterfaceA() {

}

*/
public abstract void methodA();

public abstract void methodAbs();

public default void methodDefault() {
System.out.println(“默认方法AAA”);
}
package demo02;

public interface MyInterfaceB {
public abstract void methodB();

public abstract void methodAbs();

public default void methodDefault() {
System.out.println(“默认方法BBB”);
}
package demo02;

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
@Override
public void methodA() {
// TODO 自动生成的方法存根

}

@Override
public void methodB() {
// TODO 自动生成的方法存根

}

@Override
public void methodAbs() {
// TODO 自动生成的方法存根

}

@Override
public void methodDefault() {
// TODO 自动生成的方法存根
MyInterfaceA.super.methodDefault();
}
package demo02;

public abstract class MyInterfaceAbs implements MyInterfaceA,MyInterfaceB {
@Override
public void methodB() {
// TODO 自动生成的方法存根

}

@Override
public void methodAbs() {
// TODO 自动生成的方法存根

}

@Override
public void methodDefault() {
// TODO 自动生成的方法存根
MyInterfaceA.super.methodDefault();
}
package demo02;
//在此之前，先定义一个接口MyInterface
public class Fu {
public void method() {
System.out.println(“我是父类方法！！”);
}
}
package demo02;

public class Zi extends Fu implements MyInterface{
}

3、多继承

内与接口的关系：

1、类与类之间是单继承的 直接父类只有一个

2、类与接口之间是多实现 一个类可以实现多个接口

3、接口与接口之间是多继承的

注意事项：

1.多个父接口中的抽象方法如果重复，没有关系

2.多个父接口当中的默认方法重复

例三:
运行代码如下:
package demo03;//多继承
public class Demo03Relations {
// MyInterface myinterface = new MyInterface();
}
package demo03;
/*

这个接口中一共有几个方法 4个

methodA 接口A的方法

methodB 接口B的方法

methodCommon 接口A和接口B的共同方法

method 自己的方法
**/
public interface MyInterface extends MyInterfaceA,MyInterfaceB {
public abstract void method();

@Override
default void methodDefault() {
MyInterfaceA.super.methodDefault();
}

}
package demo03;

public interface MyInterfaceA {
public abstract void methodA();
public abstract void methodCommon();//公共方法、
public default void methodDefault() {//默认方法
System.out.println(“AAAA”);
}

}
package demo03;

public interface MyInterfaceB {
public abstract void methodB();
public abstract void methodCommon();//公共方法
public default void methodDefault() {//默认方法
System.out.println(“BBBB”);
}

}
package demo03;

public class MyInterfaceImpl implements MyInterface{
@Override
public void methodA() {
// TODO 自动生成的方法存根

}

@Override
public void methodCommon() {
// TODO 自动生成的方法存根

}

@Override
public void methodB() {
// TODO 自动生成的方法存根

}

@Override
public void method() {
// TODO 自动生成的方法存根

}
4、权限

java 中有四种权限修饰符：

             public  protected  （default） private

1
同一个类中（我自己） yes yes yes yes

同一个包中（我的邻居） yes yes yes no

同一个包中的子类（儿子）yes yes yes no

不同包的类（demo05） yes yes no no

不同包的非子类 yes no no no

例四:
运行代码如下:
package demo04;//权限
public class Demo01Main {
}
package demo04;

public class MyClass {
private int num = 5;

public void mrthod() {
System.out.println(num);
}
package demo04;

public class MyAnother {
public void anotherMthode() {
MyClass myclass = new MyClass();
//System.out.println(myclass.num);
}
}
package demo04;

public class MySon1 extends MyClass {
public void method() {
//System.out.println(super.num);
}
1
2
3
}
package demo05;

import demo04.MyClass;

public class MySon2 extends MyClass {
public void method() {
}
1
}
package demo05;

import demo04.MyClass;

public class Stranger {
public void methodStranger() {
MyClass myclass = new MyClass();
}
}