Java第七课（访问控制符/权限修饰符，JavaBean规范，接口）

Java第六课回顾

ArrayList int->Integer char->character
add(E) remove(int index) get(int index)
继承 extends：
父类: 子类中共同的成员变量, 成员方法
子类: 会继承父类中所有的成员变量和成员方法
抽象类
super和this的含义和用法。
重写Override和重载Overload的区别。

Java第七课

访问控制符/权限修饰符

修饰: 类, [静态]成员变量, [静态]成员方法, 构造方法
public: 公开的, 公共的
protected: 受保护的
(default): 默认的, 不加default关键字, 不写任何内容
private: 私有的
权限范围由大到小: public->protected->default->private
default: 不常用, 练习时为了省略代码
public : 想要提供给其他类使用的成员
protected: 想要给子类继承的成员
private: 所有的普通成员变量
封装: 为了保证成员变量的安全性, 给设置为私有的
提供给外部访问这个成员变量的方法 get/set

JavaBean规范

所有的实体类

1.命名 驼峰命名法
2.成员变量私有化, 提供get/set方法
3.提供空参构造方法

static: 静态的, 属于类的, 修饰成员变量/成员方法
abstract: 抽象的, 修饰类/成员方法
final: 最终的, 修饰类/成员方法/成员变量/局部变量
修饰类: 类不能被继承
修饰方法: 方法不能被重写
成员变量: 变量不能被修改, 必须初始化
局部变量: 变量不能被修改, 必须初始化
引用类型变量: 引用地址不能被修改, 内容可以修改

接口

概述：
接⼝，是Java语⾔中⼀种引⽤类型，是⽅法的集合，如果说类的内部封装了成员变量、构造⽅法
和成员⽅法，那么接⼝的内部主要就是封装了⽅法，包含抽象⽅法（JDK 7及以前），默认⽅法
和静态⽅法（JDK 8），私有⽅法 (JDK 9)。
接⼝的定义，它与定义类⽅式相似，但是使⽤ interface 关键字。它也会被编译成 .class ⽂
件，但⼀定要明确它并不是类，⽽是另外⼀种引⽤数据类型。
引⽤数据类型：数组，类，接⼝。
接⼝的使⽤，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。⼀个实现接
⼝的类（可以看做是接⼝的⼦类），需要实现接⼝中所有的抽象⽅法，创建该类对象，就可以调
⽤⽅法了，否则它必须是⼀个抽象类。

定义格式

public interface 接⼝名称 {
 // 抽象⽅法
 // 默认⽅法
 // 静态⽅法
 // 私有⽅法
}

含有抽象⽅法
抽象⽅法：使⽤ abstract 关键字修饰，可以省略，没有⽅法体。该⽅法供⼦类实现使⽤。
代码如下：

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

含有默认⽅法和静态⽅法
默认⽅法：使⽤ default 修饰，不可省略，供⼦类调⽤或者⼦类重写。
静态⽅法：使⽤ static 修饰，供接⼝直接调⽤。
代码如下：

public interface InterFaceName {
 public default void method() {
 // 执⾏语句
 }
 public static void method2() {
 // 执⾏语句
 }
}

含有私有⽅法和私有静态⽅法
私有⽅法：使⽤ private 修饰，供接⼝中的默认⽅法或者静态⽅法调⽤。
代码如下：

public interface InterFaceName {
 private void method() {
 // 执⾏语句
 }
}

基本的实现
类与接⼝的关系为实现关系，即类实现接⼝，该类可以称为接⼝的实现类，也可以称为接⼝的⼦
类。实现的动作类似继承，格式相仿，只是关键字不同，实现使⽤ 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();
 }
}
输出结果:
吃东⻄
晚上睡

默认⽅法的使⽤
可以继承，可以重写，⼆选⼀，但是只能通过实现类的对象来调⽤。

1. 继承默认⽅法，代码如下：
   定义接⼝：

public interface LiveAble {
 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 LiveAble {
 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 LiveAble {
 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();
 }
}
输出结果:
跑起来~~~

私有⽅法的使⽤
私有⽅法：只有默认⽅法可以调⽤。
私有静态⽅法：默认⽅法和静态⽅法可以调⽤。
如果⼀个接⼝中有多个默认⽅法，并且⽅法中有重复的内容，那么可以抽取出来，封装到私有⽅
法中，供默认⽅法去调⽤。从设计的⻆度讲，私有的⽅法是对默认⽅法和静态⽅法的辅助。同学
们在已学技术的基础上，可以⾃⾏测试。
定义接⼝：

public interface LiveAble {
 default void func() {
 func1();
 func2();
 }
 private void func1() {
 System.out.println("跑起来~~~");
 }
 private void func2() {
 System.out.println("跑起来~~~");
 }
}

接⼝的多实现
接⼝中，有多个抽象⽅法时，实现类必须重写所有抽象⽅法。如果抽象⽅法有重名的，只需要重
写⼀次。代码如下：
定义多个接⼝：

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 修饰。
接⼝中，没有构造⽅法，不能创建对象。
接⼝中，没有静态代码块。