《Java之面向对象:下》

🌠作者:@TheMyth.

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

目录

👉final关键字👈

👀抽象类和抽象方法

✨接口

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

接口进阶(重点)

Clonable 接口和深拷贝

🌟内部类

成员内部类

局部内部类


👉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();
    }
}

总结:

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

抽象类和普通类的区别:
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();
    }
}

总结:

  1. 使用关键字interface来定义接口
  2. 接口不能被实例化
  3. 接口当中的成员默认是public static final修饰的
  4. 接口当中的方法默认是public abstract修饰的
  5. 接口当中的方法,不能有具体的实现,但从JDK8开始,可以写一个default修饰的方法
  6. 接口当中不能有构造方法
  7. 接口需要被类实现,使用关键字implements
  8. 接口当中可以有static修饰的方法
  9. 接口中不能有静态代码块和构造方法
  10. 接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class
  11. 先继承再实现
  12. 接口可以通过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();
    }
}

【注意事项】
1. 局部内部类只能在所定义的方法体内部使用 
2. 不能被public、static等修饰符修饰 
3. 编译器也有自己独立的字节码文件,命名格式:外部类名字$数字内部类名字.class 
4. 几乎不会使用

  • 20
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TheMythWS

你的鼓励,我的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值