面相对象高级(抽象类、接口、内部类)-CSDN博客

本文链接：https://blog.csdn.net/qq_74930471/article/details/140604899

一、抽象类

1.1抽象类的基本概念

1.2抽象类的基础代码

package com.abstract_;

public class Abstract01 {
    public static void main(String[] args) {

    }
}
abstract class Animal{
    private String name;
    public Animal(String name){
        this.name = name;
    }
    //思考：这里eat你实现了其实没有什么意义
    //即：父类方法不确定性的问题
    //==>考虑将该方法设计为抽象方法 (abstract)方法
    //==>所谓抽象方法就是没有实现的方法，没有方法体
    //==>当一个类中存在抽象方法时，需要将该类声明为abstract类
    //==>一般来说，抽象类会被继承，有其子类来实现实现抽象方法
//    public void eat(){
//        System.out.println("这是一个动物，但是不知道吃什么");
//    }
    public abstract void eat();
}

1.3抽象类的相关细节

第一部分细节

package com.abstract_;

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽两类不能被实例化
        //new A();
    }
}
//抽象类不一定包含abstract方法。也就是说，抽象类可以没有abstract方法
//还可以有实例方法
abstract class A{
    public void hi(){
        System.out.println("hi");
    }
}

第二部分细节

第八点强调一下：因为抽象方法要通过子类重写来实现，如果使用了private 、final、static来修饰就与无法通过子类实现了

package com.abstract_;

public class AbstractDetail02 {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

abstract  class E{
    public abstract void hi();
}
abstract class F extends E{

}
class G extends E {
    public void hi(){//所谓实现方法就是有方法体{},至于里有什么他不关心

    }
}
//抽象类的本质还是类，所以可以有类的各种成员
abstract class D{
    public int n1 = 10;
    public static String  ss= "抽象类中的静态属性";
    public void hi(){
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok(){
        System.out.println("ok");
    }
}

1.4抽象类的最佳实践-模版设计模式

AA类：

package com.abstract_;

public class AA {
    public void job(){
        //得到开始的时间
        long start = System.currentTimeMillis();
        long num = 0;
        //快捷键800000.fori
        for (int i = 0; i < 8000000; i++) {
            num+=i;
        }
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("AA执行时间"+(end-start));
    }
}

BB类：

package com.abstract_;

public class BB {
    public void job(){
        //得到开始的时间
        long start = System.currentTimeMillis();
        long num = 0;
        //快捷键8000.fori
        for (int i = 0; i < 800000; i++) {
            num*=i;
        }
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("BB执行时间"+(end-start));
    }
}

主函数：

package com.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.job();
        BB bb = new BB();
        bb.job();
    }
}

观察上面的代码可以发现，上述代码的复用性很差，也有很多相似的功能我们稍微改进一下

package com.abstract_;

public class AA {
    public void calculateTime(){
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("AA执行时间"+(end-start));
    }
    public void job(){
        long num = 0;
        //快捷键800000.fori
        for (int i = 0; i < 8000000; i++) {
            num+=i;
        }

    }
}

package com.abstract_;

public class BB {
    public void calculateTime(){
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("BB执行时间"+(end-start));
    }
    public void job(){
        long num = 0;
        //快捷键8000.fori
        for (int i = 0; i < 800000; i++) {
            num*=i;
        }
    }
}

package com.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();
        BB bb = new BB();
        bb.calculateTime();
    }
}

相比上面的代码我们要统计job方法的运行时间时，只需要在calculateTime()中加入方法名（job）即可。但是好像还是很不简洁，因为如果还有C类我们还需要重新去写calculateTime方法。上述方法只减少了long start 和long end 方法在同类中的重复书写。我们可以对上述代码再进行优化

父类：

package com.abstract_;

abstract public class Template {//抽象类-模版设计模式
    public abstract void job();
    public void calculateTime(){
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();//动态绑定,先看子类再看父类
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("执行时间"+(end-start));
    }
}

子类A：

package com.abstract_;

public class AA extends Template{
    public void job(){//实现了父类的抽象方法
        long num = 0;
        //快捷键800000.fori
        for (int i = 0; i < 8000000; i++) {
            num+=i;
        }

    }
}

子类B:

package com.abstract_;

public class BB extends Template{
    public void job(){//实现了父类的抽象方法
        long num = 0;
        //快捷键8000.fori
        for (int i = 0; i < 800000; i++) {
            num*=i;
        }
    }
}

