Java笔记018-抽象类、抽象类最佳实践-模板设计模式、接口、内部类

甲柒

已于 2022-12-31 18:01:05 修改

阅读量354

点赞数 1

分类专栏： Java笔记文章标签： java 开发语言设计模式 intellij-idea

于 2022-12-31 01:02:28 首次发布

本文链接：https://blog.csdn.net/qq_59621600/article/details/128499945

版权

Java笔记专栏收录该内容

42 篇文章 3 订阅

订阅专栏

本文深入探讨了Java编程中的抽象类、接口和内部类。介绍了抽象类作为模板设计模式的运用，以及其在继承和多态中的角色。详细讲解了接口的概念，强调其用于规范和多态的重要性，并展示了接口的实现和多态特性。此外，还涵盖了内部类的分类，如局部内部类、匿名内部类和成员内部类，以及它们在代码设计中的应用。通过实例展示了如何利用这些概念解决实际问题，提高代码的灵活性和可维护性。

摘要由CSDN通过智能技术生成

抽象类

先看一个问题

package com10.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();
}

父类方法的不确定性

小结：

当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类

抽象类快速入门

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。

抽象类的介绍

1、用abstract关键字来修饰一个类时，这个类就叫抽象类访问修饰符abstract类名{}

2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法
访问修饰符 abstract 返回类型方法名 (参数列表);//没有方法体

3、抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()

4、抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多

抽象类使用的注意事项和细节讨论

1、抽象类不能被实例化

2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法

3、一旦类包含了abstract方法，则这个类必须声明为abstract

4、abstract只能修饰类和方法，不能修饰属性和其他

package com10.abstract_;

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类，不能被实例化
//        new A();
    }
}

//抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法
//，还可以有实现方法
abstract class A {
    public void hi() {
        System.out.println("hi");
    }
}

//一旦类包含了abstract方法，则这个类必须声明为abstract
abstract class B {
    public abstract void hi();
}

//abstract只能修饰类和方法，不能修饰属性和其他
class C {
//    public abstract int n1 = 1;//错误
}

5、抽象类可以有任意成员【抽象奖还是类】，比如：非抽象方法、构造器、静态属性等等[举例]

6、抽象方法不能有主体，即不能实现。如图所示

7、如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例 A类,B类,C类]

8、抽象方法不能使用private、final和 static来修饰，因为这些关键字都是和重写相违背的。

package com10.abstract_;

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

//抽象方法不能使用private、final和 static来修饰，因为这些关键字都是和重写相违背的。
abstract class H {
//    public static abstract void hi();//抽象方法//错误
//
//    public final abstract void hi();//抽象方法//错误
//
//    public private abstract void hi();//抽象方法//错误
}

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
abstract class E {
    public abstract void hi();
}

abstract class F extends E {

}

abstract class G extends E {
    @Override
    public void hi() {//这里相当于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体

    }
}

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    public static String name = "甲柒";
    public int n1 = 10;

    public static void ok() {
        System.out.println("ok");
    }

    public void hi() {
        System.out.println("hi");
    }

    public abstract void hello();
}

抽象类练习题

1、题1，思考：abstract final class A{} 能编译通过吗，why?
错误，final是不能继承

2、题2，思考：abstract public static void test2(); 能编译通过吗，why?
错误，static关键字和方法重写无关

3、题3，思考：abstract private void test3(); 能编译通过吗，why?
错误，private的方法不能重写

4、编写一个Employee类，声明为抽象类，
包含如下三个属性：name，id，salary。
提供必要的构造器和抽象方法：work()。
对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。
请使用继承的思想，设计CommonEmployee类和Manager类，
要求类中提供必要的方法进行属性访问，实现work()，
提示"经理/普通员工名字工作中...."

package com10.abstract_;

public class AbstractExercise01 {
    public static void main(String[] args) {
        //测试
        Manager manager = new Manager("甲柒", 666, 6000, 8000);
        manager.work();
        new CommonEmployee("tom", 333, 4500).work();

    }
}

abstract class Employee {
    private String name;
    private int id;
    private double salary;

    public Employee(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public abstract void work();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

class Manager extends Employee {
    private double bonus;

    public Manager(String name, int id, double salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("经理 " + getName() + " 工作中...");
    }
}

class CommonEmployee extends Employee {
    public CommonEmployee(String name, int id, double salary) {
        super(name, id, salary);
    }

    @Override
    public void work() {
        System.out.println("普通员工 " + getName() + " 工作中...");
    }
}

抽象类最佳实践-模板设计模式

基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。

模板设计模式能解决的问题

1、当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

2、编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式.

最佳实践

需求

1、有多个类，完成不同的任务job

2、要求统计得到各自完成任务的时间

3、请编程实现

解决问题

1、先用最容易想到的方法

2、分析问题，提出使用模板设计模式

package com10.abstract_;

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

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;
        for (int i = 0; i < 900000; i++) {
            num += i;
        }

    }
}

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

