第10 章 - 面向对象编程-高级部分-下

10.6 抽象类
10.7 抽象类最佳实践-模板设计模式
- 10.7.1 基本介绍、模板设计模式能解决的问题
- 10.7.2 最佳实践
10.8 接口
10.9 内部类

10.6 抽象类

10.6.1 先看一个问题、问题解决之道

Abstract01.java

问题
解决之道-抽象类快速入门

当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法，这个方法就是抽象方法,用abstract 来修饰该类就是抽象类。
我们看看如何把Animal做成抽象类,并让子类Cat类实现。
abstract class Animal{
String name;
int age;
abstract public void cry();

代码：

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

10.6.2 抽象类的介绍

用abstract关键字来修饰一个类时,这个类就叫抽象类，访问修饰符 abstract类名{ }
用abstract关键字来修饰一个方法时,这个方法就是抽象方法
访问修饰符 abstract 返回类型方法名 (参数列表) ; //没有方法体，即不加 { }
抽象类的价值更多作用是在于设计,是设计者设计好后，让子类继承并实现抽象类()
抽象类，是考官比较爱问的知识点,在框架和设计模式使用较多

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

AbstractDetail01.java

抽象类不能被实例化 , [举例]
抽象类不一定要包含abstract方法。也就是说,抽象类里边可以没有abstract方法 , [举例]
一旦类包含了abstract方法,则这个类必须声明为abstract [说明]
abstract只能修饰类和方法，不能修饰属性和其它的。[说明]
抽象类可以有任意成员【抽象类本质还是类】，比如:抽象类可以有非抽象方法、构造器、静态属性等等
抽象方法不能有主体，即不能实现.如图所示
abstract void aaa ( ) { } ;//是错误的，不能有 { } 方法。
如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的。

细节1-4对应代码：

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 - 8 对应代码：

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

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

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

abstract class F extends E {

}

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

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

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

    public abstract void hello();

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

10.6.4 课堂练习题

在这里插入图片描述

第4题代码：

抽象类Employee：

abstract public 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;
    }
    //将work做成一个抽象方法
    public abstract void work();

	//get set方法
    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;}
}

子类Manager：

public class Manager extends Employee {

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

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

    @Override // 如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
    public void work() {
        System.out.println("经理 " + getName() + " 工作中..."); //重写
    }
}

子类CommonEmployee类：

public class CommonEmployee extends Employee{
    public CommonEmployee(String name, int id, double salary) {
        super(name, id, salary);
    }
    @Override
    public void work() {
        System.out.println("普通员工 " + getName() + " 工作中...");
    }
}

主类：

public class AbstractExercise01 {
    public static void main(String[] args) {
        //测试
        Manager jack = new Manager("jack", 999, 50000);
        jack.setBonus(8000);
        jack.work();

        CommonEmployee tom = new CommonEmployee("tom", 888, 20000);
        tom.work();
    }
}

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

10.7.1 基本介绍、模板设计模式能解决的问题

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

当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去,让子类去实现。
编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式.

10.7.2 最佳实践

需求：

有多个类,完成不同的任务job
要求统计得到各自完成任务的时间
请编程实现 TestTemplate.java

感情的自然流露

先用最容易想到的方法-》代码实现
分析问题,提出使用模板设计模式

在这里插入图片描述

代码：

public class LianXi {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态

        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 {
    //计算任务
    //1+....+ 800000
    @Override
    public void job() { //实现Template的抽象方法job
        long num = 0;
        for (long i = 1; i <= 800000; i++) {
            num += i;
        }
    }
}

class BB extends Template{
    public void job() {//这里也去，重写了Template的job方法
        long num = 0;
        for (long i = 1; i <= 80000; i++) {
            num *= i;
        }
    }
}

10.8 接口

10.8.1 为什么有接口、接口快速入门

为什么有接口
接口快速入门

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

代码：

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

        //创建手机，相机对象
        //Camera 实现了 UsbInterface
        Camera camera = new Camera();
        //Phone 实现了 UsbInterface
        Phone phone = new Phone();
        //创建计算机
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到计算机
        System.out.println("===============");
        computer.work(camera);//把相机接入到计算机
    }
}
interface UsbInterface { //接口
    //规定接口的相关方法,老师规定的.即规范...
    public void start();
    public void stop();
}

