面向对象3.2

crainyday

Java / JavaSE

发布于：2019年3月20日

字数：1.7k字

时长：7分钟

abstract
interface
内部类

一.abstract

abstract: 抽象的, 可以用来修饰类、方法

abstract修饰类: 抽象类

不可被实例化
抽象类有构造器 (凡是类都有构造器)
抽象方法所在的类, 一定是抽象类.
抽象类中可以没有抽象方法.

abstract修饰方法: 抽象方法

格式: 没有方法体和{}.如: public abstract void eat();
抽象方法只保留方法的功能, 而具体的执行, 交给继承抽象类的子类, 由子类重写此抽象方法.
若子类继承抽象类, 并重写了所有的抽象方法, 则此类是一个"实体类", 即可以实例化
若子类继承抽象类, 没有重写所有的抽象方法, 意味着此类中仍有抽象方法, 则此类必须声明为抽象的!

abstract不能用来修饰属性、构造器、private、final、static

A.模板方法设计模式

功能的内部一部分实现是确定的, 一部分实现是不确定的, 可以将不确定的暴露出去让子类去实现它

One More Thing 👇

//模板方法设计模式
public class TestTemplate {
    public static void main(String[] args) {
        new SubTemplate().spendTime();
    }
}
abstract class Template {
    //此部分功能不确定: 具体要执行什么代码
    public abstract void code();
    //此部分功能确定: 计算执行code()方法的时间
    public void spendTime() {
        long start = System.currentTimeMillis();
        this.code();
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为：" + (end - start));
    }
}
class SubTemplate extends Template {
    public void code() {
        boolean flag = false;
        for(int i = 2;i <= 10000;i++){
            for(int j = 2;j <= Math.sqrt(i);j++){
                if(i % j == 0){
                    flag = true;
                    break;
                }
            }
            if(!flag){
                System.out.println(i);
            }
            flag = false;
        }
    }
}

二.interface

接口(interface)是与类并行的一个概念

接口可以看做是一个特殊的抽象类, 是常量与抽象方法的一个集合, 不能包含变量、一般的方法.

常量默认有 public static final修饰, 方法默认有 public abstract修饰

接口是没有构造器的.
接口定义的就是一种功能. 此功能可以被类所实现(implements).

比如: class CC extends DD implements AA

实现接口的类, 必须要重写其中的所有的抽象方法, 方可实例化. 若没有重写所有的抽象方法, 则此类仍为一个抽象类
一个类可以实现多个接口.----java 中的类的继承是单继承的
接口与接口之间也是继承的关系, 而且可以实现多继承
接口与具体的实现类之间也存在多态性
面向接口编程的思想:

A.工厂方法的设计模式

定义一个用户创建对象的接口, 让子类决定实例化哪一个类. 工厂方法使一个类的实例化延迟到其子类.

//接口的应用: 工厂方法的设计模式
public class TestFactoryMethod {
    public static void main(String[] args) {
        IWorkFactory i = new StudentWorkFactory();
        i.getWork().doWork();
        IWorkFactory i1 = new TeacherWorkFactory();
        i1.getWork().doWork();
    }
}
//工厂接口
interface IWorkFactory{
    Work getWork();
}
//创建学生工作的工厂
class StudentWorkFactory implements IWorkFactory{
    @Override
    public Work getWork() {
        return new StudentWork();
    }
}
//创建老师工作的工厂
class TeacherWorkFactory implements IWorkFactory{
    @Override
    public Work getWork() {
        return new TeacherWork();
    }
}
interface Work{
    void doWork();
}
class StudentWork implements Work{
    @Override
    public void doWork() {
        System.out.println("学生写作业");
    }
}
class TeacherWork implements Work{
    @Override
    public void doWork() {
        System.out.println("老师批改作业");
    }
}

B.代理模式

//接口的应用: 代理模式(静态代理), 后面会有动态代理
public class TestProxy {
    public static void main(String[] args) {
        Object obj = new ProxyObject();
        obj.action();
    }
}
interface Object{
    void action();
}
//代理类
class ProxyObject implements Object{
    Object obj;
    public ProxyObject(){
        System.out.println("代理类创建成功");
        obj = new ObjctImpl();
    }
    public void action(){
        System.out.println("代理类开始执行");
        obj.action();
        System.out.println("代理类执行结束");
    }
}
//被代理类
class ObjctImpl implements Object{
    @Override
    public void action() {
        System.out.println("=====被代理类开始执行======");
        System.out.println("=====具体的操作======");
        System.out.println("=====被代理类执行完毕======");
    }
}

了解就好, 你可以将这两种设计模式当成算法记下来

三.内部类

类的第5个成员: 内部类(inner class) 例: Thread类内的State枚举类

相当于说, 我们可以在类的内部再定义类. 外面的类: 外部类. 定义在类内的类: 内部类
内部类的分类: 成员内部类(声明在类内部且方法外的) vs 局部内部类(声明在类的方法里)
成员内部类:

是外部类的一个成员: ①可以有修饰符(4个) ②static final ③可以调用外部类的属性、方法
具体类的特点: ①abstract ②还可以在其内部定义属性、方法、构造器

局部内部类(知道有就好)
关于内部类, 掌握三点:

①如何创建成员内部类的对象(如: 创建Bird类和Dog类的对象)
②如何区分调用外部类、内部类的变量(尤其是变量重名时)
③局部内部类的使用

A.成员内部类:

public class TestInnerClass {
    public static void main(String[] args) {
        //创建静态内部类的对象: 可以直接通过外部类调用静态内部类的构造器
        Person.Dog d = new Person.Dog();//区别Person.new Dog();
        //Person.Bird b = new Person.Bird();
        //创建非静态的内部类的对象: 必须先创建外部类的对象, 通过外部类的对象调用内部类的构造器
        Person p = new Person();
        Person.Bird b = p.new Bird();
        b.info();
        b.setName("杜鹃");
    }
}
class Person{
    String name = "小明";
    int age;
    //成员内部类(非static的)
    class Bird{
        String name = "黄鹂";
        int id;
        public Bird(){
        }
        public void setName(String name){//假设传过来的参数为"杜鹃"
            System.out.println(name);//杜鹃
            System.out.println(this.name);//黄鹂
            System.out.println(Person.this.name);//小明
        }
        public void info(){
            show();
        }
    }
    //成员内部类(静态内部类)
    static class Dog{
    }
    public void show(){
        System.out.println("show()");
    }
    public void method1(){
        class A{
        }
    }
}

B.局部内部类:

class OuterClass{
    //局部内部类
    //如下的使用方式较少
    public void method1(){
        class InnnerClass{
        }
    }
    //常常使用一个方法, 使其返回值为某个类或接口的对象. 而这个类或接口在方法内部创建
    //使用方式一
    public Comparable getComparable(){
        //1.创建一个实现Comparable接口的类:局部内部类
        class MyComparable implements Comparable{
            @Override
            public int compareTo(java.lang.Object o) {
                return 0;
            }
        }
        //2.返回一个实现类的对象
        return new MyComparable();
    }
    //使用方式二
    public Comparable getComparable1(){
        //返回一个实现Comparable接口的匿名内部类的对象
        return new Comparable(){
            @Override
            public int compareTo(java.lang.Object o) {
                return 0;
            }
        };
    }
}