最佳实践

设计一个抽象类(Template)，能完成如下功能:

1、编写方法calculateTime()，可以计算某段代码的耗时时间

2、编写抽象方法job()

3、编写一个子类Sub，继承抽象类Template，并实现job方法。

4、编写一个测试类TestTemplate，看看是否好用。

package com10.abstract_;

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

        BB bb = new BB();
        bb.calculateTime();
    }
}

abstract class Template {//抽象类-模板设计模式

    public abstract void job();

    public void calculateTime() {//实现方法，调用job方法
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
}

class AA extends Template {
    public void job() {

        long num = 0;
        for (int i = 0; i < 900000; i++) {
            num += i;
        }

    }
}

class BB extends Template {

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

接口

为什么有接口

usb插槽就是现实中的接口。
你可以把手机，相机，u盘都插在usb插槽上，而不用担心那个插槽是专门插哪个的，原因是做usb插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸，排线等等。

接口快速入门

这样的设计需求在java编程/php/.net/go中也是会大量存在的，一个程序就是一个世界，在现实世界存在的情况，在程序中也会出现。我们用程序来模拟一下。

package com10.interface_;

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

package com10.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);//把相机接入到计算机
    }
}

class Phone implements UsbInterface {
    @Override
    public void start() {
        System.out.println("手机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作...");
    }
}

class Camera implements UsbInterface {//实现接口，就是把接口方法实现

    @Override
    public void start() {
        System.out.println("相机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作...");
    }
}

class Computer {
    public void work(UsbInterface usbInterface) {
        //通过接口，调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，根据具体情况把这些方法写出来

语法：

interface 接口名 {
//属性
//方法(1.抽象方法 2.默认实现方法 3.静态方法)
}
class 类名 implements 接口 {
自己属性;
自己方法;
必须实现接口的抽象方法
}

小结

1、在Jdk7.0前接口里的所有方法都没有方法体，即都是抽象方法

2、Jdk8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

package com10.interface_;

public interface AInterface {
    //写属性
    public int n1 = 10;

    //在jdk8后，可以有静态方法
    public static void cry() {
        System.out.println("cry...");
    }

    //写方法
    //在接口中，抽象方法，可以省略abstract关键字
    public void hi();

    //在jdk8后，可以有默认实现方法，需要使用default关键字修饰
    default public void ok() {
        System.out.println("ok...");
    }
}

package com10.interface_;

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

//解读
//1.如果一个类 implements 实现 接口
//2.需要将该接口的所以抽象方法都实现
class A implements AInterface {
    @Override
    public void hi() {
        System.out.println("hi...");
    }
}

深入讨论

对初学者讲，理解接口的概念不算太难难的是不知道什么时候使用接口，下面例举几个应用场景：

1、说现在要制造战斗机，武装直升机。专家只需把飞机需要的功能/规格定下来即可，然后让别的人具体实现就可。

2、说现在有一个项目经理，管理三个程序员，功能开发一个软件，为了控制和管理软件项目经理可以定义一些接口，然后由程序员具体实现。

package com10.interface_;

public interface DBInterface { //项目经理

    public void connect();//连接方法

    public void close();//关闭连接
}

package com10.interface_;

//A程序
public class MysqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql");
    }
}

package com10.interface_;

//B程序员连接Oracle
public class OracleDB implements DBInterface {

    @Override
    public void connect() {
        System.out.println("连接oracle");
    }

    @Override
    public void close() {
        System.out.println("关闭oracle");
    }
}

package com10.interface_;

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

        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }

    public static void t(DBInterface db) {
        db.connect();
        db.close();
    }
}

注意事项和细节

1、接口不能被实例化

2、接口中所有的方法是public方法，接口中抽象方法，可以不用abstract 修饰

3、一个普通类实现接口，就必须将该接口的所有方法都实现。

4、抽象类实现接口，可以不用实现接口的方法。

package com10.interface_;

//1.接口不能被实例化
//2.接口中所有的方法是 public方法，接口中抽象方法，可以不用abstract 修饰
//3.一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用alt+enter来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//修饰符 public protected 默认 private

    void hi();
}

public class InterfaceDetail01 {
    public static void main(String[] args) {
//        new IA();//错误
    }
}