主函数：

package com.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();
        BB bb = new BB();
        bb.calculateTime();
    }
}

二、接口

2.1接口的基础概念

2.2接口的基础代码

接口：

package com.interface_;

public interface UsbInterface {//接口
    //规定接口的相关方法
    public void start();
    public void stop();
}

相机设备：

package com.interface_;

public class Camera implements UsbInterface{
    public void start(){
        System.out.println("相机开始工作");
    }
    public void stop(){
        System.out.println("相机停止工作");
    }
}

手机设备：

package com.interface_;

//Phone类实现UsbInterfacer
//1.即实现这个接口的方法
public class Phone implements UsbInterface{
    public void start(){
        System.out.println("手机开始工作");
    }
    public void stop(){
        System.out.println("手机停止工作");
    }
}

电脑：

package com.interface_;

public class Computer {
    //编写一个方法，让计算机工作
    //1.UsbInterface usbInterface 形参是接口类型UsbInterface
    //2.看到接口实现了UsbInterface接口类的对象的实例
    public void work(UsbInterface usbInterface){
        usbInterface.start();
        usbInterface.stop();
    }
}

主函数:

package com.interface_;

public class interface01 {
    public static void main(String[] args) {
        //创建手机，相机对象
        Camera camera = new Camera();
        Phone phone = new Phone();
        //创建计算机
        Computer computer = new Computer();
        computer.work(phone);//把手机接入计算机
        System.out.println("==============");
        computer.work(camera);

    }
}

这几个代码的逻辑：

先创建一个接口用来接收手机和相机中的方法（这个方法名必须同一，这也是接口的作用之一，用于规范），然后用电脑对接口这的方法进行选择接收。

2.3接口的相关细节

第一部分细节

package com.interface_;

public class InterFaceDetail01 {
    public static void main(String [] args){
        //new IA();
    }
}
//1.接口不能被实例化
//2.接口中所有的方法时public方法，接口中抽象方法，可以不用abstract修饰
//3.一个普通类实现接口，就必须将该接口的所有方法都实现
//4.抽象类去实践接口时，可以不实现接口的抽象方法

interface IA{
    void say();
    void hi();
}
class Cat implements IA{//alt+enter,把鼠标光标放在IA处
    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}
abstract class Tiger implements IA{

}

第二部分细节

package com.interface_;

public class InterfaceDetail02 {
    public static void main(String[] args) {
        System.out.println(IB.n1);//直接通过接口名访问，说明这就是static的
        //IB.n1;报错，说明n1是final
    }
}
interface IB{
    //接口中的属性，只能是final的，而且是public static final修饰符
    int n1 = 10;//等价public static final int n1 = 10;
    void hi();
}
interface IC{
    void say();
}
//接口不能继承其他的类，但是可以继承多个别的接口
interface ID extends IB,IC{
}
//接口的修饰符，只能是public(单独创建一个文件的时候)和默认，这点和类的修饰符是一样的
interface IE{
    
}
//一个类可以实现多个接口
class Pig implements IB,IC{
    public void hi() {}
    public void say() {}
}

2.4接口与继承类

package com.interface_;

public class ExtendsVsInterface {
    public static void main(String[] args){
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();

    }
}
//猴子
class Monkey{
    private String name;

    public Monkey(String name) {
        this.name = name;
    }

    public void climbing(){
        System.out.println(name + " 会爬树  ");
    }

    public String getName() {
        return name;
    }
}
class LittleMonkey extends  Monkey implements FishAble,BirdAble{
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName()+"通过学习可以像鱼儿一样游泳");
    }

    @Override
    public void flying() {
        System.out.println(getName()+"通过学习可以像鸟一样飞翔");
    }
}

interface FishAble{
    void swimming();
}
interface BirdAble{
    void flying();
}

小结：当子类继承了父类，就自动的拥有父亲的功能，如果子类需要扩展功能，可以通过实现接口的方式扩展，可以理解实现接口时对java单继承的一种补充。

解耦[即：接口的规范性+动态绑定机制]

2.5接口的多态性

（1）多态参数

在前面的Usb接口案例，UsbInterface usb,既可以接收手机对象，又可以接收相机对象，就体现了接口多态（接口引用可以指向实现了接口的类的对象）

package com.interface_;

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量if01 可以指向实现了IF接口对象的实例
        IF if01 = new Monster();
        if01 = new Car();
        //继承体现多态
        //父类类型的变量a可以指向继承AAA的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}
