《Java之面向对象：下》

TheMythWS

已于 2023-11-24 16:01:28 修改

阅读量1k

点赞数 20

分类专栏： JavaSE 文章标签： java 面向对象

于 2022-11-25 13:43:40 首次发布

本文链接：https://blog.csdn.net/TheMyth142857/article/details/128035430

版权

JavaSE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

🌠作者：@TheMyth.

🎇座右铭：不走心的努力都是在敷衍自己，让自己所做的选择，熠熠发光。

👉final关键字👈

【1】修饰变量；

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //第1种情况：
        //final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
        final int A = 10;//final修饰基本数据类型
        //A = 20; 报错：不可以修改值
        //第2种情况：
        final Dog d = new Dog();//final修饰引用数据类型，那么地址值就不可以改变
        //d = new Dog(); -->地址值不可以更改
        //d对象的属性依然可以改变：
        d.age = 10;
        d.weight = 13.7;
        //第3种情况：
        final Dog d2 = new Dog();
        a(d2);
        //第4种情况：
        b(d2);
    }
    public static void a(Dog d){
        d = new Dog();
    }
    public static void b(final Dog d){//d被final修饰 ，指向不可以改变
        //d = new Dog();
    }
}

第3种情况分析图：

第4种情况分析图：

【2】修饰方法；

final修饰方法，那么这个方法不可以被该类的子类重写：

【3】修饰类；

final修饰类，代表没有子类，该类不可以被继承：
一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）

【4】案例：JDK提供的Math类：看源码发现：
（1）使用Math类的时候无需导包，直接使用即可：

（2）Math类没有子类，不能被其他类继承了

（3）里面的属性全部被final修饰，方法也是被final修饰的，只是省略不写了
原因：子类没有必要进行重写。

（4）外界不可以创建对象：
Math m = new Math();

（5）发现Math类中的所有的属性，方法都被static修饰
那么不用创建对象去调用，只能通过类名.属性名类名.方法名去调用

👀抽象类和抽象方法

抽象类概念:
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类.

在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstract method), 包含抽象方法的类我们称为抽象类(abstract class).

abstract class Shape {
    public abstract void draw();
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("♦");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("●");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
public class Test {
    public static void drawMap(Shape shape) {
        shape.draw();
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        drawMap(new Rect());
        drawMap(new Cycle());
        drawMap(new Flower());
    }
}

【1】抽象类和抽象方法的关系：
抽象类中可以定义0-n个抽象方法。
【2】抽象类作用：
在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。
使子类更加的通用。

【3】代码：（根据序号进行练习）

//4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类。
//5.一个抽象类中可以有0-n个抽象方法
abstract class Person {
    //1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
    public void eat(){
        System.out.println("一顿不吃饿得慌");
    }
    //2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写。
    //3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
    public abstract void say();
    public abstract void sleep();
}
//6.抽象类可以被其他类继承：
//7.一个类继承一个抽象类，那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
//9.子类继承抽象类，就必须重写全部的抽象方法
//10.子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。
class Student extends Person{
    @Override
    public void say() {
        System.out.println("我是东北人，我喜欢说东北话。。");
    }
    @Override
    public void sleep() {
        System.out.println("东北人喜欢睡炕。。");
    }
}
public class Demo{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //11.创建抽象类的对象：-->抽象类不可以创建对象
        //Person p = new Person();

        //12.创建子类对象：
        Student s = new Student();
        s.sleep();
        s.say();
        
        //13.多态的写法：父类引用指向子类对象：
        Person p  = new Student();
        p.say();
        p.sleep();
    }
}

总结：

抽象类使用abstract修饰类
抽象类不能被实例化
此时在抽象类中，可以有抽象方法或者非抽象方法
什么是抽象方法，一个方法被abstract修饰，没有具体的实现，只要包含抽象方法，这个类一定是抽象类
当一个普通类继承了这个抽象类，必须重写抽象类中的抽象方法
抽象类最大的意义就是为了被继承
抽象方法不能被private，final，static修饰，所以一定要满足方法重写的规则
当一个子类没有重写父类的抽象方法，可以把当前子类变为abstract修饰
抽象类不一定包含抽象方法，但是有抽象方法的类一定是抽象类
抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