class Cat implements IA {
    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}

abstract class Tiger implements IA {

}

5、一个类同时可以实现多个接口[举例]

6、接口中的属性，只能是final的，而且是 public static final修饰符。比如:
int a=1;实际上是 public static final int a=1;(必须初始化)

7、接口中属性的访问形式：接口名.属性名

8、接口不能继承其它的类，但是可以继承多个别的接口[举例]

interface A extends B,C {}

9、接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

package com10.interface_;

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 {
}

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //证明 接口中的属性，是 public static final
        System.out.println(IB.n1);//说明n1 就是static
        //IB.n1 = 30; 说明n1 是 final
    }
}

//一个类同时可以实现多个接口
class Pig implements IB, IC {
    @Override
    public void hi() {
    }

    @Override
    public void say() {
    }
}

接口练习题

package com10.interface_;

interface AA {
    int a = 23; //等价 public static final int a = 23;
}

public class InterfaceExercise01 {
    public static void main(String[] args) {
        BB b = new BB();//ok
        System.out.println(b.a);  //23
        System.out.println(AA.a);  //23
        System.out.println(BB.a);  //23
    }
}

class BB implements AA {//正确
}

实现接口vs继承类

形象理解
实现接口和继承类他们究竟有什么区别呢?【演示代码.….】

package com10.interface_;

//接口
interface Fishable {
    void swimming();
}

interface Birdable {
    void flying();
}

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;
    }
}

//继承
//小结:  当子类继承了父类，就自动地拥有父类的功能
//      如果子类需要扩展功能，可以通过实现接口的方式扩展.
//      可以理解 实现接口 是 对java 单继承机制的一种补充.
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() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

实现接口vs继承类

接口和继承解决的问题不同

继承的价值主要在于：解决代码的复用性和可维护性。

接口的价值主要在于：设计，设计好各种规范(方法)，让其它类去实现这些方法。

接口比继承更加灵活

接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足 like - a的关系。

接口在一定程度上实现代码解耦[即：接口规范性+动态绑定机制]

接口的多态特性

1、多态参数(前面案例体现)
在前面的Usb接口案例，UsbInterface usb，既可以接收手机对象，又可以接收相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)

2、多态数组
演示一个案例：给Usb数组中，存放 Phone 和相机对象，Phone类还有一个特有的方法call()，请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，还雪要调F用Phone特有方法call

3、接口存在多态传递现象

package com10.interface_;

interface IF {
}

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

class Monster implements IF {
}

class Car implements IF {
}

class AAA {

}

class BBB extends AAA {
}

class CCC extends AAA {
}

package com10.interface_;

interface Usb {
    void work();
}

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

        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给Usb数组中，存放 Phone  和  相机对象，Phone类还有一个特有的方法call（），
        请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，
        还需要调用Phone 特有方法 call
         */
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定..
            //和前面一样，我们仍然需要进行类型的向下转型
            if (usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }

    }
}

class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话...");
    }

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

class Camera_ implements Usb {

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

package com10.interface_;

interface IH {
    void hi();
}

interface IG extends IH {
}

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

class Teacher implements IG {
    @Override
    public void hi() {
    }
}

接口练习题

package com10.interface_;

interface A {
    int x = 0;
}  //想到 等价 public static final int x = 0;

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

    }
}

class B {
    int x = 1;
} //普通属性

class C extends B implements A {
    public static void main(String[] args) {
        new C().pX();
    }

    public void pX() {
        //System.out.println(x); //错误，原因不明确x
        //可以明确的指定x
        //访问接口的 x 就使用 A.x
        //访问父类的 x 就使用 super.x
        System.out.println(A.x + " " + super.x);
    }
}

内部类

基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class)，嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员【思考：类的五大成员是哪些?[属性、方法、构造器、代码块、内部类]】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

基本语法

class Outer{ //外部类
    class Inner{ //内部类

    }
}
class Other{//外部其他类
}

快速入门案例

package com10.innerclass;

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

    }
}

class Outer {
    private int n1 = 100;//属性

    {
        System.out.println("代码块...");
    }

    public Outer(int n1) {//构造器
        this.n1 = n1;
    }

    public void m1() {//方法
        System.out.println("m1()");
    }

    class Inner {//内部类，在Outer类的内部

    }
}

内部类的分类

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

1、局部内部类(有类名)

2、匿名内部类(没有类名，重点)

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

1、成员内部类(没用static修饰)

2、静态内部类(使用static修饰)

局部内部类的使用

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

1、可以直接访问外部类的所有成员，包含私有的