interface IF{}
class Monster implements IF{}
class Car implements IF{}
class AAA{}
class BBB extends AAA{

}
class CCC extends AAA{

}

（2）多态数组
演示一个案例:给Usb数组中,存放 Phone和相机对象,Phone类还有一个特有的方法call（），请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，还需要调用Phone特有方法call.

package com.interface_;

public class InterfacePolyArr {
    public static void main(String[] args){
        //多态数组->接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new MyCamera();
        usbs[1] = new MyPhone();
        for (int i = 0; i <usbs.length ; i++) {
            usbs[i].work();
            if(usbs[i] instanceof MyPhone){
                ((MyPhone)usbs[i]).call();//向下转型
            }
        }
    }
}
interface Usb{
    void work();
}
class MyPhone implements Usb{
    public void call(){//特有方法
        System.out.println("手机可以打电话");
    }


    @Override
    public void work() {
        System.out.println("手机工作中");
    }
}
class MyCamera implements Usb{

    @Override
    public void work() {
        System.out.println("相机工作中");
    }
}

（3）接口存在多态传递现象

package com.interface_;

/**
 * 演示多态传递现象
 */
public class InterFacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG继承了IH接口，而Teacher类实现了IG接口
        //那么，实际上就相当于Teacher类也实现了IH接口
        IH ih = new Teacher();
    }
}
interface IH{}
interface IG extends IH{}
class Teacher implements IG{

}

2.6巩固

看一段错误代码

因为接口和父类都有x，因此无法直接反问，但可以明确的指定。

package com.interface_;

public class InterfaceExercise02 {
    public static void main(String[] args) {
        new YY().pX();
    }
}
interface XX{
    int x = 0;
}
class ZZ{
    int x = 1;
}//普通属性
class YY extends ZZ implements XX{
    public void pX(){
        //System.out.println(x);//错误，原因不明确x
        System.out.println("接口的x = "+XX.x);
        System.out.println("父类的x = "+super.x);

    }
}

2.7对于接口的个人理解

接口其实就是给下属的类提供了一个规范（方法名），在接口中的各种方法需要类进行重写实现，这样有利于上层进行管理，上层只需要传入相应的接口对象即可调用各个接口连接的类方法。

目前已经学了类的四大成员了下面讲最后一个成员内部类

三、内部类（重难点）

3.1内部类的基本概念

类的五大成员展示：

package com.innerclass;

public class InnerClass01 {//外部其它类
    public static void main(String[] args) {
    }
}
class Outer{//外部类
    private int n1 = 100;//属性
    public void m1(){//方法
        System.out.println("m1()");
    }
    {
        System.out.println("代码块");
    }
    public Outer(int n1) {//构造器
        this.n1 = n1;
    }
    class Inner{//内部类，在Outer类的内部
    }
}

内部类的分类：

定义在外部类局部位置上（比如方法内）：

（1）局部内部类（有类名）

（2）匿名内部类（没有类名，重点!!!!!!!!!!!!!!!）

定义在外部类的成员位置上：

（1）成员内部类（没用static修饰）

（2）静态内部类（使用static修饰）

3.1.1局部内部类的代码及细节

第一部分细节

在外部其他类如何调用局部内部类的方法：直接调用局部内部类所属的方法即可，在局部内部类所属的方法中，创建相应的类对象，这样在调用局部内部类所属的方法时就会调用局部内部类中的方法了（有点绕，多看代码）

总结：（1）局部内部类在方法中/代码块

（2）作用域在方法体或者代码块中

（3）本质仍然是一个类，之前学的类的知识都与之相关

第二部分细节

对于细节的理解看下面的代码

package com.innerclass;

/**
 * 演示局部内部类
 */
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}
class Outer02{
    private int n1 = 100;
    private void m2(){
        System.out.println("Outer02 m2()");
    }//私有方法
    public void m1(){//方法
        //1.局部内部类是定义在外部类的局部位置，通常在方法
        //3.不能添加访问修饰符，但是可以使用final修饰，这样就不能被继承了
        //4.作用域：仅仅在定义它的方法或代码块中
        final class Inner02{//局部内部类(本质仍然是一个类)
            //2.可以直接访问外部类的所有成员，包含私有的
            private int n1= 800;//与外部类的属性重名
            public void fi(){
                //5.局部内部类可以直接访问外部类的成员
                //7.如果外部类和局部内部类的成员重名时，默认遵守就近原则。
                // 如果想访问外部类的成员，使用(外部类名.this.成员)去访问(外部类与内部类成员重名的情况)
                System.out.println("内部类的n1=" + n1+"外部类的n1 = "+ Outer02.this.n1);
                //解读一下上述代码：Outer02.this本质就是外部类的对象，即哪个对象调用了m1，Outer02.this就指向哪个对象
                //如果只写(this.n1)就是指向的Inner02
                
                m2();//依然能够访问
            }
        }
        //6.外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.fi();
    }
}