抽象类和普通类的区别：
1.抽象类不能实例化，普通类可以
2.抽象类当中，可以包含非抽象方法和抽象方法，但是普通类只能包含非抽象方法

【4】面试题：

（1）抽象类不能创建对象，那么抽象类中是否有构造器？
抽象类中一定有构造器。构造器的作用给子类初始化对象的时候要先super调用父类的构造器。

（2）抽象类是否可以被final修饰？
不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。

（3）普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?
确实如此. 但是使用抽象类相当于多了一重编译器的校验. 使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成,
而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误,
让我们尽早发现问题. 很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛?
但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们. 充分利用编译器的校验, 在实际开发中是非常有意义的.

✨接口

接口的概念：
在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。
电脑的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备电源插座插孔上，可以插：电脑、电视机、电饭煲...所有符合规范的设备通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

【1】接口声明格式：

[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {
常量定义；
方法定义；
}
提示：
1. 创建接口时, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 "形容词" 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.

【2】代码：（根据序号练习）

/**
 * 1.类是类，接口是接口，它们是同一层次的概念。
 * 2.接口中没有构造器
 * 3.接口如何声明：interface
 * 4.在JDK1.8之前，接口中只有两部分内容：
 * （1）常量：固定修饰符：public static final
 * （2）抽象方法：固定修饰符：public abstract
 * 注意：修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。
 */
public interface TestInterface01 {
    //常量：
    /*public static final*/ int NUM = 10;
    //抽象方法：
    /*public abstract*/ void a();
    /*public abstract*/ void b(int num);
    /*public abstract*/ int c(String name);
}
interface TestInterface02{
    void e();
    void f();
}
/*
5.类和接口的关系是什么？ 实现关系  类实现接口：
6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.java只有单继承，java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9.写法：先继承 再实现：extends Person implements TestInterface01,TestInterface02
 */
class Student extends Person implements TestInterface01,TestInterface02 {
    @Override
    public void a() {
        System.out.println("---1");
    }
    @Override
    public void b(int num) {
        System.out.println("---2");
    }
    @Override
    public int c(String name) {
        return 100;
    }
    @Override
    public void e() {
        System.out.println("---3");
    }
    @Override
    public void f() {
        System.out.println("---4");
    }
}
class Test{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //10.接口不能创建对象：
        //TestInterface02 t = new TestInterface02();
        TestInterface02 t = new Student();//接口指向实现类 ---》多态：向上转型
        //11.接口中常量如何访问：
        System.out.println(TestInterface01.NUM);//接口名.常量名
        System.out.println(Student.NUM);//实现类.常量名
        Student s = new Student();
        System.out.println(s.NUM);//实现类的对象.常量名
        TestInterface01 t2 = new Student();
        System.out.println(t2.NUM);
    }
}

【3】接口的作用是什么？

定义规则，只是跟抽象类不同地方在哪？它是接口不是类。
接口定义好规则之后，实现类负责实现即可。

【4】
继承：子类对父类的继承
实现：实现类对接口的实现
手机是不是照相机

继承：手机 extends 照相机 “is-a”的关系，手机是一个照相机

上面的写法不好：

实现：手机 implements 拍照功能 “has-a”的关系，手机具备照相的能力

案例：飞机，小鸟，风筝（都没有向上抽取的类）
定义一个接口： Flyable

【5】多态的应用场合（重点）：
（1）父类当做方法的形参，传入具体的子类的对象
（2）父类当做方法的返回值，返回的是具体的子类的对象
（3）接口当做方法的形参，传入具体的实现类的对象
（4）接口当做方法的返回值，返回的是具体的实现类的对象

【6】接口和抽象类的区别（面试题）：

下面接口回答不完整！！！注意JDK1.8新特性！！！