//Phone 类 实现 UsbInterface
//解读1. 即 Phone类需要实现 UsbInterface接口 规定/声明的方法
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 {
    //编写一个方法, 计算机工作
    //解读:
    //1. UsbInterface usbInterface 形参是接口类型 UsbInterface
    //2. 看到 接收 实现了 UsbInterface接口的类的对象实例
    public void work(UsbInterface usbInterface) {
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

10.8.2 基本介绍

在这里插入图片描述

代码：

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

interface AInterface {
    //可以写属性
    public int n1 = 10;
    //可以写方法
    //在接口中，抽象方法，可以省略abstract关键字
    public void hi();

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

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

10.8.3 深入讨论接口

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

说现在要制造战斗机,武装直升机.专家只需把飞机需要的功能/规格定下来即可,然后让别的人具体实现就可。
说现在有一个项目经理(段玉),管理三个程序员,功能开发一个软件为了控制和管理软件,项目经理可以定义一些接口，然后由程序员具体实现。(1.项目质量2.项目进度3.项目奖)参加工作

假如现在有实际要求:3个程序员;编写三个类，分别完成对Mysql,Oracle,DB2数据库的连接 connect, close…

代码：

public class LianXi {
    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();
    }
}

interface DBInterface { //项目经理写的

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

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

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

class OracleDB implements DBInterface{//B程序员写的连接oracle的

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

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

10.8.4 注意事项和细节、课堂练习

接口不能被实例化
接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰，图示:
void aaa () ; 实际上是 abstract void aaa();
一个普通类实现接口,就必须将该接口的所有方法都实现。
抽象类实现接口，可以不用实现接口的方法。
一个类同时可以实现多个接口
接口中的属性,只能是final的，而且是 public static final修饰符。
比如 : int a=1 实际上是 public static final int a=1;(必须初始化)
接口中属性的访问形式:接口名.属性名
接口不能继承其它的类,但是可以继承多个别的接口[举例]
interface A extends B,C { }
接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

细节1-4点代码：

public class InterfaceDetail01 {
    public static void main(String[] args) {
        //new IA(); //接口不能被实例化
    }
}

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

    @Override
    public void hi() {
    }
}
abstract class Tiger implements  IA { //如果不写abstract就会报错
}

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //证明 接口中的属性,是 public static final
        System.out.println(IB.n1);//说明n1 就是static
        //IB.n1 = 30; 说明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 {
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

课堂练习

10.8.5 实现接口 vs 继承类

在这里插入图片描述

接口和继承解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性。
接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法。即更加的灵活.
接口比继承更加灵活
接口比继承更加灵活，继承是满足is- a的关系,而接口只需满足 like - a的关系。>接口在一定程度上实现代码解耦[即:接口规范性+动态绑定机制]

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

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

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

10.8.6 接口的多态特性、课堂练习

多态参数(前面案例体现) InterfacePolyParameter.java
在前面的Usb接口案例，Usblnterface usb，既可以接收手机对象，又可以接收相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)
多态数组 InterfacePolyArr.java
演示一个案例:给Usb数组中，存放 Phone 和相机对象,Phone类还有一个特有的方法call(0)，请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call.
Usb usbsll = new Usb[2];
接口存在多态传递现象. InterfacePolyPass.java

第1点代码：

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点代码：

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();//动态绑定.. usbs[0]就去访问Phone，usbs[1]就去访问Camera
            //和前面一样，我们仍然需要进行类型的向下转型
            if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }
    }
}

interface Usb{
    void work();
}
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("相机工作中...");
    }
}

第3点代码：

 // 演示多态传递现象
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 {
    void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
    @Override
    public void hi() {
    }
}

课堂练习

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

    }
}

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

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

class C extends B implements A {
    public void pX() {
        //System.out.println(x); //错误，原因不明确x
        //可以明确的指定x
        //访问接口的 x 就使用 A.x
        //访问父类的 x 就使用 super.x
        System.out.println(A.x + " " + super.x);
    }
    public static void main(String[] args) {
        new C().pX();
    }
}

10.9 内部类

如果定义类在局部位置(方法中/代码块) : (1) 局部内部类 (2) 匿名内部类
定义在成员位置：(1) 成员内部类 (2) 静态内部类

10.9.1 基本介绍、基本语法、快速入门案例、内部类的分类

基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员【思考:类的五大成员是哪些?[属性、方法、构造器、代码块、内部类]】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系，注意:内部类是学习的难点，同时也是重点，后面看底层源码时，有大量的内部类.
基本语法
快速入门案例：

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

内部类的分类

定义在外部类局部位置上(比如方法内):
(1)局部内部类（有类名)
(2)匿名内部类(没有类名，重点!!!)

定义在外部类的成员位置上:
成员内部类(没用static修饰)
静态内部类(使用static修饰)

10.9.2 局部内部类的使用

LocalInnerClass.java

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

可以直接访问外部类的所有成员,包含私有的
不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰,因为局部变量也可以使用final
作用域:仅仅在定义它的方法或代码块中。
局部内部类—访问---->外部类的成员[访问方式:直接访问]
外部类—访问---->局部内部类的成员
访问方式:创建对象,再访问(注意:必须在作用域内)

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

外部其他类—不能访问----->局部内部类（因为局部内部类地位是一个局部变量)
如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问【演示】
System.out.println("外部类的n2=”+外部类名.this.n2);

 // 演示局部内部类的使用
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();
   }
}

