文章详细介绍了Java中的接口概念，包括接口之间的关系、实现类与抽象类的区别，以及接口规则的案例。此外，讲解了静态修饰符的作用，如静态成员变量、静态内存、静态方法，以及main方法的定义。同时，讨论了final修饰符在类、方法和变量上的应用。内容还包括代码块的种类和对象初始化过程。最后，文章提到了内部类的三种类型：成员内部类、局部内部类和匿名内部类，以及非法修饰符组合的情况。
目录
第七章 面向对象接口
学习目标
-
接口的多继承
-
实现类实现接口后,还是抽象类
-
接口的规则体系案例
-
static静态修饰符
-
static内存表现
-
main方法的定义解析
-
四大权限修饰符
-
final修饰符
-
内部类
-
匿名内部类
1.接口的补充
1.1 接口之间的关系
类和类之间是继承关系(单继承)，类和接口之间是实现关系(多实现implements)，接口和接口之间是继承关系,支持多继承，一个接口可以同时继承多个接口. interface A extends B,C,D{}
1.2 实现类还是抽象类
实现类实现接口,重写一部分抽象方法，然而还有一部分抽象方法还没重写，实现类还是一个抽象类
public interface A {
public abstract void a1();
public abstract void a2();
}public abstract class B implements A {
public void a1(){
}
// public abstract void a2();
}抽象类B只是重写了抽象方法a1，还有抽象方法a2没有重写，所以类B还是一个抽象类
1.3 接口规则案例
接口其实就是一种规范，规范了方法的类型和权限，我们只需要按照其规则重写该接口的所有抽象方法，就可以实现接口给我的规范的方法
根据上面的例子，写一个程序
（1）Computer.java文件
/**
* 笔记本电脑类
*/
public class Computer {
/**
* 笔记本电脑,通过USB接口,使用外接设备
* 方法定义,实现设备的使用
* 返回值类型 : 这个方法经过运算后的结果的数据类型
* 参数 : 其实方法的参数,是方法运算过程中的未知数据,才是参数
*
* 笔记本电脑,通过USB接口,使用外接设备 这个功能的未知数据,就是外接设备
* 核心 : 未知设备,都有共同特性 : 满足接口规则
*
* 问题 : 这个方法调用 : 传递他什么
* 参数是引用类,要传递对象,传递接口实现类对象
*/
public void useUSB(USB usb){
// USB usb = new Mouse();
//接口引用调用方法
usb.start();
usb.end();
}
}（2）KeyBoadr.java文件
/**
* 键盘类 : 满足接口标准
*/
public class KeyBoard implements USB{
@Override
public void start() {
System.out.println("键盘工作");
}
@Override
public void end() {
System.out.println("键盘停止工作");
}
}（3）Mouse.java文件
/**
* 鼠标类 : 接入USB接口工作
* 满足接口的规则 : 程序中就是实现接口
*/
public class Mouse implements USB{
@Override
public void start() {
System.out.println("鼠标打开开关,按键,滚轮");
}
@Override
public void end() {
System.out.println("开关关了");
}
}（4）接口类USB
/**
* 定义的USB接口 : 规则指定
* 接口的规则 : 程序中的抽象方法
*/
public interface USB {
//设备开始工作
public abstract void start();
//设备结束工作
public abstract void end();
}（5）测试类USBTest
public class USBTest {
public static void main(String[] args) {
//测试笔记本案例
//创建笔记本对象
Computer computer = new Computer();
//调用笔记本的方法 useUSB
/* Mouse m = new Mouse();
computer.useUSB(m);*/
computer.useUSB( new Mouse() );
//调用笔记本的方法,传递键盘对象 (USB接口实现类对象)
computer.useUSB( new KeyBoard());
}
}computer对象的use()方法只需要按照传进来的USB多态对象，然后去调用start()和end()方法即可，因为有多态的存在，所以computer的use()方法的参数只需要是USB接口类型即可，实现了接口USB的实现类对象均可以当作参数传进来。
2.静态修饰符
static修饰符 : 最早出现在main方法中。只能修饰成员,不能写在方法的内部，被static修饰的成员，称为静态成员变量和静态的成员方法。
2.1 静态修饰成员变量
static 修饰的成员变量，是被所有的对象共享的数据。没有被static修饰的成员变量，是每个对象的独享数据或者是特有数据。
（1）Person.java文件
public class Person {
String name;
static String country = "中国";
}（2）StaticTest.java文件
public class StaticTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "张三";
Person p2 = new Person();
p2.name = "李四";
//使用对象p1修改变量country的值
p1.country = "美国";
System.out.println(p2.country);
}
}
2.2 静态内存
-
静态成员内存的特点
-
静态成员跟随自己的类进入到元数据区(静态区域)
-
静态成员属于自己的类,不属于对象
-
静态成员进入内存后,赋默认值
-
静态成员变量的初始化实际早于对象
-
当类被加载时，就会把全部类加载到元数据区，如果成员中有被static修饰的，也一起被加载到元数据区，也就为什么静态成员变量会被共享了。当对象被创建后，没有被static修饰的成员变量会被加载到栈区。
2.3 静态成员的调用方式
静态的内存图中,已经很明白了,静态属于自己的类,不是对象,静态的调用方式应该是类名.静态成员
Person.country ;//调用静态成员public static void main(String[] args) {
System.out.println(Person.country);
Person p1 = new Person();
p1.name = "张三";
Person p2 = new Person();
p2.name = "李四";
//使用对象p1修改变量country的值
Person.country = "美国";
System.out.println(Person.country);
}（1）静态的调用方式是两种 : 类名调用，对象调用. 非静态成员调用只能对象。
（2）静态成员调用方式只有类名. 非静态成员只能对象. 。
（3）静态成员的对象.静态调用方式,会被javac编译为类名调用。
2.4 静态方法
静态方法直接类名调用。 静态方法中不能直接使用非静态成员.
为什么不能调用非静态成员
可以理解为：静态是先人，非静态是后人，静态出现在内存的时间早于非静态。
public class Person {
String name;
static String country = "中国";
/**
* 静态方法
*/
public static void eat(){
System.out.println("人在吃饭" + country);
System.out.println(name); //错误写法,不允许
}
}静态内存优先于对象,在静态的方法中不能使用this和super，理由如下：
（1）this有两种含义，一种是指当前使用的对象，另一种是指当前正在被创建的对象。得先有对象才有this，而静态方法加载到内存中的时间早于对象创建，所以在静态方法中不能使用this关键字。
（2）super关键字是在一个对象内存中，区分父类成员和子类成员的一种标志，所以也是需要当对象被创建后才能使用，所以在静态方法中不能使用super关键字。
2.5 main方法
public static void main(String[] args){}-
main方法详解
-
public 最大权限 : main方法的调用者是JVM，如果不是public，那么JVM就无法调用main()方法了。
-
static 无需对象，被类名直接调用，JVM启动的时候使用类名.main启动程序。这也就是为什么使用java命令时，不是写类名.class，而是直接写类名，因为java 类名的意思是利用类名.main()的方式去调用main方法。
-
void 无返回值,调用者是JVM，方法的返回值都是返回给调用者，JVM不需要返回值,没有意义。
-
main 固定方法名称
-
args 字符串的数组，JVM调用方法main必须传递参数，后期对JVM设置参数（现阶段可以不需要理解）
-
2.6 什么时候定义静态
-
静态成员变量 : 具体功能具体分析 .
-
当你需要定义一个类的时候,分析这个类new出来的对象,是否存在共享数据,如果有共享数据,应该定义为静态变量
-
-
静态成员方法 :
-
当你类中的方法,没有使用过非静态成员你的时候,应该定义为静态.
-
3.四大权限
四大权限：public protected default private
| 权限范围 | private | default | protected | public |
|---|---|---|---|---|
| 同一类 | OK | OK | OK | OK |
| 同一包 | NO | OK | OK | OK |
| 不同包子类 | NO | NO | OK | OK |
| 不同包非子类 | NO | NO | NO | OK |
-
受保护权限 protected
-
权限的成员，为子类提供使用
-
Object类是所有类的父类，类中的方法权限有public、protected
-
关键的方式受保护权限的方法只能是子类中super调用！！！
-
子类对象不能调用，不出子类
-
例如：所有的类都继承Object类，该类有一个方法clone()的权限修饰符是protected，调用该方法得用super调用。
如果直接在该方法中创建Object的对象，通过对象再去调用clone()方法是不成立的。
4.final修饰符
final修饰符是最终的意思，不可改变。final可以修饰类，修饰方法，修饰成员变量，修饰局部变量。
4.1 final修饰类
被final修饰的类，称为最终类，不能被其他的类继承，被称为无子类或太监类。
学过的final类有哪些？有String、System、Scanner。
public final class A{} //这个类A,不能出现子类,如果继承,直接报错
public class B extends A{} //错误,编译错误,最终类不能继承4.2 final修饰方法
被final修饰的方法，最终方法，不能被子类重写，和调用无关。
一个类中的部分方法很完美，但是另一部分方法有待完成，设计为两个部分。完美的方法就是final
public class A{
public final void a(){} //方法不能被子类重写
}
public class B extends A{
public void a(){} //最终方法,不能重写
}4.3 final修饰局部变量
变量定义在方法的内部，是局部变量，被final修饰后，一次赋值，终身不改变，锁死了变量的值，看做是常量。
-
final修饰的基本类型，锁死值
-
final修饰的引用类型,锁死内存地址 (引用类型中的成员不受影响)
-
final修饰了方法的参数,调用者传递值后,方法的参数值就锁死
public static void main(String[] args) {
/**
* Student student 对象存储的是内存地址
* final修饰后,固定住的,不可改变是student变量保存的地址
* 但是,Student对象中的成员,不受影响
*/
final Student student = new Student();
student.age = 20;
student.age = 30;
System.out.println(student.age);
final int[] arr = {1,2,3};//arr变量的值,固定为内存地址,不可改变
arr[1] = 200;
show(5);
}
public static void show(final int x){
x = 6; //final修饰,不可改变,报错
}
}4.4 final修饰成员变量
成员变量的定义位置，是在类中，方法外面。成员变量在内存中有默认值。final修饰成员变量的时候，锁住的不是内存默认值,而是我们程序人员手动的赋值。
注意：成员变量如果没有赋值，系统会自动的赋上默认值，而局部变量不会，要我们自己赋值，不然会报错
（1）没加final的成员变量
-
成员变量赋值，可以定义直接写值
int age = 0; -
成员变量赋值，可以使用构造方法
public Student(int age){this.age=age;} -
成员变量赋值，可以使用set方法完成
（2）加了final的成员变量
- 成员变量赋值，可以定义直接写值
int age = 0; -
final修饰的成员变量,可以构造方法赋值,不能set方法赋值
以下是为什么被final修饰的成员变量不能用set方法赋值的原因：
答：构造方法在new对象的时候，执行一次，仅仅一次。可set方法，反复执行！
public class Student {
final int age ;
public Student (int age ){
this.age = age;
}
/*public void setAge(int age){
this.age = age;
}这样赋值时错误的*/
}5.代码块
5.1 静态代码块
写在类中方法外面 : static{}
静态代码块的执行时机：只要使用了这个类的成员(new对象、调用静态方法、静态变量)，静态代码块就会执行，而且就一次。
如上图所示，“你真帅！！！”只会执行一次
后面会自己写静态代码块 : 数据库连接池 (C3P0、Druid)
JDBC注册数据库驱动程序，使用静态代码块
5.2 构造代码块
写在类中方法外面的 {}, 创建对象的时候运行,new一次,运行一次（99%不会使用）
5.3 局部代码块
写在方法内部的 {} 局部代码块,没有用（99%不会使用）
6.对象初始化过程（子类和父类）
-
加载：父类.class文件先进入内存
-
加载：子类.class文件再进入内存
-
加载：初始化父类的静态成员(变量,代码块,方法)
-
加载：初始化子类的静态成员
-
运行：父类的静态代码块
-
运行：子类的静态代码块
-
运行：父类的构造代码块
-
运行：父类的构造方法
-
运行：子类的构造代码块
-
运行：子类的构造方法
记住一点，静态成员比非静态成员先运行。父类的非静态构造比子类的非静态构造先执行！！！
7.内部类
概述 : 所谓内部类,就是在一个类的内部,定义了另外的一个类
class A{ //外部类,封闭类
class B{} //内部类,嵌套类
}对象是生活中的存在的事物,一个事物中还存在着另一个具体的事物
class 大楼{
class 电梯{}
}7.1 成员内部类
成员内部类，是一个类定义在了另一个类的成员位置。这个内部类可以使用成员修饰符，public static final private 。
对于内部来说 : 可以直接使用外部类的成员，如果外部类要使用内部类的成员，必须要创建对象。
公式 : 外部类名.内部类名 变量名 = new 外部类对象().new 内部类对象()
//外部类
public class Outer {
public void outer(){
System.out.println("外部类的方法outer");
}
//内部类
public class Inner{
public void inner(){
System.out.println("内部类的方法inner");
}
}
}public static void main(String[] args) {
//调用内部类的方法inner()
Outer.Inner oi = new Outer().new Inner();
oi.inner();
}问题 : 内部类Inner，编译后有class文件吗？答：有class文件，名字是外部类$内部类。
内部类也是类,继承Object,可以实现接口。
7.2 局部内部类
局部内部类 ： 要定义在方法里面。方法里面是局部位置，不能使用成员修饰符，权限，静态不能用。
class A{
public void a(){
class B{} //局部内部类
}
}public class Outer {
/**
* Inner类,是方法Outer的局部
* 依然方法,才能被外界访问
*/
public void outer(){
class Inner{
public void inner(){
System.out.println("局部内部类的方法!!");
}
}
//方法,建立对象
//因为是和Inner同级，所以可以直接Inner inner = new Inner()来创建对象
Inner inner = new Inner();
inner.inner();
}
}public static void main(String[] args) {
//调用内部类的方法inner()
//不能直接调用
Outer outer = new Outer();
outer.outer();
}（1）为什么只能这样调用呢？
答：这是因为方法的生命周期问题，当方法结束后，局部内部类也就会笑死，所以不能直接在main()方法中创建局部内部类的对象，只能在方法中创建局部内部类的对象。
（2）为什么局部内部类，访问局部变量，变量必须final修饰？
答：是为了解决两个问题。第一个问题：两个方法使用一个变量，自己修改自己的，不能保证最终结果是否为我们想要的。第二个问题：生命周期问题，对象的生命长于方法，out方法已经出栈消失，Inner类的对象还活着，对象.in()内存的生命问题，in方法在访问变量x的时候，变量在内存中消失了。Sun公司为了解决两个问题，那就别改变量了，加上final得了。局部内部类，使用局部变量，变量必须final修饰，jdk8会默认添加，jdk7必须自己手动写入，不然编译过不去。
注意：final是个障眼法，在编译后，final修饰的变量会变成一个常数。所以被final修饰的变量的值不会消失，能与局部内部类共处。
用idea反编译后，就可以发现被final修饰的变量消失了，被final修饰的变量会变成一个常数5，这就避免了变量的生命周期的问题。
7.3 匿名内部类
匿名内部类，就是没有名字的内部类，只能写在方法中，为了简化代码书写。
简化：实现类实现接口，重写方法，创建对象。或者是子类继承父类，重写方法，创建对象。代码上少内容。
-
匿名内部类使用的前提：
-
必须有接口实现,或者是类的继承
-
格式 ：实现类,实现接口,重写方法,创建对象
-
new 接口或者父类(){
//重写抽象方法
};
public interface MyInter {
public abstract void inter();
public abstract void inter2();
}（1）这是非匿名的创建方式
public class InnerClassTest {
public static void main(String[] args) {
//匿名内部类,简化书写,不写实现类
//同时调用多个重写方法
/*
* new MyInter(){}; 是接口实现类的匿名对象
* 多态 : 接口 变量 = 实现类对象
*/
MyInter my = new MyInter(){
@Override
public void inter() {
System.out.println("实现类实现接口重写方法");
}
@Override
public void inter2() {
System.out.println("实现类实现接口重写方法2222");
}
};
my.inter();
my.inter2();
}
}（2）这是匿名的创建方式
public class InnerClassTest {
public static void main(String[] args) {
new MyInter(){
@Override
public void inter() {
System.out.println("你好美！！！");
}
@Override
public void inter2() {
System.out.println("你好帅！！！");
}
}.inter();
}
}两种方式的主要区别就是匿名的只能使用一次，而且要注意后面的分号，因为匿名调用是要加方法的，所以的加上分号，告知计算机你到这里就结束了。
8.非法修饰符组合
非法的修饰符的组合，主要说的是抽象abstract
-
abstract和private就是非法组合，抽象方法要重写，private不能继承。
-
abstract和final就是非法组合，抽象方法要重写，final修饰不能重写。
-
被static修饰的方法没有重写这么一说。
我已经重写了Person中类的方法，而在多态调用时，eat()方法却没和student对象实现动态绑定，这是因为在编译时，person.eat()会被编译器改为Person.eat()，也就是通过类名来调用静态方法。
感谢尚硅谷老师的指导！！！
1189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