核心区别:

抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.
如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此,此处的 Animal只能作为一个抽象类, 而不应该成为一个接口.
再次提醒: 抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.

单继承图解：

多实现图解：

JDK1.8以后的接口新增内容

在JDK1.8之前，接口中只有两部分内容：
（1）常量：固定修饰符：public static final
（2）抽象方法：固定修饰符：public abstract

在JDK1.8之后，新增非抽象方法：
（1）被public default修饰的非抽象方法：
注意1：default修饰符必须要加上，否则出错
注意2：实现类中要是想重写接口中的非抽象方法，那么不能加default修饰符，否则出错

public interface TestInterface {
    //常量：
    public static final int NUM= 10;
    //抽象方法：
    public abstract void a();
    //public default修饰的非抽象方法：
    public default void b(){
        System.out.println("-------TestInterface---b()-----");
    }
}
class Test implements TestInterface{
    public void c(){
        //用一下接口中的b方法：
        b();//如果接口中的b方法没有被重写，那么默认调用接口中的b方法，如果接口中的b方法被重写了，那么调用重写后的b方法
                                                                        //下面b方法是对接口中的b方法的重写，所以b();调用的是下面重写后的b方法。
        //super.b();不可以
        TestInterface.super.b();//可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    @Override
    public void b() {//可以重写，也可以不重写
    }
}

（2）静态方法：
注意1：static不可以省略不写
注意2：静态方法不能重写

public interface TestInterface2 {
    //常量：
    public static final int NUM = 10;
    //抽象方法：
    public abstract  void a();
    //public default非抽象方法；
    public default void b(){
        System.out.println("-----TestInterface2---b");
    }
    //静态方法：
    public static void c(){
        System.out.println("TestInterface2中的静态方法");
    }
}
class Demo implements TestInterface2{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}
class A {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();//Demo中的静态方法
        Demo.c();//Demo中的静态方法（调用静态方法-》类名.方法名（推荐！！！））
        TestInterface2.c();//TestInterface2中的静态方法
    }
}

疑问：为什么要在接口中加入非抽象方法？？？
如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大了，所有实现类都会受到影响。
现在在接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可。

图解：

接口练习：

（1）将shape类改为接口实现

/*abstract*/ interface Ishape {
    /*public abstract*/ void draw();
    public static final int NUM = 10;
    /*public default void func() {
        System.out.println("JDK8后新增的default修饰的非抽象方法");
    }*/
    public static void func() {
        System.out.println("staticFunc");
    }
}
class Rect implements Ishape {
    @Override
    public void draw() {
        System.out.println("♦");
    }
    /*@Override
    public void func() {
        System.out.println("重写那个默认方法");
    }*/
}
class Flower implements Ishape {
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
public class Test {
    public static void drawMap(Ishape shape) {
        shape.draw();
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //Ishape shape = new Ishape();
        /*Rect rect = new Rect();
        Flower flower = new Flower();*/
        Ishape shape = new Rect();//向上转型
        Ishape shape2 = new Flower();//向上转型
        drawMap(shape);
        drawMap(shape2);
        Ishape.func();
    }
}

（2）请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB接口：包含打开设备、关闭设备功能
2. 笔记本类：包含开机功能、关机功能、使用USB设备功能
3. 鼠标类：实现USB接口，并具备点击功能
4. 键盘类：实现USB接口，并具备输入功能

public interface IUSB {
    void openDevice();
    void closeDevice();
}

public class Mouse implements IUSB {
    @Override
    public void openDevice() {
        System.out.println("打开鼠标服务！");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标服务！");
    }
    public void click() {
        System.out.println("点击鼠标！");
    }
}

public class KeyBoard implements IUSB {
    @Override
    public void openDevice() {
        System.out.println("打开键盘！");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘！");
    }
    public void inPut() {
        System.out.println("键盘输入！");
    }
}

public class Computer {
    public void open() {
        System.out.println("开机！");
    }
    public void close() {
        System.out.println("关机！");
    }
    //所有的USB设备在电脑上都可以在电脑上使用
    public void useDevice(IUSB usb) {//IUSB usb = new Mouse();向上转型 接口当做方法的形参，传入具体的实现类的对象
        usb.openDevice();
        if (usb instanceof Mouse) {//usb是不是Mouse类的一个实例
            //向下转型
            Mouse mouse = (Mouse) usb;
            mouse.click();
            //((Mouse) usb).click();
        } else if (usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.inPut();
            //((KeyBoard) usb).inPut();
        }
        usb.closeDevice();
    }
}

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Computer computer = new Computer();
        /*Mouse mouse = new Mouse();
        KeyBoard keyBoard = new KeyBoard();
        computer.useDevice(mouse);
        computer.useDevice(keyBoard);*/
        /*IUSB mouseNew = new Mouse();
        IUSB keyBoardNew = new KeyBoard();
        computer.useDevice(mouseNew);
        computer.useDevice(keyBoardNew);*/
        computer.open();
        computer.useDevice(new Mouse());
        System.out.println("======");
        computer.useDevice(new KeyBoard());
        computer.close();
    }
}