2、不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final

3、作用域：仅仅在定义它的方法或代码块中。

4、局部内部类---访问---->外部类的成员[访问方式：直接访问]

5、外部类---访问---->局部内部类的成员
访问方式：创建对象，再访问(注意：必须在作用域内)

小结：
(1)局部内部类定义在方法中/代码块
(2)作用域在方法体或者代码块中
(3)本质仍然是一个类

6、外部其他类---不能访问----->局部内部类（因为局部内部类地位是一个局部变量)

7、如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问【演示】

package com10.innerclass;

/**
 * 演示局部内部类的使用
 */
public class LocalInnerClass {//

    public static void main(String[] args) {
        //演示一遍
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02的hashcode=" + outer02);
    }
}

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 f1() {
                //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
                //7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
                //   使用 外部类名.this.成员）去访问
                //   解读 Outer02.this 本质就是外部类的对象, 即哪个对象调用了m1, Outer02.this就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
        //6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }

}

匿名内部类的使用

本质是类
内部类
该类没有名字
同时还是一个对象

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

1、匿名内部类的基本语法

new 类或接口(参数列表){
    类体
};

package com10.innerclass;

interface IA {//接口

    public void cry();
}

/**
 * 演示匿名内部类的使用
 */
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.需求是 Tiger/Dog 类只是使用一次，后面再不使用
        //4. 可以使用匿名内部类来简化开发
        //5. tiger的编译类型 ? IA
        //6. tiger的运行类型 ? 就是匿名内部类  Outer04$1
        /*
            我们看底层 会分配 类名 Outer04$1
            class Outer04$1 implements IA {
                @Override
                public void cry() {
                    System.out.println("老虎叫唤...");
                }
            }
         */
        //7. jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1实例，并且把地址
        //   返回给 tiger
        //8. 匿名内部类使用一次，就不能再使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();

//        IA tiger = new Tiger();
//        tiger.cry();

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

            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());//Outer04$2
        father.test();

        //基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            void eat() {
                System.out.println("小狗吃骨头...");
            }
        };
        animal.eat();
    }
}
//class Tiger implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("老虎叫唤...");
//    }
//}
//class Dog implements  IA{
//    @Override
//    public void cry() {
//        System.out.println("小狗汪汪...");
//    }
//}

class Father {//类

    public Father(String name) {//构造器
        System.out.println("接收到name=" + name);
    }

    public void test() {//方法
    }
}

abstract class Animal { //抽象类
    abstract void eat();
}

2、匿名内部类的语法比较奇特，请注意，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。

3、可以直接访问外部类的所有成员，包含私有的[案例演示]

4、不能添加访问修饰符，因为它的地位就是一个局部变量。[过]

5、作用域：仅仅在定义它的方法或代码块中。[过]

6、匿名内部类--访问---->外部类成员[访问方式：直接访问]

7、外部其他类---不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量)

8、如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

package com10.innerclass;

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

        Outer05 outer05 = new Outer05();
        outer05.f1();
        //外部其他类---不能访问----->匿名内部类
        System.out.println("main outer05 hashcode=" + outer05);
    }
}

class Outer05 {
    private int n1 = 99;

    public void f1() {
        //创建一个基于类的匿名内部类
        //不能添加访问修饰符,因为它的地位就是一个局部变量
        //作用域 : 仅仅在定义它的方法或代码块中
        Person p = new Person() {
            private int n1 = 88;

            @Override
            public void hi() {
                //可以直接访问外部类的所有成员，包含私有的
                //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
                //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
                System.out.println("匿名内部类重写了 hi方法 n1=" + n1 +
                        " 外部内的n1=" + Outer05.this.n1);
                //Outer05.this 就是调用 f1的 对象
                System.out.println("Outer05.this hashcode=" + Outer05.this);
            }
        };
        p.hi();//动态绑定, 运行类型是 Outer05$1

        //也可以直接调用, 匿名内部类本身也是返回对象
        // class 匿名内部类 extends Person {}
//        new Person(){
//            @Override
//            public void hi() {
//                System.out.println("匿名内部类重写了 hi方法,哈哈...");
//            }
//            @Override
//            public void ok(String str) {
//                super.ok(str);
//            }
//        }.ok("jack");


    }
}

class Person {//类

    public void hi() {
        System.out.println("Person hi()");
    }

    public void ok(String str) {
        System.out.println("Person ok() " + str);
    }
}
//抽象类/接口...

匿名内部类的最佳实践

1、当作实参直接传递，简洁高效

package com10.innerclass;