10.9.3 匿名内部类的使用(重要!!!)、使用细节

一、匿名内部类的使用

在这里插入图片描述

 // 演示匿名内部类的使用
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());//Outer04$1
        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();
    }
}

interface IA {//接口
    public void cry();
}
//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(); //方法
}

二、使用细节

AnonymouslnnerClassDetail.java

1、匿名内部类的语法比较奇特,请大家注意,因为匿名内部类既是一个类的定义同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。
2、可以直接访问外部类的所有成员,包含私有的[案例演示]
3、不能添加访问修饰符,因为它的地位就是一个局部变量。
4、作用域:仅仅在定义它的方法或代码块中。
5、匿名内部类—访问---->外部类成员 [访问方式:直接访问]
6、外部其他类—不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量)
7、如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用（(外部类名.this.成员)去访问

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);
    }
}
//还可以写抽象类/接口...

10.9.4 匿名内部类的最佳实践、课堂练习

一、匿名内部类的最佳实践

当做实参直接传递，简洁高效

import com.hspedu.abstract_.AA;
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();
    }
}
//接口
interface IL {
    void show();
}
//传统方法：类->实现IL => 编程领域叫(硬编码)
class Picture implements IL {

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

二、课堂练习
1.有一个铃声接口Bell，里面有个ring方法。(右图)
2.有一个手机类Cellphone，具有闹钟功能alarmclock,参数是Bell类型(右图)
3.测试手机类的闹钟功能,通过匿名内部类(对象)作为参数，打印:懒猪起床了
4.再传入另一个匿名内部类(对象)，打印:小伙伴上课了

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

public class InnerClassExercise02 {
    public static void main(String[] args) {
    
        //解读
        //1. 传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1
        //2. 重写了 ring
        //3. Bell bell = new Bell() {
        //            @Override
        //            public void ring() {
        //                System.out.println("懒猪起床了");
        //            }
        //        }
		
		CellPhone cellPhone = new CellPhone();
		
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });

        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });
    }
}
interface Bell{ //接口
    void ring();//方法
}
class CellPhone{//类
    public void alarmClock(Bell bell){//形参是Bell接口类型
        System.out.println(bell.getClass());
        bell.ring();//动态绑定
    }
}

10.9.5 成员内部类的使用

MemberlnnerClass01.java

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

可以直接访问外部类的所有成员,包含私有的。
可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
作用域 MemberlnnerClass01.java和外部类的其他成员一样,为整个类体。比如前面案例，在外部类的成员方法中创建成员内部类对象,再调用方法.
成员内部类—访问---->外部类成员（比如:属性，方法)[访问方式:直接访问]
外部类—访问------>成员内部类(说明)访问方式:创建对象,再访问
外部其他类—访问---->成员内部类
如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

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 { //外部类
    private int n1 = 10;
    public String name = "张三";

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

    //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();
        }
    }
    //方法，返回一个Inner08实例
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
    
    //写方法
    public void t1() {
        //使用成员内部类
        //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

10.9.6 静态内部类的使用

StaticInnerClass01.java

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

可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
作用域:同其他的成员，为整个类体。（包括外部类和内部类）
静态内部类—访问---->外部类(比如:静态属性)[访问方式:直接访问所有静态成员]
外部类—访问------>静态内部类访问方式:创建对象，再访问
外部其他类—访问----->静态内部类
如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员)去访问。不用加this。

代码：

package com.hspedu.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 int n1 = 10;
    private static String name = "张三";
    private static void cry() {}
    //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();
        }
    }

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

    public Inner10 getInner10() {//可以创建非静态方法，非静态方法可以访问静态或者非静态
        return new Inner10();
    }

    public static Inner10 getInner10_() {//也可以创建静态方法，静态方法可以访问静态属性
            return new Inner10();
    }
}

课堂测试题
写出输出结果 5,5

java学习笔记(10) 第10 章下 - 面向对象编程(高级部分)

第10 章 - 面向对象编程-高级部分-下

10.6 抽象类

10.6.1 先看一个问题、问题解决之道

10.6.2 抽象类的介绍

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

10.6.4 课堂练习题

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

10.7.1 基本介绍、模板设计模式能解决的问题

10.7.2 最佳实践

10.8 接口

10.8.1 为什么有接口、接口快速入门

10.8.2 基本介绍

10.8.3 深入讨论接口

10.8.4 注意事项和细节、课堂练习

10.8.5 实现接口 vs 继承类

10.8.6 接口的多态特性、课堂练习

10.9 内部类

10.9.1 基本介绍、基本语法、快速入门案例、内部类的分类

10.9.2 局部内部类的使用

10.9.3 匿名内部类的使用(重要!!!)、使用细节

10.9.4 匿名内部类的最佳实践、课堂练习

10.9.5 成员内部类的使用

10.9.6 静态内部类的使用

相关推荐