总结：

使用关键字interface来定义接口
接口不能被实例化
接口当中的成员默认是public static final修饰的
接口当中的方法默认是public abstract修饰的
接口当中的方法，不能有具体的实现，但从JDK8开始，可以写一个default修饰的方法
接口当中不能有构造方法
接口需要被类实现，使用关键字implements
接口当中可以有static修饰的方法
接口中不能有静态代码块和构造方法
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
先继承再实现
接口可以通过extends 拓展多个接口的功能

接口进阶(重点)

实现多个接口：

在Java中，类和类之间是单继承的，一个类只能有一个父类，
即Java中不支持多继承，但是一个类可以实现多个接口。

abstract class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    /*此时不能把run写这里面，因为不是所有的动物都可以跑
    public void run() {
        System.out.println("跑！");
    }*/
}
/*class A {
    public void run() {
        System.out.println("跑！");
    }
}*/
interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}
interface IFlying {
    void fly();
}
class Dog extends Animal/*, A*/ implements IRunning { //java中只能单继承，所以引出了接口，让跑这个方法用接口来写
    public Dog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name + "正在用四条腿跑");
    }
}
class Fish extends Animal implements ISwimming {
    public Fish(String name) {
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(name + "正在用尾巴游泳");
    }
}
class Bird extends Animal implements IFlying {
    public Bird(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(name + "正在用翅膀飞");
    }
}
class Frog extends Animal implements IRunning, ISwimming {
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name + "正在往前跳");
    }
    @Override
    public void swim() {
        System.out.println(name + "正在蹬腿游泳");
    }
}
class Duck extends Animal implements IRunning, IFlying, ISwimming {
    public Duck(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name + "正在用两条腿跑");
    }
    @Override
    public void swim() {
        System.out.println(name + "正在飘在水上");
    }
    @Override
    public void fly() {
        System.out.println(name + "正在用翅膀飞");
    }
}
class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用轮子跑");
    }
}
public class Test {
    /**
     * 一定是一个动物，这样写不灵活
     *
     * @param animal
     */
    public static void func(Animal animal) {
    }
    /**
     * 只要实现了 IRunning 接口的 都可以接受
     *
     * @param iRunning
     */
    public static void walk(IRunning iRunning) {
        iRunning.run();
    }
    public static void swim(ISwimming iSwimming) {
        iSwimming.swim();
    }
    public static void fly(IFlying iFlying) {
        iFlying.fly();
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        walk(new Dog("旺财"));
        walk(new Frog("青蛙"));
        walk(new Duck("唐老鸭"));
        walk(new Robot("机器人"));
        System.out.println("===================");
        swim(new Fish("小甲鱼"));
        swim(new Frog("青蛙2号"));
        swim(new Duck("唐老鸭2号"));
        System.out.println("===================");
        fly(new Bird("小鸟"));
        fly(new Bird("唐老鸭3号"));
    }
}