//接口
interface IL {
    void show();
}

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

        //当做实参直接传递，简洁高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一副名画~~...");
            }
        });
        //传统方法
        f1(new Picture());

    }

    //静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}

//类->实现IL => 编程领域 (硬编码)
class Picture implements IL {

    @Override
    public void show() {
        System.out.println("这是一副名画XX...");
    }
}

2、

有一个铃声接口Bell，里面有个ring方法
有一个手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型
测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了
再传入另一个匿名内部类(对象)，打印：小伙伴上课了

package com10.innerclass;

interface Bell { //接口
    void ring();//方法
}

public class InnerClassExercise02 {
    public static void main(String[] args) {
        /*
        1.有一个铃声接口Bell，里面有个ring方法。(右图)
        2.有一个手机类Cellphone，具有闹钟功能alarmClock，参数是Bell类型(右图)
        3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了
        4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了
         */
        CellPhone cellPhone = new CellPhone();
        //解读
        //1. 传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1
        //2. 重写了 ring
        //3. Bell bell = new Bell() {
        //            @Override
        //            public void ring() {
        //                System.out.println("懒猪起床了");
        //            }
        //        }
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });

        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });
    }
}

class CellPhone {//类

    public void alarmClock(Bell bell) {//形参是Bell接口类型
        System.out.println(bell.getClass());
        bell.ring();//动态绑定
    }
}

匿名内部类(1)继承(2)多态(3)动态绑定(4)内部类

成员内部类的使用

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰

1、可以直接访问外部类的所有成员，包含私有

2、可以添加任意访问修饰符(public、protected、默认、private)，因为它的地位就是一个成员

3、作用域和外部类的其他成员一样，为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法

4、成员内部类---访问---->外部类(比如：属性)[访问方式:直接访问](说明)

5、外部类---访问------>内部类(说明)访问方式：创建对象，再访问

6、外部其他类---访问---->成员内部类

package com10.innerclass;

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其他类，使用成员内部类的三种方式
        //解读
        // 第一种方式
        // outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员
        // 这就是一个语法，不要特别地纠结.
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        // 第二方式 在外部类中，编写一个方法，可以返回 Inner08对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();

    }
}

class Outer08 { //外部类
    public String name = "张三";
    private int n1 = 10;

    private void hi() {
        System.out.println("hi()方法...");
    }

    //方法，返回一个Inner08实例
    public Inner08 getInner08Instance() {
        return new Inner08();
    }

    //写方法
    public void t1() {
        //使用成员内部类
        //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }

    //1.注意: 成员内部类，是定义在外部内的成员位置上
    //2.可以添加任意访问修饰符(public、protected 、默认、private)，因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;

        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
            //，可以通过  外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);
            hi();
        }
    }
}

静态内部类的使用

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

1、可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

2、可以添加任意访问修饰符(public、protected、默认、private)，因为它的地位就是一个成员

3、作用域：同其他的成员，为整个类体

4、静态内部类---访问---->外部类(比如：静态属性)[访问方式：直接访问所有静态成员]

5、外部类---访问---->静态内部类访问方式：创建对象，再访问

6、外部其他类---访问---->静态内部类

7、如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用 (外部类名.成员)

package com10.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
        //编写一个方法，可以返回静态内部类的对象实例.
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();

        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("************");
        inner10_.say();
    }
}

class Outer10 { //外部类
    private static String name = "哆啦A梦";
    private int n1 = 10;

    private static void cry() {
    }

    public static Inner10 getInner10_() {
        return new Inner10();
    }

    public void m1() { //外部类---访问------>静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public Inner10 getInner10() {
        return new Inner10();
    }

    //Inner10就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用static 修饰
    //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner10 {
        private static String name = "甲柒";

        public void say() {
            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类name= " + Outer10.name);
            cry();
        }
    }
}

内部类小结

(1)内部类有四种：局部内部类，匿名内部类，成员内部类，静态内部类
(2)重点还是掌握匿名内部类使用new类/接口(参数列表){
//.…
};
(3)成员内部类,静态内部类是放在外部类的成员位置，本质就是一个成员
(4)其他细节看笔记...

内部类练习题

package com10.innerclass;

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

    }
}

class Test {//外部类

    public Test() {//构造器
        Inner s1 = new Inner();
        s1.a = 10;
        Inner s2 = new Inner();
        System.out.println(s2.a);
    }

    public static void main(String[] args) {
        Test t = new Test();
        Inner r = t.new Inner();//5
        System.out.println(r.a);//5
    }

    class Inner { //内部类，成员内部类
        public int a = 5;
    }
}