3.1.2匿名内部类的代码及细节（非常重要！！！）

现在给定一个需求：想使用IA接口，并创建对象，使用传统方式是写一个类，实现该接口并创建对象代码如下：

package com.innerclass;

/**
 * 演示匿名内部类
 */
public class AnonymousInnerClass{
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04{
    private int n1 = 10;
    public void method(){
        //基于接口的匿名内部类
        //1.需求：想使用IA接口并创建对象
        //2.传统方式是写一个类，实现该接口并创建对象
        IA tiger = new Tiger();
        tiger.cry();
    }
}
interface IA{
    public void cry();
}
class Tiger implements IA{

    @Override
    public void cry() {
        System.out.println("老虎嗷嗷叫");
    }
}
class Father{
    public Father(String name){
        super();
    }
    public void test(){

    }
}

现在增加需求：Tiger类只使用一次，后面再不使用，那么上面的tiger类定义的就有点浪费了。如果对象增多就要定义非常多的类而这些类却只用一次，显然是非常不方便的，于是可以使用匿名内部类。

基于接口的匿名内部类：

package com.innerclass;

/**
 * 演示匿名内部类
 */
public class AnonymousInnerClass{
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04{
    private int n1 = 10;
    public void method(){
        //基于接口的匿名内部类
        //1.需求：想使用IA接口并创建对象
        //2.传统方式是写一个类，实现该接口并创建对象
        //3.使用匿名内部类简化开发
        //4.tiger的编译类型是 IA
        //5.tiger的运行类型是 就是匿名内部类xxxx==>Outer04$1
        /*
            我们看底层
            class xxx implements IA{
                System.out.println("老虎叫唤")
            }
         */
        //6.jdk底层在创建匿名内部类Outer04$1,立即马上就创建了Outer04$1实例，并且把地址返回给tiger
        //8.匿名内部类使用一次，就不能再使用
        //9.虽然匿名内部类只能使用一次，但是已经创建好的对象是可以多次使用的
        IA tiger = new IA(){
            public void cry(){
                System.out.println("老虎叫唤");
            }
        };
        tiger.cry();
        tiger.cry();
        tiger.cry();//可以重复使用
        //IA tiger = new Tiger();
        //tiger.cry();
    }
}
interface IA{
    public void cry();
}
//class Tiger implements IA{
//
//    @Override
//    public void cry() {
//        System.out.println("老虎嗷嗷叫");
//    }
//}

基于类的匿名内部类

package com.innerclass;

/**
 * 演示匿名内部类
 */
public class AnonymousInnerClass{
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04 {
    private int n1 = 10;

    public void method() {

        //演示基于类的匿名内部类
        //1.father编译类型Father
        //2.father运行类型 Outer04$2,注意区别之前初始化对象时运行类型的区别
        /*
            class Outer04$2 extends Father{
                public void test(){
                    System.out.println("匿名内部类重写了test方法")
                 }
             }
         */
        //3.同时也直接返回了匿名内部类Outer04$2的对象
        //4.注意(“jack”)参数列表会传递给Father类的构造器
        //5.底层 class 匿名内部类 extends Person{}
        Father father = new Father("jack") {
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        father.test();
    }
}

class Father {
        public Father(String name) {
        }

        public void test() {
        }
    }

对于匿名内部类的个人理解：无论是基于接口的匿名内部类还是基于类的匿名内部类，它的作用都是方法的重写（接口，类）或调用（类）。对于方法的重写，无论是接口还是类都需要使用其他类方法才能完成（用之前的知识接口implement 类extends），这是需重新创建类的，对于没有频繁用到的类显然这是浪费的，因此使用匿名内部类简化此过程，节约资源。对于匿名内部类最重要的是理解其编译类型和运行类型，了解它的运行逻辑（结合代码）。在分析代码的时候，时刻带入底层代码对匿名内部类进行分析，时刻牢记匿名内部类整体是一个对象，再结合前面多态的知识进行理解。

匿名内部类的最佳实践：

1.可以作为实参直接传入

package com.innerclass;

public class InnerClassExercise01 {
    public static void main(String[] args) {
        //当做实参直接传递，简介高效
        f1(new IL(){//根据底层代码可以分析出，相当于吧实现了接口的匿名对象传给了f1方法
          public void show() {
                System.out.println("这是一副名画");
            }
        });//注意这个括号
    }
    //静态方法,形参接口
    public static void f1(IL il){
        il.show();
    }
}
//接口
interface IL{
    void show();
}

分析底层代码可知匿名内部类实现了接口,所以这个匿名内部类对象可以直接作为实参传入到f1()中去。

再用匿名内部类实现一个小案例

package com.innerclass;

public class InnerClassExercise02 {
    public static void main(String[] args) {
        IPhone iPhone = new IPhone();
        iPhone.UseBell(new Bell() {//重写方法，并作为实参传入
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        iPhone.UseBell(new Bell() {//与上同理
            @Override
            public void ring() {
                System.out.println("同学们上课了");
            }
        });


    }
}

class IPhone {//通俗的讲，创建一个手机，把闹钟这个功能传入手机之中
    public void UseBell(Bell bell) {
        bell.ring();
    }

}

interface Bell {
    void ring();
}

3.1.3成员内部类

package com.innerclass;

public class MenberInnerClass {
    public static void main(String [] args){
        Outer08 outer08 = new Outer08();
        outer08.t1();
        //6.外部其它类，使用成员内部类的两种方式
        //第一种方式
        Outer08.Inner08 inner08 = outer08.new Inner08();//用外部类的对象new了一个内部类
        //因为这是在外部其他内调用外部类的成员内部类，所以要用"."在创建。
        //第二种方式
        //在外部内种编写一个方法，返回Inner08
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}
class Outer08{
    private int n1 = 10;
    public String name = "张三";
    private void hi(){
        System.out.println("hi()方法" + "");
    }
    //1.注意：成员内部类，是定义在外部类的成员位置上
    //2.可以添加任意访问修饰符

    public class Inner08{//成员内部类
        public double sal = 99.9;
        private int n1 = 66;
        public void say(){
            //4.可以直接访问外部类的所有成员，包含私有的
            //7.如果成员内部类的成员和外部类重名了，会遵守就近原则
            //可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("成员内部类的n1 = "+n1+"outer01 的 name"+name+"外部类的n1="+Outer08.this.n1);
            hi();
        }
    }
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
    public void t1(){
        //使用成员内部类
        //5.创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

3.1.3静态内部类

package com.innerclass;

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
        //外部其它类使用静态内部类
        //方式1(非私有)
        //因为静态内部类是通过类名直接访问的(前提是要有访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式2
        //编写一个方法，可以返回静态内部类对象的实例
        System.out.println("=====静态方法====");
        Outer10.Inner10 inner101 = outer10.getInner10();
        inner101.say();
        System.out.println("=====非静态方法====");
        Outer10.Inner10 inner102 = Outer10.getInner10_();
        inner102.say();
        //注意对比Outer10的大小写变化，结合前面的知识，静态方法在类加载时就会执行
        //使用静态方法调用可以少创建对象

    }
}
class Outer10{//外部类
    private int n1 = 10;
    private static String name = "张三";
    //Inner10就是静态内部类
    //1.放在外部类的成员位置
    //2.使用static修饰
    //3.可以访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4.可以添加任意访问修饰符(public protected 默认 private)因为它的地位就是一个成员
    //5.作用于：同其它成员，为整个类体
     static class Inner10{
        public void say(){
            //如果外部类和静态内部类的成员重名时，静态内部类访问的是默认就近就近原则。
            // 如果过想访问外部类的成员，则可以使用(外部类.成员) 这个参考之前几个内部类的代码
            System.out.println(name);
        }
    }
    public void m1()
    {
        //外部类访问静态内部类的方式就是访问对象
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
    public Inner10 getInner10(){
        return new Inner10();
    }
    public static Inner10 getInner10_(){//此处也可以是静态方法，因为静态内部类时静态成员
         return new Inner10();
    }
}

小结：

（1）内部类有四种局部内部类匿名内部类成员内部类静态内部类

（2）重点还是掌握匿名内部类的使用new 类/接口（参数列表）{};

（3）成员内部类，静态内部类是放在外部类的成员位置，本质就是一个成员