上面的代码展示了 Java 面向对象编程中最常见的用法:
一个类继承一个父类, 同时实现多种接口.
继承表达的含义是 is - a 语义, 而接口表达的含义是具有 xxx 特性 .

猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞这样设计有什么好处呢?
时刻牢记多态的好处, 让程序猿忘记类型.
有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.
甚至参数可以不是 "动物", 只要会跑，例如传参传入机器人，机器人可以跑。

接口间的继承：

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。
即：用接口可以达到多继承的目的。接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface A {
    void funcA();
}
interface B {
    void funcB();
}
interface CC extends A, B {
    void func();
}
class C implements CC {
    @Override
    public void funcA() {
        
    }
    @Override
    public void funcB() {
    }
    @Override
    public void func() {
    }
}

修改Animal类（用接口间的继承）：

abstract class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}
interface IFlying {
    void fly();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
    void bark();
}
class Dog extends Animal implements IRunning { //java中只能单继承，所以引出了接口，让跑这个方法用接口来写
    public Dog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name + "正在用四条腿跑");
    }
}
class Fish extends Animal implements ISwimming {
    public Fish(String name) {
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(name + "正在用尾巴游泳");
    }
}
class Bird extends Animal implements IFlying {
    public Bird(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(name + "正在用翅膀飞");
    }
}
class Frog extends Animal implements IAmphibious {
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name + "正在往前跳");
    }
    @Override
    public void swim() {
        System.out.println(name + "正在蹬腿游泳");
    }
    @Override
    public void bark() {
        System.out.println(name + "正在呱呱叫");
    }
}
class Duck extends Animal implements IAmphibious, IFlying {
    public Duck(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name + "正在用两条腿跑");
    }
    @Override
    public void swim() {
        System.out.println(name + "正在飘在水上");
    }
    @Override
    public void fly() {
        System.out.println(name + "正在用翅膀飞");
    }
    @Override
    public void bark() {
        System.out.println(name + "嘎嘎嘎的叫");
    }
}
class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用轮子跑");
    }
}
public class Test {
    public static void bark(IAmphibious iAmphibious) {
        iAmphibious.bark();
    }
    public static void walk(IRunning iRunning) {
        iRunning.run();
    }
    public static void swim(ISwimming iSwimming) {
        iSwimming.swim();
    }
    public static void fly(IFlying iFlying) {
        iFlying.fly();
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        walk(new Dog("旺财"));
        walk(new Frog("青蛙"));
        walk(new Duck("唐老鸭"));
        walk(new Robot("机器人"));
        System.out.println("===================");
        swim(new Fish("小甲鱼"));
        swim(new Frog("青蛙2号"));
        swim(new Duck("唐老鸭2号"));
        System.out.println("===================");
        fly(new Bird("小鸟"));
        fly(new Bird("唐老鸭3号"));
        System.out.println("===================");
        bark(new Frog("青蛙3号"));
        bark(new Duck("唐老鸭4号"));
    }
}

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.接口间的继承相当于把多个接口合并在一起.

接口使用实例：给对象数组排序

import java.util.Arrays;
class Student {
    private String name;
    private int age;
    private int score;
    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("themyth", 19, 80);
        students[1] = new Student("wangsheng", 22, 99);
        students[2] = new Student("luoyadan", 21, 85);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

异常原因：学生类不能转换为接口
点进源码：

仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确.
而两个学生对象的大小关系怎么确定?
需要我们额外指定. 让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

修改代码：

import java.util.Arrays;
class Student implements Comparable<Student> {
    private String name;
    private int age;
    private int score;
    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
    /*
    写比较规则
     */
    /*@Override
    public int compareTo(Student o) {//按年龄从小到大排序
        *//*if (this.age > o.age) {
            return 1;
        } else if (this.age < o.age) {
            return -1;
        } else {
            return 0;
        }*//*
         return this.age - o.age;                                                                      //return this.age - o.age;
    }*/
    @Override
    public int compareTo(Student o) {//按照姓名从小到大排序
        if (this.name.compareTo(o.name) > 0) {//调用的是String类的方法，注意：equals只能判断相不相等
            return 1;
        } else if (this.name.compareTo(o.name) < 0) {
            return -1;
        } else {
            return 0;
        }
    }
}
public class Test {
    public static void sort(Comparable[] array) {//传入Student数组，类型匹配
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j].compareTo(array[j + 1]) > 0) {
                    Comparable tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("themyth", 19, 80);
        students[1] = new Student("wangsheng", 22, 99);
        students[2] = new Student("luoyadan", 21, 85);
        //System.out.println(students[0].compareTo(students[1]));
        //Arrays.sort(students);
        sort(students);
        System.out.println(Arrays.toString(students));
    }
}

上面的实现很不灵活，我们只能把代码写死，每次比较不同的属性，得重写整个compareTo方法，
接下来引出更灵活的写法，写一个比较器comparator

import java.util.Arrays;
import java.util.Comparator;
class Student {
    public String name;
    public int age;
    public int score;
    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
class AgeComparator implements Comparator<Student> {//比较的是Student
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}
class ScoreComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.score - o2.score;
    }
}
class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);//String实现了Comparable接口，重写了compareTo方法
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("themyth", 19, 80);
        students[1] = new Student("wangsheng", 22, 99);
        students[2] = new Student("luoyadan", 21, 85);
        //比较器
        AgeComparator ageComparator = new AgeComparator();
        ScoreComparator scoreComparator = new ScoreComparator();
        NameComparator nameComparator = new NameComparator();
        Arrays.sort(students, nameComparator);
        System.out.println(Arrays.toString(students));
    }
}

OJ练习：

import java.util.Arrays;
import java.util.Scanner;
class PersonSortable implements Comparable<PersonSortable> { //comparable类型为PersonSortable类型的
    private String name;
    private int age;
    public PersonSortable() {
        this.name = name;
        this.age = age;
    }
    public PersonSortable(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(PersonSortable o) {
        /*if (this.name.compareTo(o.name) > 0) {//调用的是String类的方法，注意：equals只能判断相不相等
            return 1;
        } else if (this.name.compareTo(o.name) < 0) {
            return -1;
        } else {
            //姓名相同，再按照年龄从小到大排序
            return this.age - o.age;
        }*/
        //优化写法：
        if (this.name.equals(o.name)) {//姓名相同，按照年龄从小到大排序
            return this.age - o.age;
        }
        //姓名不相同，按照姓名排序
        return this.name.compareTo(o.name);
    }
    @Override
    public String toString() {
        return name + "-" + age;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        PersonSortable[] personSortables = new PersonSortable[n];
        for (int i = 0; i < personSortables.length; i++) {
            String name = sc.next();
            int age = sc.nextInt();
            personSortables[i] = new PersonSortable(name, age);
        }
        Arrays.sort(personSortables);
        for (int i = 0; i < personSortables.length; i++) {
            System.out.println(personSortables[i]);
        }
    }
}

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
class PersonSortable2 {
    private String name;
    private int age;
    public PersonSortable2() {
        this.name = name;
        this.age = age;
    }
    public PersonSortable2(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return name + "-" + age;
    }
}
class AgeComparator implements Comparator<PersonSortable2> {
    @Override
    public int compare(PersonSortable2 o1, PersonSortable2 o2) {
        return o1.getAge() - o2.getAge();
    }
}
class NameComparator implements Comparator<PersonSortable2> {
    @Override
    public int compare(PersonSortable2 o1, PersonSortable2 o2) {
        return o2.getName().compareTo(o1.getName());//降序
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        PersonSortable2[] personSortables = new PersonSortable2[n];
        for (int i = 0; i < personSortables.length; i++) {
            String name = sc.next();
            int age = sc.nextInt();
            personSortables[i] = new PersonSortable2(name, age);
        }
        AgeComparator ageComparator = new AgeComparator();
        NameComparator nameComparator = new NameComparator();
        Arrays.sort(personSortables, nameComparator);
        System.out.println("NameComparator:sort");
        for (int i = 0; i < personSortables.length; i++) {
            System.out.println(personSortables[i]);
        }
        System.out.println("AgeComparator:sort");
        Arrays.sort(personSortables, ageComparator);
        for (int i = 0; i < personSortables.length; i++) {
            System.out.println(personSortables[i]);
        }
    }
}

Clonable 接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.

空接口-》标记接口：作用就是表示当前对象是可以被克隆的

对自定义类型进行拷贝：

class Student implements Cloneable {
    public String name;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1 = new Student();
        student1.name = "themyth";
        /*Object clone = student1.clone();
        Student student2 = (Student)clone;*/
        //这儿没有用instanceof是因为所有类的父类一定是Object，不会是其它的类
        Student student2 = (Student) student1.clone();//因为clone方法返回值是Object父类，这儿要向下转型
        System.out.println(student1);
        System.out.println(student2);
    }
}

再谈深拷贝和浅拷贝：

浅拷贝：

class Money {
    public double money = 12.25;
}
class Student implements Cloneable {
    public String name;
    public Money m = new Money();
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1 = new Student();
        Student student2 = (Student) student1.clone();
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
        System.out.println("======");
        student2.m.money = 99;
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
    }
}

内存分析：

深拷贝：

class Money implements Cloneable{
    public double money = 12.25;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Student implements Cloneable {
    public String name;
    public Money m = new Money();
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //只是克隆了Student对象
        Student student = (Student) super.clone();
        //克隆了 Student对象里面的Money对象
        student.m = (Money) this.m.clone();//将student1所指向的m对象克隆一份
        return student;
        //return super.clone();
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1 = new Student();
        Student student2 = (Student) student1.clone();
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
        System.out.println("======");
        student2.m.money = 99;
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
    }
}

内存分析：

再次强调：深拷贝和浅拷贝只跟代码的实现有关系！！！

🌟内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类

【注意事项】
1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

public class A{
}
class B{
}
// A 和 B是两个独立的类，彼此之前没有关系

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

成员内部类

根据序号进行练习：

/**
 *1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
 *2.一个类TestOuter的内部的类SubTest叫内部类
 *3.内部类：成员内部类(静态的，非静态的) 和 局部内部类（位置：方法内，代码块内，构造器内）
 *4.成员内部类：
 *          里面属性，方法，构造器等
 *          修饰符：private default protect public final abstract
 */
public class TestOuter {
    //成员内部类：
    //one_非静态的成员内部类
    public class D{
        int age = 20;
        String name ="ws";
        public void method(){
            //5.内部类可以访问外部类的内容
           /* System.out.println(age);
            a();*/
            int age = 30;
            //8.内部类和外部类属性重名的时候，如何进行调用：
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOuter.this.age);//10
        }
    }
    //two_静态成员内部类：
    static class E{
        public void method(){
            //6.静态内部类中只能访问外部类中被static修饰的内容，如果确实要访问其它内容，得创建对象
            /*System.out.println(age);
            a();*/
            //即：当外部类的属性age和a方法都被static修饰后才能成功运行上面的代码
        }
    }
    //属性：
    int age = 10;
    //方法：
    public void a(){
        System.out.println("这是a方法");
        {
            System.out.println("这是一个普通块");
            class B{//局部内部类（普通块内）
            }
        }
        class A{//局部内部类（方法内）
        }
        //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
        D d = new D();
        System.out.println(d.name);
        d.method();
    }
    static{
        System.out.println("这是静态块");
    }
    {
        System.out.println("这是构造块");
    }
    //构造器：
    public TestOuter(){
        class c{//局部内部类（构造器内）
        }
    }
    public TestOuter(int age){
        this.age=age;
    }
}
class Demo {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建外部类的对象：
        TestOuter to = new TestOuter();
        to.a();
        //9.创建内部类的对象：
        //静态的成员内部类创建对象：
        TestOuter.E e = new TestOuter.E();//外部类名.内部类名
        //非静态的成员内部类创建对象：
        //错误：TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();
        TestOuter.D d = t.new D();
    }
}

静态内部类练习：

class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //静态内部类
    static class InnerClass {
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;
        public void func() {
            System.out.println("static->InnerClass::func()");
            /*2.在静态内部类中，不能直接访问外部类的非静态成员
            但是可以通过创建外部类对象，再访问它的
            System.out.println(data1);
            System.out.println(data2);
            */
            OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
    public void test() {
        InnerClass innerClass = new InnerClass();
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);
        System.out.println(innerClass.data4);
        System.out.println(innerClass.data5);//3.外部类 可以访问静态内部内当中的所有成员
        System.out.println(InnerClass.data6);//静态的成员变量，直接类名.
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //InnerClass innerClass = new InnerClass();1.静态内部类不能直接通过类名创建对象，创建静态内部类对象时，不需要先创建外部类对象
        OuterClass.InnerClass  innerClass = new OuterClass.InnerClass();
        innerClass.func();
        System.out.println("-----------");
        OuterClass outerClass = new OuterClass();
        outerClass.test();
    }
}

非静态内部类练习：

class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //非静态内部类
    class InnerClass {
        public int data1 = 142857;
        public int data4 = 4;
        private int data5 = 5;
        /*
        1.在非静态内部类中不能直接定义静态成员变量
        因为内部类是依赖于外部类才创建的，而static修饰的变量不依赖于对象的，产生矛盾
        相当于此时外部类加载到时候，这个非静态内部类不会加载
        如果实在是要定义需要加上final关键字
        常量是在程序编译时候就已经确定了
         */
        public static final int data6 = 6;
        public void func() {
            System.out.println("InnerClass::func()");
            //3.内部类和外部类属性重名的时候，如何进行调用：
            System.out.println(data1);//142857
            System.out.println(this.data1);//142857
            System.out.println("====");
            System.out.println(OuterClass.this.data1);//1
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
    public void test() {
        InnerClass innerClass = new InnerClass();
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);
        System.out.println(innerClass.data4);
        System.out.println(innerClass.data5);
        System.out.println(InnerClass.data6);//访问静态成员，直接类名.
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        /*
        2.非静态内部类也不能直接通过类名创建对象
        需要先创建外部类对象，再创建
        注意：
        静态内部类是不需要先创建外部类对象的
        而非静态内部类需要先创建外部类对象，再进行创建
         */
        //InnerClass innerClass = new InnerClass();
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.func();
    }
}

局部内部类

public class TestOuter {
    //1.在局部内部类中访问到的变量必须是被final修饰的
    public void method(){
        final int num = 10;
        class A{//局部内部类(方法内中的类)
            public void a(){
                //num = 20;
                System.out.println(num);
            }
        }
    }
    //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
    //方法结束，类也被销毁了
    public Comparable method2(){//用接口当作方法的返回值，返回的是具体的实现类的对象
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        }
        return new B();
    }
    public Comparable method3(){
        //3.匿名内部类(安卓用得比较多)
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
    }
    public void test(){
        Comparable com = new Comparable() {//相当于接口=具体的一个实现类
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
        System.out.println(com.compareTo("abc"));
    }
}

局部内部类练习：

class OuterClass {
    public void func() {
        class InnerClass {
            public int a = 1;
            public void test() {
                System.out.println("InnerClass->test()");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.test();
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.func();
    }
}

匿名内部类练习：

interface  IA {
    void func();
}
class AA implements IA {
    @Override
    public void func() {
        System.out.println("hello!");
    }
}
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //方法1：
        IA ia1 = new AA();
        ia1.func();
        //方法2：匿名内部类 new IA() {};
        new IA() {
            @Override
            public void func() {
                System.out.println("我去，还可以这样写！");
            }
        }.func();
    }
}